fidl_fuchsia_posix_socket/
fidl_fuchsia_posix_socket.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__common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
15pub struct ProviderDatagramSocketDeprecatedResponse {
16    pub s: fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
17}
18
19impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
20    for ProviderDatagramSocketDeprecatedResponse
21{
22}
23
24#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
25pub struct ProviderStreamSocketWithOptionsResponse {
26    pub s: fidl::endpoints::ClientEnd<StreamSocketMarker>,
27}
28
29impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
30    for ProviderStreamSocketWithOptionsResponse
31{
32}
33
34#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
35pub struct ProviderStreamSocketResponse {
36    pub s: fidl::endpoints::ClientEnd<StreamSocketMarker>,
37}
38
39impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
40    for ProviderStreamSocketResponse
41{
42}
43
44#[derive(Debug, PartialEq)]
45pub struct StreamSocketAcceptResponse {
46    pub addr: Option<Box<fidl_fuchsia_net::SocketAddress>>,
47    pub s: fidl::endpoints::ClientEnd<StreamSocketMarker>,
48}
49
50impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
51    for StreamSocketAcceptResponse
52{
53}
54
55#[derive(Debug, Default, PartialEq)]
56pub struct DatagramSocketDescribeResponse {
57    /// `ZX_SOCKET_DATAGRAM` on which data is sent and received.
58    pub socket: Option<fidl::Socket>,
59    /// Size of the buffer used to receive Tx metadata.
60    pub tx_meta_buf_size: Option<u64>,
61    /// Size of the buffer used to receive Rx metadata.
62    pub rx_meta_buf_size: Option<u64>,
63    /// Identifies the version of the protocol used to encode and decode
64    /// metadata sent alongside payloads over the socket.
65    pub metadata_encoding_protocol_version: Option<UdpMetadataEncodingProtocolVersion>,
66    #[doc(hidden)]
67    pub __source_breaking: fidl::marker::SourceBreaking,
68}
69
70impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
71    for DatagramSocketDescribeResponse
72{
73}
74
75#[derive(Debug, Default, PartialEq)]
76pub struct DatagramSocketRecvMsgPostflightResponse {
77    /// Represents the validity of this structure.
78    ///
79    /// The structure is invalid if the peer is closed.
80    pub validity: Option<fidl::EventPair>,
81    /// Identifies whether the `SO_TIMESTAMP` or `SO_TIMESTAMPNS` control messages are
82    /// requested.
83    pub timestamp: Option<TimestampOption>,
84    /// Identifies the status (requested or not) of up to 32 control messages.
85    /// This set size should be large enough to signal the status of all cmsgs supported
86    /// by POSIX systems as of 2022. If that changes, the set can be extended by adding
87    /// additional bits fields.
88    pub requests: Option<CmsgRequests>,
89    #[doc(hidden)]
90    pub __source_breaking: fidl::marker::SourceBreaking,
91}
92
93impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
94    for DatagramSocketRecvMsgPostflightResponse
95{
96}
97
98#[derive(Debug, Default, PartialEq)]
99pub struct DatagramSocketSendMsgPreflightResponse {
100    /// The validated destination address.
101    ///
102    /// Present only in response to an unset `to` addreess.
103    pub to: Option<fidl_fuchsia_net::SocketAddress>,
104    /// Represents the validity of this structure.
105    ///
106    /// The structure is invalid if any of the elements' peer is closed.
107    /// Datagrams sent with the associated metadata after invalidation will be
108    /// silently dropped.
109    pub validity: Option<Vec<fidl::EventPair>>,
110    /// The maximum datagram size that can be sent.
111    ///
112    /// Datagrams exceeding this will be silently dropped.
113    pub maximum_size: Option<u32>,
114    #[doc(hidden)]
115    pub __source_breaking: fidl::marker::SourceBreaking,
116}
117
118impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
119    for DatagramSocketSendMsgPreflightResponse
120{
121}
122
123#[derive(Debug, Default, PartialEq)]
124pub struct StreamSocketDescribeResponse {
125    /// `ZX_SOCKET_STREAM` on which data is sent and received.
126    pub socket: Option<fidl::Socket>,
127    #[doc(hidden)]
128    pub __source_breaking: fidl::marker::SourceBreaking,
129}
130
131impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
132    for StreamSocketDescribeResponse
133{
134}
135
136#[derive(Debug, Default, PartialEq)]
137pub struct SynchronousDatagramSocketDescribeResponse {
138    /// Signals additional information about the state of the socket such as
139    /// readiness or shutdown-ness.
140    pub event: Option<fidl::EventPair>,
141    #[doc(hidden)]
142    pub __source_breaking: fidl::marker::SourceBreaking,
143}
144
145impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
146    for SynchronousDatagramSocketDescribeResponse
147{
148}
149
150#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
151pub enum ProviderDatagramSocketWithOptionsResponse {
152    DatagramSocket(fidl::endpoints::ClientEnd<DatagramSocketMarker>),
153    SynchronousDatagramSocket(fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>),
154}
155
156impl ProviderDatagramSocketWithOptionsResponse {
157    #[inline]
158    pub fn ordinal(&self) -> u64 {
159        match *self {
160            Self::DatagramSocket(_) => 1,
161            Self::SynchronousDatagramSocket(_) => 2,
162        }
163    }
164}
165
166impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
167    for ProviderDatagramSocketWithOptionsResponse
168{
169}
170
171#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
172pub enum ProviderDatagramSocketResponse {
173    DatagramSocket(fidl::endpoints::ClientEnd<DatagramSocketMarker>),
174    SynchronousDatagramSocket(fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>),
175}
176
177impl ProviderDatagramSocketResponse {
178    #[inline]
179    pub fn ordinal(&self) -> u64 {
180        match *self {
181            Self::DatagramSocket(_) => 1,
182            Self::SynchronousDatagramSocket(_) => 2,
183        }
184    }
185}
186
187impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
188    for ProviderDatagramSocketResponse
189{
190}
191
192#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
193pub struct BaseDatagramSocketMarker;
194
195impl fidl::endpoints::ProtocolMarker for BaseDatagramSocketMarker {
196    type Proxy = BaseDatagramSocketProxy;
197    type RequestStream = BaseDatagramSocketRequestStream;
198    #[cfg(target_os = "fuchsia")]
199    type SynchronousProxy = BaseDatagramSocketSynchronousProxy;
200
201    const DEBUG_NAME: &'static str = "(anonymous) BaseDatagramSocket";
202}
203pub type BaseDatagramSocketGetInfoResult =
204    Result<(Domain, DatagramSocketProtocol), fidl_fuchsia_posix::Errno>;
205
206pub trait BaseDatagramSocketProxyInterface: Send + Sync {
207    fn r#clone(
208        &self,
209        request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
210    ) -> Result<(), fidl::Error>;
211    type CloseResponseFut: std::future::Future<
212            Output = Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error>,
213        > + Send;
214    fn r#close(&self) -> Self::CloseResponseFut;
215    type QueryResponseFut: std::future::Future<Output = Result<Vec<u8>, fidl::Error>> + Send;
216    fn r#query(&self) -> Self::QueryResponseFut;
217    type SetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketSetReuseAddressResult, fidl::Error>>
218        + Send;
219    fn r#set_reuse_address(&self, value: bool) -> Self::SetReuseAddressResponseFut;
220    type GetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketGetReuseAddressResult, fidl::Error>>
221        + Send;
222    fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut;
223    type GetErrorResponseFut: std::future::Future<Output = Result<BaseSocketGetErrorResult, fidl::Error>>
224        + Send;
225    fn r#get_error(&self) -> Self::GetErrorResponseFut;
226    type SetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketSetBroadcastResult, fidl::Error>>
227        + Send;
228    fn r#set_broadcast(&self, value: bool) -> Self::SetBroadcastResponseFut;
229    type GetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketGetBroadcastResult, fidl::Error>>
230        + Send;
231    fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut;
232    type SetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetSendBufferResult, fidl::Error>>
233        + Send;
234    fn r#set_send_buffer(&self, value_bytes: u64) -> Self::SetSendBufferResponseFut;
235    type GetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetSendBufferResult, fidl::Error>>
236        + Send;
237    fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut;
238    type SetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetReceiveBufferResult, fidl::Error>>
239        + Send;
240    fn r#set_receive_buffer(&self, value_bytes: u64) -> Self::SetReceiveBufferResponseFut;
241    type GetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetReceiveBufferResult, fidl::Error>>
242        + Send;
243    fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut;
244    type SetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketSetKeepAliveResult, fidl::Error>>
245        + Send;
246    fn r#set_keep_alive(&self, value: bool) -> Self::SetKeepAliveResponseFut;
247    type GetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketGetKeepAliveResult, fidl::Error>>
248        + Send;
249    fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut;
250    type SetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketSetOutOfBandInlineResult, fidl::Error>>
251        + Send;
252    fn r#set_out_of_band_inline(&self, value: bool) -> Self::SetOutOfBandInlineResponseFut;
253    type GetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketGetOutOfBandInlineResult, fidl::Error>>
254        + Send;
255    fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut;
256    type SetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketSetNoCheckResult, fidl::Error>>
257        + Send;
258    fn r#set_no_check(&self, value: bool) -> Self::SetNoCheckResponseFut;
259    type GetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketGetNoCheckResult, fidl::Error>>
260        + Send;
261    fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut;
262    type SetLingerResponseFut: std::future::Future<Output = Result<BaseSocketSetLingerResult, fidl::Error>>
263        + Send;
264    fn r#set_linger(&self, linger: bool, length_secs: u32) -> Self::SetLingerResponseFut;
265    type GetLingerResponseFut: std::future::Future<Output = Result<BaseSocketGetLingerResult, fidl::Error>>
266        + Send;
267    fn r#get_linger(&self) -> Self::GetLingerResponseFut;
268    type SetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketSetReusePortResult, fidl::Error>>
269        + Send;
270    fn r#set_reuse_port(&self, value: bool) -> Self::SetReusePortResponseFut;
271    type GetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketGetReusePortResult, fidl::Error>>
272        + Send;
273    fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut;
274    type GetAcceptConnResponseFut: std::future::Future<Output = Result<BaseSocketGetAcceptConnResult, fidl::Error>>
275        + Send;
276    fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut;
277    type SetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToDeviceResult, fidl::Error>>
278        + Send;
279    fn r#set_bind_to_device(&self, value: &str) -> Self::SetBindToDeviceResponseFut;
280    type GetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToDeviceResult, fidl::Error>>
281        + Send;
282    fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut;
283    type SetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error>>
284        + Send;
285    fn r#set_bind_to_interface_index(&self, value: u64)
286        -> Self::SetBindToInterfaceIndexResponseFut;
287    type GetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error>>
288        + Send;
289    fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut;
290    type SetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketSetTimestampResult, fidl::Error>>
291        + Send;
292    fn r#set_timestamp(&self, value: TimestampOption) -> Self::SetTimestampResponseFut;
293    type GetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketGetTimestampResult, fidl::Error>>
294        + Send;
295    fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut;
296    type SetMarkResponseFut: std::future::Future<Output = Result<BaseSocketSetMarkResult, fidl::Error>>
297        + Send;
298    fn r#set_mark(
299        &self,
300        domain: fidl_fuchsia_net::MarkDomain,
301        mark: &OptionalUint32,
302    ) -> Self::SetMarkResponseFut;
303    type GetMarkResponseFut: std::future::Future<Output = Result<BaseSocketGetMarkResult, fidl::Error>>
304        + Send;
305    fn r#get_mark(&self, domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut;
306    type BindResponseFut: std::future::Future<Output = Result<BaseNetworkSocketBindResult, fidl::Error>>
307        + Send;
308    fn r#bind(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut;
309    type ConnectResponseFut: std::future::Future<Output = Result<BaseNetworkSocketConnectResult, fidl::Error>>
310        + Send;
311    fn r#connect(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut;
312    type DisconnectResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDisconnectResult, fidl::Error>>
313        + Send;
314    fn r#disconnect(&self) -> Self::DisconnectResponseFut;
315    type GetSockNameResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetSockNameResult, fidl::Error>>
316        + Send;
317    fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut;
318    type GetPeerNameResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetPeerNameResult, fidl::Error>>
319        + Send;
320    fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut;
321    type ShutdownResponseFut: std::future::Future<Output = Result<BaseNetworkSocketShutdownResult, fidl::Error>>
322        + Send;
323    fn r#shutdown(&self, mode: ShutdownMode) -> Self::ShutdownResponseFut;
324    type SetIpTypeOfServiceResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error>>
325        + Send;
326    fn r#set_ip_type_of_service(&self, value: u8) -> Self::SetIpTypeOfServiceResponseFut;
327    type GetIpTypeOfServiceResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error>>
328        + Send;
329    fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut;
330    type SetIpTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTtlResult, fidl::Error>>
331        + Send;
332    fn r#set_ip_ttl(&self, value: &OptionalUint8) -> Self::SetIpTtlResponseFut;
333    type GetIpTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTtlResult, fidl::Error>>
334        + Send;
335    fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut;
336    type SetIpPacketInfoResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error>>
337        + Send;
338    fn r#set_ip_packet_info(&self, value: bool) -> Self::SetIpPacketInfoResponseFut;
339    type GetIpPacketInfoResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error>>
340        + Send;
341    fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut;
342    type SetIpReceiveTypeOfServiceResponseFut: std::future::Future<
343            Output = Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error>,
344        > + Send;
345    fn r#set_ip_receive_type_of_service(
346        &self,
347        value: bool,
348    ) -> Self::SetIpReceiveTypeOfServiceResponseFut;
349    type GetIpReceiveTypeOfServiceResponseFut: std::future::Future<
350            Output = Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error>,
351        > + Send;
352    fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut;
353    type SetIpReceiveTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error>>
354        + Send;
355    fn r#set_ip_receive_ttl(&self, value: bool) -> Self::SetIpReceiveTtlResponseFut;
356    type GetIpReceiveTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error>>
357        + Send;
358    fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut;
359    type SetIpMulticastInterfaceResponseFut: std::future::Future<
360            Output = Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error>,
361        > + Send;
362    fn r#set_ip_multicast_interface(
363        &self,
364        iface: u64,
365        address: &fidl_fuchsia_net::Ipv4Address,
366    ) -> Self::SetIpMulticastInterfaceResponseFut;
367    type GetIpMulticastInterfaceResponseFut: std::future::Future<
368            Output = Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error>,
369        > + Send;
370    fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut;
371    type SetIpMulticastTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error>>
372        + Send;
373    fn r#set_ip_multicast_ttl(&self, value: &OptionalUint8) -> Self::SetIpMulticastTtlResponseFut;
374    type GetIpMulticastTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error>>
375        + Send;
376    fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut;
377    type SetIpMulticastLoopbackResponseFut: std::future::Future<
378            Output = Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error>,
379        > + Send;
380    fn r#set_ip_multicast_loopback(&self, value: bool) -> Self::SetIpMulticastLoopbackResponseFut;
381    type GetIpMulticastLoopbackResponseFut: std::future::Future<
382            Output = Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error>,
383        > + Send;
384    fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut;
385    type AddIpMembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error>>
386        + Send;
387    fn r#add_ip_membership(
388        &self,
389        membership: &IpMulticastMembership,
390    ) -> Self::AddIpMembershipResponseFut;
391    type DropIpMembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error>>
392        + Send;
393    fn r#drop_ip_membership(
394        &self,
395        membership: &IpMulticastMembership,
396    ) -> Self::DropIpMembershipResponseFut;
397    type SetIpTransparentResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error>>
398        + Send;
399    fn r#set_ip_transparent(&self, value: bool) -> Self::SetIpTransparentResponseFut;
400    type GetIpTransparentResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error>>
401        + Send;
402    fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut;
403    type SetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<
404            Output = Result<
405                BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
406                fidl::Error,
407            >,
408        > + Send;
409    fn r#set_ip_receive_original_destination_address(
410        &self,
411        value: bool,
412    ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut;
413    type GetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<
414            Output = Result<
415                BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
416                fidl::Error,
417            >,
418        > + Send;
419    fn r#get_ip_receive_original_destination_address(
420        &self,
421    ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut;
422    type AddIpv6MembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error>>
423        + Send;
424    fn r#add_ipv6_membership(
425        &self,
426        membership: &Ipv6MulticastMembership,
427    ) -> Self::AddIpv6MembershipResponseFut;
428    type DropIpv6MembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error>>
429        + Send;
430    fn r#drop_ipv6_membership(
431        &self,
432        membership: &Ipv6MulticastMembership,
433    ) -> Self::DropIpv6MembershipResponseFut;
434    type SetIpv6MulticastInterfaceResponseFut: std::future::Future<
435            Output = Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error>,
436        > + Send;
437    fn r#set_ipv6_multicast_interface(
438        &self,
439        value: u64,
440    ) -> Self::SetIpv6MulticastInterfaceResponseFut;
441    type GetIpv6MulticastInterfaceResponseFut: std::future::Future<
442            Output = Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error>,
443        > + Send;
444    fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut;
445    type SetIpv6UnicastHopsResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error>>
446        + Send;
447    fn r#set_ipv6_unicast_hops(&self, value: &OptionalUint8)
448        -> Self::SetIpv6UnicastHopsResponseFut;
449    type GetIpv6UnicastHopsResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error>>
450        + Send;
451    fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut;
452    type SetIpv6ReceiveHopLimitResponseFut: std::future::Future<
453            Output = Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error>,
454        > + Send;
455    fn r#set_ipv6_receive_hop_limit(&self, value: bool) -> Self::SetIpv6ReceiveHopLimitResponseFut;
456    type GetIpv6ReceiveHopLimitResponseFut: std::future::Future<
457            Output = Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error>,
458        > + Send;
459    fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut;
460    type SetIpv6MulticastHopsResponseFut: std::future::Future<
461            Output = Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error>,
462        > + Send;
463    fn r#set_ipv6_multicast_hops(
464        &self,
465        value: &OptionalUint8,
466    ) -> Self::SetIpv6MulticastHopsResponseFut;
467    type GetIpv6MulticastHopsResponseFut: std::future::Future<
468            Output = Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error>,
469        > + Send;
470    fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut;
471    type SetIpv6MulticastLoopbackResponseFut: std::future::Future<
472            Output = Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error>,
473        > + Send;
474    fn r#set_ipv6_multicast_loopback(
475        &self,
476        value: bool,
477    ) -> Self::SetIpv6MulticastLoopbackResponseFut;
478    type GetIpv6MulticastLoopbackResponseFut: std::future::Future<
479            Output = Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error>,
480        > + Send;
481    fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut;
482    type SetIpv6OnlyResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error>>
483        + Send;
484    fn r#set_ipv6_only(&self, value: bool) -> Self::SetIpv6OnlyResponseFut;
485    type GetIpv6OnlyResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error>>
486        + Send;
487    fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut;
488    type SetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
489            Output = Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error>,
490        > + Send;
491    fn r#set_ipv6_receive_traffic_class(
492        &self,
493        value: bool,
494    ) -> Self::SetIpv6ReceiveTrafficClassResponseFut;
495    type GetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
496            Output = Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error>,
497        > + Send;
498    fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut;
499    type SetIpv6TrafficClassResponseFut: std::future::Future<
500            Output = Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error>,
501        > + Send;
502    fn r#set_ipv6_traffic_class(
503        &self,
504        value: &OptionalUint8,
505    ) -> Self::SetIpv6TrafficClassResponseFut;
506    type GetIpv6TrafficClassResponseFut: std::future::Future<
507            Output = Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error>,
508        > + Send;
509    fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut;
510    type SetIpv6ReceivePacketInfoResponseFut: std::future::Future<
511            Output = Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error>,
512        > + Send;
513    fn r#set_ipv6_receive_packet_info(
514        &self,
515        value: bool,
516    ) -> Self::SetIpv6ReceivePacketInfoResponseFut;
517    type GetIpv6ReceivePacketInfoResponseFut: std::future::Future<
518            Output = Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error>,
519        > + Send;
520    fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut;
521    type GetOriginalDestinationResponseFut: std::future::Future<
522            Output = Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error>,
523        > + Send;
524    fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut;
525    type GetInfoResponseFut: std::future::Future<Output = Result<BaseDatagramSocketGetInfoResult, fidl::Error>>
526        + Send;
527    fn r#get_info(&self) -> Self::GetInfoResponseFut;
528}
529#[derive(Debug)]
530#[cfg(target_os = "fuchsia")]
531pub struct BaseDatagramSocketSynchronousProxy {
532    client: fidl::client::sync::Client,
533}
534
535#[cfg(target_os = "fuchsia")]
536impl fidl::endpoints::SynchronousProxy for BaseDatagramSocketSynchronousProxy {
537    type Proxy = BaseDatagramSocketProxy;
538    type Protocol = BaseDatagramSocketMarker;
539
540    fn from_channel(inner: fidl::Channel) -> Self {
541        Self::new(inner)
542    }
543
544    fn into_channel(self) -> fidl::Channel {
545        self.client.into_channel()
546    }
547
548    fn as_channel(&self) -> &fidl::Channel {
549        self.client.as_channel()
550    }
551}
552
553#[cfg(target_os = "fuchsia")]
554impl BaseDatagramSocketSynchronousProxy {
555    pub fn new(channel: fidl::Channel) -> Self {
556        let protocol_name =
557            <BaseDatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
558        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
559    }
560
561    pub fn into_channel(self) -> fidl::Channel {
562        self.client.into_channel()
563    }
564
565    /// Waits until an event arrives and returns it. It is safe for other
566    /// threads to make concurrent requests while waiting for an event.
567    pub fn wait_for_event(
568        &self,
569        deadline: zx::MonotonicInstant,
570    ) -> Result<BaseDatagramSocketEvent, fidl::Error> {
571        BaseDatagramSocketEvent::decode(self.client.wait_for_event(deadline)?)
572    }
573
574    pub fn r#clone(
575        &self,
576        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
577    ) -> Result<(), fidl::Error> {
578        self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
579            (request,),
580            0x20d8a7aba2168a79,
581            fidl::encoding::DynamicFlags::empty(),
582        )
583    }
584
585    /// Terminates the connection.
586    ///
587    /// After calling `Close`, the client must not send any other requests.
588    ///
589    /// Servers, after sending the status response, should close the connection
590    /// regardless of status and without sending an epitaph.
591    ///
592    /// Closing the client end of the channel should be semantically equivalent
593    /// to calling `Close` without knowing when the close has completed or its
594    /// status.
595    pub fn r#close(
596        &self,
597        ___deadline: zx::MonotonicInstant,
598    ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
599        let _response = self.client.send_query::<
600            fidl::encoding::EmptyPayload,
601            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
602        >(
603            (),
604            0x5ac5d459ad7f657e,
605            fidl::encoding::DynamicFlags::empty(),
606            ___deadline,
607        )?;
608        Ok(_response.map(|x| x))
609    }
610
611    pub fn r#query(&self, ___deadline: zx::MonotonicInstant) -> Result<Vec<u8>, fidl::Error> {
612        let _response = self.client.send_query::<
613            fidl::encoding::EmptyPayload,
614            fidl_fuchsia_unknown::QueryableQueryResponse,
615        >(
616            (),
617            0x2658edee9decfc06,
618            fidl::encoding::DynamicFlags::empty(),
619            ___deadline,
620        )?;
621        Ok(_response.protocol)
622    }
623
624    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
625    pub fn r#set_reuse_address(
626        &self,
627        mut value: bool,
628        ___deadline: zx::MonotonicInstant,
629    ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
630        let _response =
631            self.client.send_query::<BaseSocketSetReuseAddressRequest, fidl::encoding::ResultType<
632                fidl::encoding::EmptyStruct,
633                fidl_fuchsia_posix::Errno,
634            >>(
635                (value,),
636                0x1fd74ee8b9a4a876,
637                fidl::encoding::DynamicFlags::empty(),
638                ___deadline,
639            )?;
640        Ok(_response.map(|x| x))
641    }
642
643    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
644    pub fn r#get_reuse_address(
645        &self,
646        ___deadline: zx::MonotonicInstant,
647    ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
648        let _response = self
649            .client
650            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
651                BaseSocketGetReuseAddressResponse,
652                fidl_fuchsia_posix::Errno,
653            >>(
654                (), 0x67b7206b8d1bc0a5, fidl::encoding::DynamicFlags::empty(), ___deadline
655            )?;
656        Ok(_response.map(|x| x.value))
657    }
658
659    /// Get `SOL_SOCKET` -> `SO_ERROR`.
660    /// Returns the last error if there is an error set on the socket.
661    pub fn r#get_error(
662        &self,
663        ___deadline: zx::MonotonicInstant,
664    ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
665        let _response =
666            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
667                fidl::encoding::EmptyStruct,
668                fidl_fuchsia_posix::Errno,
669            >>(
670                (),
671                0x5aad39b33e5f6ebb,
672                fidl::encoding::DynamicFlags::empty(),
673                ___deadline,
674            )?;
675        Ok(_response.map(|x| x))
676    }
677
678    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
679    pub fn r#set_broadcast(
680        &self,
681        mut value: bool,
682        ___deadline: zx::MonotonicInstant,
683    ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
684        let _response =
685            self.client.send_query::<BaseSocketSetBroadcastRequest, fidl::encoding::ResultType<
686                fidl::encoding::EmptyStruct,
687                fidl_fuchsia_posix::Errno,
688            >>(
689                (value,),
690                0x6023e081ce3cd947,
691                fidl::encoding::DynamicFlags::empty(),
692                ___deadline,
693            )?;
694        Ok(_response.map(|x| x))
695    }
696
697    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
698    pub fn r#get_broadcast(
699        &self,
700        ___deadline: zx::MonotonicInstant,
701    ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
702        let _response =
703            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
704                BaseSocketGetBroadcastResponse,
705                fidl_fuchsia_posix::Errno,
706            >>(
707                (),
708                0x68796fc556f9780d,
709                fidl::encoding::DynamicFlags::empty(),
710                ___deadline,
711            )?;
712        Ok(_response.map(|x| x.value))
713    }
714
715    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
716    pub fn r#set_send_buffer(
717        &self,
718        mut value_bytes: u64,
719        ___deadline: zx::MonotonicInstant,
720    ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
721        let _response =
722            self.client.send_query::<BaseSocketSetSendBufferRequest, fidl::encoding::ResultType<
723                fidl::encoding::EmptyStruct,
724                fidl_fuchsia_posix::Errno,
725            >>(
726                (value_bytes,),
727                0x756eac32d73a7a70,
728                fidl::encoding::DynamicFlags::empty(),
729                ___deadline,
730            )?;
731        Ok(_response.map(|x| x))
732    }
733
734    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
735    pub fn r#get_send_buffer(
736        &self,
737        ___deadline: zx::MonotonicInstant,
738    ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
739        let _response = self
740            .client
741            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
742                BaseSocketGetSendBufferResponse,
743                fidl_fuchsia_posix::Errno,
744            >>(
745                (), 0x78a52fd9c7b2410b, fidl::encoding::DynamicFlags::empty(), ___deadline
746            )?;
747        Ok(_response.map(|x| x.value_bytes))
748    }
749
750    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
751    pub fn r#set_receive_buffer(
752        &self,
753        mut value_bytes: u64,
754        ___deadline: zx::MonotonicInstant,
755    ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
756        let _response =
757            self.client
758                .send_query::<BaseSocketSetReceiveBufferRequest, fidl::encoding::ResultType<
759                    fidl::encoding::EmptyStruct,
760                    fidl_fuchsia_posix::Errno,
761                >>(
762                    (value_bytes,),
763                    0x6b0cf2f1919c7001,
764                    fidl::encoding::DynamicFlags::empty(),
765                    ___deadline,
766                )?;
767        Ok(_response.map(|x| x))
768    }
769
770    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
771    pub fn r#get_receive_buffer(
772        &self,
773        ___deadline: zx::MonotonicInstant,
774    ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
775        let _response = self
776            .client
777            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
778                BaseSocketGetReceiveBufferResponse,
779                fidl_fuchsia_posix::Errno,
780            >>(
781                (), 0x14c1a4b64f709e5c, fidl::encoding::DynamicFlags::empty(), ___deadline
782            )?;
783        Ok(_response.map(|x| x.value_bytes))
784    }
785
786    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
787    pub fn r#set_keep_alive(
788        &self,
789        mut value: bool,
790        ___deadline: zx::MonotonicInstant,
791    ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
792        let _response =
793            self.client.send_query::<BaseSocketSetKeepAliveRequest, fidl::encoding::ResultType<
794                fidl::encoding::EmptyStruct,
795                fidl_fuchsia_posix::Errno,
796            >>(
797                (value,),
798                0x572df8f0b920d2c7,
799                fidl::encoding::DynamicFlags::empty(),
800                ___deadline,
801            )?;
802        Ok(_response.map(|x| x))
803    }
804
805    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
806    pub fn r#get_keep_alive(
807        &self,
808        ___deadline: zx::MonotonicInstant,
809    ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
810        let _response =
811            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
812                BaseSocketGetKeepAliveResponse,
813                fidl_fuchsia_posix::Errno,
814            >>(
815                (),
816                0x2dd29d3215f2c9d2,
817                fidl::encoding::DynamicFlags::empty(),
818                ___deadline,
819            )?;
820        Ok(_response.map(|x| x.value))
821    }
822
823    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
824    pub fn r#set_out_of_band_inline(
825        &self,
826        mut value: bool,
827        ___deadline: zx::MonotonicInstant,
828    ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
829        let _response =
830            self.client
831                .send_query::<BaseSocketSetOutOfBandInlineRequest, fidl::encoding::ResultType<
832                    fidl::encoding::EmptyStruct,
833                    fidl_fuchsia_posix::Errno,
834                >>(
835                    (value,),
836                    0x3ecb49968bee439,
837                    fidl::encoding::DynamicFlags::empty(),
838                    ___deadline,
839                )?;
840        Ok(_response.map(|x| x))
841    }
842
843    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
844    pub fn r#get_out_of_band_inline(
845        &self,
846        ___deadline: zx::MonotonicInstant,
847    ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
848        let _response = self
849            .client
850            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
851                BaseSocketGetOutOfBandInlineResponse,
852                fidl_fuchsia_posix::Errno,
853            >>(
854                (), 0x348c1ab3aeca1745, fidl::encoding::DynamicFlags::empty(), ___deadline
855            )?;
856        Ok(_response.map(|x| x.value))
857    }
858
859    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
860    pub fn r#set_no_check(
861        &self,
862        mut value: bool,
863        ___deadline: zx::MonotonicInstant,
864    ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
865        let _response =
866            self.client.send_query::<BaseSocketSetNoCheckRequest, fidl::encoding::ResultType<
867                fidl::encoding::EmptyStruct,
868                fidl_fuchsia_posix::Errno,
869            >>(
870                (value,),
871                0x6bbf00c53a4c78c2,
872                fidl::encoding::DynamicFlags::empty(),
873                ___deadline,
874            )?;
875        Ok(_response.map(|x| x))
876    }
877
878    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
879    pub fn r#get_no_check(
880        &self,
881        ___deadline: zx::MonotonicInstant,
882    ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
883        let _response =
884            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
885                BaseSocketGetNoCheckResponse,
886                fidl_fuchsia_posix::Errno,
887            >>(
888                (),
889                0x2cd4249286417694,
890                fidl::encoding::DynamicFlags::empty(),
891                ___deadline,
892            )?;
893        Ok(_response.map(|x| x.value))
894    }
895
896    /// Set `SOL_SOCKET` -> `SO_LINGER`.
897    pub fn r#set_linger(
898        &self,
899        mut linger: bool,
900        mut length_secs: u32,
901        ___deadline: zx::MonotonicInstant,
902    ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
903        let _response =
904            self.client.send_query::<BaseSocketSetLingerRequest, fidl::encoding::ResultType<
905                fidl::encoding::EmptyStruct,
906                fidl_fuchsia_posix::Errno,
907            >>(
908                (linger, length_secs),
909                0x45386351246e998e,
910                fidl::encoding::DynamicFlags::empty(),
911                ___deadline,
912            )?;
913        Ok(_response.map(|x| x))
914    }
915
916    /// Get `SOL_SOCKET` -> `SO_LINGER`.
917    pub fn r#get_linger(
918        &self,
919        ___deadline: zx::MonotonicInstant,
920    ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
921        let _response =
922            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
923                BaseSocketGetLingerResponse,
924                fidl_fuchsia_posix::Errno,
925            >>(
926                (),
927                0x48eb20fc5ccb0e45,
928                fidl::encoding::DynamicFlags::empty(),
929                ___deadline,
930            )?;
931        Ok(_response.map(|x| (x.linger, x.length_secs)))
932    }
933
934    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
935    pub fn r#set_reuse_port(
936        &self,
937        mut value: bool,
938        ___deadline: zx::MonotonicInstant,
939    ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
940        let _response =
941            self.client.send_query::<BaseSocketSetReusePortRequest, fidl::encoding::ResultType<
942                fidl::encoding::EmptyStruct,
943                fidl_fuchsia_posix::Errno,
944            >>(
945                (value,),
946                0x24dd3e5cb36d9ccb,
947                fidl::encoding::DynamicFlags::empty(),
948                ___deadline,
949            )?;
950        Ok(_response.map(|x| x))
951    }
952
953    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
954    pub fn r#get_reuse_port(
955        &self,
956        ___deadline: zx::MonotonicInstant,
957    ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
958        let _response =
959            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
960                BaseSocketGetReusePortResponse,
961                fidl_fuchsia_posix::Errno,
962            >>(
963                (),
964                0x7a112c1ab54ff828,
965                fidl::encoding::DynamicFlags::empty(),
966                ___deadline,
967            )?;
968        Ok(_response.map(|x| x.value))
969    }
970
971    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
972    pub fn r#get_accept_conn(
973        &self,
974        ___deadline: zx::MonotonicInstant,
975    ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
976        let _response = self
977            .client
978            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
979                BaseSocketGetAcceptConnResponse,
980                fidl_fuchsia_posix::Errno,
981            >>(
982                (), 0x67ce6db6c2ec8966, fidl::encoding::DynamicFlags::empty(), ___deadline
983            )?;
984        Ok(_response.map(|x| x.value))
985    }
986
987    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
988    pub fn r#set_bind_to_device(
989        &self,
990        mut value: &str,
991        ___deadline: zx::MonotonicInstant,
992    ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
993        let _response =
994            self.client.send_query::<BaseSocketSetBindToDeviceRequest, fidl::encoding::ResultType<
995                fidl::encoding::EmptyStruct,
996                fidl_fuchsia_posix::Errno,
997            >>(
998                (value,),
999                0x2118b483f28aafc4,
1000                fidl::encoding::DynamicFlags::empty(),
1001                ___deadline,
1002            )?;
1003        Ok(_response.map(|x| x))
1004    }
1005
1006    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
1007    pub fn r#get_bind_to_device(
1008        &self,
1009        ___deadline: zx::MonotonicInstant,
1010    ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
1011        let _response = self
1012            .client
1013            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1014                BaseSocketGetBindToDeviceResponse,
1015                fidl_fuchsia_posix::Errno,
1016            >>(
1017                (), 0x1ab1fbf0ef7906c8, fidl::encoding::DynamicFlags::empty(), ___deadline
1018            )?;
1019        Ok(_response.map(|x| x.value))
1020    }
1021
1022    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
1023    /// If `value` is 0, this clears the bound interface.
1024    pub fn r#set_bind_to_interface_index(
1025        &self,
1026        mut value: u64,
1027        ___deadline: zx::MonotonicInstant,
1028    ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
1029        let _response =
1030            self.client
1031                .send_query::<BaseSocketSetBindToInterfaceIndexRequest, fidl::encoding::ResultType<
1032                    fidl::encoding::EmptyStruct,
1033                    fidl_fuchsia_posix::Errno,
1034                >>(
1035                    (value,),
1036                    0x6e387a0def00821,
1037                    fidl::encoding::DynamicFlags::empty(),
1038                    ___deadline,
1039                )?;
1040        Ok(_response.map(|x| x))
1041    }
1042
1043    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
1044    pub fn r#get_bind_to_interface_index(
1045        &self,
1046        ___deadline: zx::MonotonicInstant,
1047    ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
1048        let _response = self
1049            .client
1050            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1051                BaseSocketGetBindToInterfaceIndexResponse,
1052                fidl_fuchsia_posix::Errno,
1053            >>(
1054                (), 0x59c31dd3e3078295, fidl::encoding::DynamicFlags::empty(), ___deadline
1055            )?;
1056        Ok(_response.map(|x| x.value))
1057    }
1058
1059    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
1060    pub fn r#set_timestamp(
1061        &self,
1062        mut value: TimestampOption,
1063        ___deadline: zx::MonotonicInstant,
1064    ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
1065        let _response =
1066            self.client.send_query::<BaseSocketSetTimestampRequest, fidl::encoding::ResultType<
1067                fidl::encoding::EmptyStruct,
1068                fidl_fuchsia_posix::Errno,
1069            >>(
1070                (value,),
1071                0x285d6516c263d839,
1072                fidl::encoding::DynamicFlags::empty(),
1073                ___deadline,
1074            )?;
1075        Ok(_response.map(|x| x))
1076    }
1077
1078    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
1079    pub fn r#get_timestamp(
1080        &self,
1081        ___deadline: zx::MonotonicInstant,
1082    ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
1083        let _response =
1084            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1085                BaseSocketGetTimestampResponse,
1086                fidl_fuchsia_posix::Errno,
1087            >>(
1088                (),
1089                0x49f2fffbbcc2bd27,
1090                fidl::encoding::DynamicFlags::empty(),
1091                ___deadline,
1092            )?;
1093        Ok(_response.map(|x| x.value))
1094    }
1095
1096    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
1097    /// unlike the standard SO_MARK, this API has multiple mark domains and each
1098    /// mark can be set independently in each domain.
1099    pub fn r#set_mark(
1100        &self,
1101        mut domain: fidl_fuchsia_net::MarkDomain,
1102        mut mark: &OptionalUint32,
1103        ___deadline: zx::MonotonicInstant,
1104    ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
1105        let _response =
1106            self.client.send_query::<BaseSocketSetMarkRequest, fidl::encoding::ResultType<
1107                fidl::encoding::EmptyStruct,
1108                fidl_fuchsia_posix::Errno,
1109            >>(
1110                (domain, mark),
1111                0x6ead6de09f653236,
1112                fidl::encoding::DynamicFlags::empty(),
1113                ___deadline,
1114            )?;
1115        Ok(_response.map(|x| x))
1116    }
1117
1118    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
1119    /// unlike the standard SO_MARK, this API has multiple mark domains and each
1120    /// mark can be retrieved independently in each domain.
1121    pub fn r#get_mark(
1122        &self,
1123        mut domain: fidl_fuchsia_net::MarkDomain,
1124        ___deadline: zx::MonotonicInstant,
1125    ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
1126        let _response =
1127            self.client.send_query::<BaseSocketGetMarkRequest, fidl::encoding::ResultType<
1128                BaseSocketGetMarkResponse,
1129                fidl_fuchsia_posix::Errno,
1130            >>(
1131                (domain,),
1132                0x57a2752c61d93d47,
1133                fidl::encoding::DynamicFlags::empty(),
1134                ___deadline,
1135            )?;
1136        Ok(_response.map(|x| x.mark))
1137    }
1138
1139    /// Sets the local address used for the socket.
1140    pub fn r#bind(
1141        &self,
1142        mut addr: &fidl_fuchsia_net::SocketAddress,
1143        ___deadline: zx::MonotonicInstant,
1144    ) -> Result<BaseNetworkSocketBindResult, fidl::Error> {
1145        let _response =
1146            self.client.send_query::<BaseNetworkSocketBindRequest, fidl::encoding::ResultType<
1147                fidl::encoding::EmptyStruct,
1148                fidl_fuchsia_posix::Errno,
1149            >>(
1150                (addr,),
1151                0x4bc6400ae92125d,
1152                fidl::encoding::DynamicFlags::empty(),
1153                ___deadline,
1154            )?;
1155        Ok(_response.map(|x| x))
1156    }
1157
1158    /// Initiates a connection to a remote address.
1159    pub fn r#connect(
1160        &self,
1161        mut addr: &fidl_fuchsia_net::SocketAddress,
1162        ___deadline: zx::MonotonicInstant,
1163    ) -> Result<BaseNetworkSocketConnectResult, fidl::Error> {
1164        let _response =
1165            self.client.send_query::<BaseNetworkSocketConnectRequest, fidl::encoding::ResultType<
1166                fidl::encoding::EmptyStruct,
1167                fidl_fuchsia_posix::Errno,
1168            >>(
1169                (addr,),
1170                0x5f05f19bfdd38871,
1171                fidl::encoding::DynamicFlags::empty(),
1172                ___deadline,
1173            )?;
1174        Ok(_response.map(|x| x))
1175    }
1176
1177    /// Clears connection information from this socket.
1178    pub fn r#disconnect(
1179        &self,
1180        ___deadline: zx::MonotonicInstant,
1181    ) -> Result<BaseNetworkSocketDisconnectResult, fidl::Error> {
1182        let _response =
1183            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1184                fidl::encoding::EmptyStruct,
1185                fidl_fuchsia_posix::Errno,
1186            >>(
1187                (),
1188                0x74e63b91f7b29b2,
1189                fidl::encoding::DynamicFlags::empty(),
1190                ___deadline,
1191            )?;
1192        Ok(_response.map(|x| x))
1193    }
1194
1195    /// Retrieves the local socket address.
1196    pub fn r#get_sock_name(
1197        &self,
1198        ___deadline: zx::MonotonicInstant,
1199    ) -> Result<BaseNetworkSocketGetSockNameResult, fidl::Error> {
1200        let _response = self
1201            .client
1202            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1203                BaseNetworkSocketGetSockNameResponse,
1204                fidl_fuchsia_posix::Errno,
1205            >>(
1206                (), 0x475f23f84a1a4f85, fidl::encoding::DynamicFlags::empty(), ___deadline
1207            )?;
1208        Ok(_response.map(|x| x.addr))
1209    }
1210
1211    /// Retrieves the remote socket address.
1212    pub fn r#get_peer_name(
1213        &self,
1214        ___deadline: zx::MonotonicInstant,
1215    ) -> Result<BaseNetworkSocketGetPeerNameResult, fidl::Error> {
1216        let _response = self
1217            .client
1218            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1219                BaseNetworkSocketGetPeerNameResponse,
1220                fidl_fuchsia_posix::Errno,
1221            >>(
1222                (), 0x1ffecf4bd5b6432e, fidl::encoding::DynamicFlags::empty(), ___deadline
1223            )?;
1224        Ok(_response.map(|x| x.addr))
1225    }
1226
1227    /// Shuts down part of the socket.
1228    pub fn r#shutdown(
1229        &self,
1230        mut mode: ShutdownMode,
1231        ___deadline: zx::MonotonicInstant,
1232    ) -> Result<BaseNetworkSocketShutdownResult, fidl::Error> {
1233        let _response =
1234            self.client.send_query::<BaseNetworkSocketShutdownRequest, fidl::encoding::ResultType<
1235                fidl::encoding::EmptyStruct,
1236                fidl_fuchsia_posix::Errno,
1237            >>(
1238                (mode,),
1239                0x247f38b6db68c336,
1240                fidl::encoding::DynamicFlags::empty(),
1241                ___deadline,
1242            )?;
1243        Ok(_response.map(|x| x))
1244    }
1245
1246    /// Set `SOL_IP` -> `IP_TOS`.
1247    pub fn r#set_ip_type_of_service(
1248        &self,
1249        mut value: u8,
1250        ___deadline: zx::MonotonicInstant,
1251    ) -> Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error> {
1252        let _response = self.client.send_query::<
1253            BaseNetworkSocketSetIpTypeOfServiceRequest,
1254            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1255        >(
1256            (value,),
1257            0x995c600475b6d46,
1258            fidl::encoding::DynamicFlags::empty(),
1259            ___deadline,
1260        )?;
1261        Ok(_response.map(|x| x))
1262    }
1263
1264    /// Get `SOL_IP` -> `IP_TOS`.
1265    pub fn r#get_ip_type_of_service(
1266        &self,
1267        ___deadline: zx::MonotonicInstant,
1268    ) -> Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error> {
1269        let _response = self
1270            .client
1271            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1272                BaseNetworkSocketGetIpTypeOfServiceResponse,
1273                fidl_fuchsia_posix::Errno,
1274            >>(
1275                (), 0x3814a04259f75fcb, fidl::encoding::DynamicFlags::empty(), ___deadline
1276            )?;
1277        Ok(_response.map(|x| x.value))
1278    }
1279
1280    /// Set `SOL_IP` -> `IP_TTL`.
1281    pub fn r#set_ip_ttl(
1282        &self,
1283        mut value: &OptionalUint8,
1284        ___deadline: zx::MonotonicInstant,
1285    ) -> Result<BaseNetworkSocketSetIpTtlResult, fidl::Error> {
1286        let _response =
1287            self.client.send_query::<BaseNetworkSocketSetIpTtlRequest, fidl::encoding::ResultType<
1288                fidl::encoding::EmptyStruct,
1289                fidl_fuchsia_posix::Errno,
1290            >>(
1291                (value,),
1292                0x29e2424b433ae1ef,
1293                fidl::encoding::DynamicFlags::empty(),
1294                ___deadline,
1295            )?;
1296        Ok(_response.map(|x| x))
1297    }
1298
1299    /// Get `SOL_IP` -> `IP_TTL`.
1300    pub fn r#get_ip_ttl(
1301        &self,
1302        ___deadline: zx::MonotonicInstant,
1303    ) -> Result<BaseNetworkSocketGetIpTtlResult, fidl::Error> {
1304        let _response = self
1305            .client
1306            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1307                BaseNetworkSocketGetIpTtlResponse,
1308                fidl_fuchsia_posix::Errno,
1309            >>(
1310                (), 0x47e47fa1f24da471, fidl::encoding::DynamicFlags::empty(), ___deadline
1311            )?;
1312        Ok(_response.map(|x| x.value))
1313    }
1314
1315    /// Set `SOL_IP` -> `IP_PKTINFO`.
1316    pub fn r#set_ip_packet_info(
1317        &self,
1318        mut value: bool,
1319        ___deadline: zx::MonotonicInstant,
1320    ) -> Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error> {
1321        let _response =
1322            self.client
1323                .send_query::<BaseNetworkSocketSetIpPacketInfoRequest, fidl::encoding::ResultType<
1324                    fidl::encoding::EmptyStruct,
1325                    fidl_fuchsia_posix::Errno,
1326                >>(
1327                    (value,),
1328                    0x392d16bee20c0e16,
1329                    fidl::encoding::DynamicFlags::empty(),
1330                    ___deadline,
1331                )?;
1332        Ok(_response.map(|x| x))
1333    }
1334
1335    /// Get `SOL_IP` -> `IP_PKTINFO`.
1336    pub fn r#get_ip_packet_info(
1337        &self,
1338        ___deadline: zx::MonotonicInstant,
1339    ) -> Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error> {
1340        let _response = self
1341            .client
1342            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1343                BaseNetworkSocketGetIpPacketInfoResponse,
1344                fidl_fuchsia_posix::Errno,
1345            >>(
1346                (), 0x54b505f242280740, fidl::encoding::DynamicFlags::empty(), ___deadline
1347            )?;
1348        Ok(_response.map(|x| x.value))
1349    }
1350
1351    /// Set `SOL_IP` -> `IP_RECVTOS`.
1352    pub fn r#set_ip_receive_type_of_service(
1353        &self,
1354        mut value: bool,
1355        ___deadline: zx::MonotonicInstant,
1356    ) -> Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error> {
1357        let _response = self.client.send_query::<
1358            BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
1359            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1360        >(
1361            (value,),
1362            0x6c4f6714995f84ef,
1363            fidl::encoding::DynamicFlags::empty(),
1364            ___deadline,
1365        )?;
1366        Ok(_response.map(|x| x))
1367    }
1368
1369    /// Get `SOL_IP` -> `IP_RECVTOS`.
1370    pub fn r#get_ip_receive_type_of_service(
1371        &self,
1372        ___deadline: zx::MonotonicInstant,
1373    ) -> Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error> {
1374        let _response = self
1375            .client
1376            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1377                BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
1378                fidl_fuchsia_posix::Errno,
1379            >>(
1380                (), 0x4158ba7dc2795960, fidl::encoding::DynamicFlags::empty(), ___deadline
1381            )?;
1382        Ok(_response.map(|x| x.value))
1383    }
1384
1385    /// Set `SOL_IP` -> `IP_RECVTTL`.
1386    pub fn r#set_ip_receive_ttl(
1387        &self,
1388        mut value: bool,
1389        ___deadline: zx::MonotonicInstant,
1390    ) -> Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error> {
1391        let _response =
1392            self.client
1393                .send_query::<BaseNetworkSocketSetIpReceiveTtlRequest, fidl::encoding::ResultType<
1394                    fidl::encoding::EmptyStruct,
1395                    fidl_fuchsia_posix::Errno,
1396                >>(
1397                    (value,),
1398                    0x46f15be0ce0ab82b,
1399                    fidl::encoding::DynamicFlags::empty(),
1400                    ___deadline,
1401                )?;
1402        Ok(_response.map(|x| x))
1403    }
1404
1405    /// Get `SOL_IP` -> `IP_RECVTTL`.
1406    pub fn r#get_ip_receive_ttl(
1407        &self,
1408        ___deadline: zx::MonotonicInstant,
1409    ) -> Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error> {
1410        let _response = self
1411            .client
1412            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1413                BaseNetworkSocketGetIpReceiveTtlResponse,
1414                fidl_fuchsia_posix::Errno,
1415            >>(
1416                (), 0x678ddd5a5dfa2eb5, fidl::encoding::DynamicFlags::empty(), ___deadline
1417            )?;
1418        Ok(_response.map(|x| x.value))
1419    }
1420
1421    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
1422    pub fn r#set_ip_multicast_interface(
1423        &self,
1424        mut iface: u64,
1425        mut address: &fidl_fuchsia_net::Ipv4Address,
1426        ___deadline: zx::MonotonicInstant,
1427    ) -> Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error> {
1428        let _response = self.client.send_query::<
1429            BaseNetworkSocketSetIpMulticastInterfaceRequest,
1430            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1431        >(
1432            (iface, address,),
1433            0x752fbfa9b12befe,
1434            fidl::encoding::DynamicFlags::empty(),
1435            ___deadline,
1436        )?;
1437        Ok(_response.map(|x| x))
1438    }
1439
1440    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
1441    pub fn r#get_ip_multicast_interface(
1442        &self,
1443        ___deadline: zx::MonotonicInstant,
1444    ) -> Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error> {
1445        let _response = self
1446            .client
1447            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1448                BaseNetworkSocketGetIpMulticastInterfaceResponse,
1449                fidl_fuchsia_posix::Errno,
1450            >>(
1451                (), 0x320bd14c4df046c4, fidl::encoding::DynamicFlags::empty(), ___deadline
1452            )?;
1453        Ok(_response.map(|x| x.value))
1454    }
1455
1456    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
1457    pub fn r#set_ip_multicast_ttl(
1458        &self,
1459        mut value: &OptionalUint8,
1460        ___deadline: zx::MonotonicInstant,
1461    ) -> Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error> {
1462        let _response =
1463            self.client
1464                .send_query::<BaseNetworkSocketSetIpMulticastTtlRequest, fidl::encoding::ResultType<
1465                    fidl::encoding::EmptyStruct,
1466                    fidl_fuchsia_posix::Errno,
1467                >>(
1468                    (value,),
1469                    0x63134d53772916a1,
1470                    fidl::encoding::DynamicFlags::empty(),
1471                    ___deadline,
1472                )?;
1473        Ok(_response.map(|x| x))
1474    }
1475
1476    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
1477    pub fn r#get_ip_multicast_ttl(
1478        &self,
1479        ___deadline: zx::MonotonicInstant,
1480    ) -> Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error> {
1481        let _response = self
1482            .client
1483            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1484                BaseNetworkSocketGetIpMulticastTtlResponse,
1485                fidl_fuchsia_posix::Errno,
1486            >>(
1487                (), 0x4665cd378f39e1a, fidl::encoding::DynamicFlags::empty(), ___deadline
1488            )?;
1489        Ok(_response.map(|x| x.value))
1490    }
1491
1492    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
1493    pub fn r#set_ip_multicast_loopback(
1494        &self,
1495        mut value: bool,
1496        ___deadline: zx::MonotonicInstant,
1497    ) -> Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error> {
1498        let _response = self.client.send_query::<
1499            BaseNetworkSocketSetIpMulticastLoopbackRequest,
1500            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1501        >(
1502            (value,),
1503            0x20c55c11f00943ea,
1504            fidl::encoding::DynamicFlags::empty(),
1505            ___deadline,
1506        )?;
1507        Ok(_response.map(|x| x))
1508    }
1509
1510    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
1511    pub fn r#get_ip_multicast_loopback(
1512        &self,
1513        ___deadline: zx::MonotonicInstant,
1514    ) -> Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error> {
1515        let _response = self
1516            .client
1517            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1518                BaseNetworkSocketGetIpMulticastLoopbackResponse,
1519                fidl_fuchsia_posix::Errno,
1520            >>(
1521                (), 0x3b6b26ff558298f2, fidl::encoding::DynamicFlags::empty(), ___deadline
1522            )?;
1523        Ok(_response.map(|x| x.value))
1524    }
1525
1526    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
1527    pub fn r#add_ip_membership(
1528        &self,
1529        mut membership: &IpMulticastMembership,
1530        ___deadline: zx::MonotonicInstant,
1531    ) -> Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error> {
1532        let _response =
1533            self.client
1534                .send_query::<BaseNetworkSocketAddIpMembershipRequest, fidl::encoding::ResultType<
1535                    fidl::encoding::EmptyStruct,
1536                    fidl_fuchsia_posix::Errno,
1537                >>(
1538                    (membership,),
1539                    0x76bc7df115a3b4d0,
1540                    fidl::encoding::DynamicFlags::empty(),
1541                    ___deadline,
1542                )?;
1543        Ok(_response.map(|x| x))
1544    }
1545
1546    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
1547    pub fn r#drop_ip_membership(
1548        &self,
1549        mut membership: &IpMulticastMembership,
1550        ___deadline: zx::MonotonicInstant,
1551    ) -> Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error> {
1552        let _response =
1553            self.client
1554                .send_query::<BaseNetworkSocketDropIpMembershipRequest, fidl::encoding::ResultType<
1555                    fidl::encoding::EmptyStruct,
1556                    fidl_fuchsia_posix::Errno,
1557                >>(
1558                    (membership,),
1559                    0x2888f3099188d03,
1560                    fidl::encoding::DynamicFlags::empty(),
1561                    ___deadline,
1562                )?;
1563        Ok(_response.map(|x| x))
1564    }
1565
1566    /// Set `SOL_IP` -> `IP_TRANSPARENT`
1567    pub fn r#set_ip_transparent(
1568        &self,
1569        mut value: bool,
1570        ___deadline: zx::MonotonicInstant,
1571    ) -> Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error> {
1572        let _response =
1573            self.client
1574                .send_query::<BaseNetworkSocketSetIpTransparentRequest, fidl::encoding::ResultType<
1575                    fidl::encoding::EmptyStruct,
1576                    fidl_fuchsia_posix::Errno,
1577                >>(
1578                    (value,),
1579                    0x1ae532b0c066e3a0,
1580                    fidl::encoding::DynamicFlags::empty(),
1581                    ___deadline,
1582                )?;
1583        Ok(_response.map(|x| x))
1584    }
1585
1586    /// Get `SOL_IP` -> `IP_TRANSPARENT`
1587    pub fn r#get_ip_transparent(
1588        &self,
1589        ___deadline: zx::MonotonicInstant,
1590    ) -> Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error> {
1591        let _response = self
1592            .client
1593            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1594                BaseNetworkSocketGetIpTransparentResponse,
1595                fidl_fuchsia_posix::Errno,
1596            >>(
1597                (), 0x51d43695962ebfb5, fidl::encoding::DynamicFlags::empty(), ___deadline
1598            )?;
1599        Ok(_response.map(|x| x.value))
1600    }
1601
1602    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
1603    pub fn r#set_ip_receive_original_destination_address(
1604        &self,
1605        mut value: bool,
1606        ___deadline: zx::MonotonicInstant,
1607    ) -> Result<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error> {
1608        let _response = self.client.send_query::<
1609            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
1610            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1611        >(
1612            (value,),
1613            0x4722b4ce52f7840,
1614            fidl::encoding::DynamicFlags::empty(),
1615            ___deadline,
1616        )?;
1617        Ok(_response.map(|x| x))
1618    }
1619
1620    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
1621    pub fn r#get_ip_receive_original_destination_address(
1622        &self,
1623        ___deadline: zx::MonotonicInstant,
1624    ) -> Result<BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error> {
1625        let _response = self
1626            .client
1627            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1628                BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
1629                fidl_fuchsia_posix::Errno,
1630            >>(
1631                (), 0x2a0e7dc5d6bfdfe9, fidl::encoding::DynamicFlags::empty(), ___deadline
1632            )?;
1633        Ok(_response.map(|x| x.value))
1634    }
1635
1636    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
1637    pub fn r#add_ipv6_membership(
1638        &self,
1639        mut membership: &Ipv6MulticastMembership,
1640        ___deadline: zx::MonotonicInstant,
1641    ) -> Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error> {
1642        let _response =
1643            self.client
1644                .send_query::<BaseNetworkSocketAddIpv6MembershipRequest, fidl::encoding::ResultType<
1645                    fidl::encoding::EmptyStruct,
1646                    fidl_fuchsia_posix::Errno,
1647                >>(
1648                    (membership,),
1649                    0x7c94727acb4ea4b3,
1650                    fidl::encoding::DynamicFlags::empty(),
1651                    ___deadline,
1652                )?;
1653        Ok(_response.map(|x| x))
1654    }
1655
1656    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
1657    pub fn r#drop_ipv6_membership(
1658        &self,
1659        mut membership: &Ipv6MulticastMembership,
1660        ___deadline: zx::MonotonicInstant,
1661    ) -> Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error> {
1662        let _response = self.client.send_query::<
1663            BaseNetworkSocketDropIpv6MembershipRequest,
1664            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1665        >(
1666            (membership,),
1667            0x42104c70ccaba304,
1668            fidl::encoding::DynamicFlags::empty(),
1669            ___deadline,
1670        )?;
1671        Ok(_response.map(|x| x))
1672    }
1673
1674    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
1675    pub fn r#set_ipv6_multicast_interface(
1676        &self,
1677        mut value: u64,
1678        ___deadline: zx::MonotonicInstant,
1679    ) -> Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error> {
1680        let _response = self.client.send_query::<
1681            BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
1682            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1683        >(
1684            (value,),
1685            0x135f76db3774ab3b,
1686            fidl::encoding::DynamicFlags::empty(),
1687            ___deadline,
1688        )?;
1689        Ok(_response.map(|x| x))
1690    }
1691
1692    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
1693    pub fn r#get_ipv6_multicast_interface(
1694        &self,
1695        ___deadline: zx::MonotonicInstant,
1696    ) -> Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error> {
1697        let _response = self
1698            .client
1699            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1700                BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
1701                fidl_fuchsia_posix::Errno,
1702            >>(
1703                (), 0x1f26fcdd348f1882, fidl::encoding::DynamicFlags::empty(), ___deadline
1704            )?;
1705        Ok(_response.map(|x| x.value))
1706    }
1707
1708    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
1709    pub fn r#set_ipv6_unicast_hops(
1710        &self,
1711        mut value: &OptionalUint8,
1712        ___deadline: zx::MonotonicInstant,
1713    ) -> Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error> {
1714        let _response = self.client.send_query::<
1715            BaseNetworkSocketSetIpv6UnicastHopsRequest,
1716            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1717        >(
1718            (value,),
1719            0x157d51e98f462859,
1720            fidl::encoding::DynamicFlags::empty(),
1721            ___deadline,
1722        )?;
1723        Ok(_response.map(|x| x))
1724    }
1725
1726    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
1727    pub fn r#get_ipv6_unicast_hops(
1728        &self,
1729        ___deadline: zx::MonotonicInstant,
1730    ) -> Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error> {
1731        let _response = self
1732            .client
1733            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1734                BaseNetworkSocketGetIpv6UnicastHopsResponse,
1735                fidl_fuchsia_posix::Errno,
1736            >>(
1737                (), 0x21f4641cad8bd8d2, fidl::encoding::DynamicFlags::empty(), ___deadline
1738            )?;
1739        Ok(_response.map(|x| x.value))
1740    }
1741
1742    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
1743    pub fn r#set_ipv6_receive_hop_limit(
1744        &self,
1745        mut value: bool,
1746        ___deadline: zx::MonotonicInstant,
1747    ) -> Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error> {
1748        let _response = self.client.send_query::<
1749            BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
1750            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1751        >(
1752            (value,),
1753            0x5c24808ed2e84a1e,
1754            fidl::encoding::DynamicFlags::empty(),
1755            ___deadline,
1756        )?;
1757        Ok(_response.map(|x| x))
1758    }
1759
1760    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
1761    pub fn r#get_ipv6_receive_hop_limit(
1762        &self,
1763        ___deadline: zx::MonotonicInstant,
1764    ) -> Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error> {
1765        let _response = self
1766            .client
1767            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1768                BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
1769                fidl_fuchsia_posix::Errno,
1770            >>(
1771                (), 0x341e06689885b4c0, fidl::encoding::DynamicFlags::empty(), ___deadline
1772            )?;
1773        Ok(_response.map(|x| x.value))
1774    }
1775
1776    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
1777    pub fn r#set_ipv6_multicast_hops(
1778        &self,
1779        mut value: &OptionalUint8,
1780        ___deadline: zx::MonotonicInstant,
1781    ) -> Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error> {
1782        let _response = self.client.send_query::<
1783            BaseNetworkSocketSetIpv6MulticastHopsRequest,
1784            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1785        >(
1786            (value,),
1787            0x25b9cd4d181f82c1,
1788            fidl::encoding::DynamicFlags::empty(),
1789            ___deadline,
1790        )?;
1791        Ok(_response.map(|x| x))
1792    }
1793
1794    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
1795    pub fn r#get_ipv6_multicast_hops(
1796        &self,
1797        ___deadline: zx::MonotonicInstant,
1798    ) -> Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error> {
1799        let _response = self
1800            .client
1801            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1802                BaseNetworkSocketGetIpv6MulticastHopsResponse,
1803                fidl_fuchsia_posix::Errno,
1804            >>(
1805                (), 0x52916948a365012a, fidl::encoding::DynamicFlags::empty(), ___deadline
1806            )?;
1807        Ok(_response.map(|x| x.value))
1808    }
1809
1810    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
1811    pub fn r#set_ipv6_multicast_loopback(
1812        &self,
1813        mut value: bool,
1814        ___deadline: zx::MonotonicInstant,
1815    ) -> Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error> {
1816        let _response = self.client.send_query::<
1817            BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
1818            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1819        >(
1820            (value,),
1821            0x55701c409ff41b40,
1822            fidl::encoding::DynamicFlags::empty(),
1823            ___deadline,
1824        )?;
1825        Ok(_response.map(|x| x))
1826    }
1827
1828    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
1829    pub fn r#get_ipv6_multicast_loopback(
1830        &self,
1831        ___deadline: zx::MonotonicInstant,
1832    ) -> Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error> {
1833        let _response = self
1834            .client
1835            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1836                BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
1837                fidl_fuchsia_posix::Errno,
1838            >>(
1839                (), 0x4415b701fde319c3, fidl::encoding::DynamicFlags::empty(), ___deadline
1840            )?;
1841        Ok(_response.map(|x| x.value))
1842    }
1843
1844    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
1845    pub fn r#set_ipv6_only(
1846        &self,
1847        mut value: bool,
1848        ___deadline: zx::MonotonicInstant,
1849    ) -> Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
1850        let _response =
1851            self.client
1852                .send_query::<BaseNetworkSocketSetIpv6OnlyRequest, fidl::encoding::ResultType<
1853                    fidl::encoding::EmptyStruct,
1854                    fidl_fuchsia_posix::Errno,
1855                >>(
1856                    (value,),
1857                    0x4873f1364758cbba,
1858                    fidl::encoding::DynamicFlags::empty(),
1859                    ___deadline,
1860                )?;
1861        Ok(_response.map(|x| x))
1862    }
1863
1864    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
1865    pub fn r#get_ipv6_only(
1866        &self,
1867        ___deadline: zx::MonotonicInstant,
1868    ) -> Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
1869        let _response = self
1870            .client
1871            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1872                BaseNetworkSocketGetIpv6OnlyResponse,
1873                fidl_fuchsia_posix::Errno,
1874            >>(
1875                (), 0x4aa3340a1a26b89c, fidl::encoding::DynamicFlags::empty(), ___deadline
1876            )?;
1877        Ok(_response.map(|x| x.value))
1878    }
1879
1880    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
1881    pub fn r#set_ipv6_receive_traffic_class(
1882        &self,
1883        mut value: bool,
1884        ___deadline: zx::MonotonicInstant,
1885    ) -> Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error> {
1886        let _response = self.client.send_query::<
1887            BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
1888            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1889        >(
1890            (value,),
1891            0x58f07c8788d099a0,
1892            fidl::encoding::DynamicFlags::empty(),
1893            ___deadline,
1894        )?;
1895        Ok(_response.map(|x| x))
1896    }
1897
1898    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
1899    pub fn r#get_ipv6_receive_traffic_class(
1900        &self,
1901        ___deadline: zx::MonotonicInstant,
1902    ) -> Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error> {
1903        let _response = self
1904            .client
1905            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1906                BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
1907                fidl_fuchsia_posix::Errno,
1908            >>(
1909                (), 0x2e334df1da553ffa, fidl::encoding::DynamicFlags::empty(), ___deadline
1910            )?;
1911        Ok(_response.map(|x| x.value))
1912    }
1913
1914    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
1915    pub fn r#set_ipv6_traffic_class(
1916        &self,
1917        mut value: &OptionalUint8,
1918        ___deadline: zx::MonotonicInstant,
1919    ) -> Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error> {
1920        let _response = self.client.send_query::<
1921            BaseNetworkSocketSetIpv6TrafficClassRequest,
1922            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1923        >(
1924            (value,),
1925            0x6af077800c5a0b4f,
1926            fidl::encoding::DynamicFlags::empty(),
1927            ___deadline,
1928        )?;
1929        Ok(_response.map(|x| x))
1930    }
1931
1932    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
1933    pub fn r#get_ipv6_traffic_class(
1934        &self,
1935        ___deadline: zx::MonotonicInstant,
1936    ) -> Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error> {
1937        let _response = self
1938            .client
1939            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1940                BaseNetworkSocketGetIpv6TrafficClassResponse,
1941                fidl_fuchsia_posix::Errno,
1942            >>(
1943                (), 0x6baf6eed8fc2f04, fidl::encoding::DynamicFlags::empty(), ___deadline
1944            )?;
1945        Ok(_response.map(|x| x.value))
1946    }
1947
1948    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
1949    pub fn r#set_ipv6_receive_packet_info(
1950        &self,
1951        mut value: bool,
1952        ___deadline: zx::MonotonicInstant,
1953    ) -> Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error> {
1954        let _response = self.client.send_query::<
1955            BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
1956            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
1957        >(
1958            (value,),
1959            0x19259775b1a92768,
1960            fidl::encoding::DynamicFlags::empty(),
1961            ___deadline,
1962        )?;
1963        Ok(_response.map(|x| x))
1964    }
1965
1966    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
1967    pub fn r#get_ipv6_receive_packet_info(
1968        &self,
1969        ___deadline: zx::MonotonicInstant,
1970    ) -> Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error> {
1971        let _response = self
1972            .client
1973            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1974                BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
1975                fidl_fuchsia_posix::Errno,
1976            >>(
1977                (), 0x7acd4a2775baec75, fidl::encoding::DynamicFlags::empty(), ___deadline
1978            )?;
1979        Ok(_response.map(|x| x.value))
1980    }
1981
1982    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
1983    pub fn r#get_original_destination(
1984        &self,
1985        ___deadline: zx::MonotonicInstant,
1986    ) -> Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error> {
1987        let _response = self
1988            .client
1989            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
1990                BaseNetworkSocketGetOriginalDestinationResponse,
1991                fidl_fuchsia_posix::Errno,
1992            >>(
1993                (), 0x38bf28f0dafdbac0, fidl::encoding::DynamicFlags::empty(), ___deadline
1994            )?;
1995        Ok(_response.map(|x| x.value))
1996    }
1997
1998    /// Retrieves creation information from the socket.
1999    ///
2000    /// - response `domain` the socket's associated domain.
2001    /// - response `proto` the socket's associated protocol.
2002    pub fn r#get_info(
2003        &self,
2004        ___deadline: zx::MonotonicInstant,
2005    ) -> Result<BaseDatagramSocketGetInfoResult, fidl::Error> {
2006        let _response = self
2007            .client
2008            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
2009                BaseDatagramSocketGetInfoResponse,
2010                fidl_fuchsia_posix::Errno,
2011            >>(
2012                (), 0x48aa0a1f6a32d2ed, fidl::encoding::DynamicFlags::empty(), ___deadline
2013            )?;
2014        Ok(_response.map(|x| (x.domain, x.proto)))
2015    }
2016}
2017
2018#[cfg(target_os = "fuchsia")]
2019impl From<BaseDatagramSocketSynchronousProxy> for zx::Handle {
2020    fn from(value: BaseDatagramSocketSynchronousProxy) -> Self {
2021        value.into_channel().into()
2022    }
2023}
2024
2025#[cfg(target_os = "fuchsia")]
2026impl From<fidl::Channel> for BaseDatagramSocketSynchronousProxy {
2027    fn from(value: fidl::Channel) -> Self {
2028        Self::new(value)
2029    }
2030}
2031
2032#[derive(Debug, Clone)]
2033pub struct BaseDatagramSocketProxy {
2034    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
2035}
2036
2037impl fidl::endpoints::Proxy for BaseDatagramSocketProxy {
2038    type Protocol = BaseDatagramSocketMarker;
2039
2040    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
2041        Self::new(inner)
2042    }
2043
2044    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
2045        self.client.into_channel().map_err(|client| Self { client })
2046    }
2047
2048    fn as_channel(&self) -> &::fidl::AsyncChannel {
2049        self.client.as_channel()
2050    }
2051}
2052
2053impl BaseDatagramSocketProxy {
2054    /// Create a new Proxy for fuchsia.posix.socket/BaseDatagramSocket.
2055    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
2056        let protocol_name =
2057            <BaseDatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
2058        Self { client: fidl::client::Client::new(channel, protocol_name) }
2059    }
2060
2061    /// Get a Stream of events from the remote end of the protocol.
2062    ///
2063    /// # Panics
2064    ///
2065    /// Panics if the event stream was already taken.
2066    pub fn take_event_stream(&self) -> BaseDatagramSocketEventStream {
2067        BaseDatagramSocketEventStream { event_receiver: self.client.take_event_receiver() }
2068    }
2069
2070    pub fn r#clone(
2071        &self,
2072        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
2073    ) -> Result<(), fidl::Error> {
2074        BaseDatagramSocketProxyInterface::r#clone(self, request)
2075    }
2076
2077    /// Terminates the connection.
2078    ///
2079    /// After calling `Close`, the client must not send any other requests.
2080    ///
2081    /// Servers, after sending the status response, should close the connection
2082    /// regardless of status and without sending an epitaph.
2083    ///
2084    /// Closing the client end of the channel should be semantically equivalent
2085    /// to calling `Close` without knowing when the close has completed or its
2086    /// status.
2087    pub fn r#close(
2088        &self,
2089    ) -> fidl::client::QueryResponseFut<
2090        fidl_fuchsia_unknown::CloseableCloseResult,
2091        fidl::encoding::DefaultFuchsiaResourceDialect,
2092    > {
2093        BaseDatagramSocketProxyInterface::r#close(self)
2094    }
2095
2096    pub fn r#query(
2097        &self,
2098    ) -> fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>
2099    {
2100        BaseDatagramSocketProxyInterface::r#query(self)
2101    }
2102
2103    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
2104    pub fn r#set_reuse_address(
2105        &self,
2106        mut value: bool,
2107    ) -> fidl::client::QueryResponseFut<
2108        BaseSocketSetReuseAddressResult,
2109        fidl::encoding::DefaultFuchsiaResourceDialect,
2110    > {
2111        BaseDatagramSocketProxyInterface::r#set_reuse_address(self, value)
2112    }
2113
2114    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
2115    pub fn r#get_reuse_address(
2116        &self,
2117    ) -> fidl::client::QueryResponseFut<
2118        BaseSocketGetReuseAddressResult,
2119        fidl::encoding::DefaultFuchsiaResourceDialect,
2120    > {
2121        BaseDatagramSocketProxyInterface::r#get_reuse_address(self)
2122    }
2123
2124    /// Get `SOL_SOCKET` -> `SO_ERROR`.
2125    /// Returns the last error if there is an error set on the socket.
2126    pub fn r#get_error(
2127        &self,
2128    ) -> fidl::client::QueryResponseFut<
2129        BaseSocketGetErrorResult,
2130        fidl::encoding::DefaultFuchsiaResourceDialect,
2131    > {
2132        BaseDatagramSocketProxyInterface::r#get_error(self)
2133    }
2134
2135    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
2136    pub fn r#set_broadcast(
2137        &self,
2138        mut value: bool,
2139    ) -> fidl::client::QueryResponseFut<
2140        BaseSocketSetBroadcastResult,
2141        fidl::encoding::DefaultFuchsiaResourceDialect,
2142    > {
2143        BaseDatagramSocketProxyInterface::r#set_broadcast(self, value)
2144    }
2145
2146    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
2147    pub fn r#get_broadcast(
2148        &self,
2149    ) -> fidl::client::QueryResponseFut<
2150        BaseSocketGetBroadcastResult,
2151        fidl::encoding::DefaultFuchsiaResourceDialect,
2152    > {
2153        BaseDatagramSocketProxyInterface::r#get_broadcast(self)
2154    }
2155
2156    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
2157    pub fn r#set_send_buffer(
2158        &self,
2159        mut value_bytes: u64,
2160    ) -> fidl::client::QueryResponseFut<
2161        BaseSocketSetSendBufferResult,
2162        fidl::encoding::DefaultFuchsiaResourceDialect,
2163    > {
2164        BaseDatagramSocketProxyInterface::r#set_send_buffer(self, value_bytes)
2165    }
2166
2167    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
2168    pub fn r#get_send_buffer(
2169        &self,
2170    ) -> fidl::client::QueryResponseFut<
2171        BaseSocketGetSendBufferResult,
2172        fidl::encoding::DefaultFuchsiaResourceDialect,
2173    > {
2174        BaseDatagramSocketProxyInterface::r#get_send_buffer(self)
2175    }
2176
2177    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
2178    pub fn r#set_receive_buffer(
2179        &self,
2180        mut value_bytes: u64,
2181    ) -> fidl::client::QueryResponseFut<
2182        BaseSocketSetReceiveBufferResult,
2183        fidl::encoding::DefaultFuchsiaResourceDialect,
2184    > {
2185        BaseDatagramSocketProxyInterface::r#set_receive_buffer(self, value_bytes)
2186    }
2187
2188    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
2189    pub fn r#get_receive_buffer(
2190        &self,
2191    ) -> fidl::client::QueryResponseFut<
2192        BaseSocketGetReceiveBufferResult,
2193        fidl::encoding::DefaultFuchsiaResourceDialect,
2194    > {
2195        BaseDatagramSocketProxyInterface::r#get_receive_buffer(self)
2196    }
2197
2198    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
2199    pub fn r#set_keep_alive(
2200        &self,
2201        mut value: bool,
2202    ) -> fidl::client::QueryResponseFut<
2203        BaseSocketSetKeepAliveResult,
2204        fidl::encoding::DefaultFuchsiaResourceDialect,
2205    > {
2206        BaseDatagramSocketProxyInterface::r#set_keep_alive(self, value)
2207    }
2208
2209    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
2210    pub fn r#get_keep_alive(
2211        &self,
2212    ) -> fidl::client::QueryResponseFut<
2213        BaseSocketGetKeepAliveResult,
2214        fidl::encoding::DefaultFuchsiaResourceDialect,
2215    > {
2216        BaseDatagramSocketProxyInterface::r#get_keep_alive(self)
2217    }
2218
2219    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
2220    pub fn r#set_out_of_band_inline(
2221        &self,
2222        mut value: bool,
2223    ) -> fidl::client::QueryResponseFut<
2224        BaseSocketSetOutOfBandInlineResult,
2225        fidl::encoding::DefaultFuchsiaResourceDialect,
2226    > {
2227        BaseDatagramSocketProxyInterface::r#set_out_of_band_inline(self, value)
2228    }
2229
2230    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
2231    pub fn r#get_out_of_band_inline(
2232        &self,
2233    ) -> fidl::client::QueryResponseFut<
2234        BaseSocketGetOutOfBandInlineResult,
2235        fidl::encoding::DefaultFuchsiaResourceDialect,
2236    > {
2237        BaseDatagramSocketProxyInterface::r#get_out_of_band_inline(self)
2238    }
2239
2240    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
2241    pub fn r#set_no_check(
2242        &self,
2243        mut value: bool,
2244    ) -> fidl::client::QueryResponseFut<
2245        BaseSocketSetNoCheckResult,
2246        fidl::encoding::DefaultFuchsiaResourceDialect,
2247    > {
2248        BaseDatagramSocketProxyInterface::r#set_no_check(self, value)
2249    }
2250
2251    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
2252    pub fn r#get_no_check(
2253        &self,
2254    ) -> fidl::client::QueryResponseFut<
2255        BaseSocketGetNoCheckResult,
2256        fidl::encoding::DefaultFuchsiaResourceDialect,
2257    > {
2258        BaseDatagramSocketProxyInterface::r#get_no_check(self)
2259    }
2260
2261    /// Set `SOL_SOCKET` -> `SO_LINGER`.
2262    pub fn r#set_linger(
2263        &self,
2264        mut linger: bool,
2265        mut length_secs: u32,
2266    ) -> fidl::client::QueryResponseFut<
2267        BaseSocketSetLingerResult,
2268        fidl::encoding::DefaultFuchsiaResourceDialect,
2269    > {
2270        BaseDatagramSocketProxyInterface::r#set_linger(self, linger, length_secs)
2271    }
2272
2273    /// Get `SOL_SOCKET` -> `SO_LINGER`.
2274    pub fn r#get_linger(
2275        &self,
2276    ) -> fidl::client::QueryResponseFut<
2277        BaseSocketGetLingerResult,
2278        fidl::encoding::DefaultFuchsiaResourceDialect,
2279    > {
2280        BaseDatagramSocketProxyInterface::r#get_linger(self)
2281    }
2282
2283    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
2284    pub fn r#set_reuse_port(
2285        &self,
2286        mut value: bool,
2287    ) -> fidl::client::QueryResponseFut<
2288        BaseSocketSetReusePortResult,
2289        fidl::encoding::DefaultFuchsiaResourceDialect,
2290    > {
2291        BaseDatagramSocketProxyInterface::r#set_reuse_port(self, value)
2292    }
2293
2294    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
2295    pub fn r#get_reuse_port(
2296        &self,
2297    ) -> fidl::client::QueryResponseFut<
2298        BaseSocketGetReusePortResult,
2299        fidl::encoding::DefaultFuchsiaResourceDialect,
2300    > {
2301        BaseDatagramSocketProxyInterface::r#get_reuse_port(self)
2302    }
2303
2304    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
2305    pub fn r#get_accept_conn(
2306        &self,
2307    ) -> fidl::client::QueryResponseFut<
2308        BaseSocketGetAcceptConnResult,
2309        fidl::encoding::DefaultFuchsiaResourceDialect,
2310    > {
2311        BaseDatagramSocketProxyInterface::r#get_accept_conn(self)
2312    }
2313
2314    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
2315    pub fn r#set_bind_to_device(
2316        &self,
2317        mut value: &str,
2318    ) -> fidl::client::QueryResponseFut<
2319        BaseSocketSetBindToDeviceResult,
2320        fidl::encoding::DefaultFuchsiaResourceDialect,
2321    > {
2322        BaseDatagramSocketProxyInterface::r#set_bind_to_device(self, value)
2323    }
2324
2325    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
2326    pub fn r#get_bind_to_device(
2327        &self,
2328    ) -> fidl::client::QueryResponseFut<
2329        BaseSocketGetBindToDeviceResult,
2330        fidl::encoding::DefaultFuchsiaResourceDialect,
2331    > {
2332        BaseDatagramSocketProxyInterface::r#get_bind_to_device(self)
2333    }
2334
2335    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
2336    /// If `value` is 0, this clears the bound interface.
2337    pub fn r#set_bind_to_interface_index(
2338        &self,
2339        mut value: u64,
2340    ) -> fidl::client::QueryResponseFut<
2341        BaseSocketSetBindToInterfaceIndexResult,
2342        fidl::encoding::DefaultFuchsiaResourceDialect,
2343    > {
2344        BaseDatagramSocketProxyInterface::r#set_bind_to_interface_index(self, value)
2345    }
2346
2347    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
2348    pub fn r#get_bind_to_interface_index(
2349        &self,
2350    ) -> fidl::client::QueryResponseFut<
2351        BaseSocketGetBindToInterfaceIndexResult,
2352        fidl::encoding::DefaultFuchsiaResourceDialect,
2353    > {
2354        BaseDatagramSocketProxyInterface::r#get_bind_to_interface_index(self)
2355    }
2356
2357    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
2358    pub fn r#set_timestamp(
2359        &self,
2360        mut value: TimestampOption,
2361    ) -> fidl::client::QueryResponseFut<
2362        BaseSocketSetTimestampResult,
2363        fidl::encoding::DefaultFuchsiaResourceDialect,
2364    > {
2365        BaseDatagramSocketProxyInterface::r#set_timestamp(self, value)
2366    }
2367
2368    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
2369    pub fn r#get_timestamp(
2370        &self,
2371    ) -> fidl::client::QueryResponseFut<
2372        BaseSocketGetTimestampResult,
2373        fidl::encoding::DefaultFuchsiaResourceDialect,
2374    > {
2375        BaseDatagramSocketProxyInterface::r#get_timestamp(self)
2376    }
2377
2378    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
2379    /// unlike the standard SO_MARK, this API has multiple mark domains and each
2380    /// mark can be set independently in each domain.
2381    pub fn r#set_mark(
2382        &self,
2383        mut domain: fidl_fuchsia_net::MarkDomain,
2384        mut mark: &OptionalUint32,
2385    ) -> fidl::client::QueryResponseFut<
2386        BaseSocketSetMarkResult,
2387        fidl::encoding::DefaultFuchsiaResourceDialect,
2388    > {
2389        BaseDatagramSocketProxyInterface::r#set_mark(self, domain, mark)
2390    }
2391
2392    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
2393    /// unlike the standard SO_MARK, this API has multiple mark domains and each
2394    /// mark can be retrieved independently in each domain.
2395    pub fn r#get_mark(
2396        &self,
2397        mut domain: fidl_fuchsia_net::MarkDomain,
2398    ) -> fidl::client::QueryResponseFut<
2399        BaseSocketGetMarkResult,
2400        fidl::encoding::DefaultFuchsiaResourceDialect,
2401    > {
2402        BaseDatagramSocketProxyInterface::r#get_mark(self, domain)
2403    }
2404
2405    /// Sets the local address used for the socket.
2406    pub fn r#bind(
2407        &self,
2408        mut addr: &fidl_fuchsia_net::SocketAddress,
2409    ) -> fidl::client::QueryResponseFut<
2410        BaseNetworkSocketBindResult,
2411        fidl::encoding::DefaultFuchsiaResourceDialect,
2412    > {
2413        BaseDatagramSocketProxyInterface::r#bind(self, addr)
2414    }
2415
2416    /// Initiates a connection to a remote address.
2417    pub fn r#connect(
2418        &self,
2419        mut addr: &fidl_fuchsia_net::SocketAddress,
2420    ) -> fidl::client::QueryResponseFut<
2421        BaseNetworkSocketConnectResult,
2422        fidl::encoding::DefaultFuchsiaResourceDialect,
2423    > {
2424        BaseDatagramSocketProxyInterface::r#connect(self, addr)
2425    }
2426
2427    /// Clears connection information from this socket.
2428    pub fn r#disconnect(
2429        &self,
2430    ) -> fidl::client::QueryResponseFut<
2431        BaseNetworkSocketDisconnectResult,
2432        fidl::encoding::DefaultFuchsiaResourceDialect,
2433    > {
2434        BaseDatagramSocketProxyInterface::r#disconnect(self)
2435    }
2436
2437    /// Retrieves the local socket address.
2438    pub fn r#get_sock_name(
2439        &self,
2440    ) -> fidl::client::QueryResponseFut<
2441        BaseNetworkSocketGetSockNameResult,
2442        fidl::encoding::DefaultFuchsiaResourceDialect,
2443    > {
2444        BaseDatagramSocketProxyInterface::r#get_sock_name(self)
2445    }
2446
2447    /// Retrieves the remote socket address.
2448    pub fn r#get_peer_name(
2449        &self,
2450    ) -> fidl::client::QueryResponseFut<
2451        BaseNetworkSocketGetPeerNameResult,
2452        fidl::encoding::DefaultFuchsiaResourceDialect,
2453    > {
2454        BaseDatagramSocketProxyInterface::r#get_peer_name(self)
2455    }
2456
2457    /// Shuts down part of the socket.
2458    pub fn r#shutdown(
2459        &self,
2460        mut mode: ShutdownMode,
2461    ) -> fidl::client::QueryResponseFut<
2462        BaseNetworkSocketShutdownResult,
2463        fidl::encoding::DefaultFuchsiaResourceDialect,
2464    > {
2465        BaseDatagramSocketProxyInterface::r#shutdown(self, mode)
2466    }
2467
2468    /// Set `SOL_IP` -> `IP_TOS`.
2469    pub fn r#set_ip_type_of_service(
2470        &self,
2471        mut value: u8,
2472    ) -> fidl::client::QueryResponseFut<
2473        BaseNetworkSocketSetIpTypeOfServiceResult,
2474        fidl::encoding::DefaultFuchsiaResourceDialect,
2475    > {
2476        BaseDatagramSocketProxyInterface::r#set_ip_type_of_service(self, value)
2477    }
2478
2479    /// Get `SOL_IP` -> `IP_TOS`.
2480    pub fn r#get_ip_type_of_service(
2481        &self,
2482    ) -> fidl::client::QueryResponseFut<
2483        BaseNetworkSocketGetIpTypeOfServiceResult,
2484        fidl::encoding::DefaultFuchsiaResourceDialect,
2485    > {
2486        BaseDatagramSocketProxyInterface::r#get_ip_type_of_service(self)
2487    }
2488
2489    /// Set `SOL_IP` -> `IP_TTL`.
2490    pub fn r#set_ip_ttl(
2491        &self,
2492        mut value: &OptionalUint8,
2493    ) -> fidl::client::QueryResponseFut<
2494        BaseNetworkSocketSetIpTtlResult,
2495        fidl::encoding::DefaultFuchsiaResourceDialect,
2496    > {
2497        BaseDatagramSocketProxyInterface::r#set_ip_ttl(self, value)
2498    }
2499
2500    /// Get `SOL_IP` -> `IP_TTL`.
2501    pub fn r#get_ip_ttl(
2502        &self,
2503    ) -> fidl::client::QueryResponseFut<
2504        BaseNetworkSocketGetIpTtlResult,
2505        fidl::encoding::DefaultFuchsiaResourceDialect,
2506    > {
2507        BaseDatagramSocketProxyInterface::r#get_ip_ttl(self)
2508    }
2509
2510    /// Set `SOL_IP` -> `IP_PKTINFO`.
2511    pub fn r#set_ip_packet_info(
2512        &self,
2513        mut value: bool,
2514    ) -> fidl::client::QueryResponseFut<
2515        BaseNetworkSocketSetIpPacketInfoResult,
2516        fidl::encoding::DefaultFuchsiaResourceDialect,
2517    > {
2518        BaseDatagramSocketProxyInterface::r#set_ip_packet_info(self, value)
2519    }
2520
2521    /// Get `SOL_IP` -> `IP_PKTINFO`.
2522    pub fn r#get_ip_packet_info(
2523        &self,
2524    ) -> fidl::client::QueryResponseFut<
2525        BaseNetworkSocketGetIpPacketInfoResult,
2526        fidl::encoding::DefaultFuchsiaResourceDialect,
2527    > {
2528        BaseDatagramSocketProxyInterface::r#get_ip_packet_info(self)
2529    }
2530
2531    /// Set `SOL_IP` -> `IP_RECVTOS`.
2532    pub fn r#set_ip_receive_type_of_service(
2533        &self,
2534        mut value: bool,
2535    ) -> fidl::client::QueryResponseFut<
2536        BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
2537        fidl::encoding::DefaultFuchsiaResourceDialect,
2538    > {
2539        BaseDatagramSocketProxyInterface::r#set_ip_receive_type_of_service(self, value)
2540    }
2541
2542    /// Get `SOL_IP` -> `IP_RECVTOS`.
2543    pub fn r#get_ip_receive_type_of_service(
2544        &self,
2545    ) -> fidl::client::QueryResponseFut<
2546        BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
2547        fidl::encoding::DefaultFuchsiaResourceDialect,
2548    > {
2549        BaseDatagramSocketProxyInterface::r#get_ip_receive_type_of_service(self)
2550    }
2551
2552    /// Set `SOL_IP` -> `IP_RECVTTL`.
2553    pub fn r#set_ip_receive_ttl(
2554        &self,
2555        mut value: bool,
2556    ) -> fidl::client::QueryResponseFut<
2557        BaseNetworkSocketSetIpReceiveTtlResult,
2558        fidl::encoding::DefaultFuchsiaResourceDialect,
2559    > {
2560        BaseDatagramSocketProxyInterface::r#set_ip_receive_ttl(self, value)
2561    }
2562
2563    /// Get `SOL_IP` -> `IP_RECVTTL`.
2564    pub fn r#get_ip_receive_ttl(
2565        &self,
2566    ) -> fidl::client::QueryResponseFut<
2567        BaseNetworkSocketGetIpReceiveTtlResult,
2568        fidl::encoding::DefaultFuchsiaResourceDialect,
2569    > {
2570        BaseDatagramSocketProxyInterface::r#get_ip_receive_ttl(self)
2571    }
2572
2573    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
2574    pub fn r#set_ip_multicast_interface(
2575        &self,
2576        mut iface: u64,
2577        mut address: &fidl_fuchsia_net::Ipv4Address,
2578    ) -> fidl::client::QueryResponseFut<
2579        BaseNetworkSocketSetIpMulticastInterfaceResult,
2580        fidl::encoding::DefaultFuchsiaResourceDialect,
2581    > {
2582        BaseDatagramSocketProxyInterface::r#set_ip_multicast_interface(self, iface, address)
2583    }
2584
2585    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
2586    pub fn r#get_ip_multicast_interface(
2587        &self,
2588    ) -> fidl::client::QueryResponseFut<
2589        BaseNetworkSocketGetIpMulticastInterfaceResult,
2590        fidl::encoding::DefaultFuchsiaResourceDialect,
2591    > {
2592        BaseDatagramSocketProxyInterface::r#get_ip_multicast_interface(self)
2593    }
2594
2595    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
2596    pub fn r#set_ip_multicast_ttl(
2597        &self,
2598        mut value: &OptionalUint8,
2599    ) -> fidl::client::QueryResponseFut<
2600        BaseNetworkSocketSetIpMulticastTtlResult,
2601        fidl::encoding::DefaultFuchsiaResourceDialect,
2602    > {
2603        BaseDatagramSocketProxyInterface::r#set_ip_multicast_ttl(self, value)
2604    }
2605
2606    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
2607    pub fn r#get_ip_multicast_ttl(
2608        &self,
2609    ) -> fidl::client::QueryResponseFut<
2610        BaseNetworkSocketGetIpMulticastTtlResult,
2611        fidl::encoding::DefaultFuchsiaResourceDialect,
2612    > {
2613        BaseDatagramSocketProxyInterface::r#get_ip_multicast_ttl(self)
2614    }
2615
2616    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
2617    pub fn r#set_ip_multicast_loopback(
2618        &self,
2619        mut value: bool,
2620    ) -> fidl::client::QueryResponseFut<
2621        BaseNetworkSocketSetIpMulticastLoopbackResult,
2622        fidl::encoding::DefaultFuchsiaResourceDialect,
2623    > {
2624        BaseDatagramSocketProxyInterface::r#set_ip_multicast_loopback(self, value)
2625    }
2626
2627    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
2628    pub fn r#get_ip_multicast_loopback(
2629        &self,
2630    ) -> fidl::client::QueryResponseFut<
2631        BaseNetworkSocketGetIpMulticastLoopbackResult,
2632        fidl::encoding::DefaultFuchsiaResourceDialect,
2633    > {
2634        BaseDatagramSocketProxyInterface::r#get_ip_multicast_loopback(self)
2635    }
2636
2637    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
2638    pub fn r#add_ip_membership(
2639        &self,
2640        mut membership: &IpMulticastMembership,
2641    ) -> fidl::client::QueryResponseFut<
2642        BaseNetworkSocketAddIpMembershipResult,
2643        fidl::encoding::DefaultFuchsiaResourceDialect,
2644    > {
2645        BaseDatagramSocketProxyInterface::r#add_ip_membership(self, membership)
2646    }
2647
2648    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
2649    pub fn r#drop_ip_membership(
2650        &self,
2651        mut membership: &IpMulticastMembership,
2652    ) -> fidl::client::QueryResponseFut<
2653        BaseNetworkSocketDropIpMembershipResult,
2654        fidl::encoding::DefaultFuchsiaResourceDialect,
2655    > {
2656        BaseDatagramSocketProxyInterface::r#drop_ip_membership(self, membership)
2657    }
2658
2659    /// Set `SOL_IP` -> `IP_TRANSPARENT`
2660    pub fn r#set_ip_transparent(
2661        &self,
2662        mut value: bool,
2663    ) -> fidl::client::QueryResponseFut<
2664        BaseNetworkSocketSetIpTransparentResult,
2665        fidl::encoding::DefaultFuchsiaResourceDialect,
2666    > {
2667        BaseDatagramSocketProxyInterface::r#set_ip_transparent(self, value)
2668    }
2669
2670    /// Get `SOL_IP` -> `IP_TRANSPARENT`
2671    pub fn r#get_ip_transparent(
2672        &self,
2673    ) -> fidl::client::QueryResponseFut<
2674        BaseNetworkSocketGetIpTransparentResult,
2675        fidl::encoding::DefaultFuchsiaResourceDialect,
2676    > {
2677        BaseDatagramSocketProxyInterface::r#get_ip_transparent(self)
2678    }
2679
2680    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
2681    pub fn r#set_ip_receive_original_destination_address(
2682        &self,
2683        mut value: bool,
2684    ) -> fidl::client::QueryResponseFut<
2685        BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
2686        fidl::encoding::DefaultFuchsiaResourceDialect,
2687    > {
2688        BaseDatagramSocketProxyInterface::r#set_ip_receive_original_destination_address(self, value)
2689    }
2690
2691    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
2692    pub fn r#get_ip_receive_original_destination_address(
2693        &self,
2694    ) -> fidl::client::QueryResponseFut<
2695        BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
2696        fidl::encoding::DefaultFuchsiaResourceDialect,
2697    > {
2698        BaseDatagramSocketProxyInterface::r#get_ip_receive_original_destination_address(self)
2699    }
2700
2701    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
2702    pub fn r#add_ipv6_membership(
2703        &self,
2704        mut membership: &Ipv6MulticastMembership,
2705    ) -> fidl::client::QueryResponseFut<
2706        BaseNetworkSocketAddIpv6MembershipResult,
2707        fidl::encoding::DefaultFuchsiaResourceDialect,
2708    > {
2709        BaseDatagramSocketProxyInterface::r#add_ipv6_membership(self, membership)
2710    }
2711
2712    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
2713    pub fn r#drop_ipv6_membership(
2714        &self,
2715        mut membership: &Ipv6MulticastMembership,
2716    ) -> fidl::client::QueryResponseFut<
2717        BaseNetworkSocketDropIpv6MembershipResult,
2718        fidl::encoding::DefaultFuchsiaResourceDialect,
2719    > {
2720        BaseDatagramSocketProxyInterface::r#drop_ipv6_membership(self, membership)
2721    }
2722
2723    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
2724    pub fn r#set_ipv6_multicast_interface(
2725        &self,
2726        mut value: u64,
2727    ) -> fidl::client::QueryResponseFut<
2728        BaseNetworkSocketSetIpv6MulticastInterfaceResult,
2729        fidl::encoding::DefaultFuchsiaResourceDialect,
2730    > {
2731        BaseDatagramSocketProxyInterface::r#set_ipv6_multicast_interface(self, value)
2732    }
2733
2734    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
2735    pub fn r#get_ipv6_multicast_interface(
2736        &self,
2737    ) -> fidl::client::QueryResponseFut<
2738        BaseNetworkSocketGetIpv6MulticastInterfaceResult,
2739        fidl::encoding::DefaultFuchsiaResourceDialect,
2740    > {
2741        BaseDatagramSocketProxyInterface::r#get_ipv6_multicast_interface(self)
2742    }
2743
2744    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
2745    pub fn r#set_ipv6_unicast_hops(
2746        &self,
2747        mut value: &OptionalUint8,
2748    ) -> fidl::client::QueryResponseFut<
2749        BaseNetworkSocketSetIpv6UnicastHopsResult,
2750        fidl::encoding::DefaultFuchsiaResourceDialect,
2751    > {
2752        BaseDatagramSocketProxyInterface::r#set_ipv6_unicast_hops(self, value)
2753    }
2754
2755    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
2756    pub fn r#get_ipv6_unicast_hops(
2757        &self,
2758    ) -> fidl::client::QueryResponseFut<
2759        BaseNetworkSocketGetIpv6UnicastHopsResult,
2760        fidl::encoding::DefaultFuchsiaResourceDialect,
2761    > {
2762        BaseDatagramSocketProxyInterface::r#get_ipv6_unicast_hops(self)
2763    }
2764
2765    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
2766    pub fn r#set_ipv6_receive_hop_limit(
2767        &self,
2768        mut value: bool,
2769    ) -> fidl::client::QueryResponseFut<
2770        BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
2771        fidl::encoding::DefaultFuchsiaResourceDialect,
2772    > {
2773        BaseDatagramSocketProxyInterface::r#set_ipv6_receive_hop_limit(self, value)
2774    }
2775
2776    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
2777    pub fn r#get_ipv6_receive_hop_limit(
2778        &self,
2779    ) -> fidl::client::QueryResponseFut<
2780        BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
2781        fidl::encoding::DefaultFuchsiaResourceDialect,
2782    > {
2783        BaseDatagramSocketProxyInterface::r#get_ipv6_receive_hop_limit(self)
2784    }
2785
2786    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
2787    pub fn r#set_ipv6_multicast_hops(
2788        &self,
2789        mut value: &OptionalUint8,
2790    ) -> fidl::client::QueryResponseFut<
2791        BaseNetworkSocketSetIpv6MulticastHopsResult,
2792        fidl::encoding::DefaultFuchsiaResourceDialect,
2793    > {
2794        BaseDatagramSocketProxyInterface::r#set_ipv6_multicast_hops(self, value)
2795    }
2796
2797    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
2798    pub fn r#get_ipv6_multicast_hops(
2799        &self,
2800    ) -> fidl::client::QueryResponseFut<
2801        BaseNetworkSocketGetIpv6MulticastHopsResult,
2802        fidl::encoding::DefaultFuchsiaResourceDialect,
2803    > {
2804        BaseDatagramSocketProxyInterface::r#get_ipv6_multicast_hops(self)
2805    }
2806
2807    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
2808    pub fn r#set_ipv6_multicast_loopback(
2809        &self,
2810        mut value: bool,
2811    ) -> fidl::client::QueryResponseFut<
2812        BaseNetworkSocketSetIpv6MulticastLoopbackResult,
2813        fidl::encoding::DefaultFuchsiaResourceDialect,
2814    > {
2815        BaseDatagramSocketProxyInterface::r#set_ipv6_multicast_loopback(self, value)
2816    }
2817
2818    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
2819    pub fn r#get_ipv6_multicast_loopback(
2820        &self,
2821    ) -> fidl::client::QueryResponseFut<
2822        BaseNetworkSocketGetIpv6MulticastLoopbackResult,
2823        fidl::encoding::DefaultFuchsiaResourceDialect,
2824    > {
2825        BaseDatagramSocketProxyInterface::r#get_ipv6_multicast_loopback(self)
2826    }
2827
2828    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
2829    pub fn r#set_ipv6_only(
2830        &self,
2831        mut value: bool,
2832    ) -> fidl::client::QueryResponseFut<
2833        BaseNetworkSocketSetIpv6OnlyResult,
2834        fidl::encoding::DefaultFuchsiaResourceDialect,
2835    > {
2836        BaseDatagramSocketProxyInterface::r#set_ipv6_only(self, value)
2837    }
2838
2839    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
2840    pub fn r#get_ipv6_only(
2841        &self,
2842    ) -> fidl::client::QueryResponseFut<
2843        BaseNetworkSocketGetIpv6OnlyResult,
2844        fidl::encoding::DefaultFuchsiaResourceDialect,
2845    > {
2846        BaseDatagramSocketProxyInterface::r#get_ipv6_only(self)
2847    }
2848
2849    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
2850    pub fn r#set_ipv6_receive_traffic_class(
2851        &self,
2852        mut value: bool,
2853    ) -> fidl::client::QueryResponseFut<
2854        BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
2855        fidl::encoding::DefaultFuchsiaResourceDialect,
2856    > {
2857        BaseDatagramSocketProxyInterface::r#set_ipv6_receive_traffic_class(self, value)
2858    }
2859
2860    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
2861    pub fn r#get_ipv6_receive_traffic_class(
2862        &self,
2863    ) -> fidl::client::QueryResponseFut<
2864        BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
2865        fidl::encoding::DefaultFuchsiaResourceDialect,
2866    > {
2867        BaseDatagramSocketProxyInterface::r#get_ipv6_receive_traffic_class(self)
2868    }
2869
2870    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
2871    pub fn r#set_ipv6_traffic_class(
2872        &self,
2873        mut value: &OptionalUint8,
2874    ) -> fidl::client::QueryResponseFut<
2875        BaseNetworkSocketSetIpv6TrafficClassResult,
2876        fidl::encoding::DefaultFuchsiaResourceDialect,
2877    > {
2878        BaseDatagramSocketProxyInterface::r#set_ipv6_traffic_class(self, value)
2879    }
2880
2881    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
2882    pub fn r#get_ipv6_traffic_class(
2883        &self,
2884    ) -> fidl::client::QueryResponseFut<
2885        BaseNetworkSocketGetIpv6TrafficClassResult,
2886        fidl::encoding::DefaultFuchsiaResourceDialect,
2887    > {
2888        BaseDatagramSocketProxyInterface::r#get_ipv6_traffic_class(self)
2889    }
2890
2891    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
2892    pub fn r#set_ipv6_receive_packet_info(
2893        &self,
2894        mut value: bool,
2895    ) -> fidl::client::QueryResponseFut<
2896        BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
2897        fidl::encoding::DefaultFuchsiaResourceDialect,
2898    > {
2899        BaseDatagramSocketProxyInterface::r#set_ipv6_receive_packet_info(self, value)
2900    }
2901
2902    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
2903    pub fn r#get_ipv6_receive_packet_info(
2904        &self,
2905    ) -> fidl::client::QueryResponseFut<
2906        BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
2907        fidl::encoding::DefaultFuchsiaResourceDialect,
2908    > {
2909        BaseDatagramSocketProxyInterface::r#get_ipv6_receive_packet_info(self)
2910    }
2911
2912    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
2913    pub fn r#get_original_destination(
2914        &self,
2915    ) -> fidl::client::QueryResponseFut<
2916        BaseNetworkSocketGetOriginalDestinationResult,
2917        fidl::encoding::DefaultFuchsiaResourceDialect,
2918    > {
2919        BaseDatagramSocketProxyInterface::r#get_original_destination(self)
2920    }
2921
2922    /// Retrieves creation information from the socket.
2923    ///
2924    /// - response `domain` the socket's associated domain.
2925    /// - response `proto` the socket's associated protocol.
2926    pub fn r#get_info(
2927        &self,
2928    ) -> fidl::client::QueryResponseFut<
2929        BaseDatagramSocketGetInfoResult,
2930        fidl::encoding::DefaultFuchsiaResourceDialect,
2931    > {
2932        BaseDatagramSocketProxyInterface::r#get_info(self)
2933    }
2934}
2935
2936impl BaseDatagramSocketProxyInterface for BaseDatagramSocketProxy {
2937    fn r#clone(
2938        &self,
2939        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
2940    ) -> Result<(), fidl::Error> {
2941        self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
2942            (request,),
2943            0x20d8a7aba2168a79,
2944            fidl::encoding::DynamicFlags::empty(),
2945        )
2946    }
2947
2948    type CloseResponseFut = fidl::client::QueryResponseFut<
2949        fidl_fuchsia_unknown::CloseableCloseResult,
2950        fidl::encoding::DefaultFuchsiaResourceDialect,
2951    >;
2952    fn r#close(&self) -> Self::CloseResponseFut {
2953        fn _decode(
2954            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2955        ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
2956            let _response = fidl::client::decode_transaction_body::<
2957                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
2958                fidl::encoding::DefaultFuchsiaResourceDialect,
2959                0x5ac5d459ad7f657e,
2960            >(_buf?)?;
2961            Ok(_response.map(|x| x))
2962        }
2963        self.client.send_query_and_decode::<
2964            fidl::encoding::EmptyPayload,
2965            fidl_fuchsia_unknown::CloseableCloseResult,
2966        >(
2967            (),
2968            0x5ac5d459ad7f657e,
2969            fidl::encoding::DynamicFlags::empty(),
2970            _decode,
2971        )
2972    }
2973
2974    type QueryResponseFut =
2975        fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>;
2976    fn r#query(&self) -> Self::QueryResponseFut {
2977        fn _decode(
2978            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2979        ) -> Result<Vec<u8>, fidl::Error> {
2980            let _response = fidl::client::decode_transaction_body::<
2981                fidl_fuchsia_unknown::QueryableQueryResponse,
2982                fidl::encoding::DefaultFuchsiaResourceDialect,
2983                0x2658edee9decfc06,
2984            >(_buf?)?;
2985            Ok(_response.protocol)
2986        }
2987        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<u8>>(
2988            (),
2989            0x2658edee9decfc06,
2990            fidl::encoding::DynamicFlags::empty(),
2991            _decode,
2992        )
2993    }
2994
2995    type SetReuseAddressResponseFut = fidl::client::QueryResponseFut<
2996        BaseSocketSetReuseAddressResult,
2997        fidl::encoding::DefaultFuchsiaResourceDialect,
2998    >;
2999    fn r#set_reuse_address(&self, mut value: bool) -> Self::SetReuseAddressResponseFut {
3000        fn _decode(
3001            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3002        ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
3003            let _response = fidl::client::decode_transaction_body::<
3004                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3005                fidl::encoding::DefaultFuchsiaResourceDialect,
3006                0x1fd74ee8b9a4a876,
3007            >(_buf?)?;
3008            Ok(_response.map(|x| x))
3009        }
3010        self.client.send_query_and_decode::<
3011            BaseSocketSetReuseAddressRequest,
3012            BaseSocketSetReuseAddressResult,
3013        >(
3014            (value,),
3015            0x1fd74ee8b9a4a876,
3016            fidl::encoding::DynamicFlags::empty(),
3017            _decode,
3018        )
3019    }
3020
3021    type GetReuseAddressResponseFut = fidl::client::QueryResponseFut<
3022        BaseSocketGetReuseAddressResult,
3023        fidl::encoding::DefaultFuchsiaResourceDialect,
3024    >;
3025    fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut {
3026        fn _decode(
3027            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3028        ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
3029            let _response = fidl::client::decode_transaction_body::<
3030                fidl::encoding::ResultType<
3031                    BaseSocketGetReuseAddressResponse,
3032                    fidl_fuchsia_posix::Errno,
3033                >,
3034                fidl::encoding::DefaultFuchsiaResourceDialect,
3035                0x67b7206b8d1bc0a5,
3036            >(_buf?)?;
3037            Ok(_response.map(|x| x.value))
3038        }
3039        self.client
3040            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReuseAddressResult>(
3041                (),
3042                0x67b7206b8d1bc0a5,
3043                fidl::encoding::DynamicFlags::empty(),
3044                _decode,
3045            )
3046    }
3047
3048    type GetErrorResponseFut = fidl::client::QueryResponseFut<
3049        BaseSocketGetErrorResult,
3050        fidl::encoding::DefaultFuchsiaResourceDialect,
3051    >;
3052    fn r#get_error(&self) -> Self::GetErrorResponseFut {
3053        fn _decode(
3054            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3055        ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
3056            let _response = fidl::client::decode_transaction_body::<
3057                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3058                fidl::encoding::DefaultFuchsiaResourceDialect,
3059                0x5aad39b33e5f6ebb,
3060            >(_buf?)?;
3061            Ok(_response.map(|x| x))
3062        }
3063        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetErrorResult>(
3064            (),
3065            0x5aad39b33e5f6ebb,
3066            fidl::encoding::DynamicFlags::empty(),
3067            _decode,
3068        )
3069    }
3070
3071    type SetBroadcastResponseFut = fidl::client::QueryResponseFut<
3072        BaseSocketSetBroadcastResult,
3073        fidl::encoding::DefaultFuchsiaResourceDialect,
3074    >;
3075    fn r#set_broadcast(&self, mut value: bool) -> Self::SetBroadcastResponseFut {
3076        fn _decode(
3077            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3078        ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
3079            let _response = fidl::client::decode_transaction_body::<
3080                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3081                fidl::encoding::DefaultFuchsiaResourceDialect,
3082                0x6023e081ce3cd947,
3083            >(_buf?)?;
3084            Ok(_response.map(|x| x))
3085        }
3086        self.client
3087            .send_query_and_decode::<BaseSocketSetBroadcastRequest, BaseSocketSetBroadcastResult>(
3088                (value,),
3089                0x6023e081ce3cd947,
3090                fidl::encoding::DynamicFlags::empty(),
3091                _decode,
3092            )
3093    }
3094
3095    type GetBroadcastResponseFut = fidl::client::QueryResponseFut<
3096        BaseSocketGetBroadcastResult,
3097        fidl::encoding::DefaultFuchsiaResourceDialect,
3098    >;
3099    fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut {
3100        fn _decode(
3101            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3102        ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
3103            let _response = fidl::client::decode_transaction_body::<
3104                fidl::encoding::ResultType<
3105                    BaseSocketGetBroadcastResponse,
3106                    fidl_fuchsia_posix::Errno,
3107                >,
3108                fidl::encoding::DefaultFuchsiaResourceDialect,
3109                0x68796fc556f9780d,
3110            >(_buf?)?;
3111            Ok(_response.map(|x| x.value))
3112        }
3113        self.client
3114            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBroadcastResult>(
3115                (),
3116                0x68796fc556f9780d,
3117                fidl::encoding::DynamicFlags::empty(),
3118                _decode,
3119            )
3120    }
3121
3122    type SetSendBufferResponseFut = fidl::client::QueryResponseFut<
3123        BaseSocketSetSendBufferResult,
3124        fidl::encoding::DefaultFuchsiaResourceDialect,
3125    >;
3126    fn r#set_send_buffer(&self, mut value_bytes: u64) -> Self::SetSendBufferResponseFut {
3127        fn _decode(
3128            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3129        ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
3130            let _response = fidl::client::decode_transaction_body::<
3131                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3132                fidl::encoding::DefaultFuchsiaResourceDialect,
3133                0x756eac32d73a7a70,
3134            >(_buf?)?;
3135            Ok(_response.map(|x| x))
3136        }
3137        self.client
3138            .send_query_and_decode::<BaseSocketSetSendBufferRequest, BaseSocketSetSendBufferResult>(
3139                (value_bytes,),
3140                0x756eac32d73a7a70,
3141                fidl::encoding::DynamicFlags::empty(),
3142                _decode,
3143            )
3144    }
3145
3146    type GetSendBufferResponseFut = fidl::client::QueryResponseFut<
3147        BaseSocketGetSendBufferResult,
3148        fidl::encoding::DefaultFuchsiaResourceDialect,
3149    >;
3150    fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut {
3151        fn _decode(
3152            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3153        ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
3154            let _response = fidl::client::decode_transaction_body::<
3155                fidl::encoding::ResultType<
3156                    BaseSocketGetSendBufferResponse,
3157                    fidl_fuchsia_posix::Errno,
3158                >,
3159                fidl::encoding::DefaultFuchsiaResourceDialect,
3160                0x78a52fd9c7b2410b,
3161            >(_buf?)?;
3162            Ok(_response.map(|x| x.value_bytes))
3163        }
3164        self.client
3165            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetSendBufferResult>(
3166                (),
3167                0x78a52fd9c7b2410b,
3168                fidl::encoding::DynamicFlags::empty(),
3169                _decode,
3170            )
3171    }
3172
3173    type SetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
3174        BaseSocketSetReceiveBufferResult,
3175        fidl::encoding::DefaultFuchsiaResourceDialect,
3176    >;
3177    fn r#set_receive_buffer(&self, mut value_bytes: u64) -> Self::SetReceiveBufferResponseFut {
3178        fn _decode(
3179            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3180        ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
3181            let _response = fidl::client::decode_transaction_body::<
3182                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3183                fidl::encoding::DefaultFuchsiaResourceDialect,
3184                0x6b0cf2f1919c7001,
3185            >(_buf?)?;
3186            Ok(_response.map(|x| x))
3187        }
3188        self.client.send_query_and_decode::<
3189            BaseSocketSetReceiveBufferRequest,
3190            BaseSocketSetReceiveBufferResult,
3191        >(
3192            (value_bytes,),
3193            0x6b0cf2f1919c7001,
3194            fidl::encoding::DynamicFlags::empty(),
3195            _decode,
3196        )
3197    }
3198
3199    type GetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
3200        BaseSocketGetReceiveBufferResult,
3201        fidl::encoding::DefaultFuchsiaResourceDialect,
3202    >;
3203    fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut {
3204        fn _decode(
3205            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3206        ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
3207            let _response = fidl::client::decode_transaction_body::<
3208                fidl::encoding::ResultType<
3209                    BaseSocketGetReceiveBufferResponse,
3210                    fidl_fuchsia_posix::Errno,
3211                >,
3212                fidl::encoding::DefaultFuchsiaResourceDialect,
3213                0x14c1a4b64f709e5c,
3214            >(_buf?)?;
3215            Ok(_response.map(|x| x.value_bytes))
3216        }
3217        self.client.send_query_and_decode::<
3218            fidl::encoding::EmptyPayload,
3219            BaseSocketGetReceiveBufferResult,
3220        >(
3221            (),
3222            0x14c1a4b64f709e5c,
3223            fidl::encoding::DynamicFlags::empty(),
3224            _decode,
3225        )
3226    }
3227
3228    type SetKeepAliveResponseFut = fidl::client::QueryResponseFut<
3229        BaseSocketSetKeepAliveResult,
3230        fidl::encoding::DefaultFuchsiaResourceDialect,
3231    >;
3232    fn r#set_keep_alive(&self, mut value: bool) -> Self::SetKeepAliveResponseFut {
3233        fn _decode(
3234            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3235        ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
3236            let _response = fidl::client::decode_transaction_body::<
3237                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3238                fidl::encoding::DefaultFuchsiaResourceDialect,
3239                0x572df8f0b920d2c7,
3240            >(_buf?)?;
3241            Ok(_response.map(|x| x))
3242        }
3243        self.client
3244            .send_query_and_decode::<BaseSocketSetKeepAliveRequest, BaseSocketSetKeepAliveResult>(
3245                (value,),
3246                0x572df8f0b920d2c7,
3247                fidl::encoding::DynamicFlags::empty(),
3248                _decode,
3249            )
3250    }
3251
3252    type GetKeepAliveResponseFut = fidl::client::QueryResponseFut<
3253        BaseSocketGetKeepAliveResult,
3254        fidl::encoding::DefaultFuchsiaResourceDialect,
3255    >;
3256    fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut {
3257        fn _decode(
3258            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3259        ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
3260            let _response = fidl::client::decode_transaction_body::<
3261                fidl::encoding::ResultType<
3262                    BaseSocketGetKeepAliveResponse,
3263                    fidl_fuchsia_posix::Errno,
3264                >,
3265                fidl::encoding::DefaultFuchsiaResourceDialect,
3266                0x2dd29d3215f2c9d2,
3267            >(_buf?)?;
3268            Ok(_response.map(|x| x.value))
3269        }
3270        self.client
3271            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetKeepAliveResult>(
3272                (),
3273                0x2dd29d3215f2c9d2,
3274                fidl::encoding::DynamicFlags::empty(),
3275                _decode,
3276            )
3277    }
3278
3279    type SetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
3280        BaseSocketSetOutOfBandInlineResult,
3281        fidl::encoding::DefaultFuchsiaResourceDialect,
3282    >;
3283    fn r#set_out_of_band_inline(&self, mut value: bool) -> Self::SetOutOfBandInlineResponseFut {
3284        fn _decode(
3285            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3286        ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
3287            let _response = fidl::client::decode_transaction_body::<
3288                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3289                fidl::encoding::DefaultFuchsiaResourceDialect,
3290                0x3ecb49968bee439,
3291            >(_buf?)?;
3292            Ok(_response.map(|x| x))
3293        }
3294        self.client.send_query_and_decode::<
3295            BaseSocketSetOutOfBandInlineRequest,
3296            BaseSocketSetOutOfBandInlineResult,
3297        >(
3298            (value,),
3299            0x3ecb49968bee439,
3300            fidl::encoding::DynamicFlags::empty(),
3301            _decode,
3302        )
3303    }
3304
3305    type GetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
3306        BaseSocketGetOutOfBandInlineResult,
3307        fidl::encoding::DefaultFuchsiaResourceDialect,
3308    >;
3309    fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut {
3310        fn _decode(
3311            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3312        ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
3313            let _response = fidl::client::decode_transaction_body::<
3314                fidl::encoding::ResultType<
3315                    BaseSocketGetOutOfBandInlineResponse,
3316                    fidl_fuchsia_posix::Errno,
3317                >,
3318                fidl::encoding::DefaultFuchsiaResourceDialect,
3319                0x348c1ab3aeca1745,
3320            >(_buf?)?;
3321            Ok(_response.map(|x| x.value))
3322        }
3323        self.client.send_query_and_decode::<
3324            fidl::encoding::EmptyPayload,
3325            BaseSocketGetOutOfBandInlineResult,
3326        >(
3327            (),
3328            0x348c1ab3aeca1745,
3329            fidl::encoding::DynamicFlags::empty(),
3330            _decode,
3331        )
3332    }
3333
3334    type SetNoCheckResponseFut = fidl::client::QueryResponseFut<
3335        BaseSocketSetNoCheckResult,
3336        fidl::encoding::DefaultFuchsiaResourceDialect,
3337    >;
3338    fn r#set_no_check(&self, mut value: bool) -> Self::SetNoCheckResponseFut {
3339        fn _decode(
3340            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3341        ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
3342            let _response = fidl::client::decode_transaction_body::<
3343                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3344                fidl::encoding::DefaultFuchsiaResourceDialect,
3345                0x6bbf00c53a4c78c2,
3346            >(_buf?)?;
3347            Ok(_response.map(|x| x))
3348        }
3349        self.client
3350            .send_query_and_decode::<BaseSocketSetNoCheckRequest, BaseSocketSetNoCheckResult>(
3351                (value,),
3352                0x6bbf00c53a4c78c2,
3353                fidl::encoding::DynamicFlags::empty(),
3354                _decode,
3355            )
3356    }
3357
3358    type GetNoCheckResponseFut = fidl::client::QueryResponseFut<
3359        BaseSocketGetNoCheckResult,
3360        fidl::encoding::DefaultFuchsiaResourceDialect,
3361    >;
3362    fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut {
3363        fn _decode(
3364            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3365        ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
3366            let _response = fidl::client::decode_transaction_body::<
3367                fidl::encoding::ResultType<BaseSocketGetNoCheckResponse, fidl_fuchsia_posix::Errno>,
3368                fidl::encoding::DefaultFuchsiaResourceDialect,
3369                0x2cd4249286417694,
3370            >(_buf?)?;
3371            Ok(_response.map(|x| x.value))
3372        }
3373        self.client
3374            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetNoCheckResult>(
3375                (),
3376                0x2cd4249286417694,
3377                fidl::encoding::DynamicFlags::empty(),
3378                _decode,
3379            )
3380    }
3381
3382    type SetLingerResponseFut = fidl::client::QueryResponseFut<
3383        BaseSocketSetLingerResult,
3384        fidl::encoding::DefaultFuchsiaResourceDialect,
3385    >;
3386    fn r#set_linger(&self, mut linger: bool, mut length_secs: u32) -> Self::SetLingerResponseFut {
3387        fn _decode(
3388            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3389        ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
3390            let _response = fidl::client::decode_transaction_body::<
3391                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3392                fidl::encoding::DefaultFuchsiaResourceDialect,
3393                0x45386351246e998e,
3394            >(_buf?)?;
3395            Ok(_response.map(|x| x))
3396        }
3397        self.client.send_query_and_decode::<BaseSocketSetLingerRequest, BaseSocketSetLingerResult>(
3398            (linger, length_secs),
3399            0x45386351246e998e,
3400            fidl::encoding::DynamicFlags::empty(),
3401            _decode,
3402        )
3403    }
3404
3405    type GetLingerResponseFut = fidl::client::QueryResponseFut<
3406        BaseSocketGetLingerResult,
3407        fidl::encoding::DefaultFuchsiaResourceDialect,
3408    >;
3409    fn r#get_linger(&self) -> Self::GetLingerResponseFut {
3410        fn _decode(
3411            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3412        ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
3413            let _response = fidl::client::decode_transaction_body::<
3414                fidl::encoding::ResultType<BaseSocketGetLingerResponse, fidl_fuchsia_posix::Errno>,
3415                fidl::encoding::DefaultFuchsiaResourceDialect,
3416                0x48eb20fc5ccb0e45,
3417            >(_buf?)?;
3418            Ok(_response.map(|x| (x.linger, x.length_secs)))
3419        }
3420        self.client
3421            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetLingerResult>(
3422                (),
3423                0x48eb20fc5ccb0e45,
3424                fidl::encoding::DynamicFlags::empty(),
3425                _decode,
3426            )
3427    }
3428
3429    type SetReusePortResponseFut = fidl::client::QueryResponseFut<
3430        BaseSocketSetReusePortResult,
3431        fidl::encoding::DefaultFuchsiaResourceDialect,
3432    >;
3433    fn r#set_reuse_port(&self, mut value: bool) -> Self::SetReusePortResponseFut {
3434        fn _decode(
3435            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3436        ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
3437            let _response = fidl::client::decode_transaction_body::<
3438                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3439                fidl::encoding::DefaultFuchsiaResourceDialect,
3440                0x24dd3e5cb36d9ccb,
3441            >(_buf?)?;
3442            Ok(_response.map(|x| x))
3443        }
3444        self.client
3445            .send_query_and_decode::<BaseSocketSetReusePortRequest, BaseSocketSetReusePortResult>(
3446                (value,),
3447                0x24dd3e5cb36d9ccb,
3448                fidl::encoding::DynamicFlags::empty(),
3449                _decode,
3450            )
3451    }
3452
3453    type GetReusePortResponseFut = fidl::client::QueryResponseFut<
3454        BaseSocketGetReusePortResult,
3455        fidl::encoding::DefaultFuchsiaResourceDialect,
3456    >;
3457    fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut {
3458        fn _decode(
3459            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3460        ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
3461            let _response = fidl::client::decode_transaction_body::<
3462                fidl::encoding::ResultType<
3463                    BaseSocketGetReusePortResponse,
3464                    fidl_fuchsia_posix::Errno,
3465                >,
3466                fidl::encoding::DefaultFuchsiaResourceDialect,
3467                0x7a112c1ab54ff828,
3468            >(_buf?)?;
3469            Ok(_response.map(|x| x.value))
3470        }
3471        self.client
3472            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReusePortResult>(
3473                (),
3474                0x7a112c1ab54ff828,
3475                fidl::encoding::DynamicFlags::empty(),
3476                _decode,
3477            )
3478    }
3479
3480    type GetAcceptConnResponseFut = fidl::client::QueryResponseFut<
3481        BaseSocketGetAcceptConnResult,
3482        fidl::encoding::DefaultFuchsiaResourceDialect,
3483    >;
3484    fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut {
3485        fn _decode(
3486            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3487        ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
3488            let _response = fidl::client::decode_transaction_body::<
3489                fidl::encoding::ResultType<
3490                    BaseSocketGetAcceptConnResponse,
3491                    fidl_fuchsia_posix::Errno,
3492                >,
3493                fidl::encoding::DefaultFuchsiaResourceDialect,
3494                0x67ce6db6c2ec8966,
3495            >(_buf?)?;
3496            Ok(_response.map(|x| x.value))
3497        }
3498        self.client
3499            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetAcceptConnResult>(
3500                (),
3501                0x67ce6db6c2ec8966,
3502                fidl::encoding::DynamicFlags::empty(),
3503                _decode,
3504            )
3505    }
3506
3507    type SetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
3508        BaseSocketSetBindToDeviceResult,
3509        fidl::encoding::DefaultFuchsiaResourceDialect,
3510    >;
3511    fn r#set_bind_to_device(&self, mut value: &str) -> Self::SetBindToDeviceResponseFut {
3512        fn _decode(
3513            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3514        ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
3515            let _response = fidl::client::decode_transaction_body::<
3516                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3517                fidl::encoding::DefaultFuchsiaResourceDialect,
3518                0x2118b483f28aafc4,
3519            >(_buf?)?;
3520            Ok(_response.map(|x| x))
3521        }
3522        self.client.send_query_and_decode::<
3523            BaseSocketSetBindToDeviceRequest,
3524            BaseSocketSetBindToDeviceResult,
3525        >(
3526            (value,),
3527            0x2118b483f28aafc4,
3528            fidl::encoding::DynamicFlags::empty(),
3529            _decode,
3530        )
3531    }
3532
3533    type GetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
3534        BaseSocketGetBindToDeviceResult,
3535        fidl::encoding::DefaultFuchsiaResourceDialect,
3536    >;
3537    fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut {
3538        fn _decode(
3539            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3540        ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
3541            let _response = fidl::client::decode_transaction_body::<
3542                fidl::encoding::ResultType<
3543                    BaseSocketGetBindToDeviceResponse,
3544                    fidl_fuchsia_posix::Errno,
3545                >,
3546                fidl::encoding::DefaultFuchsiaResourceDialect,
3547                0x1ab1fbf0ef7906c8,
3548            >(_buf?)?;
3549            Ok(_response.map(|x| x.value))
3550        }
3551        self.client
3552            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBindToDeviceResult>(
3553                (),
3554                0x1ab1fbf0ef7906c8,
3555                fidl::encoding::DynamicFlags::empty(),
3556                _decode,
3557            )
3558    }
3559
3560    type SetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
3561        BaseSocketSetBindToInterfaceIndexResult,
3562        fidl::encoding::DefaultFuchsiaResourceDialect,
3563    >;
3564    fn r#set_bind_to_interface_index(
3565        &self,
3566        mut value: u64,
3567    ) -> Self::SetBindToInterfaceIndexResponseFut {
3568        fn _decode(
3569            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3570        ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
3571            let _response = fidl::client::decode_transaction_body::<
3572                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3573                fidl::encoding::DefaultFuchsiaResourceDialect,
3574                0x6e387a0def00821,
3575            >(_buf?)?;
3576            Ok(_response.map(|x| x))
3577        }
3578        self.client.send_query_and_decode::<
3579            BaseSocketSetBindToInterfaceIndexRequest,
3580            BaseSocketSetBindToInterfaceIndexResult,
3581        >(
3582            (value,),
3583            0x6e387a0def00821,
3584            fidl::encoding::DynamicFlags::empty(),
3585            _decode,
3586        )
3587    }
3588
3589    type GetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
3590        BaseSocketGetBindToInterfaceIndexResult,
3591        fidl::encoding::DefaultFuchsiaResourceDialect,
3592    >;
3593    fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut {
3594        fn _decode(
3595            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3596        ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
3597            let _response = fidl::client::decode_transaction_body::<
3598                fidl::encoding::ResultType<
3599                    BaseSocketGetBindToInterfaceIndexResponse,
3600                    fidl_fuchsia_posix::Errno,
3601                >,
3602                fidl::encoding::DefaultFuchsiaResourceDialect,
3603                0x59c31dd3e3078295,
3604            >(_buf?)?;
3605            Ok(_response.map(|x| x.value))
3606        }
3607        self.client.send_query_and_decode::<
3608            fidl::encoding::EmptyPayload,
3609            BaseSocketGetBindToInterfaceIndexResult,
3610        >(
3611            (),
3612            0x59c31dd3e3078295,
3613            fidl::encoding::DynamicFlags::empty(),
3614            _decode,
3615        )
3616    }
3617
3618    type SetTimestampResponseFut = fidl::client::QueryResponseFut<
3619        BaseSocketSetTimestampResult,
3620        fidl::encoding::DefaultFuchsiaResourceDialect,
3621    >;
3622    fn r#set_timestamp(&self, mut value: TimestampOption) -> Self::SetTimestampResponseFut {
3623        fn _decode(
3624            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3625        ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
3626            let _response = fidl::client::decode_transaction_body::<
3627                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3628                fidl::encoding::DefaultFuchsiaResourceDialect,
3629                0x285d6516c263d839,
3630            >(_buf?)?;
3631            Ok(_response.map(|x| x))
3632        }
3633        self.client
3634            .send_query_and_decode::<BaseSocketSetTimestampRequest, BaseSocketSetTimestampResult>(
3635                (value,),
3636                0x285d6516c263d839,
3637                fidl::encoding::DynamicFlags::empty(),
3638                _decode,
3639            )
3640    }
3641
3642    type GetTimestampResponseFut = fidl::client::QueryResponseFut<
3643        BaseSocketGetTimestampResult,
3644        fidl::encoding::DefaultFuchsiaResourceDialect,
3645    >;
3646    fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut {
3647        fn _decode(
3648            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3649        ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
3650            let _response = fidl::client::decode_transaction_body::<
3651                fidl::encoding::ResultType<
3652                    BaseSocketGetTimestampResponse,
3653                    fidl_fuchsia_posix::Errno,
3654                >,
3655                fidl::encoding::DefaultFuchsiaResourceDialect,
3656                0x49f2fffbbcc2bd27,
3657            >(_buf?)?;
3658            Ok(_response.map(|x| x.value))
3659        }
3660        self.client
3661            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetTimestampResult>(
3662                (),
3663                0x49f2fffbbcc2bd27,
3664                fidl::encoding::DynamicFlags::empty(),
3665                _decode,
3666            )
3667    }
3668
3669    type SetMarkResponseFut = fidl::client::QueryResponseFut<
3670        BaseSocketSetMarkResult,
3671        fidl::encoding::DefaultFuchsiaResourceDialect,
3672    >;
3673    fn r#set_mark(
3674        &self,
3675        mut domain: fidl_fuchsia_net::MarkDomain,
3676        mut mark: &OptionalUint32,
3677    ) -> Self::SetMarkResponseFut {
3678        fn _decode(
3679            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3680        ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
3681            let _response = fidl::client::decode_transaction_body::<
3682                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3683                fidl::encoding::DefaultFuchsiaResourceDialect,
3684                0x6ead6de09f653236,
3685            >(_buf?)?;
3686            Ok(_response.map(|x| x))
3687        }
3688        self.client.send_query_and_decode::<BaseSocketSetMarkRequest, BaseSocketSetMarkResult>(
3689            (domain, mark),
3690            0x6ead6de09f653236,
3691            fidl::encoding::DynamicFlags::empty(),
3692            _decode,
3693        )
3694    }
3695
3696    type GetMarkResponseFut = fidl::client::QueryResponseFut<
3697        BaseSocketGetMarkResult,
3698        fidl::encoding::DefaultFuchsiaResourceDialect,
3699    >;
3700    fn r#get_mark(&self, mut domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut {
3701        fn _decode(
3702            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3703        ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
3704            let _response = fidl::client::decode_transaction_body::<
3705                fidl::encoding::ResultType<BaseSocketGetMarkResponse, fidl_fuchsia_posix::Errno>,
3706                fidl::encoding::DefaultFuchsiaResourceDialect,
3707                0x57a2752c61d93d47,
3708            >(_buf?)?;
3709            Ok(_response.map(|x| x.mark))
3710        }
3711        self.client.send_query_and_decode::<BaseSocketGetMarkRequest, BaseSocketGetMarkResult>(
3712            (domain,),
3713            0x57a2752c61d93d47,
3714            fidl::encoding::DynamicFlags::empty(),
3715            _decode,
3716        )
3717    }
3718
3719    type BindResponseFut = fidl::client::QueryResponseFut<
3720        BaseNetworkSocketBindResult,
3721        fidl::encoding::DefaultFuchsiaResourceDialect,
3722    >;
3723    fn r#bind(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut {
3724        fn _decode(
3725            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3726        ) -> Result<BaseNetworkSocketBindResult, fidl::Error> {
3727            let _response = fidl::client::decode_transaction_body::<
3728                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3729                fidl::encoding::DefaultFuchsiaResourceDialect,
3730                0x4bc6400ae92125d,
3731            >(_buf?)?;
3732            Ok(_response.map(|x| x))
3733        }
3734        self.client
3735            .send_query_and_decode::<BaseNetworkSocketBindRequest, BaseNetworkSocketBindResult>(
3736                (addr,),
3737                0x4bc6400ae92125d,
3738                fidl::encoding::DynamicFlags::empty(),
3739                _decode,
3740            )
3741    }
3742
3743    type ConnectResponseFut = fidl::client::QueryResponseFut<
3744        BaseNetworkSocketConnectResult,
3745        fidl::encoding::DefaultFuchsiaResourceDialect,
3746    >;
3747    fn r#connect(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut {
3748        fn _decode(
3749            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3750        ) -> Result<BaseNetworkSocketConnectResult, fidl::Error> {
3751            let _response = fidl::client::decode_transaction_body::<
3752                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3753                fidl::encoding::DefaultFuchsiaResourceDialect,
3754                0x5f05f19bfdd38871,
3755            >(_buf?)?;
3756            Ok(_response.map(|x| x))
3757        }
3758        self.client.send_query_and_decode::<
3759            BaseNetworkSocketConnectRequest,
3760            BaseNetworkSocketConnectResult,
3761        >(
3762            (addr,),
3763            0x5f05f19bfdd38871,
3764            fidl::encoding::DynamicFlags::empty(),
3765            _decode,
3766        )
3767    }
3768
3769    type DisconnectResponseFut = fidl::client::QueryResponseFut<
3770        BaseNetworkSocketDisconnectResult,
3771        fidl::encoding::DefaultFuchsiaResourceDialect,
3772    >;
3773    fn r#disconnect(&self) -> Self::DisconnectResponseFut {
3774        fn _decode(
3775            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3776        ) -> Result<BaseNetworkSocketDisconnectResult, fidl::Error> {
3777            let _response = fidl::client::decode_transaction_body::<
3778                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3779                fidl::encoding::DefaultFuchsiaResourceDialect,
3780                0x74e63b91f7b29b2,
3781            >(_buf?)?;
3782            Ok(_response.map(|x| x))
3783        }
3784        self.client.send_query_and_decode::<
3785            fidl::encoding::EmptyPayload,
3786            BaseNetworkSocketDisconnectResult,
3787        >(
3788            (),
3789            0x74e63b91f7b29b2,
3790            fidl::encoding::DynamicFlags::empty(),
3791            _decode,
3792        )
3793    }
3794
3795    type GetSockNameResponseFut = fidl::client::QueryResponseFut<
3796        BaseNetworkSocketGetSockNameResult,
3797        fidl::encoding::DefaultFuchsiaResourceDialect,
3798    >;
3799    fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut {
3800        fn _decode(
3801            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3802        ) -> Result<BaseNetworkSocketGetSockNameResult, fidl::Error> {
3803            let _response = fidl::client::decode_transaction_body::<
3804                fidl::encoding::ResultType<
3805                    BaseNetworkSocketGetSockNameResponse,
3806                    fidl_fuchsia_posix::Errno,
3807                >,
3808                fidl::encoding::DefaultFuchsiaResourceDialect,
3809                0x475f23f84a1a4f85,
3810            >(_buf?)?;
3811            Ok(_response.map(|x| x.addr))
3812        }
3813        self.client.send_query_and_decode::<
3814            fidl::encoding::EmptyPayload,
3815            BaseNetworkSocketGetSockNameResult,
3816        >(
3817            (),
3818            0x475f23f84a1a4f85,
3819            fidl::encoding::DynamicFlags::empty(),
3820            _decode,
3821        )
3822    }
3823
3824    type GetPeerNameResponseFut = fidl::client::QueryResponseFut<
3825        BaseNetworkSocketGetPeerNameResult,
3826        fidl::encoding::DefaultFuchsiaResourceDialect,
3827    >;
3828    fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut {
3829        fn _decode(
3830            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3831        ) -> Result<BaseNetworkSocketGetPeerNameResult, fidl::Error> {
3832            let _response = fidl::client::decode_transaction_body::<
3833                fidl::encoding::ResultType<
3834                    BaseNetworkSocketGetPeerNameResponse,
3835                    fidl_fuchsia_posix::Errno,
3836                >,
3837                fidl::encoding::DefaultFuchsiaResourceDialect,
3838                0x1ffecf4bd5b6432e,
3839            >(_buf?)?;
3840            Ok(_response.map(|x| x.addr))
3841        }
3842        self.client.send_query_and_decode::<
3843            fidl::encoding::EmptyPayload,
3844            BaseNetworkSocketGetPeerNameResult,
3845        >(
3846            (),
3847            0x1ffecf4bd5b6432e,
3848            fidl::encoding::DynamicFlags::empty(),
3849            _decode,
3850        )
3851    }
3852
3853    type ShutdownResponseFut = fidl::client::QueryResponseFut<
3854        BaseNetworkSocketShutdownResult,
3855        fidl::encoding::DefaultFuchsiaResourceDialect,
3856    >;
3857    fn r#shutdown(&self, mut mode: ShutdownMode) -> Self::ShutdownResponseFut {
3858        fn _decode(
3859            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3860        ) -> Result<BaseNetworkSocketShutdownResult, fidl::Error> {
3861            let _response = fidl::client::decode_transaction_body::<
3862                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3863                fidl::encoding::DefaultFuchsiaResourceDialect,
3864                0x247f38b6db68c336,
3865            >(_buf?)?;
3866            Ok(_response.map(|x| x))
3867        }
3868        self.client.send_query_and_decode::<
3869            BaseNetworkSocketShutdownRequest,
3870            BaseNetworkSocketShutdownResult,
3871        >(
3872            (mode,),
3873            0x247f38b6db68c336,
3874            fidl::encoding::DynamicFlags::empty(),
3875            _decode,
3876        )
3877    }
3878
3879    type SetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
3880        BaseNetworkSocketSetIpTypeOfServiceResult,
3881        fidl::encoding::DefaultFuchsiaResourceDialect,
3882    >;
3883    fn r#set_ip_type_of_service(&self, mut value: u8) -> Self::SetIpTypeOfServiceResponseFut {
3884        fn _decode(
3885            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3886        ) -> Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error> {
3887            let _response = fidl::client::decode_transaction_body::<
3888                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3889                fidl::encoding::DefaultFuchsiaResourceDialect,
3890                0x995c600475b6d46,
3891            >(_buf?)?;
3892            Ok(_response.map(|x| x))
3893        }
3894        self.client.send_query_and_decode::<
3895            BaseNetworkSocketSetIpTypeOfServiceRequest,
3896            BaseNetworkSocketSetIpTypeOfServiceResult,
3897        >(
3898            (value,),
3899            0x995c600475b6d46,
3900            fidl::encoding::DynamicFlags::empty(),
3901            _decode,
3902        )
3903    }
3904
3905    type GetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
3906        BaseNetworkSocketGetIpTypeOfServiceResult,
3907        fidl::encoding::DefaultFuchsiaResourceDialect,
3908    >;
3909    fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut {
3910        fn _decode(
3911            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3912        ) -> Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error> {
3913            let _response = fidl::client::decode_transaction_body::<
3914                fidl::encoding::ResultType<
3915                    BaseNetworkSocketGetIpTypeOfServiceResponse,
3916                    fidl_fuchsia_posix::Errno,
3917                >,
3918                fidl::encoding::DefaultFuchsiaResourceDialect,
3919                0x3814a04259f75fcb,
3920            >(_buf?)?;
3921            Ok(_response.map(|x| x.value))
3922        }
3923        self.client.send_query_and_decode::<
3924            fidl::encoding::EmptyPayload,
3925            BaseNetworkSocketGetIpTypeOfServiceResult,
3926        >(
3927            (),
3928            0x3814a04259f75fcb,
3929            fidl::encoding::DynamicFlags::empty(),
3930            _decode,
3931        )
3932    }
3933
3934    type SetIpTtlResponseFut = fidl::client::QueryResponseFut<
3935        BaseNetworkSocketSetIpTtlResult,
3936        fidl::encoding::DefaultFuchsiaResourceDialect,
3937    >;
3938    fn r#set_ip_ttl(&self, mut value: &OptionalUint8) -> Self::SetIpTtlResponseFut {
3939        fn _decode(
3940            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3941        ) -> Result<BaseNetworkSocketSetIpTtlResult, fidl::Error> {
3942            let _response = fidl::client::decode_transaction_body::<
3943                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3944                fidl::encoding::DefaultFuchsiaResourceDialect,
3945                0x29e2424b433ae1ef,
3946            >(_buf?)?;
3947            Ok(_response.map(|x| x))
3948        }
3949        self.client.send_query_and_decode::<
3950            BaseNetworkSocketSetIpTtlRequest,
3951            BaseNetworkSocketSetIpTtlResult,
3952        >(
3953            (value,),
3954            0x29e2424b433ae1ef,
3955            fidl::encoding::DynamicFlags::empty(),
3956            _decode,
3957        )
3958    }
3959
3960    type GetIpTtlResponseFut = fidl::client::QueryResponseFut<
3961        BaseNetworkSocketGetIpTtlResult,
3962        fidl::encoding::DefaultFuchsiaResourceDialect,
3963    >;
3964    fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut {
3965        fn _decode(
3966            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3967        ) -> Result<BaseNetworkSocketGetIpTtlResult, fidl::Error> {
3968            let _response = fidl::client::decode_transaction_body::<
3969                fidl::encoding::ResultType<
3970                    BaseNetworkSocketGetIpTtlResponse,
3971                    fidl_fuchsia_posix::Errno,
3972                >,
3973                fidl::encoding::DefaultFuchsiaResourceDialect,
3974                0x47e47fa1f24da471,
3975            >(_buf?)?;
3976            Ok(_response.map(|x| x.value))
3977        }
3978        self.client
3979            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseNetworkSocketGetIpTtlResult>(
3980                (),
3981                0x47e47fa1f24da471,
3982                fidl::encoding::DynamicFlags::empty(),
3983                _decode,
3984            )
3985    }
3986
3987    type SetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
3988        BaseNetworkSocketSetIpPacketInfoResult,
3989        fidl::encoding::DefaultFuchsiaResourceDialect,
3990    >;
3991    fn r#set_ip_packet_info(&self, mut value: bool) -> Self::SetIpPacketInfoResponseFut {
3992        fn _decode(
3993            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
3994        ) -> Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error> {
3995            let _response = fidl::client::decode_transaction_body::<
3996                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
3997                fidl::encoding::DefaultFuchsiaResourceDialect,
3998                0x392d16bee20c0e16,
3999            >(_buf?)?;
4000            Ok(_response.map(|x| x))
4001        }
4002        self.client.send_query_and_decode::<
4003            BaseNetworkSocketSetIpPacketInfoRequest,
4004            BaseNetworkSocketSetIpPacketInfoResult,
4005        >(
4006            (value,),
4007            0x392d16bee20c0e16,
4008            fidl::encoding::DynamicFlags::empty(),
4009            _decode,
4010        )
4011    }
4012
4013    type GetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
4014        BaseNetworkSocketGetIpPacketInfoResult,
4015        fidl::encoding::DefaultFuchsiaResourceDialect,
4016    >;
4017    fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut {
4018        fn _decode(
4019            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4020        ) -> Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error> {
4021            let _response = fidl::client::decode_transaction_body::<
4022                fidl::encoding::ResultType<
4023                    BaseNetworkSocketGetIpPacketInfoResponse,
4024                    fidl_fuchsia_posix::Errno,
4025                >,
4026                fidl::encoding::DefaultFuchsiaResourceDialect,
4027                0x54b505f242280740,
4028            >(_buf?)?;
4029            Ok(_response.map(|x| x.value))
4030        }
4031        self.client.send_query_and_decode::<
4032            fidl::encoding::EmptyPayload,
4033            BaseNetworkSocketGetIpPacketInfoResult,
4034        >(
4035            (),
4036            0x54b505f242280740,
4037            fidl::encoding::DynamicFlags::empty(),
4038            _decode,
4039        )
4040    }
4041
4042    type SetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
4043        BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
4044        fidl::encoding::DefaultFuchsiaResourceDialect,
4045    >;
4046    fn r#set_ip_receive_type_of_service(
4047        &self,
4048        mut value: bool,
4049    ) -> Self::SetIpReceiveTypeOfServiceResponseFut {
4050        fn _decode(
4051            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4052        ) -> Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error> {
4053            let _response = fidl::client::decode_transaction_body::<
4054                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4055                fidl::encoding::DefaultFuchsiaResourceDialect,
4056                0x6c4f6714995f84ef,
4057            >(_buf?)?;
4058            Ok(_response.map(|x| x))
4059        }
4060        self.client.send_query_and_decode::<
4061            BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
4062            BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
4063        >(
4064            (value,),
4065            0x6c4f6714995f84ef,
4066            fidl::encoding::DynamicFlags::empty(),
4067            _decode,
4068        )
4069    }
4070
4071    type GetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
4072        BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
4073        fidl::encoding::DefaultFuchsiaResourceDialect,
4074    >;
4075    fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut {
4076        fn _decode(
4077            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4078        ) -> Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error> {
4079            let _response = fidl::client::decode_transaction_body::<
4080                fidl::encoding::ResultType<
4081                    BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
4082                    fidl_fuchsia_posix::Errno,
4083                >,
4084                fidl::encoding::DefaultFuchsiaResourceDialect,
4085                0x4158ba7dc2795960,
4086            >(_buf?)?;
4087            Ok(_response.map(|x| x.value))
4088        }
4089        self.client.send_query_and_decode::<
4090            fidl::encoding::EmptyPayload,
4091            BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
4092        >(
4093            (),
4094            0x4158ba7dc2795960,
4095            fidl::encoding::DynamicFlags::empty(),
4096            _decode,
4097        )
4098    }
4099
4100    type SetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
4101        BaseNetworkSocketSetIpReceiveTtlResult,
4102        fidl::encoding::DefaultFuchsiaResourceDialect,
4103    >;
4104    fn r#set_ip_receive_ttl(&self, mut value: bool) -> Self::SetIpReceiveTtlResponseFut {
4105        fn _decode(
4106            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4107        ) -> Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error> {
4108            let _response = fidl::client::decode_transaction_body::<
4109                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4110                fidl::encoding::DefaultFuchsiaResourceDialect,
4111                0x46f15be0ce0ab82b,
4112            >(_buf?)?;
4113            Ok(_response.map(|x| x))
4114        }
4115        self.client.send_query_and_decode::<
4116            BaseNetworkSocketSetIpReceiveTtlRequest,
4117            BaseNetworkSocketSetIpReceiveTtlResult,
4118        >(
4119            (value,),
4120            0x46f15be0ce0ab82b,
4121            fidl::encoding::DynamicFlags::empty(),
4122            _decode,
4123        )
4124    }
4125
4126    type GetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
4127        BaseNetworkSocketGetIpReceiveTtlResult,
4128        fidl::encoding::DefaultFuchsiaResourceDialect,
4129    >;
4130    fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut {
4131        fn _decode(
4132            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4133        ) -> Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error> {
4134            let _response = fidl::client::decode_transaction_body::<
4135                fidl::encoding::ResultType<
4136                    BaseNetworkSocketGetIpReceiveTtlResponse,
4137                    fidl_fuchsia_posix::Errno,
4138                >,
4139                fidl::encoding::DefaultFuchsiaResourceDialect,
4140                0x678ddd5a5dfa2eb5,
4141            >(_buf?)?;
4142            Ok(_response.map(|x| x.value))
4143        }
4144        self.client.send_query_and_decode::<
4145            fidl::encoding::EmptyPayload,
4146            BaseNetworkSocketGetIpReceiveTtlResult,
4147        >(
4148            (),
4149            0x678ddd5a5dfa2eb5,
4150            fidl::encoding::DynamicFlags::empty(),
4151            _decode,
4152        )
4153    }
4154
4155    type SetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
4156        BaseNetworkSocketSetIpMulticastInterfaceResult,
4157        fidl::encoding::DefaultFuchsiaResourceDialect,
4158    >;
4159    fn r#set_ip_multicast_interface(
4160        &self,
4161        mut iface: u64,
4162        mut address: &fidl_fuchsia_net::Ipv4Address,
4163    ) -> Self::SetIpMulticastInterfaceResponseFut {
4164        fn _decode(
4165            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4166        ) -> Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error> {
4167            let _response = fidl::client::decode_transaction_body::<
4168                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4169                fidl::encoding::DefaultFuchsiaResourceDialect,
4170                0x752fbfa9b12befe,
4171            >(_buf?)?;
4172            Ok(_response.map(|x| x))
4173        }
4174        self.client.send_query_and_decode::<
4175            BaseNetworkSocketSetIpMulticastInterfaceRequest,
4176            BaseNetworkSocketSetIpMulticastInterfaceResult,
4177        >(
4178            (iface, address,),
4179            0x752fbfa9b12befe,
4180            fidl::encoding::DynamicFlags::empty(),
4181            _decode,
4182        )
4183    }
4184
4185    type GetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
4186        BaseNetworkSocketGetIpMulticastInterfaceResult,
4187        fidl::encoding::DefaultFuchsiaResourceDialect,
4188    >;
4189    fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut {
4190        fn _decode(
4191            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4192        ) -> Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error> {
4193            let _response = fidl::client::decode_transaction_body::<
4194                fidl::encoding::ResultType<
4195                    BaseNetworkSocketGetIpMulticastInterfaceResponse,
4196                    fidl_fuchsia_posix::Errno,
4197                >,
4198                fidl::encoding::DefaultFuchsiaResourceDialect,
4199                0x320bd14c4df046c4,
4200            >(_buf?)?;
4201            Ok(_response.map(|x| x.value))
4202        }
4203        self.client.send_query_and_decode::<
4204            fidl::encoding::EmptyPayload,
4205            BaseNetworkSocketGetIpMulticastInterfaceResult,
4206        >(
4207            (),
4208            0x320bd14c4df046c4,
4209            fidl::encoding::DynamicFlags::empty(),
4210            _decode,
4211        )
4212    }
4213
4214    type SetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
4215        BaseNetworkSocketSetIpMulticastTtlResult,
4216        fidl::encoding::DefaultFuchsiaResourceDialect,
4217    >;
4218    fn r#set_ip_multicast_ttl(
4219        &self,
4220        mut value: &OptionalUint8,
4221    ) -> Self::SetIpMulticastTtlResponseFut {
4222        fn _decode(
4223            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4224        ) -> Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error> {
4225            let _response = fidl::client::decode_transaction_body::<
4226                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4227                fidl::encoding::DefaultFuchsiaResourceDialect,
4228                0x63134d53772916a1,
4229            >(_buf?)?;
4230            Ok(_response.map(|x| x))
4231        }
4232        self.client.send_query_and_decode::<
4233            BaseNetworkSocketSetIpMulticastTtlRequest,
4234            BaseNetworkSocketSetIpMulticastTtlResult,
4235        >(
4236            (value,),
4237            0x63134d53772916a1,
4238            fidl::encoding::DynamicFlags::empty(),
4239            _decode,
4240        )
4241    }
4242
4243    type GetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
4244        BaseNetworkSocketGetIpMulticastTtlResult,
4245        fidl::encoding::DefaultFuchsiaResourceDialect,
4246    >;
4247    fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut {
4248        fn _decode(
4249            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4250        ) -> Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error> {
4251            let _response = fidl::client::decode_transaction_body::<
4252                fidl::encoding::ResultType<
4253                    BaseNetworkSocketGetIpMulticastTtlResponse,
4254                    fidl_fuchsia_posix::Errno,
4255                >,
4256                fidl::encoding::DefaultFuchsiaResourceDialect,
4257                0x4665cd378f39e1a,
4258            >(_buf?)?;
4259            Ok(_response.map(|x| x.value))
4260        }
4261        self.client.send_query_and_decode::<
4262            fidl::encoding::EmptyPayload,
4263            BaseNetworkSocketGetIpMulticastTtlResult,
4264        >(
4265            (),
4266            0x4665cd378f39e1a,
4267            fidl::encoding::DynamicFlags::empty(),
4268            _decode,
4269        )
4270    }
4271
4272    type SetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
4273        BaseNetworkSocketSetIpMulticastLoopbackResult,
4274        fidl::encoding::DefaultFuchsiaResourceDialect,
4275    >;
4276    fn r#set_ip_multicast_loopback(
4277        &self,
4278        mut value: bool,
4279    ) -> Self::SetIpMulticastLoopbackResponseFut {
4280        fn _decode(
4281            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4282        ) -> Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error> {
4283            let _response = fidl::client::decode_transaction_body::<
4284                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4285                fidl::encoding::DefaultFuchsiaResourceDialect,
4286                0x20c55c11f00943ea,
4287            >(_buf?)?;
4288            Ok(_response.map(|x| x))
4289        }
4290        self.client.send_query_and_decode::<
4291            BaseNetworkSocketSetIpMulticastLoopbackRequest,
4292            BaseNetworkSocketSetIpMulticastLoopbackResult,
4293        >(
4294            (value,),
4295            0x20c55c11f00943ea,
4296            fidl::encoding::DynamicFlags::empty(),
4297            _decode,
4298        )
4299    }
4300
4301    type GetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
4302        BaseNetworkSocketGetIpMulticastLoopbackResult,
4303        fidl::encoding::DefaultFuchsiaResourceDialect,
4304    >;
4305    fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut {
4306        fn _decode(
4307            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4308        ) -> Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error> {
4309            let _response = fidl::client::decode_transaction_body::<
4310                fidl::encoding::ResultType<
4311                    BaseNetworkSocketGetIpMulticastLoopbackResponse,
4312                    fidl_fuchsia_posix::Errno,
4313                >,
4314                fidl::encoding::DefaultFuchsiaResourceDialect,
4315                0x3b6b26ff558298f2,
4316            >(_buf?)?;
4317            Ok(_response.map(|x| x.value))
4318        }
4319        self.client.send_query_and_decode::<
4320            fidl::encoding::EmptyPayload,
4321            BaseNetworkSocketGetIpMulticastLoopbackResult,
4322        >(
4323            (),
4324            0x3b6b26ff558298f2,
4325            fidl::encoding::DynamicFlags::empty(),
4326            _decode,
4327        )
4328    }
4329
4330    type AddIpMembershipResponseFut = fidl::client::QueryResponseFut<
4331        BaseNetworkSocketAddIpMembershipResult,
4332        fidl::encoding::DefaultFuchsiaResourceDialect,
4333    >;
4334    fn r#add_ip_membership(
4335        &self,
4336        mut membership: &IpMulticastMembership,
4337    ) -> Self::AddIpMembershipResponseFut {
4338        fn _decode(
4339            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4340        ) -> Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error> {
4341            let _response = fidl::client::decode_transaction_body::<
4342                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4343                fidl::encoding::DefaultFuchsiaResourceDialect,
4344                0x76bc7df115a3b4d0,
4345            >(_buf?)?;
4346            Ok(_response.map(|x| x))
4347        }
4348        self.client.send_query_and_decode::<
4349            BaseNetworkSocketAddIpMembershipRequest,
4350            BaseNetworkSocketAddIpMembershipResult,
4351        >(
4352            (membership,),
4353            0x76bc7df115a3b4d0,
4354            fidl::encoding::DynamicFlags::empty(),
4355            _decode,
4356        )
4357    }
4358
4359    type DropIpMembershipResponseFut = fidl::client::QueryResponseFut<
4360        BaseNetworkSocketDropIpMembershipResult,
4361        fidl::encoding::DefaultFuchsiaResourceDialect,
4362    >;
4363    fn r#drop_ip_membership(
4364        &self,
4365        mut membership: &IpMulticastMembership,
4366    ) -> Self::DropIpMembershipResponseFut {
4367        fn _decode(
4368            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4369        ) -> Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error> {
4370            let _response = fidl::client::decode_transaction_body::<
4371                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4372                fidl::encoding::DefaultFuchsiaResourceDialect,
4373                0x2888f3099188d03,
4374            >(_buf?)?;
4375            Ok(_response.map(|x| x))
4376        }
4377        self.client.send_query_and_decode::<
4378            BaseNetworkSocketDropIpMembershipRequest,
4379            BaseNetworkSocketDropIpMembershipResult,
4380        >(
4381            (membership,),
4382            0x2888f3099188d03,
4383            fidl::encoding::DynamicFlags::empty(),
4384            _decode,
4385        )
4386    }
4387
4388    type SetIpTransparentResponseFut = fidl::client::QueryResponseFut<
4389        BaseNetworkSocketSetIpTransparentResult,
4390        fidl::encoding::DefaultFuchsiaResourceDialect,
4391    >;
4392    fn r#set_ip_transparent(&self, mut value: bool) -> Self::SetIpTransparentResponseFut {
4393        fn _decode(
4394            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4395        ) -> Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error> {
4396            let _response = fidl::client::decode_transaction_body::<
4397                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4398                fidl::encoding::DefaultFuchsiaResourceDialect,
4399                0x1ae532b0c066e3a0,
4400            >(_buf?)?;
4401            Ok(_response.map(|x| x))
4402        }
4403        self.client.send_query_and_decode::<
4404            BaseNetworkSocketSetIpTransparentRequest,
4405            BaseNetworkSocketSetIpTransparentResult,
4406        >(
4407            (value,),
4408            0x1ae532b0c066e3a0,
4409            fidl::encoding::DynamicFlags::empty(),
4410            _decode,
4411        )
4412    }
4413
4414    type GetIpTransparentResponseFut = fidl::client::QueryResponseFut<
4415        BaseNetworkSocketGetIpTransparentResult,
4416        fidl::encoding::DefaultFuchsiaResourceDialect,
4417    >;
4418    fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut {
4419        fn _decode(
4420            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4421        ) -> Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error> {
4422            let _response = fidl::client::decode_transaction_body::<
4423                fidl::encoding::ResultType<
4424                    BaseNetworkSocketGetIpTransparentResponse,
4425                    fidl_fuchsia_posix::Errno,
4426                >,
4427                fidl::encoding::DefaultFuchsiaResourceDialect,
4428                0x51d43695962ebfb5,
4429            >(_buf?)?;
4430            Ok(_response.map(|x| x.value))
4431        }
4432        self.client.send_query_and_decode::<
4433            fidl::encoding::EmptyPayload,
4434            BaseNetworkSocketGetIpTransparentResult,
4435        >(
4436            (),
4437            0x51d43695962ebfb5,
4438            fidl::encoding::DynamicFlags::empty(),
4439            _decode,
4440        )
4441    }
4442
4443    type SetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
4444        BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
4445        fidl::encoding::DefaultFuchsiaResourceDialect,
4446    >;
4447    fn r#set_ip_receive_original_destination_address(
4448        &self,
4449        mut value: bool,
4450    ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut {
4451        fn _decode(
4452            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4453        ) -> Result<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error>
4454        {
4455            let _response = fidl::client::decode_transaction_body::<
4456                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4457                fidl::encoding::DefaultFuchsiaResourceDialect,
4458                0x4722b4ce52f7840,
4459            >(_buf?)?;
4460            Ok(_response.map(|x| x))
4461        }
4462        self.client.send_query_and_decode::<
4463            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
4464            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
4465        >(
4466            (value,),
4467            0x4722b4ce52f7840,
4468            fidl::encoding::DynamicFlags::empty(),
4469            _decode,
4470        )
4471    }
4472
4473    type GetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
4474        BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
4475        fidl::encoding::DefaultFuchsiaResourceDialect,
4476    >;
4477    fn r#get_ip_receive_original_destination_address(
4478        &self,
4479    ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut {
4480        fn _decode(
4481            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4482        ) -> Result<BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error>
4483        {
4484            let _response = fidl::client::decode_transaction_body::<
4485                fidl::encoding::ResultType<
4486                    BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
4487                    fidl_fuchsia_posix::Errno,
4488                >,
4489                fidl::encoding::DefaultFuchsiaResourceDialect,
4490                0x2a0e7dc5d6bfdfe9,
4491            >(_buf?)?;
4492            Ok(_response.map(|x| x.value))
4493        }
4494        self.client.send_query_and_decode::<
4495            fidl::encoding::EmptyPayload,
4496            BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
4497        >(
4498            (),
4499            0x2a0e7dc5d6bfdfe9,
4500            fidl::encoding::DynamicFlags::empty(),
4501            _decode,
4502        )
4503    }
4504
4505    type AddIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
4506        BaseNetworkSocketAddIpv6MembershipResult,
4507        fidl::encoding::DefaultFuchsiaResourceDialect,
4508    >;
4509    fn r#add_ipv6_membership(
4510        &self,
4511        mut membership: &Ipv6MulticastMembership,
4512    ) -> Self::AddIpv6MembershipResponseFut {
4513        fn _decode(
4514            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4515        ) -> Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error> {
4516            let _response = fidl::client::decode_transaction_body::<
4517                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4518                fidl::encoding::DefaultFuchsiaResourceDialect,
4519                0x7c94727acb4ea4b3,
4520            >(_buf?)?;
4521            Ok(_response.map(|x| x))
4522        }
4523        self.client.send_query_and_decode::<
4524            BaseNetworkSocketAddIpv6MembershipRequest,
4525            BaseNetworkSocketAddIpv6MembershipResult,
4526        >(
4527            (membership,),
4528            0x7c94727acb4ea4b3,
4529            fidl::encoding::DynamicFlags::empty(),
4530            _decode,
4531        )
4532    }
4533
4534    type DropIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
4535        BaseNetworkSocketDropIpv6MembershipResult,
4536        fidl::encoding::DefaultFuchsiaResourceDialect,
4537    >;
4538    fn r#drop_ipv6_membership(
4539        &self,
4540        mut membership: &Ipv6MulticastMembership,
4541    ) -> Self::DropIpv6MembershipResponseFut {
4542        fn _decode(
4543            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4544        ) -> Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error> {
4545            let _response = fidl::client::decode_transaction_body::<
4546                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4547                fidl::encoding::DefaultFuchsiaResourceDialect,
4548                0x42104c70ccaba304,
4549            >(_buf?)?;
4550            Ok(_response.map(|x| x))
4551        }
4552        self.client.send_query_and_decode::<
4553            BaseNetworkSocketDropIpv6MembershipRequest,
4554            BaseNetworkSocketDropIpv6MembershipResult,
4555        >(
4556            (membership,),
4557            0x42104c70ccaba304,
4558            fidl::encoding::DynamicFlags::empty(),
4559            _decode,
4560        )
4561    }
4562
4563    type SetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
4564        BaseNetworkSocketSetIpv6MulticastInterfaceResult,
4565        fidl::encoding::DefaultFuchsiaResourceDialect,
4566    >;
4567    fn r#set_ipv6_multicast_interface(
4568        &self,
4569        mut value: u64,
4570    ) -> Self::SetIpv6MulticastInterfaceResponseFut {
4571        fn _decode(
4572            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4573        ) -> Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error> {
4574            let _response = fidl::client::decode_transaction_body::<
4575                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4576                fidl::encoding::DefaultFuchsiaResourceDialect,
4577                0x135f76db3774ab3b,
4578            >(_buf?)?;
4579            Ok(_response.map(|x| x))
4580        }
4581        self.client.send_query_and_decode::<
4582            BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
4583            BaseNetworkSocketSetIpv6MulticastInterfaceResult,
4584        >(
4585            (value,),
4586            0x135f76db3774ab3b,
4587            fidl::encoding::DynamicFlags::empty(),
4588            _decode,
4589        )
4590    }
4591
4592    type GetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
4593        BaseNetworkSocketGetIpv6MulticastInterfaceResult,
4594        fidl::encoding::DefaultFuchsiaResourceDialect,
4595    >;
4596    fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut {
4597        fn _decode(
4598            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4599        ) -> Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error> {
4600            let _response = fidl::client::decode_transaction_body::<
4601                fidl::encoding::ResultType<
4602                    BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
4603                    fidl_fuchsia_posix::Errno,
4604                >,
4605                fidl::encoding::DefaultFuchsiaResourceDialect,
4606                0x1f26fcdd348f1882,
4607            >(_buf?)?;
4608            Ok(_response.map(|x| x.value))
4609        }
4610        self.client.send_query_and_decode::<
4611            fidl::encoding::EmptyPayload,
4612            BaseNetworkSocketGetIpv6MulticastInterfaceResult,
4613        >(
4614            (),
4615            0x1f26fcdd348f1882,
4616            fidl::encoding::DynamicFlags::empty(),
4617            _decode,
4618        )
4619    }
4620
4621    type SetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
4622        BaseNetworkSocketSetIpv6UnicastHopsResult,
4623        fidl::encoding::DefaultFuchsiaResourceDialect,
4624    >;
4625    fn r#set_ipv6_unicast_hops(
4626        &self,
4627        mut value: &OptionalUint8,
4628    ) -> Self::SetIpv6UnicastHopsResponseFut {
4629        fn _decode(
4630            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4631        ) -> Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error> {
4632            let _response = fidl::client::decode_transaction_body::<
4633                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4634                fidl::encoding::DefaultFuchsiaResourceDialect,
4635                0x157d51e98f462859,
4636            >(_buf?)?;
4637            Ok(_response.map(|x| x))
4638        }
4639        self.client.send_query_and_decode::<
4640            BaseNetworkSocketSetIpv6UnicastHopsRequest,
4641            BaseNetworkSocketSetIpv6UnicastHopsResult,
4642        >(
4643            (value,),
4644            0x157d51e98f462859,
4645            fidl::encoding::DynamicFlags::empty(),
4646            _decode,
4647        )
4648    }
4649
4650    type GetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
4651        BaseNetworkSocketGetIpv6UnicastHopsResult,
4652        fidl::encoding::DefaultFuchsiaResourceDialect,
4653    >;
4654    fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut {
4655        fn _decode(
4656            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4657        ) -> Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error> {
4658            let _response = fidl::client::decode_transaction_body::<
4659                fidl::encoding::ResultType<
4660                    BaseNetworkSocketGetIpv6UnicastHopsResponse,
4661                    fidl_fuchsia_posix::Errno,
4662                >,
4663                fidl::encoding::DefaultFuchsiaResourceDialect,
4664                0x21f4641cad8bd8d2,
4665            >(_buf?)?;
4666            Ok(_response.map(|x| x.value))
4667        }
4668        self.client.send_query_and_decode::<
4669            fidl::encoding::EmptyPayload,
4670            BaseNetworkSocketGetIpv6UnicastHopsResult,
4671        >(
4672            (),
4673            0x21f4641cad8bd8d2,
4674            fidl::encoding::DynamicFlags::empty(),
4675            _decode,
4676        )
4677    }
4678
4679    type SetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
4680        BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
4681        fidl::encoding::DefaultFuchsiaResourceDialect,
4682    >;
4683    fn r#set_ipv6_receive_hop_limit(
4684        &self,
4685        mut value: bool,
4686    ) -> Self::SetIpv6ReceiveHopLimitResponseFut {
4687        fn _decode(
4688            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4689        ) -> Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error> {
4690            let _response = fidl::client::decode_transaction_body::<
4691                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4692                fidl::encoding::DefaultFuchsiaResourceDialect,
4693                0x5c24808ed2e84a1e,
4694            >(_buf?)?;
4695            Ok(_response.map(|x| x))
4696        }
4697        self.client.send_query_and_decode::<
4698            BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
4699            BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
4700        >(
4701            (value,),
4702            0x5c24808ed2e84a1e,
4703            fidl::encoding::DynamicFlags::empty(),
4704            _decode,
4705        )
4706    }
4707
4708    type GetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
4709        BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
4710        fidl::encoding::DefaultFuchsiaResourceDialect,
4711    >;
4712    fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut {
4713        fn _decode(
4714            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4715        ) -> Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error> {
4716            let _response = fidl::client::decode_transaction_body::<
4717                fidl::encoding::ResultType<
4718                    BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
4719                    fidl_fuchsia_posix::Errno,
4720                >,
4721                fidl::encoding::DefaultFuchsiaResourceDialect,
4722                0x341e06689885b4c0,
4723            >(_buf?)?;
4724            Ok(_response.map(|x| x.value))
4725        }
4726        self.client.send_query_and_decode::<
4727            fidl::encoding::EmptyPayload,
4728            BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
4729        >(
4730            (),
4731            0x341e06689885b4c0,
4732            fidl::encoding::DynamicFlags::empty(),
4733            _decode,
4734        )
4735    }
4736
4737    type SetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
4738        BaseNetworkSocketSetIpv6MulticastHopsResult,
4739        fidl::encoding::DefaultFuchsiaResourceDialect,
4740    >;
4741    fn r#set_ipv6_multicast_hops(
4742        &self,
4743        mut value: &OptionalUint8,
4744    ) -> Self::SetIpv6MulticastHopsResponseFut {
4745        fn _decode(
4746            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4747        ) -> Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error> {
4748            let _response = fidl::client::decode_transaction_body::<
4749                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4750                fidl::encoding::DefaultFuchsiaResourceDialect,
4751                0x25b9cd4d181f82c1,
4752            >(_buf?)?;
4753            Ok(_response.map(|x| x))
4754        }
4755        self.client.send_query_and_decode::<
4756            BaseNetworkSocketSetIpv6MulticastHopsRequest,
4757            BaseNetworkSocketSetIpv6MulticastHopsResult,
4758        >(
4759            (value,),
4760            0x25b9cd4d181f82c1,
4761            fidl::encoding::DynamicFlags::empty(),
4762            _decode,
4763        )
4764    }
4765
4766    type GetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
4767        BaseNetworkSocketGetIpv6MulticastHopsResult,
4768        fidl::encoding::DefaultFuchsiaResourceDialect,
4769    >;
4770    fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut {
4771        fn _decode(
4772            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4773        ) -> Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error> {
4774            let _response = fidl::client::decode_transaction_body::<
4775                fidl::encoding::ResultType<
4776                    BaseNetworkSocketGetIpv6MulticastHopsResponse,
4777                    fidl_fuchsia_posix::Errno,
4778                >,
4779                fidl::encoding::DefaultFuchsiaResourceDialect,
4780                0x52916948a365012a,
4781            >(_buf?)?;
4782            Ok(_response.map(|x| x.value))
4783        }
4784        self.client.send_query_and_decode::<
4785            fidl::encoding::EmptyPayload,
4786            BaseNetworkSocketGetIpv6MulticastHopsResult,
4787        >(
4788            (),
4789            0x52916948a365012a,
4790            fidl::encoding::DynamicFlags::empty(),
4791            _decode,
4792        )
4793    }
4794
4795    type SetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
4796        BaseNetworkSocketSetIpv6MulticastLoopbackResult,
4797        fidl::encoding::DefaultFuchsiaResourceDialect,
4798    >;
4799    fn r#set_ipv6_multicast_loopback(
4800        &self,
4801        mut value: bool,
4802    ) -> Self::SetIpv6MulticastLoopbackResponseFut {
4803        fn _decode(
4804            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4805        ) -> Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error> {
4806            let _response = fidl::client::decode_transaction_body::<
4807                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4808                fidl::encoding::DefaultFuchsiaResourceDialect,
4809                0x55701c409ff41b40,
4810            >(_buf?)?;
4811            Ok(_response.map(|x| x))
4812        }
4813        self.client.send_query_and_decode::<
4814            BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
4815            BaseNetworkSocketSetIpv6MulticastLoopbackResult,
4816        >(
4817            (value,),
4818            0x55701c409ff41b40,
4819            fidl::encoding::DynamicFlags::empty(),
4820            _decode,
4821        )
4822    }
4823
4824    type GetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
4825        BaseNetworkSocketGetIpv6MulticastLoopbackResult,
4826        fidl::encoding::DefaultFuchsiaResourceDialect,
4827    >;
4828    fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut {
4829        fn _decode(
4830            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4831        ) -> Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error> {
4832            let _response = fidl::client::decode_transaction_body::<
4833                fidl::encoding::ResultType<
4834                    BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
4835                    fidl_fuchsia_posix::Errno,
4836                >,
4837                fidl::encoding::DefaultFuchsiaResourceDialect,
4838                0x4415b701fde319c3,
4839            >(_buf?)?;
4840            Ok(_response.map(|x| x.value))
4841        }
4842        self.client.send_query_and_decode::<
4843            fidl::encoding::EmptyPayload,
4844            BaseNetworkSocketGetIpv6MulticastLoopbackResult,
4845        >(
4846            (),
4847            0x4415b701fde319c3,
4848            fidl::encoding::DynamicFlags::empty(),
4849            _decode,
4850        )
4851    }
4852
4853    type SetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
4854        BaseNetworkSocketSetIpv6OnlyResult,
4855        fidl::encoding::DefaultFuchsiaResourceDialect,
4856    >;
4857    fn r#set_ipv6_only(&self, mut value: bool) -> Self::SetIpv6OnlyResponseFut {
4858        fn _decode(
4859            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4860        ) -> Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
4861            let _response = fidl::client::decode_transaction_body::<
4862                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4863                fidl::encoding::DefaultFuchsiaResourceDialect,
4864                0x4873f1364758cbba,
4865            >(_buf?)?;
4866            Ok(_response.map(|x| x))
4867        }
4868        self.client.send_query_and_decode::<
4869            BaseNetworkSocketSetIpv6OnlyRequest,
4870            BaseNetworkSocketSetIpv6OnlyResult,
4871        >(
4872            (value,),
4873            0x4873f1364758cbba,
4874            fidl::encoding::DynamicFlags::empty(),
4875            _decode,
4876        )
4877    }
4878
4879    type GetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
4880        BaseNetworkSocketGetIpv6OnlyResult,
4881        fidl::encoding::DefaultFuchsiaResourceDialect,
4882    >;
4883    fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut {
4884        fn _decode(
4885            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4886        ) -> Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
4887            let _response = fidl::client::decode_transaction_body::<
4888                fidl::encoding::ResultType<
4889                    BaseNetworkSocketGetIpv6OnlyResponse,
4890                    fidl_fuchsia_posix::Errno,
4891                >,
4892                fidl::encoding::DefaultFuchsiaResourceDialect,
4893                0x4aa3340a1a26b89c,
4894            >(_buf?)?;
4895            Ok(_response.map(|x| x.value))
4896        }
4897        self.client.send_query_and_decode::<
4898            fidl::encoding::EmptyPayload,
4899            BaseNetworkSocketGetIpv6OnlyResult,
4900        >(
4901            (),
4902            0x4aa3340a1a26b89c,
4903            fidl::encoding::DynamicFlags::empty(),
4904            _decode,
4905        )
4906    }
4907
4908    type SetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
4909        BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
4910        fidl::encoding::DefaultFuchsiaResourceDialect,
4911    >;
4912    fn r#set_ipv6_receive_traffic_class(
4913        &self,
4914        mut value: bool,
4915    ) -> Self::SetIpv6ReceiveTrafficClassResponseFut {
4916        fn _decode(
4917            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4918        ) -> Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error> {
4919            let _response = fidl::client::decode_transaction_body::<
4920                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4921                fidl::encoding::DefaultFuchsiaResourceDialect,
4922                0x58f07c8788d099a0,
4923            >(_buf?)?;
4924            Ok(_response.map(|x| x))
4925        }
4926        self.client.send_query_and_decode::<
4927            BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
4928            BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
4929        >(
4930            (value,),
4931            0x58f07c8788d099a0,
4932            fidl::encoding::DynamicFlags::empty(),
4933            _decode,
4934        )
4935    }
4936
4937    type GetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
4938        BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
4939        fidl::encoding::DefaultFuchsiaResourceDialect,
4940    >;
4941    fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut {
4942        fn _decode(
4943            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4944        ) -> Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error> {
4945            let _response = fidl::client::decode_transaction_body::<
4946                fidl::encoding::ResultType<
4947                    BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
4948                    fidl_fuchsia_posix::Errno,
4949                >,
4950                fidl::encoding::DefaultFuchsiaResourceDialect,
4951                0x2e334df1da553ffa,
4952            >(_buf?)?;
4953            Ok(_response.map(|x| x.value))
4954        }
4955        self.client.send_query_and_decode::<
4956            fidl::encoding::EmptyPayload,
4957            BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
4958        >(
4959            (),
4960            0x2e334df1da553ffa,
4961            fidl::encoding::DynamicFlags::empty(),
4962            _decode,
4963        )
4964    }
4965
4966    type SetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
4967        BaseNetworkSocketSetIpv6TrafficClassResult,
4968        fidl::encoding::DefaultFuchsiaResourceDialect,
4969    >;
4970    fn r#set_ipv6_traffic_class(
4971        &self,
4972        mut value: &OptionalUint8,
4973    ) -> Self::SetIpv6TrafficClassResponseFut {
4974        fn _decode(
4975            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
4976        ) -> Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error> {
4977            let _response = fidl::client::decode_transaction_body::<
4978                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
4979                fidl::encoding::DefaultFuchsiaResourceDialect,
4980                0x6af077800c5a0b4f,
4981            >(_buf?)?;
4982            Ok(_response.map(|x| x))
4983        }
4984        self.client.send_query_and_decode::<
4985            BaseNetworkSocketSetIpv6TrafficClassRequest,
4986            BaseNetworkSocketSetIpv6TrafficClassResult,
4987        >(
4988            (value,),
4989            0x6af077800c5a0b4f,
4990            fidl::encoding::DynamicFlags::empty(),
4991            _decode,
4992        )
4993    }
4994
4995    type GetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
4996        BaseNetworkSocketGetIpv6TrafficClassResult,
4997        fidl::encoding::DefaultFuchsiaResourceDialect,
4998    >;
4999    fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut {
5000        fn _decode(
5001            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5002        ) -> Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error> {
5003            let _response = fidl::client::decode_transaction_body::<
5004                fidl::encoding::ResultType<
5005                    BaseNetworkSocketGetIpv6TrafficClassResponse,
5006                    fidl_fuchsia_posix::Errno,
5007                >,
5008                fidl::encoding::DefaultFuchsiaResourceDialect,
5009                0x6baf6eed8fc2f04,
5010            >(_buf?)?;
5011            Ok(_response.map(|x| x.value))
5012        }
5013        self.client.send_query_and_decode::<
5014            fidl::encoding::EmptyPayload,
5015            BaseNetworkSocketGetIpv6TrafficClassResult,
5016        >(
5017            (),
5018            0x6baf6eed8fc2f04,
5019            fidl::encoding::DynamicFlags::empty(),
5020            _decode,
5021        )
5022    }
5023
5024    type SetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
5025        BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
5026        fidl::encoding::DefaultFuchsiaResourceDialect,
5027    >;
5028    fn r#set_ipv6_receive_packet_info(
5029        &self,
5030        mut value: bool,
5031    ) -> Self::SetIpv6ReceivePacketInfoResponseFut {
5032        fn _decode(
5033            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5034        ) -> Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error> {
5035            let _response = fidl::client::decode_transaction_body::<
5036                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
5037                fidl::encoding::DefaultFuchsiaResourceDialect,
5038                0x19259775b1a92768,
5039            >(_buf?)?;
5040            Ok(_response.map(|x| x))
5041        }
5042        self.client.send_query_and_decode::<
5043            BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
5044            BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
5045        >(
5046            (value,),
5047            0x19259775b1a92768,
5048            fidl::encoding::DynamicFlags::empty(),
5049            _decode,
5050        )
5051    }
5052
5053    type GetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
5054        BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
5055        fidl::encoding::DefaultFuchsiaResourceDialect,
5056    >;
5057    fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut {
5058        fn _decode(
5059            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5060        ) -> Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error> {
5061            let _response = fidl::client::decode_transaction_body::<
5062                fidl::encoding::ResultType<
5063                    BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
5064                    fidl_fuchsia_posix::Errno,
5065                >,
5066                fidl::encoding::DefaultFuchsiaResourceDialect,
5067                0x7acd4a2775baec75,
5068            >(_buf?)?;
5069            Ok(_response.map(|x| x.value))
5070        }
5071        self.client.send_query_and_decode::<
5072            fidl::encoding::EmptyPayload,
5073            BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
5074        >(
5075            (),
5076            0x7acd4a2775baec75,
5077            fidl::encoding::DynamicFlags::empty(),
5078            _decode,
5079        )
5080    }
5081
5082    type GetOriginalDestinationResponseFut = fidl::client::QueryResponseFut<
5083        BaseNetworkSocketGetOriginalDestinationResult,
5084        fidl::encoding::DefaultFuchsiaResourceDialect,
5085    >;
5086    fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut {
5087        fn _decode(
5088            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5089        ) -> Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error> {
5090            let _response = fidl::client::decode_transaction_body::<
5091                fidl::encoding::ResultType<
5092                    BaseNetworkSocketGetOriginalDestinationResponse,
5093                    fidl_fuchsia_posix::Errno,
5094                >,
5095                fidl::encoding::DefaultFuchsiaResourceDialect,
5096                0x38bf28f0dafdbac0,
5097            >(_buf?)?;
5098            Ok(_response.map(|x| x.value))
5099        }
5100        self.client.send_query_and_decode::<
5101            fidl::encoding::EmptyPayload,
5102            BaseNetworkSocketGetOriginalDestinationResult,
5103        >(
5104            (),
5105            0x38bf28f0dafdbac0,
5106            fidl::encoding::DynamicFlags::empty(),
5107            _decode,
5108        )
5109    }
5110
5111    type GetInfoResponseFut = fidl::client::QueryResponseFut<
5112        BaseDatagramSocketGetInfoResult,
5113        fidl::encoding::DefaultFuchsiaResourceDialect,
5114    >;
5115    fn r#get_info(&self) -> Self::GetInfoResponseFut {
5116        fn _decode(
5117            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
5118        ) -> Result<BaseDatagramSocketGetInfoResult, fidl::Error> {
5119            let _response = fidl::client::decode_transaction_body::<
5120                fidl::encoding::ResultType<
5121                    BaseDatagramSocketGetInfoResponse,
5122                    fidl_fuchsia_posix::Errno,
5123                >,
5124                fidl::encoding::DefaultFuchsiaResourceDialect,
5125                0x48aa0a1f6a32d2ed,
5126            >(_buf?)?;
5127            Ok(_response.map(|x| (x.domain, x.proto)))
5128        }
5129        self.client
5130            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseDatagramSocketGetInfoResult>(
5131                (),
5132                0x48aa0a1f6a32d2ed,
5133                fidl::encoding::DynamicFlags::empty(),
5134                _decode,
5135            )
5136    }
5137}
5138
5139pub struct BaseDatagramSocketEventStream {
5140    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
5141}
5142
5143impl std::marker::Unpin for BaseDatagramSocketEventStream {}
5144
5145impl futures::stream::FusedStream for BaseDatagramSocketEventStream {
5146    fn is_terminated(&self) -> bool {
5147        self.event_receiver.is_terminated()
5148    }
5149}
5150
5151impl futures::Stream for BaseDatagramSocketEventStream {
5152    type Item = Result<BaseDatagramSocketEvent, fidl::Error>;
5153
5154    fn poll_next(
5155        mut self: std::pin::Pin<&mut Self>,
5156        cx: &mut std::task::Context<'_>,
5157    ) -> std::task::Poll<Option<Self::Item>> {
5158        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
5159            &mut self.event_receiver,
5160            cx
5161        )?) {
5162            Some(buf) => std::task::Poll::Ready(Some(BaseDatagramSocketEvent::decode(buf))),
5163            None => std::task::Poll::Ready(None),
5164        }
5165    }
5166}
5167
5168#[derive(Debug)]
5169pub enum BaseDatagramSocketEvent {}
5170
5171impl BaseDatagramSocketEvent {
5172    /// Decodes a message buffer as a [`BaseDatagramSocketEvent`].
5173    fn decode(
5174        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
5175    ) -> Result<BaseDatagramSocketEvent, fidl::Error> {
5176        let (bytes, _handles) = buf.split_mut();
5177        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
5178        debug_assert_eq!(tx_header.tx_id, 0);
5179        match tx_header.ordinal {
5180            _ => Err(fidl::Error::UnknownOrdinal {
5181                ordinal: tx_header.ordinal,
5182                protocol_name:
5183                    <BaseDatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
5184            }),
5185        }
5186    }
5187}
5188
5189/// A Stream of incoming requests for fuchsia.posix.socket/BaseDatagramSocket.
5190pub struct BaseDatagramSocketRequestStream {
5191    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
5192    is_terminated: bool,
5193}
5194
5195impl std::marker::Unpin for BaseDatagramSocketRequestStream {}
5196
5197impl futures::stream::FusedStream for BaseDatagramSocketRequestStream {
5198    fn is_terminated(&self) -> bool {
5199        self.is_terminated
5200    }
5201}
5202
5203impl fidl::endpoints::RequestStream for BaseDatagramSocketRequestStream {
5204    type Protocol = BaseDatagramSocketMarker;
5205    type ControlHandle = BaseDatagramSocketControlHandle;
5206
5207    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
5208        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
5209    }
5210
5211    fn control_handle(&self) -> Self::ControlHandle {
5212        BaseDatagramSocketControlHandle { inner: self.inner.clone() }
5213    }
5214
5215    fn into_inner(
5216        self,
5217    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
5218    {
5219        (self.inner, self.is_terminated)
5220    }
5221
5222    fn from_inner(
5223        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
5224        is_terminated: bool,
5225    ) -> Self {
5226        Self { inner, is_terminated }
5227    }
5228}
5229
5230impl futures::Stream for BaseDatagramSocketRequestStream {
5231    type Item = Result<BaseDatagramSocketRequest, fidl::Error>;
5232
5233    fn poll_next(
5234        mut self: std::pin::Pin<&mut Self>,
5235        cx: &mut std::task::Context<'_>,
5236    ) -> std::task::Poll<Option<Self::Item>> {
5237        let this = &mut *self;
5238        if this.inner.check_shutdown(cx) {
5239            this.is_terminated = true;
5240            return std::task::Poll::Ready(None);
5241        }
5242        if this.is_terminated {
5243            panic!("polled BaseDatagramSocketRequestStream after completion");
5244        }
5245        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
5246            |bytes, handles| {
5247                match this.inner.channel().read_etc(cx, bytes, handles) {
5248                    std::task::Poll::Ready(Ok(())) => {}
5249                    std::task::Poll::Pending => return std::task::Poll::Pending,
5250                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
5251                        this.is_terminated = true;
5252                        return std::task::Poll::Ready(None);
5253                    }
5254                    std::task::Poll::Ready(Err(e)) => {
5255                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
5256                            e.into(),
5257                        ))))
5258                    }
5259                }
5260
5261                // A message has been received from the channel
5262                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
5263
5264                std::task::Poll::Ready(Some(match header.ordinal {
5265                0x20d8a7aba2168a79 => {
5266                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
5267                    let mut req = fidl::new_empty!(fidl_fuchsia_unknown::CloneableCloneRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5268                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_unknown::CloneableCloneRequest>(&header, _body_bytes, handles, &mut req)?;
5269                    let control_handle = BaseDatagramSocketControlHandle {
5270                        inner: this.inner.clone(),
5271                    };
5272                    Ok(BaseDatagramSocketRequest::Clone {request: req.request,
5273
5274                        control_handle,
5275                    })
5276                }
5277                0x5ac5d459ad7f657e => {
5278                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5279                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5280                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5281                    let control_handle = BaseDatagramSocketControlHandle {
5282                        inner: this.inner.clone(),
5283                    };
5284                    Ok(BaseDatagramSocketRequest::Close {
5285                        responder: BaseDatagramSocketCloseResponder {
5286                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5287                            tx_id: header.tx_id,
5288                        },
5289                    })
5290                }
5291                0x2658edee9decfc06 => {
5292                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5293                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5294                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5295                    let control_handle = BaseDatagramSocketControlHandle {
5296                        inner: this.inner.clone(),
5297                    };
5298                    Ok(BaseDatagramSocketRequest::Query {
5299                        responder: BaseDatagramSocketQueryResponder {
5300                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5301                            tx_id: header.tx_id,
5302                        },
5303                    })
5304                }
5305                0x1fd74ee8b9a4a876 => {
5306                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5307                    let mut req = fidl::new_empty!(BaseSocketSetReuseAddressRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5308                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReuseAddressRequest>(&header, _body_bytes, handles, &mut req)?;
5309                    let control_handle = BaseDatagramSocketControlHandle {
5310                        inner: this.inner.clone(),
5311                    };
5312                    Ok(BaseDatagramSocketRequest::SetReuseAddress {value: req.value,
5313
5314                        responder: BaseDatagramSocketSetReuseAddressResponder {
5315                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5316                            tx_id: header.tx_id,
5317                        },
5318                    })
5319                }
5320                0x67b7206b8d1bc0a5 => {
5321                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5322                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5323                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5324                    let control_handle = BaseDatagramSocketControlHandle {
5325                        inner: this.inner.clone(),
5326                    };
5327                    Ok(BaseDatagramSocketRequest::GetReuseAddress {
5328                        responder: BaseDatagramSocketGetReuseAddressResponder {
5329                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5330                            tx_id: header.tx_id,
5331                        },
5332                    })
5333                }
5334                0x5aad39b33e5f6ebb => {
5335                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5336                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5337                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5338                    let control_handle = BaseDatagramSocketControlHandle {
5339                        inner: this.inner.clone(),
5340                    };
5341                    Ok(BaseDatagramSocketRequest::GetError {
5342                        responder: BaseDatagramSocketGetErrorResponder {
5343                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5344                            tx_id: header.tx_id,
5345                        },
5346                    })
5347                }
5348                0x6023e081ce3cd947 => {
5349                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5350                    let mut req = fidl::new_empty!(BaseSocketSetBroadcastRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5351                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBroadcastRequest>(&header, _body_bytes, handles, &mut req)?;
5352                    let control_handle = BaseDatagramSocketControlHandle {
5353                        inner: this.inner.clone(),
5354                    };
5355                    Ok(BaseDatagramSocketRequest::SetBroadcast {value: req.value,
5356
5357                        responder: BaseDatagramSocketSetBroadcastResponder {
5358                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5359                            tx_id: header.tx_id,
5360                        },
5361                    })
5362                }
5363                0x68796fc556f9780d => {
5364                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5365                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5366                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5367                    let control_handle = BaseDatagramSocketControlHandle {
5368                        inner: this.inner.clone(),
5369                    };
5370                    Ok(BaseDatagramSocketRequest::GetBroadcast {
5371                        responder: BaseDatagramSocketGetBroadcastResponder {
5372                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5373                            tx_id: header.tx_id,
5374                        },
5375                    })
5376                }
5377                0x756eac32d73a7a70 => {
5378                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5379                    let mut req = fidl::new_empty!(BaseSocketSetSendBufferRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5380                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetSendBufferRequest>(&header, _body_bytes, handles, &mut req)?;
5381                    let control_handle = BaseDatagramSocketControlHandle {
5382                        inner: this.inner.clone(),
5383                    };
5384                    Ok(BaseDatagramSocketRequest::SetSendBuffer {value_bytes: req.value_bytes,
5385
5386                        responder: BaseDatagramSocketSetSendBufferResponder {
5387                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5388                            tx_id: header.tx_id,
5389                        },
5390                    })
5391                }
5392                0x78a52fd9c7b2410b => {
5393                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5394                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5395                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5396                    let control_handle = BaseDatagramSocketControlHandle {
5397                        inner: this.inner.clone(),
5398                    };
5399                    Ok(BaseDatagramSocketRequest::GetSendBuffer {
5400                        responder: BaseDatagramSocketGetSendBufferResponder {
5401                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5402                            tx_id: header.tx_id,
5403                        },
5404                    })
5405                }
5406                0x6b0cf2f1919c7001 => {
5407                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5408                    let mut req = fidl::new_empty!(BaseSocketSetReceiveBufferRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5409                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReceiveBufferRequest>(&header, _body_bytes, handles, &mut req)?;
5410                    let control_handle = BaseDatagramSocketControlHandle {
5411                        inner: this.inner.clone(),
5412                    };
5413                    Ok(BaseDatagramSocketRequest::SetReceiveBuffer {value_bytes: req.value_bytes,
5414
5415                        responder: BaseDatagramSocketSetReceiveBufferResponder {
5416                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5417                            tx_id: header.tx_id,
5418                        },
5419                    })
5420                }
5421                0x14c1a4b64f709e5c => {
5422                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5423                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5424                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5425                    let control_handle = BaseDatagramSocketControlHandle {
5426                        inner: this.inner.clone(),
5427                    };
5428                    Ok(BaseDatagramSocketRequest::GetReceiveBuffer {
5429                        responder: BaseDatagramSocketGetReceiveBufferResponder {
5430                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5431                            tx_id: header.tx_id,
5432                        },
5433                    })
5434                }
5435                0x572df8f0b920d2c7 => {
5436                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5437                    let mut req = fidl::new_empty!(BaseSocketSetKeepAliveRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5438                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetKeepAliveRequest>(&header, _body_bytes, handles, &mut req)?;
5439                    let control_handle = BaseDatagramSocketControlHandle {
5440                        inner: this.inner.clone(),
5441                    };
5442                    Ok(BaseDatagramSocketRequest::SetKeepAlive {value: req.value,
5443
5444                        responder: BaseDatagramSocketSetKeepAliveResponder {
5445                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5446                            tx_id: header.tx_id,
5447                        },
5448                    })
5449                }
5450                0x2dd29d3215f2c9d2 => {
5451                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5452                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5453                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5454                    let control_handle = BaseDatagramSocketControlHandle {
5455                        inner: this.inner.clone(),
5456                    };
5457                    Ok(BaseDatagramSocketRequest::GetKeepAlive {
5458                        responder: BaseDatagramSocketGetKeepAliveResponder {
5459                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5460                            tx_id: header.tx_id,
5461                        },
5462                    })
5463                }
5464                0x3ecb49968bee439 => {
5465                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5466                    let mut req = fidl::new_empty!(BaseSocketSetOutOfBandInlineRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5467                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetOutOfBandInlineRequest>(&header, _body_bytes, handles, &mut req)?;
5468                    let control_handle = BaseDatagramSocketControlHandle {
5469                        inner: this.inner.clone(),
5470                    };
5471                    Ok(BaseDatagramSocketRequest::SetOutOfBandInline {value: req.value,
5472
5473                        responder: BaseDatagramSocketSetOutOfBandInlineResponder {
5474                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5475                            tx_id: header.tx_id,
5476                        },
5477                    })
5478                }
5479                0x348c1ab3aeca1745 => {
5480                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5481                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5482                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5483                    let control_handle = BaseDatagramSocketControlHandle {
5484                        inner: this.inner.clone(),
5485                    };
5486                    Ok(BaseDatagramSocketRequest::GetOutOfBandInline {
5487                        responder: BaseDatagramSocketGetOutOfBandInlineResponder {
5488                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5489                            tx_id: header.tx_id,
5490                        },
5491                    })
5492                }
5493                0x6bbf00c53a4c78c2 => {
5494                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5495                    let mut req = fidl::new_empty!(BaseSocketSetNoCheckRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5496                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetNoCheckRequest>(&header, _body_bytes, handles, &mut req)?;
5497                    let control_handle = BaseDatagramSocketControlHandle {
5498                        inner: this.inner.clone(),
5499                    };
5500                    Ok(BaseDatagramSocketRequest::SetNoCheck {value: req.value,
5501
5502                        responder: BaseDatagramSocketSetNoCheckResponder {
5503                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5504                            tx_id: header.tx_id,
5505                        },
5506                    })
5507                }
5508                0x2cd4249286417694 => {
5509                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5510                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5511                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5512                    let control_handle = BaseDatagramSocketControlHandle {
5513                        inner: this.inner.clone(),
5514                    };
5515                    Ok(BaseDatagramSocketRequest::GetNoCheck {
5516                        responder: BaseDatagramSocketGetNoCheckResponder {
5517                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5518                            tx_id: header.tx_id,
5519                        },
5520                    })
5521                }
5522                0x45386351246e998e => {
5523                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5524                    let mut req = fidl::new_empty!(BaseSocketSetLingerRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5525                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetLingerRequest>(&header, _body_bytes, handles, &mut req)?;
5526                    let control_handle = BaseDatagramSocketControlHandle {
5527                        inner: this.inner.clone(),
5528                    };
5529                    Ok(BaseDatagramSocketRequest::SetLinger {linger: req.linger,
5530length_secs: req.length_secs,
5531
5532                        responder: BaseDatagramSocketSetLingerResponder {
5533                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5534                            tx_id: header.tx_id,
5535                        },
5536                    })
5537                }
5538                0x48eb20fc5ccb0e45 => {
5539                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5540                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5541                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5542                    let control_handle = BaseDatagramSocketControlHandle {
5543                        inner: this.inner.clone(),
5544                    };
5545                    Ok(BaseDatagramSocketRequest::GetLinger {
5546                        responder: BaseDatagramSocketGetLingerResponder {
5547                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5548                            tx_id: header.tx_id,
5549                        },
5550                    })
5551                }
5552                0x24dd3e5cb36d9ccb => {
5553                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5554                    let mut req = fidl::new_empty!(BaseSocketSetReusePortRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5555                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReusePortRequest>(&header, _body_bytes, handles, &mut req)?;
5556                    let control_handle = BaseDatagramSocketControlHandle {
5557                        inner: this.inner.clone(),
5558                    };
5559                    Ok(BaseDatagramSocketRequest::SetReusePort {value: req.value,
5560
5561                        responder: BaseDatagramSocketSetReusePortResponder {
5562                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5563                            tx_id: header.tx_id,
5564                        },
5565                    })
5566                }
5567                0x7a112c1ab54ff828 => {
5568                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5569                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5570                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5571                    let control_handle = BaseDatagramSocketControlHandle {
5572                        inner: this.inner.clone(),
5573                    };
5574                    Ok(BaseDatagramSocketRequest::GetReusePort {
5575                        responder: BaseDatagramSocketGetReusePortResponder {
5576                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5577                            tx_id: header.tx_id,
5578                        },
5579                    })
5580                }
5581                0x67ce6db6c2ec8966 => {
5582                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5583                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5584                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5585                    let control_handle = BaseDatagramSocketControlHandle {
5586                        inner: this.inner.clone(),
5587                    };
5588                    Ok(BaseDatagramSocketRequest::GetAcceptConn {
5589                        responder: BaseDatagramSocketGetAcceptConnResponder {
5590                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5591                            tx_id: header.tx_id,
5592                        },
5593                    })
5594                }
5595                0x2118b483f28aafc4 => {
5596                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5597                    let mut req = fidl::new_empty!(BaseSocketSetBindToDeviceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5598                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToDeviceRequest>(&header, _body_bytes, handles, &mut req)?;
5599                    let control_handle = BaseDatagramSocketControlHandle {
5600                        inner: this.inner.clone(),
5601                    };
5602                    Ok(BaseDatagramSocketRequest::SetBindToDevice {value: req.value,
5603
5604                        responder: BaseDatagramSocketSetBindToDeviceResponder {
5605                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5606                            tx_id: header.tx_id,
5607                        },
5608                    })
5609                }
5610                0x1ab1fbf0ef7906c8 => {
5611                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5612                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5613                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5614                    let control_handle = BaseDatagramSocketControlHandle {
5615                        inner: this.inner.clone(),
5616                    };
5617                    Ok(BaseDatagramSocketRequest::GetBindToDevice {
5618                        responder: BaseDatagramSocketGetBindToDeviceResponder {
5619                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5620                            tx_id: header.tx_id,
5621                        },
5622                    })
5623                }
5624                0x6e387a0def00821 => {
5625                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5626                    let mut req = fidl::new_empty!(BaseSocketSetBindToInterfaceIndexRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5627                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToInterfaceIndexRequest>(&header, _body_bytes, handles, &mut req)?;
5628                    let control_handle = BaseDatagramSocketControlHandle {
5629                        inner: this.inner.clone(),
5630                    };
5631                    Ok(BaseDatagramSocketRequest::SetBindToInterfaceIndex {value: req.value,
5632
5633                        responder: BaseDatagramSocketSetBindToInterfaceIndexResponder {
5634                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5635                            tx_id: header.tx_id,
5636                        },
5637                    })
5638                }
5639                0x59c31dd3e3078295 => {
5640                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5641                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5642                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5643                    let control_handle = BaseDatagramSocketControlHandle {
5644                        inner: this.inner.clone(),
5645                    };
5646                    Ok(BaseDatagramSocketRequest::GetBindToInterfaceIndex {
5647                        responder: BaseDatagramSocketGetBindToInterfaceIndexResponder {
5648                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5649                            tx_id: header.tx_id,
5650                        },
5651                    })
5652                }
5653                0x285d6516c263d839 => {
5654                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5655                    let mut req = fidl::new_empty!(BaseSocketSetTimestampRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5656                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetTimestampRequest>(&header, _body_bytes, handles, &mut req)?;
5657                    let control_handle = BaseDatagramSocketControlHandle {
5658                        inner: this.inner.clone(),
5659                    };
5660                    Ok(BaseDatagramSocketRequest::SetTimestamp {value: req.value,
5661
5662                        responder: BaseDatagramSocketSetTimestampResponder {
5663                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5664                            tx_id: header.tx_id,
5665                        },
5666                    })
5667                }
5668                0x49f2fffbbcc2bd27 => {
5669                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5670                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5671                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5672                    let control_handle = BaseDatagramSocketControlHandle {
5673                        inner: this.inner.clone(),
5674                    };
5675                    Ok(BaseDatagramSocketRequest::GetTimestamp {
5676                        responder: BaseDatagramSocketGetTimestampResponder {
5677                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5678                            tx_id: header.tx_id,
5679                        },
5680                    })
5681                }
5682                0x6ead6de09f653236 => {
5683                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5684                    let mut req = fidl::new_empty!(BaseSocketSetMarkRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5685                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
5686                    let control_handle = BaseDatagramSocketControlHandle {
5687                        inner: this.inner.clone(),
5688                    };
5689                    Ok(BaseDatagramSocketRequest::SetMark {domain: req.domain,
5690mark: req.mark,
5691
5692                        responder: BaseDatagramSocketSetMarkResponder {
5693                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5694                            tx_id: header.tx_id,
5695                        },
5696                    })
5697                }
5698                0x57a2752c61d93d47 => {
5699                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5700                    let mut req = fidl::new_empty!(BaseSocketGetMarkRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5701                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketGetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
5702                    let control_handle = BaseDatagramSocketControlHandle {
5703                        inner: this.inner.clone(),
5704                    };
5705                    Ok(BaseDatagramSocketRequest::GetMark {domain: req.domain,
5706
5707                        responder: BaseDatagramSocketGetMarkResponder {
5708                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5709                            tx_id: header.tx_id,
5710                        },
5711                    })
5712                }
5713                0x4bc6400ae92125d => {
5714                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5715                    let mut req = fidl::new_empty!(BaseNetworkSocketBindRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5716                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketBindRequest>(&header, _body_bytes, handles, &mut req)?;
5717                    let control_handle = BaseDatagramSocketControlHandle {
5718                        inner: this.inner.clone(),
5719                    };
5720                    Ok(BaseDatagramSocketRequest::Bind {addr: req.addr,
5721
5722                        responder: BaseDatagramSocketBindResponder {
5723                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5724                            tx_id: header.tx_id,
5725                        },
5726                    })
5727                }
5728                0x5f05f19bfdd38871 => {
5729                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5730                    let mut req = fidl::new_empty!(BaseNetworkSocketConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5731                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketConnectRequest>(&header, _body_bytes, handles, &mut req)?;
5732                    let control_handle = BaseDatagramSocketControlHandle {
5733                        inner: this.inner.clone(),
5734                    };
5735                    Ok(BaseDatagramSocketRequest::Connect {addr: req.addr,
5736
5737                        responder: BaseDatagramSocketConnectResponder {
5738                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5739                            tx_id: header.tx_id,
5740                        },
5741                    })
5742                }
5743                0x74e63b91f7b29b2 => {
5744                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5745                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5746                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5747                    let control_handle = BaseDatagramSocketControlHandle {
5748                        inner: this.inner.clone(),
5749                    };
5750                    Ok(BaseDatagramSocketRequest::Disconnect {
5751                        responder: BaseDatagramSocketDisconnectResponder {
5752                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5753                            tx_id: header.tx_id,
5754                        },
5755                    })
5756                }
5757                0x475f23f84a1a4f85 => {
5758                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5759                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5760                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5761                    let control_handle = BaseDatagramSocketControlHandle {
5762                        inner: this.inner.clone(),
5763                    };
5764                    Ok(BaseDatagramSocketRequest::GetSockName {
5765                        responder: BaseDatagramSocketGetSockNameResponder {
5766                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5767                            tx_id: header.tx_id,
5768                        },
5769                    })
5770                }
5771                0x1ffecf4bd5b6432e => {
5772                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5773                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5774                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5775                    let control_handle = BaseDatagramSocketControlHandle {
5776                        inner: this.inner.clone(),
5777                    };
5778                    Ok(BaseDatagramSocketRequest::GetPeerName {
5779                        responder: BaseDatagramSocketGetPeerNameResponder {
5780                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5781                            tx_id: header.tx_id,
5782                        },
5783                    })
5784                }
5785                0x247f38b6db68c336 => {
5786                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5787                    let mut req = fidl::new_empty!(BaseNetworkSocketShutdownRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5788                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketShutdownRequest>(&header, _body_bytes, handles, &mut req)?;
5789                    let control_handle = BaseDatagramSocketControlHandle {
5790                        inner: this.inner.clone(),
5791                    };
5792                    Ok(BaseDatagramSocketRequest::Shutdown {mode: req.mode,
5793
5794                        responder: BaseDatagramSocketShutdownResponder {
5795                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5796                            tx_id: header.tx_id,
5797                        },
5798                    })
5799                }
5800                0x995c600475b6d46 => {
5801                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5802                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpTypeOfServiceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5803                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
5804                    let control_handle = BaseDatagramSocketControlHandle {
5805                        inner: this.inner.clone(),
5806                    };
5807                    Ok(BaseDatagramSocketRequest::SetIpTypeOfService {value: req.value,
5808
5809                        responder: BaseDatagramSocketSetIpTypeOfServiceResponder {
5810                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5811                            tx_id: header.tx_id,
5812                        },
5813                    })
5814                }
5815                0x3814a04259f75fcb => {
5816                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5817                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5818                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5819                    let control_handle = BaseDatagramSocketControlHandle {
5820                        inner: this.inner.clone(),
5821                    };
5822                    Ok(BaseDatagramSocketRequest::GetIpTypeOfService {
5823                        responder: BaseDatagramSocketGetIpTypeOfServiceResponder {
5824                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5825                            tx_id: header.tx_id,
5826                        },
5827                    })
5828                }
5829                0x29e2424b433ae1ef => {
5830                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5831                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpTtlRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5832                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTtlRequest>(&header, _body_bytes, handles, &mut req)?;
5833                    let control_handle = BaseDatagramSocketControlHandle {
5834                        inner: this.inner.clone(),
5835                    };
5836                    Ok(BaseDatagramSocketRequest::SetIpTtl {value: req.value,
5837
5838                        responder: BaseDatagramSocketSetIpTtlResponder {
5839                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5840                            tx_id: header.tx_id,
5841                        },
5842                    })
5843                }
5844                0x47e47fa1f24da471 => {
5845                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5846                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5847                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5848                    let control_handle = BaseDatagramSocketControlHandle {
5849                        inner: this.inner.clone(),
5850                    };
5851                    Ok(BaseDatagramSocketRequest::GetIpTtl {
5852                        responder: BaseDatagramSocketGetIpTtlResponder {
5853                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5854                            tx_id: header.tx_id,
5855                        },
5856                    })
5857                }
5858                0x392d16bee20c0e16 => {
5859                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5860                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpPacketInfoRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5861                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpPacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
5862                    let control_handle = BaseDatagramSocketControlHandle {
5863                        inner: this.inner.clone(),
5864                    };
5865                    Ok(BaseDatagramSocketRequest::SetIpPacketInfo {value: req.value,
5866
5867                        responder: BaseDatagramSocketSetIpPacketInfoResponder {
5868                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5869                            tx_id: header.tx_id,
5870                        },
5871                    })
5872                }
5873                0x54b505f242280740 => {
5874                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5875                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5876                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5877                    let control_handle = BaseDatagramSocketControlHandle {
5878                        inner: this.inner.clone(),
5879                    };
5880                    Ok(BaseDatagramSocketRequest::GetIpPacketInfo {
5881                        responder: BaseDatagramSocketGetIpPacketInfoResponder {
5882                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5883                            tx_id: header.tx_id,
5884                        },
5885                    })
5886                }
5887                0x6c4f6714995f84ef => {
5888                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5889                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpReceiveTypeOfServiceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5890                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
5891                    let control_handle = BaseDatagramSocketControlHandle {
5892                        inner: this.inner.clone(),
5893                    };
5894                    Ok(BaseDatagramSocketRequest::SetIpReceiveTypeOfService {value: req.value,
5895
5896                        responder: BaseDatagramSocketSetIpReceiveTypeOfServiceResponder {
5897                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5898                            tx_id: header.tx_id,
5899                        },
5900                    })
5901                }
5902                0x4158ba7dc2795960 => {
5903                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5904                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5905                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5906                    let control_handle = BaseDatagramSocketControlHandle {
5907                        inner: this.inner.clone(),
5908                    };
5909                    Ok(BaseDatagramSocketRequest::GetIpReceiveTypeOfService {
5910                        responder: BaseDatagramSocketGetIpReceiveTypeOfServiceResponder {
5911                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5912                            tx_id: header.tx_id,
5913                        },
5914                    })
5915                }
5916                0x46f15be0ce0ab82b => {
5917                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5918                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpReceiveTtlRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5919                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveTtlRequest>(&header, _body_bytes, handles, &mut req)?;
5920                    let control_handle = BaseDatagramSocketControlHandle {
5921                        inner: this.inner.clone(),
5922                    };
5923                    Ok(BaseDatagramSocketRequest::SetIpReceiveTtl {value: req.value,
5924
5925                        responder: BaseDatagramSocketSetIpReceiveTtlResponder {
5926                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5927                            tx_id: header.tx_id,
5928                        },
5929                    })
5930                }
5931                0x678ddd5a5dfa2eb5 => {
5932                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5933                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5934                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5935                    let control_handle = BaseDatagramSocketControlHandle {
5936                        inner: this.inner.clone(),
5937                    };
5938                    Ok(BaseDatagramSocketRequest::GetIpReceiveTtl {
5939                        responder: BaseDatagramSocketGetIpReceiveTtlResponder {
5940                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5941                            tx_id: header.tx_id,
5942                        },
5943                    })
5944                }
5945                0x752fbfa9b12befe => {
5946                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5947                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpMulticastInterfaceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5948                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
5949                    let control_handle = BaseDatagramSocketControlHandle {
5950                        inner: this.inner.clone(),
5951                    };
5952                    Ok(BaseDatagramSocketRequest::SetIpMulticastInterface {iface: req.iface,
5953address: req.address,
5954
5955                        responder: BaseDatagramSocketSetIpMulticastInterfaceResponder {
5956                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5957                            tx_id: header.tx_id,
5958                        },
5959                    })
5960                }
5961                0x320bd14c4df046c4 => {
5962                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5963                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5964                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5965                    let control_handle = BaseDatagramSocketControlHandle {
5966                        inner: this.inner.clone(),
5967                    };
5968                    Ok(BaseDatagramSocketRequest::GetIpMulticastInterface {
5969                        responder: BaseDatagramSocketGetIpMulticastInterfaceResponder {
5970                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5971                            tx_id: header.tx_id,
5972                        },
5973                    })
5974                }
5975                0x63134d53772916a1 => {
5976                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5977                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpMulticastTtlRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
5978                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastTtlRequest>(&header, _body_bytes, handles, &mut req)?;
5979                    let control_handle = BaseDatagramSocketControlHandle {
5980                        inner: this.inner.clone(),
5981                    };
5982                    Ok(BaseDatagramSocketRequest::SetIpMulticastTtl {value: req.value,
5983
5984                        responder: BaseDatagramSocketSetIpMulticastTtlResponder {
5985                            control_handle: std::mem::ManuallyDrop::new(control_handle),
5986                            tx_id: header.tx_id,
5987                        },
5988                    })
5989                }
5990                0x4665cd378f39e1a => {
5991                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
5992                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
5993                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
5994                    let control_handle = BaseDatagramSocketControlHandle {
5995                        inner: this.inner.clone(),
5996                    };
5997                    Ok(BaseDatagramSocketRequest::GetIpMulticastTtl {
5998                        responder: BaseDatagramSocketGetIpMulticastTtlResponder {
5999                            control_handle: std::mem::ManuallyDrop::new(control_handle),
6000                            tx_id: header.tx_id,
6001                        },
6002                    })
6003                }
6004                0x20c55c11f00943ea => {
6005                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6006                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpMulticastLoopbackRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6007                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
6008                    let control_handle = BaseDatagramSocketControlHandle {
6009                        inner: this.inner.clone(),
6010                    };
6011                    Ok(BaseDatagramSocketRequest::SetIpMulticastLoopback {value: req.value,
6012
6013                        responder: BaseDatagramSocketSetIpMulticastLoopbackResponder {
6014                            control_handle: std::mem::ManuallyDrop::new(control_handle),
6015                            tx_id: header.tx_id,
6016                        },
6017                    })
6018                }
6019                0x3b6b26ff558298f2 => {
6020                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6021                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
6022                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6023                    let control_handle = BaseDatagramSocketControlHandle {
6024                        inner: this.inner.clone(),
6025                    };
6026                    Ok(BaseDatagramSocketRequest::GetIpMulticastLoopback {
6027                        responder: BaseDatagramSocketGetIpMulticastLoopbackResponder {
6028                            control_handle: std::mem::ManuallyDrop::new(control_handle),
6029                            tx_id: header.tx_id,
6030                        },
6031                    })
6032                }
6033                0x76bc7df115a3b4d0 => {
6034                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6035                    let mut req = fidl::new_empty!(BaseNetworkSocketAddIpMembershipRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6036                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketAddIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
6037                    let control_handle = BaseDatagramSocketControlHandle {
6038                        inner: this.inner.clone(),
6039                    };
6040                    Ok(BaseDatagramSocketRequest::AddIpMembership {membership: req.membership,
6041
6042                        responder: BaseDatagramSocketAddIpMembershipResponder {
6043                            control_handle: std::mem::ManuallyDrop::new(control_handle),
6044                            tx_id: header.tx_id,
6045                        },
6046                    })
6047                }
6048                0x2888f3099188d03 => {
6049                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6050                    let mut req = fidl::new_empty!(BaseNetworkSocketDropIpMembershipRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6051                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketDropIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
6052                    let control_handle = BaseDatagramSocketControlHandle {
6053                        inner: this.inner.clone(),
6054                    };
6055                    Ok(BaseDatagramSocketRequest::DropIpMembership {membership: req.membership,
6056
6057                        responder: BaseDatagramSocketDropIpMembershipResponder {
6058                            control_handle: std::mem::ManuallyDrop::new(control_handle),
6059                            tx_id: header.tx_id,
6060                        },
6061                    })
6062                }
6063                0x1ae532b0c066e3a0 => {
6064                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6065                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpTransparentRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6066                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTransparentRequest>(&header, _body_bytes, handles, &mut req)?;
6067                    let control_handle = BaseDatagramSocketControlHandle {
6068                        inner: this.inner.clone(),
6069                    };
6070                    Ok(BaseDatagramSocketRequest::SetIpTransparent {value: req.value,
6071
6072                        responder: BaseDatagramSocketSetIpTransparentResponder {
6073                            control_handle: std::mem::ManuallyDrop::new(control_handle),
6074                            tx_id: header.tx_id,
6075                        },
6076                    })
6077                }
6078                0x51d43695962ebfb5 => {
6079                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6080                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
6081                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6082                    let control_handle = BaseDatagramSocketControlHandle {
6083                        inner: this.inner.clone(),
6084                    };
6085                    Ok(BaseDatagramSocketRequest::GetIpTransparent {
6086                        responder: BaseDatagramSocketGetIpTransparentResponder {
6087                            control_handle: std::mem::ManuallyDrop::new(control_handle),
6088                            tx_id: header.tx_id,
6089                        },
6090                    })
6091                }
6092                0x4722b4ce52f7840 => {
6093                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6094                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6095                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest>(&header, _body_bytes, handles, &mut req)?;
6096                    let control_handle = BaseDatagramSocketControlHandle {
6097                        inner: this.inner.clone(),
6098                    };
6099                    Ok(BaseDatagramSocketRequest::SetIpReceiveOriginalDestinationAddress {value: req.value,
6100
6101                        responder: BaseDatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
6102                            control_handle: std::mem::ManuallyDrop::new(control_handle),
6103                            tx_id: header.tx_id,
6104                        },
6105                    })
6106                }
6107                0x2a0e7dc5d6bfdfe9 => {
6108                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6109                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
6110                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6111                    let control_handle = BaseDatagramSocketControlHandle {
6112                        inner: this.inner.clone(),
6113                    };
6114                    Ok(BaseDatagramSocketRequest::GetIpReceiveOriginalDestinationAddress {
6115                        responder: BaseDatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
6116                            control_handle: std::mem::ManuallyDrop::new(control_handle),
6117                            tx_id: header.tx_id,
6118                        },
6119                    })
6120                }
6121                0x7c94727acb4ea4b3 => {
6122                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6123                    let mut req = fidl::new_empty!(BaseNetworkSocketAddIpv6MembershipRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6124                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketAddIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
6125                    let control_handle = BaseDatagramSocketControlHandle {
6126                        inner: this.inner.clone(),
6127                    };
6128                    Ok(BaseDatagramSocketRequest::AddIpv6Membership {membership: req.membership,
6129
6130                        responder: BaseDatagramSocketAddIpv6MembershipResponder {
6131                            control_handle: std::mem::ManuallyDrop::new(control_handle),
6132                            tx_id: header.tx_id,
6133                        },
6134                    })
6135                }
6136                0x42104c70ccaba304 => {
6137                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6138                    let mut req = fidl::new_empty!(BaseNetworkSocketDropIpv6MembershipRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6139                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketDropIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
6140                    let control_handle = BaseDatagramSocketControlHandle {
6141                        inner: this.inner.clone(),
6142                    };
6143                    Ok(BaseDatagramSocketRequest::DropIpv6Membership {membership: req.membership,
6144
6145                        responder: BaseDatagramSocketDropIpv6MembershipResponder {
6146                            control_handle: std::mem::ManuallyDrop::new(control_handle),
6147                            tx_id: header.tx_id,
6148                        },
6149                    })
6150                }
6151                0x135f76db3774ab3b => {
6152                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6153                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6MulticastInterfaceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6154                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
6155                    let control_handle = BaseDatagramSocketControlHandle {
6156                        inner: this.inner.clone(),
6157                    };
6158                    Ok(BaseDatagramSocketRequest::SetIpv6MulticastInterface {value: req.value,
6159
6160                        responder: BaseDatagramSocketSetIpv6MulticastInterfaceResponder {
6161                            control_handle: std::mem::ManuallyDrop::new(control_handle),
6162                            tx_id: header.tx_id,
6163                        },
6164                    })
6165                }
6166                0x1f26fcdd348f1882 => {
6167                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6168                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
6169                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6170                    let control_handle = BaseDatagramSocketControlHandle {
6171                        inner: this.inner.clone(),
6172                    };
6173                    Ok(BaseDatagramSocketRequest::GetIpv6MulticastInterface {
6174                        responder: BaseDatagramSocketGetIpv6MulticastInterfaceResponder {
6175                            control_handle: std::mem::ManuallyDrop::new(control_handle),
6176                            tx_id: header.tx_id,
6177                        },
6178                    })
6179                }
6180                0x157d51e98f462859 => {
6181                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6182                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6UnicastHopsRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6183                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6UnicastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
6184                    let control_handle = BaseDatagramSocketControlHandle {
6185                        inner: this.inner.clone(),
6186                    };
6187                    Ok(BaseDatagramSocketRequest::SetIpv6UnicastHops {value: req.value,
6188
6189                        responder: BaseDatagramSocketSetIpv6UnicastHopsResponder {
6190                            control_handle: std::mem::ManuallyDrop::new(control_handle),
6191                            tx_id: header.tx_id,
6192                        },
6193                    })
6194                }
6195                0x21f4641cad8bd8d2 => {
6196                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6197                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
6198                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6199                    let control_handle = BaseDatagramSocketControlHandle {
6200                        inner: this.inner.clone(),
6201                    };
6202                    Ok(BaseDatagramSocketRequest::GetIpv6UnicastHops {
6203                        responder: BaseDatagramSocketGetIpv6UnicastHopsResponder {
6204                            control_handle: std::mem::ManuallyDrop::new(control_handle),
6205                            tx_id: header.tx_id,
6206                        },
6207                    })
6208                }
6209                0x5c24808ed2e84a1e => {
6210                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6211                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6ReceiveHopLimitRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6212                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceiveHopLimitRequest>(&header, _body_bytes, handles, &mut req)?;
6213                    let control_handle = BaseDatagramSocketControlHandle {
6214                        inner: this.inner.clone(),
6215                    };
6216                    Ok(BaseDatagramSocketRequest::SetIpv6ReceiveHopLimit {value: req.value,
6217
6218                        responder: BaseDatagramSocketSetIpv6ReceiveHopLimitResponder {
6219                            control_handle: std::mem::ManuallyDrop::new(control_handle),
6220                            tx_id: header.tx_id,
6221                        },
6222                    })
6223                }
6224                0x341e06689885b4c0 => {
6225                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6226                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
6227                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6228                    let control_handle = BaseDatagramSocketControlHandle {
6229                        inner: this.inner.clone(),
6230                    };
6231                    Ok(BaseDatagramSocketRequest::GetIpv6ReceiveHopLimit {
6232                        responder: BaseDatagramSocketGetIpv6ReceiveHopLimitResponder {
6233                            control_handle: std::mem::ManuallyDrop::new(control_handle),
6234                            tx_id: header.tx_id,
6235                        },
6236                    })
6237                }
6238                0x25b9cd4d181f82c1 => {
6239                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6240                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6MulticastHopsRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6241                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
6242                    let control_handle = BaseDatagramSocketControlHandle {
6243                        inner: this.inner.clone(),
6244                    };
6245                    Ok(BaseDatagramSocketRequest::SetIpv6MulticastHops {value: req.value,
6246
6247                        responder: BaseDatagramSocketSetIpv6MulticastHopsResponder {
6248                            control_handle: std::mem::ManuallyDrop::new(control_handle),
6249                            tx_id: header.tx_id,
6250                        },
6251                    })
6252                }
6253                0x52916948a365012a => {
6254                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6255                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
6256                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6257                    let control_handle = BaseDatagramSocketControlHandle {
6258                        inner: this.inner.clone(),
6259                    };
6260                    Ok(BaseDatagramSocketRequest::GetIpv6MulticastHops {
6261                        responder: BaseDatagramSocketGetIpv6MulticastHopsResponder {
6262                            control_handle: std::mem::ManuallyDrop::new(control_handle),
6263                            tx_id: header.tx_id,
6264                        },
6265                    })
6266                }
6267                0x55701c409ff41b40 => {
6268                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6269                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6MulticastLoopbackRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6270                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
6271                    let control_handle = BaseDatagramSocketControlHandle {
6272                        inner: this.inner.clone(),
6273                    };
6274                    Ok(BaseDatagramSocketRequest::SetIpv6MulticastLoopback {value: req.value,
6275
6276                        responder: BaseDatagramSocketSetIpv6MulticastLoopbackResponder {
6277                            control_handle: std::mem::ManuallyDrop::new(control_handle),
6278                            tx_id: header.tx_id,
6279                        },
6280                    })
6281                }
6282                0x4415b701fde319c3 => {
6283                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6284                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
6285                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6286                    let control_handle = BaseDatagramSocketControlHandle {
6287                        inner: this.inner.clone(),
6288                    };
6289                    Ok(BaseDatagramSocketRequest::GetIpv6MulticastLoopback {
6290                        responder: BaseDatagramSocketGetIpv6MulticastLoopbackResponder {
6291                            control_handle: std::mem::ManuallyDrop::new(control_handle),
6292                            tx_id: header.tx_id,
6293                        },
6294                    })
6295                }
6296                0x4873f1364758cbba => {
6297                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6298                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6OnlyRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6299                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6OnlyRequest>(&header, _body_bytes, handles, &mut req)?;
6300                    let control_handle = BaseDatagramSocketControlHandle {
6301                        inner: this.inner.clone(),
6302                    };
6303                    Ok(BaseDatagramSocketRequest::SetIpv6Only {value: req.value,
6304
6305                        responder: BaseDatagramSocketSetIpv6OnlyResponder {
6306                            control_handle: std::mem::ManuallyDrop::new(control_handle),
6307                            tx_id: header.tx_id,
6308                        },
6309                    })
6310                }
6311                0x4aa3340a1a26b89c => {
6312                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6313                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
6314                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6315                    let control_handle = BaseDatagramSocketControlHandle {
6316                        inner: this.inner.clone(),
6317                    };
6318                    Ok(BaseDatagramSocketRequest::GetIpv6Only {
6319                        responder: BaseDatagramSocketGetIpv6OnlyResponder {
6320                            control_handle: std::mem::ManuallyDrop::new(control_handle),
6321                            tx_id: header.tx_id,
6322                        },
6323                    })
6324                }
6325                0x58f07c8788d099a0 => {
6326                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6327                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6328                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
6329                    let control_handle = BaseDatagramSocketControlHandle {
6330                        inner: this.inner.clone(),
6331                    };
6332                    Ok(BaseDatagramSocketRequest::SetIpv6ReceiveTrafficClass {value: req.value,
6333
6334                        responder: BaseDatagramSocketSetIpv6ReceiveTrafficClassResponder {
6335                            control_handle: std::mem::ManuallyDrop::new(control_handle),
6336                            tx_id: header.tx_id,
6337                        },
6338                    })
6339                }
6340                0x2e334df1da553ffa => {
6341                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6342                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
6343                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6344                    let control_handle = BaseDatagramSocketControlHandle {
6345                        inner: this.inner.clone(),
6346                    };
6347                    Ok(BaseDatagramSocketRequest::GetIpv6ReceiveTrafficClass {
6348                        responder: BaseDatagramSocketGetIpv6ReceiveTrafficClassResponder {
6349                            control_handle: std::mem::ManuallyDrop::new(control_handle),
6350                            tx_id: header.tx_id,
6351                        },
6352                    })
6353                }
6354                0x6af077800c5a0b4f => {
6355                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6356                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6TrafficClassRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6357                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6TrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
6358                    let control_handle = BaseDatagramSocketControlHandle {
6359                        inner: this.inner.clone(),
6360                    };
6361                    Ok(BaseDatagramSocketRequest::SetIpv6TrafficClass {value: req.value,
6362
6363                        responder: BaseDatagramSocketSetIpv6TrafficClassResponder {
6364                            control_handle: std::mem::ManuallyDrop::new(control_handle),
6365                            tx_id: header.tx_id,
6366                        },
6367                    })
6368                }
6369                0x6baf6eed8fc2f04 => {
6370                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6371                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
6372                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6373                    let control_handle = BaseDatagramSocketControlHandle {
6374                        inner: this.inner.clone(),
6375                    };
6376                    Ok(BaseDatagramSocketRequest::GetIpv6TrafficClass {
6377                        responder: BaseDatagramSocketGetIpv6TrafficClassResponder {
6378                            control_handle: std::mem::ManuallyDrop::new(control_handle),
6379                            tx_id: header.tx_id,
6380                        },
6381                    })
6382                }
6383                0x19259775b1a92768 => {
6384                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6385                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6ReceivePacketInfoRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
6386                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceivePacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
6387                    let control_handle = BaseDatagramSocketControlHandle {
6388                        inner: this.inner.clone(),
6389                    };
6390                    Ok(BaseDatagramSocketRequest::SetIpv6ReceivePacketInfo {value: req.value,
6391
6392                        responder: BaseDatagramSocketSetIpv6ReceivePacketInfoResponder {
6393                            control_handle: std::mem::ManuallyDrop::new(control_handle),
6394                            tx_id: header.tx_id,
6395                        },
6396                    })
6397                }
6398                0x7acd4a2775baec75 => {
6399                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6400                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
6401                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6402                    let control_handle = BaseDatagramSocketControlHandle {
6403                        inner: this.inner.clone(),
6404                    };
6405                    Ok(BaseDatagramSocketRequest::GetIpv6ReceivePacketInfo {
6406                        responder: BaseDatagramSocketGetIpv6ReceivePacketInfoResponder {
6407                            control_handle: std::mem::ManuallyDrop::new(control_handle),
6408                            tx_id: header.tx_id,
6409                        },
6410                    })
6411                }
6412                0x38bf28f0dafdbac0 => {
6413                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6414                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
6415                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6416                    let control_handle = BaseDatagramSocketControlHandle {
6417                        inner: this.inner.clone(),
6418                    };
6419                    Ok(BaseDatagramSocketRequest::GetOriginalDestination {
6420                        responder: BaseDatagramSocketGetOriginalDestinationResponder {
6421                            control_handle: std::mem::ManuallyDrop::new(control_handle),
6422                            tx_id: header.tx_id,
6423                        },
6424                    })
6425                }
6426                0x48aa0a1f6a32d2ed => {
6427                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
6428                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
6429                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
6430                    let control_handle = BaseDatagramSocketControlHandle {
6431                        inner: this.inner.clone(),
6432                    };
6433                    Ok(BaseDatagramSocketRequest::GetInfo {
6434                        responder: BaseDatagramSocketGetInfoResponder {
6435                            control_handle: std::mem::ManuallyDrop::new(control_handle),
6436                            tx_id: header.tx_id,
6437                        },
6438                    })
6439                }
6440                _ => Err(fidl::Error::UnknownOrdinal {
6441                    ordinal: header.ordinal,
6442                    protocol_name: <BaseDatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
6443                }),
6444            }))
6445            },
6446        )
6447    }
6448}
6449
6450/// Base protocol shared by all datagram sockets.
6451///
6452/// Complete implementations of a datagram socket should compose this protocol.
6453#[derive(Debug)]
6454pub enum BaseDatagramSocketRequest {
6455    Clone {
6456        request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
6457        control_handle: BaseDatagramSocketControlHandle,
6458    },
6459    /// Terminates the connection.
6460    ///
6461    /// After calling `Close`, the client must not send any other requests.
6462    ///
6463    /// Servers, after sending the status response, should close the connection
6464    /// regardless of status and without sending an epitaph.
6465    ///
6466    /// Closing the client end of the channel should be semantically equivalent
6467    /// to calling `Close` without knowing when the close has completed or its
6468    /// status.
6469    Close {
6470        responder: BaseDatagramSocketCloseResponder,
6471    },
6472    Query {
6473        responder: BaseDatagramSocketQueryResponder,
6474    },
6475    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
6476    SetReuseAddress {
6477        value: bool,
6478        responder: BaseDatagramSocketSetReuseAddressResponder,
6479    },
6480    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
6481    GetReuseAddress {
6482        responder: BaseDatagramSocketGetReuseAddressResponder,
6483    },
6484    /// Get `SOL_SOCKET` -> `SO_ERROR`.
6485    /// Returns the last error if there is an error set on the socket.
6486    GetError {
6487        responder: BaseDatagramSocketGetErrorResponder,
6488    },
6489    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
6490    SetBroadcast {
6491        value: bool,
6492        responder: BaseDatagramSocketSetBroadcastResponder,
6493    },
6494    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
6495    GetBroadcast {
6496        responder: BaseDatagramSocketGetBroadcastResponder,
6497    },
6498    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
6499    SetSendBuffer {
6500        value_bytes: u64,
6501        responder: BaseDatagramSocketSetSendBufferResponder,
6502    },
6503    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
6504    GetSendBuffer {
6505        responder: BaseDatagramSocketGetSendBufferResponder,
6506    },
6507    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
6508    SetReceiveBuffer {
6509        value_bytes: u64,
6510        responder: BaseDatagramSocketSetReceiveBufferResponder,
6511    },
6512    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
6513    GetReceiveBuffer {
6514        responder: BaseDatagramSocketGetReceiveBufferResponder,
6515    },
6516    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
6517    SetKeepAlive {
6518        value: bool,
6519        responder: BaseDatagramSocketSetKeepAliveResponder,
6520    },
6521    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
6522    GetKeepAlive {
6523        responder: BaseDatagramSocketGetKeepAliveResponder,
6524    },
6525    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
6526    SetOutOfBandInline {
6527        value: bool,
6528        responder: BaseDatagramSocketSetOutOfBandInlineResponder,
6529    },
6530    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
6531    GetOutOfBandInline {
6532        responder: BaseDatagramSocketGetOutOfBandInlineResponder,
6533    },
6534    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
6535    SetNoCheck {
6536        value: bool,
6537        responder: BaseDatagramSocketSetNoCheckResponder,
6538    },
6539    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
6540    GetNoCheck {
6541        responder: BaseDatagramSocketGetNoCheckResponder,
6542    },
6543    /// Set `SOL_SOCKET` -> `SO_LINGER`.
6544    SetLinger {
6545        linger: bool,
6546        length_secs: u32,
6547        responder: BaseDatagramSocketSetLingerResponder,
6548    },
6549    /// Get `SOL_SOCKET` -> `SO_LINGER`.
6550    GetLinger {
6551        responder: BaseDatagramSocketGetLingerResponder,
6552    },
6553    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
6554    SetReusePort {
6555        value: bool,
6556        responder: BaseDatagramSocketSetReusePortResponder,
6557    },
6558    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
6559    GetReusePort {
6560        responder: BaseDatagramSocketGetReusePortResponder,
6561    },
6562    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
6563    GetAcceptConn {
6564        responder: BaseDatagramSocketGetAcceptConnResponder,
6565    },
6566    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
6567    SetBindToDevice {
6568        value: String,
6569        responder: BaseDatagramSocketSetBindToDeviceResponder,
6570    },
6571    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
6572    GetBindToDevice {
6573        responder: BaseDatagramSocketGetBindToDeviceResponder,
6574    },
6575    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
6576    /// If `value` is 0, this clears the bound interface.
6577    SetBindToInterfaceIndex {
6578        value: u64,
6579        responder: BaseDatagramSocketSetBindToInterfaceIndexResponder,
6580    },
6581    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
6582    GetBindToInterfaceIndex {
6583        responder: BaseDatagramSocketGetBindToInterfaceIndexResponder,
6584    },
6585    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
6586    SetTimestamp {
6587        value: TimestampOption,
6588        responder: BaseDatagramSocketSetTimestampResponder,
6589    },
6590    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
6591    GetTimestamp {
6592        responder: BaseDatagramSocketGetTimestampResponder,
6593    },
6594    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
6595    /// unlike the standard SO_MARK, this API has multiple mark domains and each
6596    /// mark can be set independently in each domain.
6597    SetMark {
6598        domain: fidl_fuchsia_net::MarkDomain,
6599        mark: OptionalUint32,
6600        responder: BaseDatagramSocketSetMarkResponder,
6601    },
6602    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
6603    /// unlike the standard SO_MARK, this API has multiple mark domains and each
6604    /// mark can be retrieved independently in each domain.
6605    GetMark {
6606        domain: fidl_fuchsia_net::MarkDomain,
6607        responder: BaseDatagramSocketGetMarkResponder,
6608    },
6609    /// Sets the local address used for the socket.
6610    Bind {
6611        addr: fidl_fuchsia_net::SocketAddress,
6612        responder: BaseDatagramSocketBindResponder,
6613    },
6614    /// Initiates a connection to a remote address.
6615    Connect {
6616        addr: fidl_fuchsia_net::SocketAddress,
6617        responder: BaseDatagramSocketConnectResponder,
6618    },
6619    /// Clears connection information from this socket.
6620    Disconnect {
6621        responder: BaseDatagramSocketDisconnectResponder,
6622    },
6623    /// Retrieves the local socket address.
6624    GetSockName {
6625        responder: BaseDatagramSocketGetSockNameResponder,
6626    },
6627    /// Retrieves the remote socket address.
6628    GetPeerName {
6629        responder: BaseDatagramSocketGetPeerNameResponder,
6630    },
6631    /// Shuts down part of the socket.
6632    Shutdown {
6633        mode: ShutdownMode,
6634        responder: BaseDatagramSocketShutdownResponder,
6635    },
6636    /// Set `SOL_IP` -> `IP_TOS`.
6637    SetIpTypeOfService {
6638        value: u8,
6639        responder: BaseDatagramSocketSetIpTypeOfServiceResponder,
6640    },
6641    /// Get `SOL_IP` -> `IP_TOS`.
6642    GetIpTypeOfService {
6643        responder: BaseDatagramSocketGetIpTypeOfServiceResponder,
6644    },
6645    /// Set `SOL_IP` -> `IP_TTL`.
6646    SetIpTtl {
6647        value: OptionalUint8,
6648        responder: BaseDatagramSocketSetIpTtlResponder,
6649    },
6650    /// Get `SOL_IP` -> `IP_TTL`.
6651    GetIpTtl {
6652        responder: BaseDatagramSocketGetIpTtlResponder,
6653    },
6654    /// Set `SOL_IP` -> `IP_PKTINFO`.
6655    SetIpPacketInfo {
6656        value: bool,
6657        responder: BaseDatagramSocketSetIpPacketInfoResponder,
6658    },
6659    /// Get `SOL_IP` -> `IP_PKTINFO`.
6660    GetIpPacketInfo {
6661        responder: BaseDatagramSocketGetIpPacketInfoResponder,
6662    },
6663    /// Set `SOL_IP` -> `IP_RECVTOS`.
6664    SetIpReceiveTypeOfService {
6665        value: bool,
6666        responder: BaseDatagramSocketSetIpReceiveTypeOfServiceResponder,
6667    },
6668    /// Get `SOL_IP` -> `IP_RECVTOS`.
6669    GetIpReceiveTypeOfService {
6670        responder: BaseDatagramSocketGetIpReceiveTypeOfServiceResponder,
6671    },
6672    /// Set `SOL_IP` -> `IP_RECVTTL`.
6673    SetIpReceiveTtl {
6674        value: bool,
6675        responder: BaseDatagramSocketSetIpReceiveTtlResponder,
6676    },
6677    /// Get `SOL_IP` -> `IP_RECVTTL`.
6678    GetIpReceiveTtl {
6679        responder: BaseDatagramSocketGetIpReceiveTtlResponder,
6680    },
6681    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
6682    SetIpMulticastInterface {
6683        iface: u64,
6684        address: fidl_fuchsia_net::Ipv4Address,
6685        responder: BaseDatagramSocketSetIpMulticastInterfaceResponder,
6686    },
6687    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
6688    GetIpMulticastInterface {
6689        responder: BaseDatagramSocketGetIpMulticastInterfaceResponder,
6690    },
6691    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
6692    SetIpMulticastTtl {
6693        value: OptionalUint8,
6694        responder: BaseDatagramSocketSetIpMulticastTtlResponder,
6695    },
6696    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
6697    GetIpMulticastTtl {
6698        responder: BaseDatagramSocketGetIpMulticastTtlResponder,
6699    },
6700    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
6701    SetIpMulticastLoopback {
6702        value: bool,
6703        responder: BaseDatagramSocketSetIpMulticastLoopbackResponder,
6704    },
6705    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
6706    GetIpMulticastLoopback {
6707        responder: BaseDatagramSocketGetIpMulticastLoopbackResponder,
6708    },
6709    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
6710    AddIpMembership {
6711        membership: IpMulticastMembership,
6712        responder: BaseDatagramSocketAddIpMembershipResponder,
6713    },
6714    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
6715    DropIpMembership {
6716        membership: IpMulticastMembership,
6717        responder: BaseDatagramSocketDropIpMembershipResponder,
6718    },
6719    /// Set `SOL_IP` -> `IP_TRANSPARENT`
6720    SetIpTransparent {
6721        value: bool,
6722        responder: BaseDatagramSocketSetIpTransparentResponder,
6723    },
6724    /// Get `SOL_IP` -> `IP_TRANSPARENT`
6725    GetIpTransparent {
6726        responder: BaseDatagramSocketGetIpTransparentResponder,
6727    },
6728    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
6729    SetIpReceiveOriginalDestinationAddress {
6730        value: bool,
6731        responder: BaseDatagramSocketSetIpReceiveOriginalDestinationAddressResponder,
6732    },
6733    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
6734    GetIpReceiveOriginalDestinationAddress {
6735        responder: BaseDatagramSocketGetIpReceiveOriginalDestinationAddressResponder,
6736    },
6737    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
6738    AddIpv6Membership {
6739        membership: Ipv6MulticastMembership,
6740        responder: BaseDatagramSocketAddIpv6MembershipResponder,
6741    },
6742    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
6743    DropIpv6Membership {
6744        membership: Ipv6MulticastMembership,
6745        responder: BaseDatagramSocketDropIpv6MembershipResponder,
6746    },
6747    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
6748    SetIpv6MulticastInterface {
6749        value: u64,
6750        responder: BaseDatagramSocketSetIpv6MulticastInterfaceResponder,
6751    },
6752    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
6753    GetIpv6MulticastInterface {
6754        responder: BaseDatagramSocketGetIpv6MulticastInterfaceResponder,
6755    },
6756    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
6757    SetIpv6UnicastHops {
6758        value: OptionalUint8,
6759        responder: BaseDatagramSocketSetIpv6UnicastHopsResponder,
6760    },
6761    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
6762    GetIpv6UnicastHops {
6763        responder: BaseDatagramSocketGetIpv6UnicastHopsResponder,
6764    },
6765    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
6766    SetIpv6ReceiveHopLimit {
6767        value: bool,
6768        responder: BaseDatagramSocketSetIpv6ReceiveHopLimitResponder,
6769    },
6770    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
6771    GetIpv6ReceiveHopLimit {
6772        responder: BaseDatagramSocketGetIpv6ReceiveHopLimitResponder,
6773    },
6774    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
6775    SetIpv6MulticastHops {
6776        value: OptionalUint8,
6777        responder: BaseDatagramSocketSetIpv6MulticastHopsResponder,
6778    },
6779    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
6780    GetIpv6MulticastHops {
6781        responder: BaseDatagramSocketGetIpv6MulticastHopsResponder,
6782    },
6783    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
6784    SetIpv6MulticastLoopback {
6785        value: bool,
6786        responder: BaseDatagramSocketSetIpv6MulticastLoopbackResponder,
6787    },
6788    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
6789    GetIpv6MulticastLoopback {
6790        responder: BaseDatagramSocketGetIpv6MulticastLoopbackResponder,
6791    },
6792    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
6793    SetIpv6Only {
6794        value: bool,
6795        responder: BaseDatagramSocketSetIpv6OnlyResponder,
6796    },
6797    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
6798    GetIpv6Only {
6799        responder: BaseDatagramSocketGetIpv6OnlyResponder,
6800    },
6801    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
6802    SetIpv6ReceiveTrafficClass {
6803        value: bool,
6804        responder: BaseDatagramSocketSetIpv6ReceiveTrafficClassResponder,
6805    },
6806    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
6807    GetIpv6ReceiveTrafficClass {
6808        responder: BaseDatagramSocketGetIpv6ReceiveTrafficClassResponder,
6809    },
6810    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
6811    SetIpv6TrafficClass {
6812        value: OptionalUint8,
6813        responder: BaseDatagramSocketSetIpv6TrafficClassResponder,
6814    },
6815    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
6816    GetIpv6TrafficClass {
6817        responder: BaseDatagramSocketGetIpv6TrafficClassResponder,
6818    },
6819    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
6820    SetIpv6ReceivePacketInfo {
6821        value: bool,
6822        responder: BaseDatagramSocketSetIpv6ReceivePacketInfoResponder,
6823    },
6824    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
6825    GetIpv6ReceivePacketInfo {
6826        responder: BaseDatagramSocketGetIpv6ReceivePacketInfoResponder,
6827    },
6828    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
6829    GetOriginalDestination {
6830        responder: BaseDatagramSocketGetOriginalDestinationResponder,
6831    },
6832    /// Retrieves creation information from the socket.
6833    ///
6834    /// - response `domain` the socket's associated domain.
6835    /// - response `proto` the socket's associated protocol.
6836    GetInfo {
6837        responder: BaseDatagramSocketGetInfoResponder,
6838    },
6839}
6840
6841impl BaseDatagramSocketRequest {
6842    #[allow(irrefutable_let_patterns)]
6843    pub fn into_clone(
6844        self,
6845    ) -> Option<(
6846        fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
6847        BaseDatagramSocketControlHandle,
6848    )> {
6849        if let BaseDatagramSocketRequest::Clone { request, control_handle } = self {
6850            Some((request, control_handle))
6851        } else {
6852            None
6853        }
6854    }
6855
6856    #[allow(irrefutable_let_patterns)]
6857    pub fn into_close(self) -> Option<(BaseDatagramSocketCloseResponder)> {
6858        if let BaseDatagramSocketRequest::Close { responder } = self {
6859            Some((responder))
6860        } else {
6861            None
6862        }
6863    }
6864
6865    #[allow(irrefutable_let_patterns)]
6866    pub fn into_query(self) -> Option<(BaseDatagramSocketQueryResponder)> {
6867        if let BaseDatagramSocketRequest::Query { responder } = self {
6868            Some((responder))
6869        } else {
6870            None
6871        }
6872    }
6873
6874    #[allow(irrefutable_let_patterns)]
6875    pub fn into_set_reuse_address(
6876        self,
6877    ) -> Option<(bool, BaseDatagramSocketSetReuseAddressResponder)> {
6878        if let BaseDatagramSocketRequest::SetReuseAddress { value, responder } = self {
6879            Some((value, responder))
6880        } else {
6881            None
6882        }
6883    }
6884
6885    #[allow(irrefutable_let_patterns)]
6886    pub fn into_get_reuse_address(self) -> Option<(BaseDatagramSocketGetReuseAddressResponder)> {
6887        if let BaseDatagramSocketRequest::GetReuseAddress { responder } = self {
6888            Some((responder))
6889        } else {
6890            None
6891        }
6892    }
6893
6894    #[allow(irrefutable_let_patterns)]
6895    pub fn into_get_error(self) -> Option<(BaseDatagramSocketGetErrorResponder)> {
6896        if let BaseDatagramSocketRequest::GetError { responder } = self {
6897            Some((responder))
6898        } else {
6899            None
6900        }
6901    }
6902
6903    #[allow(irrefutable_let_patterns)]
6904    pub fn into_set_broadcast(self) -> Option<(bool, BaseDatagramSocketSetBroadcastResponder)> {
6905        if let BaseDatagramSocketRequest::SetBroadcast { value, responder } = self {
6906            Some((value, responder))
6907        } else {
6908            None
6909        }
6910    }
6911
6912    #[allow(irrefutable_let_patterns)]
6913    pub fn into_get_broadcast(self) -> Option<(BaseDatagramSocketGetBroadcastResponder)> {
6914        if let BaseDatagramSocketRequest::GetBroadcast { responder } = self {
6915            Some((responder))
6916        } else {
6917            None
6918        }
6919    }
6920
6921    #[allow(irrefutable_let_patterns)]
6922    pub fn into_set_send_buffer(self) -> Option<(u64, BaseDatagramSocketSetSendBufferResponder)> {
6923        if let BaseDatagramSocketRequest::SetSendBuffer { value_bytes, responder } = self {
6924            Some((value_bytes, responder))
6925        } else {
6926            None
6927        }
6928    }
6929
6930    #[allow(irrefutable_let_patterns)]
6931    pub fn into_get_send_buffer(self) -> Option<(BaseDatagramSocketGetSendBufferResponder)> {
6932        if let BaseDatagramSocketRequest::GetSendBuffer { responder } = self {
6933            Some((responder))
6934        } else {
6935            None
6936        }
6937    }
6938
6939    #[allow(irrefutable_let_patterns)]
6940    pub fn into_set_receive_buffer(
6941        self,
6942    ) -> Option<(u64, BaseDatagramSocketSetReceiveBufferResponder)> {
6943        if let BaseDatagramSocketRequest::SetReceiveBuffer { value_bytes, responder } = self {
6944            Some((value_bytes, responder))
6945        } else {
6946            None
6947        }
6948    }
6949
6950    #[allow(irrefutable_let_patterns)]
6951    pub fn into_get_receive_buffer(self) -> Option<(BaseDatagramSocketGetReceiveBufferResponder)> {
6952        if let BaseDatagramSocketRequest::GetReceiveBuffer { responder } = self {
6953            Some((responder))
6954        } else {
6955            None
6956        }
6957    }
6958
6959    #[allow(irrefutable_let_patterns)]
6960    pub fn into_set_keep_alive(self) -> Option<(bool, BaseDatagramSocketSetKeepAliveResponder)> {
6961        if let BaseDatagramSocketRequest::SetKeepAlive { value, responder } = self {
6962            Some((value, responder))
6963        } else {
6964            None
6965        }
6966    }
6967
6968    #[allow(irrefutable_let_patterns)]
6969    pub fn into_get_keep_alive(self) -> Option<(BaseDatagramSocketGetKeepAliveResponder)> {
6970        if let BaseDatagramSocketRequest::GetKeepAlive { responder } = self {
6971            Some((responder))
6972        } else {
6973            None
6974        }
6975    }
6976
6977    #[allow(irrefutable_let_patterns)]
6978    pub fn into_set_out_of_band_inline(
6979        self,
6980    ) -> Option<(bool, BaseDatagramSocketSetOutOfBandInlineResponder)> {
6981        if let BaseDatagramSocketRequest::SetOutOfBandInline { value, responder } = self {
6982            Some((value, responder))
6983        } else {
6984            None
6985        }
6986    }
6987
6988    #[allow(irrefutable_let_patterns)]
6989    pub fn into_get_out_of_band_inline(
6990        self,
6991    ) -> Option<(BaseDatagramSocketGetOutOfBandInlineResponder)> {
6992        if let BaseDatagramSocketRequest::GetOutOfBandInline { responder } = self {
6993            Some((responder))
6994        } else {
6995            None
6996        }
6997    }
6998
6999    #[allow(irrefutable_let_patterns)]
7000    pub fn into_set_no_check(self) -> Option<(bool, BaseDatagramSocketSetNoCheckResponder)> {
7001        if let BaseDatagramSocketRequest::SetNoCheck { value, responder } = self {
7002            Some((value, responder))
7003        } else {
7004            None
7005        }
7006    }
7007
7008    #[allow(irrefutable_let_patterns)]
7009    pub fn into_get_no_check(self) -> Option<(BaseDatagramSocketGetNoCheckResponder)> {
7010        if let BaseDatagramSocketRequest::GetNoCheck { responder } = self {
7011            Some((responder))
7012        } else {
7013            None
7014        }
7015    }
7016
7017    #[allow(irrefutable_let_patterns)]
7018    pub fn into_set_linger(self) -> Option<(bool, u32, BaseDatagramSocketSetLingerResponder)> {
7019        if let BaseDatagramSocketRequest::SetLinger { linger, length_secs, responder } = self {
7020            Some((linger, length_secs, responder))
7021        } else {
7022            None
7023        }
7024    }
7025
7026    #[allow(irrefutable_let_patterns)]
7027    pub fn into_get_linger(self) -> Option<(BaseDatagramSocketGetLingerResponder)> {
7028        if let BaseDatagramSocketRequest::GetLinger { responder } = self {
7029            Some((responder))
7030        } else {
7031            None
7032        }
7033    }
7034
7035    #[allow(irrefutable_let_patterns)]
7036    pub fn into_set_reuse_port(self) -> Option<(bool, BaseDatagramSocketSetReusePortResponder)> {
7037        if let BaseDatagramSocketRequest::SetReusePort { value, responder } = self {
7038            Some((value, responder))
7039        } else {
7040            None
7041        }
7042    }
7043
7044    #[allow(irrefutable_let_patterns)]
7045    pub fn into_get_reuse_port(self) -> Option<(BaseDatagramSocketGetReusePortResponder)> {
7046        if let BaseDatagramSocketRequest::GetReusePort { responder } = self {
7047            Some((responder))
7048        } else {
7049            None
7050        }
7051    }
7052
7053    #[allow(irrefutable_let_patterns)]
7054    pub fn into_get_accept_conn(self) -> Option<(BaseDatagramSocketGetAcceptConnResponder)> {
7055        if let BaseDatagramSocketRequest::GetAcceptConn { responder } = self {
7056            Some((responder))
7057        } else {
7058            None
7059        }
7060    }
7061
7062    #[allow(irrefutable_let_patterns)]
7063    pub fn into_set_bind_to_device(
7064        self,
7065    ) -> Option<(String, BaseDatagramSocketSetBindToDeviceResponder)> {
7066        if let BaseDatagramSocketRequest::SetBindToDevice { value, responder } = self {
7067            Some((value, responder))
7068        } else {
7069            None
7070        }
7071    }
7072
7073    #[allow(irrefutable_let_patterns)]
7074    pub fn into_get_bind_to_device(self) -> Option<(BaseDatagramSocketGetBindToDeviceResponder)> {
7075        if let BaseDatagramSocketRequest::GetBindToDevice { responder } = self {
7076            Some((responder))
7077        } else {
7078            None
7079        }
7080    }
7081
7082    #[allow(irrefutable_let_patterns)]
7083    pub fn into_set_bind_to_interface_index(
7084        self,
7085    ) -> Option<(u64, BaseDatagramSocketSetBindToInterfaceIndexResponder)> {
7086        if let BaseDatagramSocketRequest::SetBindToInterfaceIndex { value, responder } = self {
7087            Some((value, responder))
7088        } else {
7089            None
7090        }
7091    }
7092
7093    #[allow(irrefutable_let_patterns)]
7094    pub fn into_get_bind_to_interface_index(
7095        self,
7096    ) -> Option<(BaseDatagramSocketGetBindToInterfaceIndexResponder)> {
7097        if let BaseDatagramSocketRequest::GetBindToInterfaceIndex { responder } = self {
7098            Some((responder))
7099        } else {
7100            None
7101        }
7102    }
7103
7104    #[allow(irrefutable_let_patterns)]
7105    pub fn into_set_timestamp(
7106        self,
7107    ) -> Option<(TimestampOption, BaseDatagramSocketSetTimestampResponder)> {
7108        if let BaseDatagramSocketRequest::SetTimestamp { value, responder } = self {
7109            Some((value, responder))
7110        } else {
7111            None
7112        }
7113    }
7114
7115    #[allow(irrefutable_let_patterns)]
7116    pub fn into_get_timestamp(self) -> Option<(BaseDatagramSocketGetTimestampResponder)> {
7117        if let BaseDatagramSocketRequest::GetTimestamp { responder } = self {
7118            Some((responder))
7119        } else {
7120            None
7121        }
7122    }
7123
7124    #[allow(irrefutable_let_patterns)]
7125    pub fn into_set_mark(
7126        self,
7127    ) -> Option<(fidl_fuchsia_net::MarkDomain, OptionalUint32, BaseDatagramSocketSetMarkResponder)>
7128    {
7129        if let BaseDatagramSocketRequest::SetMark { domain, mark, responder } = self {
7130            Some((domain, mark, responder))
7131        } else {
7132            None
7133        }
7134    }
7135
7136    #[allow(irrefutable_let_patterns)]
7137    pub fn into_get_mark(
7138        self,
7139    ) -> Option<(fidl_fuchsia_net::MarkDomain, BaseDatagramSocketGetMarkResponder)> {
7140        if let BaseDatagramSocketRequest::GetMark { domain, responder } = self {
7141            Some((domain, responder))
7142        } else {
7143            None
7144        }
7145    }
7146
7147    #[allow(irrefutable_let_patterns)]
7148    pub fn into_bind(
7149        self,
7150    ) -> Option<(fidl_fuchsia_net::SocketAddress, BaseDatagramSocketBindResponder)> {
7151        if let BaseDatagramSocketRequest::Bind { addr, responder } = self {
7152            Some((addr, responder))
7153        } else {
7154            None
7155        }
7156    }
7157
7158    #[allow(irrefutable_let_patterns)]
7159    pub fn into_connect(
7160        self,
7161    ) -> Option<(fidl_fuchsia_net::SocketAddress, BaseDatagramSocketConnectResponder)> {
7162        if let BaseDatagramSocketRequest::Connect { addr, responder } = self {
7163            Some((addr, responder))
7164        } else {
7165            None
7166        }
7167    }
7168
7169    #[allow(irrefutable_let_patterns)]
7170    pub fn into_disconnect(self) -> Option<(BaseDatagramSocketDisconnectResponder)> {
7171        if let BaseDatagramSocketRequest::Disconnect { responder } = self {
7172            Some((responder))
7173        } else {
7174            None
7175        }
7176    }
7177
7178    #[allow(irrefutable_let_patterns)]
7179    pub fn into_get_sock_name(self) -> Option<(BaseDatagramSocketGetSockNameResponder)> {
7180        if let BaseDatagramSocketRequest::GetSockName { responder } = self {
7181            Some((responder))
7182        } else {
7183            None
7184        }
7185    }
7186
7187    #[allow(irrefutable_let_patterns)]
7188    pub fn into_get_peer_name(self) -> Option<(BaseDatagramSocketGetPeerNameResponder)> {
7189        if let BaseDatagramSocketRequest::GetPeerName { responder } = self {
7190            Some((responder))
7191        } else {
7192            None
7193        }
7194    }
7195
7196    #[allow(irrefutable_let_patterns)]
7197    pub fn into_shutdown(self) -> Option<(ShutdownMode, BaseDatagramSocketShutdownResponder)> {
7198        if let BaseDatagramSocketRequest::Shutdown { mode, responder } = self {
7199            Some((mode, responder))
7200        } else {
7201            None
7202        }
7203    }
7204
7205    #[allow(irrefutable_let_patterns)]
7206    pub fn into_set_ip_type_of_service(
7207        self,
7208    ) -> Option<(u8, BaseDatagramSocketSetIpTypeOfServiceResponder)> {
7209        if let BaseDatagramSocketRequest::SetIpTypeOfService { value, responder } = self {
7210            Some((value, responder))
7211        } else {
7212            None
7213        }
7214    }
7215
7216    #[allow(irrefutable_let_patterns)]
7217    pub fn into_get_ip_type_of_service(
7218        self,
7219    ) -> Option<(BaseDatagramSocketGetIpTypeOfServiceResponder)> {
7220        if let BaseDatagramSocketRequest::GetIpTypeOfService { responder } = self {
7221            Some((responder))
7222        } else {
7223            None
7224        }
7225    }
7226
7227    #[allow(irrefutable_let_patterns)]
7228    pub fn into_set_ip_ttl(self) -> Option<(OptionalUint8, BaseDatagramSocketSetIpTtlResponder)> {
7229        if let BaseDatagramSocketRequest::SetIpTtl { value, responder } = self {
7230            Some((value, responder))
7231        } else {
7232            None
7233        }
7234    }
7235
7236    #[allow(irrefutable_let_patterns)]
7237    pub fn into_get_ip_ttl(self) -> Option<(BaseDatagramSocketGetIpTtlResponder)> {
7238        if let BaseDatagramSocketRequest::GetIpTtl { responder } = self {
7239            Some((responder))
7240        } else {
7241            None
7242        }
7243    }
7244
7245    #[allow(irrefutable_let_patterns)]
7246    pub fn into_set_ip_packet_info(
7247        self,
7248    ) -> Option<(bool, BaseDatagramSocketSetIpPacketInfoResponder)> {
7249        if let BaseDatagramSocketRequest::SetIpPacketInfo { value, responder } = self {
7250            Some((value, responder))
7251        } else {
7252            None
7253        }
7254    }
7255
7256    #[allow(irrefutable_let_patterns)]
7257    pub fn into_get_ip_packet_info(self) -> Option<(BaseDatagramSocketGetIpPacketInfoResponder)> {
7258        if let BaseDatagramSocketRequest::GetIpPacketInfo { responder } = self {
7259            Some((responder))
7260        } else {
7261            None
7262        }
7263    }
7264
7265    #[allow(irrefutable_let_patterns)]
7266    pub fn into_set_ip_receive_type_of_service(
7267        self,
7268    ) -> Option<(bool, BaseDatagramSocketSetIpReceiveTypeOfServiceResponder)> {
7269        if let BaseDatagramSocketRequest::SetIpReceiveTypeOfService { value, responder } = self {
7270            Some((value, responder))
7271        } else {
7272            None
7273        }
7274    }
7275
7276    #[allow(irrefutable_let_patterns)]
7277    pub fn into_get_ip_receive_type_of_service(
7278        self,
7279    ) -> Option<(BaseDatagramSocketGetIpReceiveTypeOfServiceResponder)> {
7280        if let BaseDatagramSocketRequest::GetIpReceiveTypeOfService { responder } = self {
7281            Some((responder))
7282        } else {
7283            None
7284        }
7285    }
7286
7287    #[allow(irrefutable_let_patterns)]
7288    pub fn into_set_ip_receive_ttl(
7289        self,
7290    ) -> Option<(bool, BaseDatagramSocketSetIpReceiveTtlResponder)> {
7291        if let BaseDatagramSocketRequest::SetIpReceiveTtl { value, responder } = self {
7292            Some((value, responder))
7293        } else {
7294            None
7295        }
7296    }
7297
7298    #[allow(irrefutable_let_patterns)]
7299    pub fn into_get_ip_receive_ttl(self) -> Option<(BaseDatagramSocketGetIpReceiveTtlResponder)> {
7300        if let BaseDatagramSocketRequest::GetIpReceiveTtl { responder } = self {
7301            Some((responder))
7302        } else {
7303            None
7304        }
7305    }
7306
7307    #[allow(irrefutable_let_patterns)]
7308    pub fn into_set_ip_multicast_interface(
7309        self,
7310    ) -> Option<(
7311        u64,
7312        fidl_fuchsia_net::Ipv4Address,
7313        BaseDatagramSocketSetIpMulticastInterfaceResponder,
7314    )> {
7315        if let BaseDatagramSocketRequest::SetIpMulticastInterface { iface, address, responder } =
7316            self
7317        {
7318            Some((iface, address, responder))
7319        } else {
7320            None
7321        }
7322    }
7323
7324    #[allow(irrefutable_let_patterns)]
7325    pub fn into_get_ip_multicast_interface(
7326        self,
7327    ) -> Option<(BaseDatagramSocketGetIpMulticastInterfaceResponder)> {
7328        if let BaseDatagramSocketRequest::GetIpMulticastInterface { responder } = self {
7329            Some((responder))
7330        } else {
7331            None
7332        }
7333    }
7334
7335    #[allow(irrefutable_let_patterns)]
7336    pub fn into_set_ip_multicast_ttl(
7337        self,
7338    ) -> Option<(OptionalUint8, BaseDatagramSocketSetIpMulticastTtlResponder)> {
7339        if let BaseDatagramSocketRequest::SetIpMulticastTtl { value, responder } = self {
7340            Some((value, responder))
7341        } else {
7342            None
7343        }
7344    }
7345
7346    #[allow(irrefutable_let_patterns)]
7347    pub fn into_get_ip_multicast_ttl(
7348        self,
7349    ) -> Option<(BaseDatagramSocketGetIpMulticastTtlResponder)> {
7350        if let BaseDatagramSocketRequest::GetIpMulticastTtl { responder } = self {
7351            Some((responder))
7352        } else {
7353            None
7354        }
7355    }
7356
7357    #[allow(irrefutable_let_patterns)]
7358    pub fn into_set_ip_multicast_loopback(
7359        self,
7360    ) -> Option<(bool, BaseDatagramSocketSetIpMulticastLoopbackResponder)> {
7361        if let BaseDatagramSocketRequest::SetIpMulticastLoopback { value, responder } = self {
7362            Some((value, responder))
7363        } else {
7364            None
7365        }
7366    }
7367
7368    #[allow(irrefutable_let_patterns)]
7369    pub fn into_get_ip_multicast_loopback(
7370        self,
7371    ) -> Option<(BaseDatagramSocketGetIpMulticastLoopbackResponder)> {
7372        if let BaseDatagramSocketRequest::GetIpMulticastLoopback { responder } = self {
7373            Some((responder))
7374        } else {
7375            None
7376        }
7377    }
7378
7379    #[allow(irrefutable_let_patterns)]
7380    pub fn into_add_ip_membership(
7381        self,
7382    ) -> Option<(IpMulticastMembership, BaseDatagramSocketAddIpMembershipResponder)> {
7383        if let BaseDatagramSocketRequest::AddIpMembership { membership, responder } = self {
7384            Some((membership, responder))
7385        } else {
7386            None
7387        }
7388    }
7389
7390    #[allow(irrefutable_let_patterns)]
7391    pub fn into_drop_ip_membership(
7392        self,
7393    ) -> Option<(IpMulticastMembership, BaseDatagramSocketDropIpMembershipResponder)> {
7394        if let BaseDatagramSocketRequest::DropIpMembership { membership, responder } = self {
7395            Some((membership, responder))
7396        } else {
7397            None
7398        }
7399    }
7400
7401    #[allow(irrefutable_let_patterns)]
7402    pub fn into_set_ip_transparent(
7403        self,
7404    ) -> Option<(bool, BaseDatagramSocketSetIpTransparentResponder)> {
7405        if let BaseDatagramSocketRequest::SetIpTransparent { value, responder } = self {
7406            Some((value, responder))
7407        } else {
7408            None
7409        }
7410    }
7411
7412    #[allow(irrefutable_let_patterns)]
7413    pub fn into_get_ip_transparent(self) -> Option<(BaseDatagramSocketGetIpTransparentResponder)> {
7414        if let BaseDatagramSocketRequest::GetIpTransparent { responder } = self {
7415            Some((responder))
7416        } else {
7417            None
7418        }
7419    }
7420
7421    #[allow(irrefutable_let_patterns)]
7422    pub fn into_set_ip_receive_original_destination_address(
7423        self,
7424    ) -> Option<(bool, BaseDatagramSocketSetIpReceiveOriginalDestinationAddressResponder)> {
7425        if let BaseDatagramSocketRequest::SetIpReceiveOriginalDestinationAddress {
7426            value,
7427            responder,
7428        } = self
7429        {
7430            Some((value, responder))
7431        } else {
7432            None
7433        }
7434    }
7435
7436    #[allow(irrefutable_let_patterns)]
7437    pub fn into_get_ip_receive_original_destination_address(
7438        self,
7439    ) -> Option<(BaseDatagramSocketGetIpReceiveOriginalDestinationAddressResponder)> {
7440        if let BaseDatagramSocketRequest::GetIpReceiveOriginalDestinationAddress { responder } =
7441            self
7442        {
7443            Some((responder))
7444        } else {
7445            None
7446        }
7447    }
7448
7449    #[allow(irrefutable_let_patterns)]
7450    pub fn into_add_ipv6_membership(
7451        self,
7452    ) -> Option<(Ipv6MulticastMembership, BaseDatagramSocketAddIpv6MembershipResponder)> {
7453        if let BaseDatagramSocketRequest::AddIpv6Membership { membership, responder } = self {
7454            Some((membership, responder))
7455        } else {
7456            None
7457        }
7458    }
7459
7460    #[allow(irrefutable_let_patterns)]
7461    pub fn into_drop_ipv6_membership(
7462        self,
7463    ) -> Option<(Ipv6MulticastMembership, BaseDatagramSocketDropIpv6MembershipResponder)> {
7464        if let BaseDatagramSocketRequest::DropIpv6Membership { membership, responder } = self {
7465            Some((membership, responder))
7466        } else {
7467            None
7468        }
7469    }
7470
7471    #[allow(irrefutable_let_patterns)]
7472    pub fn into_set_ipv6_multicast_interface(
7473        self,
7474    ) -> Option<(u64, BaseDatagramSocketSetIpv6MulticastInterfaceResponder)> {
7475        if let BaseDatagramSocketRequest::SetIpv6MulticastInterface { value, responder } = self {
7476            Some((value, responder))
7477        } else {
7478            None
7479        }
7480    }
7481
7482    #[allow(irrefutable_let_patterns)]
7483    pub fn into_get_ipv6_multicast_interface(
7484        self,
7485    ) -> Option<(BaseDatagramSocketGetIpv6MulticastInterfaceResponder)> {
7486        if let BaseDatagramSocketRequest::GetIpv6MulticastInterface { responder } = self {
7487            Some((responder))
7488        } else {
7489            None
7490        }
7491    }
7492
7493    #[allow(irrefutable_let_patterns)]
7494    pub fn into_set_ipv6_unicast_hops(
7495        self,
7496    ) -> Option<(OptionalUint8, BaseDatagramSocketSetIpv6UnicastHopsResponder)> {
7497        if let BaseDatagramSocketRequest::SetIpv6UnicastHops { value, responder } = self {
7498            Some((value, responder))
7499        } else {
7500            None
7501        }
7502    }
7503
7504    #[allow(irrefutable_let_patterns)]
7505    pub fn into_get_ipv6_unicast_hops(
7506        self,
7507    ) -> Option<(BaseDatagramSocketGetIpv6UnicastHopsResponder)> {
7508        if let BaseDatagramSocketRequest::GetIpv6UnicastHops { responder } = self {
7509            Some((responder))
7510        } else {
7511            None
7512        }
7513    }
7514
7515    #[allow(irrefutable_let_patterns)]
7516    pub fn into_set_ipv6_receive_hop_limit(
7517        self,
7518    ) -> Option<(bool, BaseDatagramSocketSetIpv6ReceiveHopLimitResponder)> {
7519        if let BaseDatagramSocketRequest::SetIpv6ReceiveHopLimit { value, responder } = self {
7520            Some((value, responder))
7521        } else {
7522            None
7523        }
7524    }
7525
7526    #[allow(irrefutable_let_patterns)]
7527    pub fn into_get_ipv6_receive_hop_limit(
7528        self,
7529    ) -> Option<(BaseDatagramSocketGetIpv6ReceiveHopLimitResponder)> {
7530        if let BaseDatagramSocketRequest::GetIpv6ReceiveHopLimit { responder } = self {
7531            Some((responder))
7532        } else {
7533            None
7534        }
7535    }
7536
7537    #[allow(irrefutable_let_patterns)]
7538    pub fn into_set_ipv6_multicast_hops(
7539        self,
7540    ) -> Option<(OptionalUint8, BaseDatagramSocketSetIpv6MulticastHopsResponder)> {
7541        if let BaseDatagramSocketRequest::SetIpv6MulticastHops { value, responder } = self {
7542            Some((value, responder))
7543        } else {
7544            None
7545        }
7546    }
7547
7548    #[allow(irrefutable_let_patterns)]
7549    pub fn into_get_ipv6_multicast_hops(
7550        self,
7551    ) -> Option<(BaseDatagramSocketGetIpv6MulticastHopsResponder)> {
7552        if let BaseDatagramSocketRequest::GetIpv6MulticastHops { responder } = self {
7553            Some((responder))
7554        } else {
7555            None
7556        }
7557    }
7558
7559    #[allow(irrefutable_let_patterns)]
7560    pub fn into_set_ipv6_multicast_loopback(
7561        self,
7562    ) -> Option<(bool, BaseDatagramSocketSetIpv6MulticastLoopbackResponder)> {
7563        if let BaseDatagramSocketRequest::SetIpv6MulticastLoopback { value, responder } = self {
7564            Some((value, responder))
7565        } else {
7566            None
7567        }
7568    }
7569
7570    #[allow(irrefutable_let_patterns)]
7571    pub fn into_get_ipv6_multicast_loopback(
7572        self,
7573    ) -> Option<(BaseDatagramSocketGetIpv6MulticastLoopbackResponder)> {
7574        if let BaseDatagramSocketRequest::GetIpv6MulticastLoopback { responder } = self {
7575            Some((responder))
7576        } else {
7577            None
7578        }
7579    }
7580
7581    #[allow(irrefutable_let_patterns)]
7582    pub fn into_set_ipv6_only(self) -> Option<(bool, BaseDatagramSocketSetIpv6OnlyResponder)> {
7583        if let BaseDatagramSocketRequest::SetIpv6Only { value, responder } = self {
7584            Some((value, responder))
7585        } else {
7586            None
7587        }
7588    }
7589
7590    #[allow(irrefutable_let_patterns)]
7591    pub fn into_get_ipv6_only(self) -> Option<(BaseDatagramSocketGetIpv6OnlyResponder)> {
7592        if let BaseDatagramSocketRequest::GetIpv6Only { responder } = self {
7593            Some((responder))
7594        } else {
7595            None
7596        }
7597    }
7598
7599    #[allow(irrefutable_let_patterns)]
7600    pub fn into_set_ipv6_receive_traffic_class(
7601        self,
7602    ) -> Option<(bool, BaseDatagramSocketSetIpv6ReceiveTrafficClassResponder)> {
7603        if let BaseDatagramSocketRequest::SetIpv6ReceiveTrafficClass { value, responder } = self {
7604            Some((value, responder))
7605        } else {
7606            None
7607        }
7608    }
7609
7610    #[allow(irrefutable_let_patterns)]
7611    pub fn into_get_ipv6_receive_traffic_class(
7612        self,
7613    ) -> Option<(BaseDatagramSocketGetIpv6ReceiveTrafficClassResponder)> {
7614        if let BaseDatagramSocketRequest::GetIpv6ReceiveTrafficClass { responder } = self {
7615            Some((responder))
7616        } else {
7617            None
7618        }
7619    }
7620
7621    #[allow(irrefutable_let_patterns)]
7622    pub fn into_set_ipv6_traffic_class(
7623        self,
7624    ) -> Option<(OptionalUint8, BaseDatagramSocketSetIpv6TrafficClassResponder)> {
7625        if let BaseDatagramSocketRequest::SetIpv6TrafficClass { value, responder } = self {
7626            Some((value, responder))
7627        } else {
7628            None
7629        }
7630    }
7631
7632    #[allow(irrefutable_let_patterns)]
7633    pub fn into_get_ipv6_traffic_class(
7634        self,
7635    ) -> Option<(BaseDatagramSocketGetIpv6TrafficClassResponder)> {
7636        if let BaseDatagramSocketRequest::GetIpv6TrafficClass { responder } = self {
7637            Some((responder))
7638        } else {
7639            None
7640        }
7641    }
7642
7643    #[allow(irrefutable_let_patterns)]
7644    pub fn into_set_ipv6_receive_packet_info(
7645        self,
7646    ) -> Option<(bool, BaseDatagramSocketSetIpv6ReceivePacketInfoResponder)> {
7647        if let BaseDatagramSocketRequest::SetIpv6ReceivePacketInfo { value, responder } = self {
7648            Some((value, responder))
7649        } else {
7650            None
7651        }
7652    }
7653
7654    #[allow(irrefutable_let_patterns)]
7655    pub fn into_get_ipv6_receive_packet_info(
7656        self,
7657    ) -> Option<(BaseDatagramSocketGetIpv6ReceivePacketInfoResponder)> {
7658        if let BaseDatagramSocketRequest::GetIpv6ReceivePacketInfo { responder } = self {
7659            Some((responder))
7660        } else {
7661            None
7662        }
7663    }
7664
7665    #[allow(irrefutable_let_patterns)]
7666    pub fn into_get_original_destination(
7667        self,
7668    ) -> Option<(BaseDatagramSocketGetOriginalDestinationResponder)> {
7669        if let BaseDatagramSocketRequest::GetOriginalDestination { responder } = self {
7670            Some((responder))
7671        } else {
7672            None
7673        }
7674    }
7675
7676    #[allow(irrefutable_let_patterns)]
7677    pub fn into_get_info(self) -> Option<(BaseDatagramSocketGetInfoResponder)> {
7678        if let BaseDatagramSocketRequest::GetInfo { responder } = self {
7679            Some((responder))
7680        } else {
7681            None
7682        }
7683    }
7684
7685    /// Name of the method defined in FIDL
7686    pub fn method_name(&self) -> &'static str {
7687        match *self {
7688            BaseDatagramSocketRequest::Clone { .. } => "clone",
7689            BaseDatagramSocketRequest::Close { .. } => "close",
7690            BaseDatagramSocketRequest::Query { .. } => "query",
7691            BaseDatagramSocketRequest::SetReuseAddress { .. } => "set_reuse_address",
7692            BaseDatagramSocketRequest::GetReuseAddress { .. } => "get_reuse_address",
7693            BaseDatagramSocketRequest::GetError { .. } => "get_error",
7694            BaseDatagramSocketRequest::SetBroadcast { .. } => "set_broadcast",
7695            BaseDatagramSocketRequest::GetBroadcast { .. } => "get_broadcast",
7696            BaseDatagramSocketRequest::SetSendBuffer { .. } => "set_send_buffer",
7697            BaseDatagramSocketRequest::GetSendBuffer { .. } => "get_send_buffer",
7698            BaseDatagramSocketRequest::SetReceiveBuffer { .. } => "set_receive_buffer",
7699            BaseDatagramSocketRequest::GetReceiveBuffer { .. } => "get_receive_buffer",
7700            BaseDatagramSocketRequest::SetKeepAlive { .. } => "set_keep_alive",
7701            BaseDatagramSocketRequest::GetKeepAlive { .. } => "get_keep_alive",
7702            BaseDatagramSocketRequest::SetOutOfBandInline { .. } => "set_out_of_band_inline",
7703            BaseDatagramSocketRequest::GetOutOfBandInline { .. } => "get_out_of_band_inline",
7704            BaseDatagramSocketRequest::SetNoCheck { .. } => "set_no_check",
7705            BaseDatagramSocketRequest::GetNoCheck { .. } => "get_no_check",
7706            BaseDatagramSocketRequest::SetLinger { .. } => "set_linger",
7707            BaseDatagramSocketRequest::GetLinger { .. } => "get_linger",
7708            BaseDatagramSocketRequest::SetReusePort { .. } => "set_reuse_port",
7709            BaseDatagramSocketRequest::GetReusePort { .. } => "get_reuse_port",
7710            BaseDatagramSocketRequest::GetAcceptConn { .. } => "get_accept_conn",
7711            BaseDatagramSocketRequest::SetBindToDevice { .. } => "set_bind_to_device",
7712            BaseDatagramSocketRequest::GetBindToDevice { .. } => "get_bind_to_device",
7713            BaseDatagramSocketRequest::SetBindToInterfaceIndex { .. } => {
7714                "set_bind_to_interface_index"
7715            }
7716            BaseDatagramSocketRequest::GetBindToInterfaceIndex { .. } => {
7717                "get_bind_to_interface_index"
7718            }
7719            BaseDatagramSocketRequest::SetTimestamp { .. } => "set_timestamp",
7720            BaseDatagramSocketRequest::GetTimestamp { .. } => "get_timestamp",
7721            BaseDatagramSocketRequest::SetMark { .. } => "set_mark",
7722            BaseDatagramSocketRequest::GetMark { .. } => "get_mark",
7723            BaseDatagramSocketRequest::Bind { .. } => "bind",
7724            BaseDatagramSocketRequest::Connect { .. } => "connect",
7725            BaseDatagramSocketRequest::Disconnect { .. } => "disconnect",
7726            BaseDatagramSocketRequest::GetSockName { .. } => "get_sock_name",
7727            BaseDatagramSocketRequest::GetPeerName { .. } => "get_peer_name",
7728            BaseDatagramSocketRequest::Shutdown { .. } => "shutdown",
7729            BaseDatagramSocketRequest::SetIpTypeOfService { .. } => "set_ip_type_of_service",
7730            BaseDatagramSocketRequest::GetIpTypeOfService { .. } => "get_ip_type_of_service",
7731            BaseDatagramSocketRequest::SetIpTtl { .. } => "set_ip_ttl",
7732            BaseDatagramSocketRequest::GetIpTtl { .. } => "get_ip_ttl",
7733            BaseDatagramSocketRequest::SetIpPacketInfo { .. } => "set_ip_packet_info",
7734            BaseDatagramSocketRequest::GetIpPacketInfo { .. } => "get_ip_packet_info",
7735            BaseDatagramSocketRequest::SetIpReceiveTypeOfService { .. } => {
7736                "set_ip_receive_type_of_service"
7737            }
7738            BaseDatagramSocketRequest::GetIpReceiveTypeOfService { .. } => {
7739                "get_ip_receive_type_of_service"
7740            }
7741            BaseDatagramSocketRequest::SetIpReceiveTtl { .. } => "set_ip_receive_ttl",
7742            BaseDatagramSocketRequest::GetIpReceiveTtl { .. } => "get_ip_receive_ttl",
7743            BaseDatagramSocketRequest::SetIpMulticastInterface { .. } => {
7744                "set_ip_multicast_interface"
7745            }
7746            BaseDatagramSocketRequest::GetIpMulticastInterface { .. } => {
7747                "get_ip_multicast_interface"
7748            }
7749            BaseDatagramSocketRequest::SetIpMulticastTtl { .. } => "set_ip_multicast_ttl",
7750            BaseDatagramSocketRequest::GetIpMulticastTtl { .. } => "get_ip_multicast_ttl",
7751            BaseDatagramSocketRequest::SetIpMulticastLoopback { .. } => "set_ip_multicast_loopback",
7752            BaseDatagramSocketRequest::GetIpMulticastLoopback { .. } => "get_ip_multicast_loopback",
7753            BaseDatagramSocketRequest::AddIpMembership { .. } => "add_ip_membership",
7754            BaseDatagramSocketRequest::DropIpMembership { .. } => "drop_ip_membership",
7755            BaseDatagramSocketRequest::SetIpTransparent { .. } => "set_ip_transparent",
7756            BaseDatagramSocketRequest::GetIpTransparent { .. } => "get_ip_transparent",
7757            BaseDatagramSocketRequest::SetIpReceiveOriginalDestinationAddress { .. } => {
7758                "set_ip_receive_original_destination_address"
7759            }
7760            BaseDatagramSocketRequest::GetIpReceiveOriginalDestinationAddress { .. } => {
7761                "get_ip_receive_original_destination_address"
7762            }
7763            BaseDatagramSocketRequest::AddIpv6Membership { .. } => "add_ipv6_membership",
7764            BaseDatagramSocketRequest::DropIpv6Membership { .. } => "drop_ipv6_membership",
7765            BaseDatagramSocketRequest::SetIpv6MulticastInterface { .. } => {
7766                "set_ipv6_multicast_interface"
7767            }
7768            BaseDatagramSocketRequest::GetIpv6MulticastInterface { .. } => {
7769                "get_ipv6_multicast_interface"
7770            }
7771            BaseDatagramSocketRequest::SetIpv6UnicastHops { .. } => "set_ipv6_unicast_hops",
7772            BaseDatagramSocketRequest::GetIpv6UnicastHops { .. } => "get_ipv6_unicast_hops",
7773            BaseDatagramSocketRequest::SetIpv6ReceiveHopLimit { .. } => {
7774                "set_ipv6_receive_hop_limit"
7775            }
7776            BaseDatagramSocketRequest::GetIpv6ReceiveHopLimit { .. } => {
7777                "get_ipv6_receive_hop_limit"
7778            }
7779            BaseDatagramSocketRequest::SetIpv6MulticastHops { .. } => "set_ipv6_multicast_hops",
7780            BaseDatagramSocketRequest::GetIpv6MulticastHops { .. } => "get_ipv6_multicast_hops",
7781            BaseDatagramSocketRequest::SetIpv6MulticastLoopback { .. } => {
7782                "set_ipv6_multicast_loopback"
7783            }
7784            BaseDatagramSocketRequest::GetIpv6MulticastLoopback { .. } => {
7785                "get_ipv6_multicast_loopback"
7786            }
7787            BaseDatagramSocketRequest::SetIpv6Only { .. } => "set_ipv6_only",
7788            BaseDatagramSocketRequest::GetIpv6Only { .. } => "get_ipv6_only",
7789            BaseDatagramSocketRequest::SetIpv6ReceiveTrafficClass { .. } => {
7790                "set_ipv6_receive_traffic_class"
7791            }
7792            BaseDatagramSocketRequest::GetIpv6ReceiveTrafficClass { .. } => {
7793                "get_ipv6_receive_traffic_class"
7794            }
7795            BaseDatagramSocketRequest::SetIpv6TrafficClass { .. } => "set_ipv6_traffic_class",
7796            BaseDatagramSocketRequest::GetIpv6TrafficClass { .. } => "get_ipv6_traffic_class",
7797            BaseDatagramSocketRequest::SetIpv6ReceivePacketInfo { .. } => {
7798                "set_ipv6_receive_packet_info"
7799            }
7800            BaseDatagramSocketRequest::GetIpv6ReceivePacketInfo { .. } => {
7801                "get_ipv6_receive_packet_info"
7802            }
7803            BaseDatagramSocketRequest::GetOriginalDestination { .. } => "get_original_destination",
7804            BaseDatagramSocketRequest::GetInfo { .. } => "get_info",
7805        }
7806    }
7807}
7808
7809#[derive(Debug, Clone)]
7810pub struct BaseDatagramSocketControlHandle {
7811    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
7812}
7813
7814impl fidl::endpoints::ControlHandle for BaseDatagramSocketControlHandle {
7815    fn shutdown(&self) {
7816        self.inner.shutdown()
7817    }
7818    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
7819        self.inner.shutdown_with_epitaph(status)
7820    }
7821
7822    fn is_closed(&self) -> bool {
7823        self.inner.channel().is_closed()
7824    }
7825    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
7826        self.inner.channel().on_closed()
7827    }
7828
7829    #[cfg(target_os = "fuchsia")]
7830    fn signal_peer(
7831        &self,
7832        clear_mask: zx::Signals,
7833        set_mask: zx::Signals,
7834    ) -> Result<(), zx_status::Status> {
7835        use fidl::Peered;
7836        self.inner.channel().signal_peer(clear_mask, set_mask)
7837    }
7838}
7839
7840impl BaseDatagramSocketControlHandle {}
7841
7842#[must_use = "FIDL methods require a response to be sent"]
7843#[derive(Debug)]
7844pub struct BaseDatagramSocketCloseResponder {
7845    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
7846    tx_id: u32,
7847}
7848
7849/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
7850/// if the responder is dropped without sending a response, so that the client
7851/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
7852impl std::ops::Drop for BaseDatagramSocketCloseResponder {
7853    fn drop(&mut self) {
7854        self.control_handle.shutdown();
7855        // Safety: drops once, never accessed again
7856        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7857    }
7858}
7859
7860impl fidl::endpoints::Responder for BaseDatagramSocketCloseResponder {
7861    type ControlHandle = BaseDatagramSocketControlHandle;
7862
7863    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
7864        &self.control_handle
7865    }
7866
7867    fn drop_without_shutdown(mut self) {
7868        // Safety: drops once, never accessed again due to mem::forget
7869        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7870        // Prevent Drop from running (which would shut down the channel)
7871        std::mem::forget(self);
7872    }
7873}
7874
7875impl BaseDatagramSocketCloseResponder {
7876    /// Sends a response to the FIDL transaction.
7877    ///
7878    /// Sets the channel to shutdown if an error occurs.
7879    pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
7880        let _result = self.send_raw(result);
7881        if _result.is_err() {
7882            self.control_handle.shutdown();
7883        }
7884        self.drop_without_shutdown();
7885        _result
7886    }
7887
7888    /// Similar to "send" but does not shutdown the channel if an error occurs.
7889    pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
7890        let _result = self.send_raw(result);
7891        self.drop_without_shutdown();
7892        _result
7893    }
7894
7895    fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
7896        self.control_handle
7897            .inner
7898            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
7899                result,
7900                self.tx_id,
7901                0x5ac5d459ad7f657e,
7902                fidl::encoding::DynamicFlags::empty(),
7903            )
7904    }
7905}
7906
7907#[must_use = "FIDL methods require a response to be sent"]
7908#[derive(Debug)]
7909pub struct BaseDatagramSocketQueryResponder {
7910    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
7911    tx_id: u32,
7912}
7913
7914/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
7915/// if the responder is dropped without sending a response, so that the client
7916/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
7917impl std::ops::Drop for BaseDatagramSocketQueryResponder {
7918    fn drop(&mut self) {
7919        self.control_handle.shutdown();
7920        // Safety: drops once, never accessed again
7921        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7922    }
7923}
7924
7925impl fidl::endpoints::Responder for BaseDatagramSocketQueryResponder {
7926    type ControlHandle = BaseDatagramSocketControlHandle;
7927
7928    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
7929        &self.control_handle
7930    }
7931
7932    fn drop_without_shutdown(mut self) {
7933        // Safety: drops once, never accessed again due to mem::forget
7934        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7935        // Prevent Drop from running (which would shut down the channel)
7936        std::mem::forget(self);
7937    }
7938}
7939
7940impl BaseDatagramSocketQueryResponder {
7941    /// Sends a response to the FIDL transaction.
7942    ///
7943    /// Sets the channel to shutdown if an error occurs.
7944    pub fn send(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
7945        let _result = self.send_raw(protocol);
7946        if _result.is_err() {
7947            self.control_handle.shutdown();
7948        }
7949        self.drop_without_shutdown();
7950        _result
7951    }
7952
7953    /// Similar to "send" but does not shutdown the channel if an error occurs.
7954    pub fn send_no_shutdown_on_err(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
7955        let _result = self.send_raw(protocol);
7956        self.drop_without_shutdown();
7957        _result
7958    }
7959
7960    fn send_raw(&self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
7961        self.control_handle.inner.send::<fidl_fuchsia_unknown::QueryableQueryResponse>(
7962            (protocol,),
7963            self.tx_id,
7964            0x2658edee9decfc06,
7965            fidl::encoding::DynamicFlags::empty(),
7966        )
7967    }
7968}
7969
7970#[must_use = "FIDL methods require a response to be sent"]
7971#[derive(Debug)]
7972pub struct BaseDatagramSocketSetReuseAddressResponder {
7973    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
7974    tx_id: u32,
7975}
7976
7977/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
7978/// if the responder is dropped without sending a response, so that the client
7979/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
7980impl std::ops::Drop for BaseDatagramSocketSetReuseAddressResponder {
7981    fn drop(&mut self) {
7982        self.control_handle.shutdown();
7983        // Safety: drops once, never accessed again
7984        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7985    }
7986}
7987
7988impl fidl::endpoints::Responder for BaseDatagramSocketSetReuseAddressResponder {
7989    type ControlHandle = BaseDatagramSocketControlHandle;
7990
7991    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
7992        &self.control_handle
7993    }
7994
7995    fn drop_without_shutdown(mut self) {
7996        // Safety: drops once, never accessed again due to mem::forget
7997        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
7998        // Prevent Drop from running (which would shut down the channel)
7999        std::mem::forget(self);
8000    }
8001}
8002
8003impl BaseDatagramSocketSetReuseAddressResponder {
8004    /// Sends a response to the FIDL transaction.
8005    ///
8006    /// Sets the channel to shutdown if an error occurs.
8007    pub fn send(
8008        self,
8009        mut result: Result<(), fidl_fuchsia_posix::Errno>,
8010    ) -> Result<(), fidl::Error> {
8011        let _result = self.send_raw(result);
8012        if _result.is_err() {
8013            self.control_handle.shutdown();
8014        }
8015        self.drop_without_shutdown();
8016        _result
8017    }
8018
8019    /// Similar to "send" but does not shutdown the channel if an error occurs.
8020    pub fn send_no_shutdown_on_err(
8021        self,
8022        mut result: Result<(), fidl_fuchsia_posix::Errno>,
8023    ) -> Result<(), fidl::Error> {
8024        let _result = self.send_raw(result);
8025        self.drop_without_shutdown();
8026        _result
8027    }
8028
8029    fn send_raw(
8030        &self,
8031        mut result: Result<(), fidl_fuchsia_posix::Errno>,
8032    ) -> Result<(), fidl::Error> {
8033        self.control_handle.inner.send::<fidl::encoding::ResultType<
8034            fidl::encoding::EmptyStruct,
8035            fidl_fuchsia_posix::Errno,
8036        >>(
8037            result,
8038            self.tx_id,
8039            0x1fd74ee8b9a4a876,
8040            fidl::encoding::DynamicFlags::empty(),
8041        )
8042    }
8043}
8044
8045#[must_use = "FIDL methods require a response to be sent"]
8046#[derive(Debug)]
8047pub struct BaseDatagramSocketGetReuseAddressResponder {
8048    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
8049    tx_id: u32,
8050}
8051
8052/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
8053/// if the responder is dropped without sending a response, so that the client
8054/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
8055impl std::ops::Drop for BaseDatagramSocketGetReuseAddressResponder {
8056    fn drop(&mut self) {
8057        self.control_handle.shutdown();
8058        // Safety: drops once, never accessed again
8059        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8060    }
8061}
8062
8063impl fidl::endpoints::Responder for BaseDatagramSocketGetReuseAddressResponder {
8064    type ControlHandle = BaseDatagramSocketControlHandle;
8065
8066    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
8067        &self.control_handle
8068    }
8069
8070    fn drop_without_shutdown(mut self) {
8071        // Safety: drops once, never accessed again due to mem::forget
8072        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8073        // Prevent Drop from running (which would shut down the channel)
8074        std::mem::forget(self);
8075    }
8076}
8077
8078impl BaseDatagramSocketGetReuseAddressResponder {
8079    /// Sends a response to the FIDL transaction.
8080    ///
8081    /// Sets the channel to shutdown if an error occurs.
8082    pub fn send(
8083        self,
8084        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
8085    ) -> Result<(), fidl::Error> {
8086        let _result = self.send_raw(result);
8087        if _result.is_err() {
8088            self.control_handle.shutdown();
8089        }
8090        self.drop_without_shutdown();
8091        _result
8092    }
8093
8094    /// Similar to "send" but does not shutdown the channel if an error occurs.
8095    pub fn send_no_shutdown_on_err(
8096        self,
8097        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
8098    ) -> Result<(), fidl::Error> {
8099        let _result = self.send_raw(result);
8100        self.drop_without_shutdown();
8101        _result
8102    }
8103
8104    fn send_raw(
8105        &self,
8106        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
8107    ) -> Result<(), fidl::Error> {
8108        self.control_handle.inner.send::<fidl::encoding::ResultType<
8109            BaseSocketGetReuseAddressResponse,
8110            fidl_fuchsia_posix::Errno,
8111        >>(
8112            result.map(|value| (value,)),
8113            self.tx_id,
8114            0x67b7206b8d1bc0a5,
8115            fidl::encoding::DynamicFlags::empty(),
8116        )
8117    }
8118}
8119
8120#[must_use = "FIDL methods require a response to be sent"]
8121#[derive(Debug)]
8122pub struct BaseDatagramSocketGetErrorResponder {
8123    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
8124    tx_id: u32,
8125}
8126
8127/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
8128/// if the responder is dropped without sending a response, so that the client
8129/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
8130impl std::ops::Drop for BaseDatagramSocketGetErrorResponder {
8131    fn drop(&mut self) {
8132        self.control_handle.shutdown();
8133        // Safety: drops once, never accessed again
8134        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8135    }
8136}
8137
8138impl fidl::endpoints::Responder for BaseDatagramSocketGetErrorResponder {
8139    type ControlHandle = BaseDatagramSocketControlHandle;
8140
8141    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
8142        &self.control_handle
8143    }
8144
8145    fn drop_without_shutdown(mut self) {
8146        // Safety: drops once, never accessed again due to mem::forget
8147        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8148        // Prevent Drop from running (which would shut down the channel)
8149        std::mem::forget(self);
8150    }
8151}
8152
8153impl BaseDatagramSocketGetErrorResponder {
8154    /// Sends a response to the FIDL transaction.
8155    ///
8156    /// Sets the channel to shutdown if an error occurs.
8157    pub fn send(
8158        self,
8159        mut result: Result<(), fidl_fuchsia_posix::Errno>,
8160    ) -> Result<(), fidl::Error> {
8161        let _result = self.send_raw(result);
8162        if _result.is_err() {
8163            self.control_handle.shutdown();
8164        }
8165        self.drop_without_shutdown();
8166        _result
8167    }
8168
8169    /// Similar to "send" but does not shutdown the channel if an error occurs.
8170    pub fn send_no_shutdown_on_err(
8171        self,
8172        mut result: Result<(), fidl_fuchsia_posix::Errno>,
8173    ) -> Result<(), fidl::Error> {
8174        let _result = self.send_raw(result);
8175        self.drop_without_shutdown();
8176        _result
8177    }
8178
8179    fn send_raw(
8180        &self,
8181        mut result: Result<(), fidl_fuchsia_posix::Errno>,
8182    ) -> Result<(), fidl::Error> {
8183        self.control_handle.inner.send::<fidl::encoding::ResultType<
8184            fidl::encoding::EmptyStruct,
8185            fidl_fuchsia_posix::Errno,
8186        >>(
8187            result,
8188            self.tx_id,
8189            0x5aad39b33e5f6ebb,
8190            fidl::encoding::DynamicFlags::empty(),
8191        )
8192    }
8193}
8194
8195#[must_use = "FIDL methods require a response to be sent"]
8196#[derive(Debug)]
8197pub struct BaseDatagramSocketSetBroadcastResponder {
8198    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
8199    tx_id: u32,
8200}
8201
8202/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
8203/// if the responder is dropped without sending a response, so that the client
8204/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
8205impl std::ops::Drop for BaseDatagramSocketSetBroadcastResponder {
8206    fn drop(&mut self) {
8207        self.control_handle.shutdown();
8208        // Safety: drops once, never accessed again
8209        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8210    }
8211}
8212
8213impl fidl::endpoints::Responder for BaseDatagramSocketSetBroadcastResponder {
8214    type ControlHandle = BaseDatagramSocketControlHandle;
8215
8216    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
8217        &self.control_handle
8218    }
8219
8220    fn drop_without_shutdown(mut self) {
8221        // Safety: drops once, never accessed again due to mem::forget
8222        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8223        // Prevent Drop from running (which would shut down the channel)
8224        std::mem::forget(self);
8225    }
8226}
8227
8228impl BaseDatagramSocketSetBroadcastResponder {
8229    /// Sends a response to the FIDL transaction.
8230    ///
8231    /// Sets the channel to shutdown if an error occurs.
8232    pub fn send(
8233        self,
8234        mut result: Result<(), fidl_fuchsia_posix::Errno>,
8235    ) -> Result<(), fidl::Error> {
8236        let _result = self.send_raw(result);
8237        if _result.is_err() {
8238            self.control_handle.shutdown();
8239        }
8240        self.drop_without_shutdown();
8241        _result
8242    }
8243
8244    /// Similar to "send" but does not shutdown the channel if an error occurs.
8245    pub fn send_no_shutdown_on_err(
8246        self,
8247        mut result: Result<(), fidl_fuchsia_posix::Errno>,
8248    ) -> Result<(), fidl::Error> {
8249        let _result = self.send_raw(result);
8250        self.drop_without_shutdown();
8251        _result
8252    }
8253
8254    fn send_raw(
8255        &self,
8256        mut result: Result<(), fidl_fuchsia_posix::Errno>,
8257    ) -> Result<(), fidl::Error> {
8258        self.control_handle.inner.send::<fidl::encoding::ResultType<
8259            fidl::encoding::EmptyStruct,
8260            fidl_fuchsia_posix::Errno,
8261        >>(
8262            result,
8263            self.tx_id,
8264            0x6023e081ce3cd947,
8265            fidl::encoding::DynamicFlags::empty(),
8266        )
8267    }
8268}
8269
8270#[must_use = "FIDL methods require a response to be sent"]
8271#[derive(Debug)]
8272pub struct BaseDatagramSocketGetBroadcastResponder {
8273    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
8274    tx_id: u32,
8275}
8276
8277/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
8278/// if the responder is dropped without sending a response, so that the client
8279/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
8280impl std::ops::Drop for BaseDatagramSocketGetBroadcastResponder {
8281    fn drop(&mut self) {
8282        self.control_handle.shutdown();
8283        // Safety: drops once, never accessed again
8284        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8285    }
8286}
8287
8288impl fidl::endpoints::Responder for BaseDatagramSocketGetBroadcastResponder {
8289    type ControlHandle = BaseDatagramSocketControlHandle;
8290
8291    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
8292        &self.control_handle
8293    }
8294
8295    fn drop_without_shutdown(mut self) {
8296        // Safety: drops once, never accessed again due to mem::forget
8297        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8298        // Prevent Drop from running (which would shut down the channel)
8299        std::mem::forget(self);
8300    }
8301}
8302
8303impl BaseDatagramSocketGetBroadcastResponder {
8304    /// Sends a response to the FIDL transaction.
8305    ///
8306    /// Sets the channel to shutdown if an error occurs.
8307    pub fn send(
8308        self,
8309        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
8310    ) -> Result<(), fidl::Error> {
8311        let _result = self.send_raw(result);
8312        if _result.is_err() {
8313            self.control_handle.shutdown();
8314        }
8315        self.drop_without_shutdown();
8316        _result
8317    }
8318
8319    /// Similar to "send" but does not shutdown the channel if an error occurs.
8320    pub fn send_no_shutdown_on_err(
8321        self,
8322        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
8323    ) -> Result<(), fidl::Error> {
8324        let _result = self.send_raw(result);
8325        self.drop_without_shutdown();
8326        _result
8327    }
8328
8329    fn send_raw(
8330        &self,
8331        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
8332    ) -> Result<(), fidl::Error> {
8333        self.control_handle.inner.send::<fidl::encoding::ResultType<
8334            BaseSocketGetBroadcastResponse,
8335            fidl_fuchsia_posix::Errno,
8336        >>(
8337            result.map(|value| (value,)),
8338            self.tx_id,
8339            0x68796fc556f9780d,
8340            fidl::encoding::DynamicFlags::empty(),
8341        )
8342    }
8343}
8344
8345#[must_use = "FIDL methods require a response to be sent"]
8346#[derive(Debug)]
8347pub struct BaseDatagramSocketSetSendBufferResponder {
8348    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
8349    tx_id: u32,
8350}
8351
8352/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
8353/// if the responder is dropped without sending a response, so that the client
8354/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
8355impl std::ops::Drop for BaseDatagramSocketSetSendBufferResponder {
8356    fn drop(&mut self) {
8357        self.control_handle.shutdown();
8358        // Safety: drops once, never accessed again
8359        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8360    }
8361}
8362
8363impl fidl::endpoints::Responder for BaseDatagramSocketSetSendBufferResponder {
8364    type ControlHandle = BaseDatagramSocketControlHandle;
8365
8366    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
8367        &self.control_handle
8368    }
8369
8370    fn drop_without_shutdown(mut self) {
8371        // Safety: drops once, never accessed again due to mem::forget
8372        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8373        // Prevent Drop from running (which would shut down the channel)
8374        std::mem::forget(self);
8375    }
8376}
8377
8378impl BaseDatagramSocketSetSendBufferResponder {
8379    /// Sends a response to the FIDL transaction.
8380    ///
8381    /// Sets the channel to shutdown if an error occurs.
8382    pub fn send(
8383        self,
8384        mut result: Result<(), fidl_fuchsia_posix::Errno>,
8385    ) -> Result<(), fidl::Error> {
8386        let _result = self.send_raw(result);
8387        if _result.is_err() {
8388            self.control_handle.shutdown();
8389        }
8390        self.drop_without_shutdown();
8391        _result
8392    }
8393
8394    /// Similar to "send" but does not shutdown the channel if an error occurs.
8395    pub fn send_no_shutdown_on_err(
8396        self,
8397        mut result: Result<(), fidl_fuchsia_posix::Errno>,
8398    ) -> Result<(), fidl::Error> {
8399        let _result = self.send_raw(result);
8400        self.drop_without_shutdown();
8401        _result
8402    }
8403
8404    fn send_raw(
8405        &self,
8406        mut result: Result<(), fidl_fuchsia_posix::Errno>,
8407    ) -> Result<(), fidl::Error> {
8408        self.control_handle.inner.send::<fidl::encoding::ResultType<
8409            fidl::encoding::EmptyStruct,
8410            fidl_fuchsia_posix::Errno,
8411        >>(
8412            result,
8413            self.tx_id,
8414            0x756eac32d73a7a70,
8415            fidl::encoding::DynamicFlags::empty(),
8416        )
8417    }
8418}
8419
8420#[must_use = "FIDL methods require a response to be sent"]
8421#[derive(Debug)]
8422pub struct BaseDatagramSocketGetSendBufferResponder {
8423    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
8424    tx_id: u32,
8425}
8426
8427/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
8428/// if the responder is dropped without sending a response, so that the client
8429/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
8430impl std::ops::Drop for BaseDatagramSocketGetSendBufferResponder {
8431    fn drop(&mut self) {
8432        self.control_handle.shutdown();
8433        // Safety: drops once, never accessed again
8434        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8435    }
8436}
8437
8438impl fidl::endpoints::Responder for BaseDatagramSocketGetSendBufferResponder {
8439    type ControlHandle = BaseDatagramSocketControlHandle;
8440
8441    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
8442        &self.control_handle
8443    }
8444
8445    fn drop_without_shutdown(mut self) {
8446        // Safety: drops once, never accessed again due to mem::forget
8447        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8448        // Prevent Drop from running (which would shut down the channel)
8449        std::mem::forget(self);
8450    }
8451}
8452
8453impl BaseDatagramSocketGetSendBufferResponder {
8454    /// Sends a response to the FIDL transaction.
8455    ///
8456    /// Sets the channel to shutdown if an error occurs.
8457    pub fn send(
8458        self,
8459        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
8460    ) -> Result<(), fidl::Error> {
8461        let _result = self.send_raw(result);
8462        if _result.is_err() {
8463            self.control_handle.shutdown();
8464        }
8465        self.drop_without_shutdown();
8466        _result
8467    }
8468
8469    /// Similar to "send" but does not shutdown the channel if an error occurs.
8470    pub fn send_no_shutdown_on_err(
8471        self,
8472        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
8473    ) -> Result<(), fidl::Error> {
8474        let _result = self.send_raw(result);
8475        self.drop_without_shutdown();
8476        _result
8477    }
8478
8479    fn send_raw(
8480        &self,
8481        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
8482    ) -> Result<(), fidl::Error> {
8483        self.control_handle.inner.send::<fidl::encoding::ResultType<
8484            BaseSocketGetSendBufferResponse,
8485            fidl_fuchsia_posix::Errno,
8486        >>(
8487            result.map(|value_bytes| (value_bytes,)),
8488            self.tx_id,
8489            0x78a52fd9c7b2410b,
8490            fidl::encoding::DynamicFlags::empty(),
8491        )
8492    }
8493}
8494
8495#[must_use = "FIDL methods require a response to be sent"]
8496#[derive(Debug)]
8497pub struct BaseDatagramSocketSetReceiveBufferResponder {
8498    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
8499    tx_id: u32,
8500}
8501
8502/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
8503/// if the responder is dropped without sending a response, so that the client
8504/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
8505impl std::ops::Drop for BaseDatagramSocketSetReceiveBufferResponder {
8506    fn drop(&mut self) {
8507        self.control_handle.shutdown();
8508        // Safety: drops once, never accessed again
8509        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8510    }
8511}
8512
8513impl fidl::endpoints::Responder for BaseDatagramSocketSetReceiveBufferResponder {
8514    type ControlHandle = BaseDatagramSocketControlHandle;
8515
8516    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
8517        &self.control_handle
8518    }
8519
8520    fn drop_without_shutdown(mut self) {
8521        // Safety: drops once, never accessed again due to mem::forget
8522        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8523        // Prevent Drop from running (which would shut down the channel)
8524        std::mem::forget(self);
8525    }
8526}
8527
8528impl BaseDatagramSocketSetReceiveBufferResponder {
8529    /// Sends a response to the FIDL transaction.
8530    ///
8531    /// Sets the channel to shutdown if an error occurs.
8532    pub fn send(
8533        self,
8534        mut result: Result<(), fidl_fuchsia_posix::Errno>,
8535    ) -> Result<(), fidl::Error> {
8536        let _result = self.send_raw(result);
8537        if _result.is_err() {
8538            self.control_handle.shutdown();
8539        }
8540        self.drop_without_shutdown();
8541        _result
8542    }
8543
8544    /// Similar to "send" but does not shutdown the channel if an error occurs.
8545    pub fn send_no_shutdown_on_err(
8546        self,
8547        mut result: Result<(), fidl_fuchsia_posix::Errno>,
8548    ) -> Result<(), fidl::Error> {
8549        let _result = self.send_raw(result);
8550        self.drop_without_shutdown();
8551        _result
8552    }
8553
8554    fn send_raw(
8555        &self,
8556        mut result: Result<(), fidl_fuchsia_posix::Errno>,
8557    ) -> Result<(), fidl::Error> {
8558        self.control_handle.inner.send::<fidl::encoding::ResultType<
8559            fidl::encoding::EmptyStruct,
8560            fidl_fuchsia_posix::Errno,
8561        >>(
8562            result,
8563            self.tx_id,
8564            0x6b0cf2f1919c7001,
8565            fidl::encoding::DynamicFlags::empty(),
8566        )
8567    }
8568}
8569
8570#[must_use = "FIDL methods require a response to be sent"]
8571#[derive(Debug)]
8572pub struct BaseDatagramSocketGetReceiveBufferResponder {
8573    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
8574    tx_id: u32,
8575}
8576
8577/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
8578/// if the responder is dropped without sending a response, so that the client
8579/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
8580impl std::ops::Drop for BaseDatagramSocketGetReceiveBufferResponder {
8581    fn drop(&mut self) {
8582        self.control_handle.shutdown();
8583        // Safety: drops once, never accessed again
8584        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8585    }
8586}
8587
8588impl fidl::endpoints::Responder for BaseDatagramSocketGetReceiveBufferResponder {
8589    type ControlHandle = BaseDatagramSocketControlHandle;
8590
8591    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
8592        &self.control_handle
8593    }
8594
8595    fn drop_without_shutdown(mut self) {
8596        // Safety: drops once, never accessed again due to mem::forget
8597        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8598        // Prevent Drop from running (which would shut down the channel)
8599        std::mem::forget(self);
8600    }
8601}
8602
8603impl BaseDatagramSocketGetReceiveBufferResponder {
8604    /// Sends a response to the FIDL transaction.
8605    ///
8606    /// Sets the channel to shutdown if an error occurs.
8607    pub fn send(
8608        self,
8609        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
8610    ) -> Result<(), fidl::Error> {
8611        let _result = self.send_raw(result);
8612        if _result.is_err() {
8613            self.control_handle.shutdown();
8614        }
8615        self.drop_without_shutdown();
8616        _result
8617    }
8618
8619    /// Similar to "send" but does not shutdown the channel if an error occurs.
8620    pub fn send_no_shutdown_on_err(
8621        self,
8622        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
8623    ) -> Result<(), fidl::Error> {
8624        let _result = self.send_raw(result);
8625        self.drop_without_shutdown();
8626        _result
8627    }
8628
8629    fn send_raw(
8630        &self,
8631        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
8632    ) -> Result<(), fidl::Error> {
8633        self.control_handle.inner.send::<fidl::encoding::ResultType<
8634            BaseSocketGetReceiveBufferResponse,
8635            fidl_fuchsia_posix::Errno,
8636        >>(
8637            result.map(|value_bytes| (value_bytes,)),
8638            self.tx_id,
8639            0x14c1a4b64f709e5c,
8640            fidl::encoding::DynamicFlags::empty(),
8641        )
8642    }
8643}
8644
8645#[must_use = "FIDL methods require a response to be sent"]
8646#[derive(Debug)]
8647pub struct BaseDatagramSocketSetKeepAliveResponder {
8648    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
8649    tx_id: u32,
8650}
8651
8652/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
8653/// if the responder is dropped without sending a response, so that the client
8654/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
8655impl std::ops::Drop for BaseDatagramSocketSetKeepAliveResponder {
8656    fn drop(&mut self) {
8657        self.control_handle.shutdown();
8658        // Safety: drops once, never accessed again
8659        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8660    }
8661}
8662
8663impl fidl::endpoints::Responder for BaseDatagramSocketSetKeepAliveResponder {
8664    type ControlHandle = BaseDatagramSocketControlHandle;
8665
8666    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
8667        &self.control_handle
8668    }
8669
8670    fn drop_without_shutdown(mut self) {
8671        // Safety: drops once, never accessed again due to mem::forget
8672        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8673        // Prevent Drop from running (which would shut down the channel)
8674        std::mem::forget(self);
8675    }
8676}
8677
8678impl BaseDatagramSocketSetKeepAliveResponder {
8679    /// Sends a response to the FIDL transaction.
8680    ///
8681    /// Sets the channel to shutdown if an error occurs.
8682    pub fn send(
8683        self,
8684        mut result: Result<(), fidl_fuchsia_posix::Errno>,
8685    ) -> Result<(), fidl::Error> {
8686        let _result = self.send_raw(result);
8687        if _result.is_err() {
8688            self.control_handle.shutdown();
8689        }
8690        self.drop_without_shutdown();
8691        _result
8692    }
8693
8694    /// Similar to "send" but does not shutdown the channel if an error occurs.
8695    pub fn send_no_shutdown_on_err(
8696        self,
8697        mut result: Result<(), fidl_fuchsia_posix::Errno>,
8698    ) -> Result<(), fidl::Error> {
8699        let _result = self.send_raw(result);
8700        self.drop_without_shutdown();
8701        _result
8702    }
8703
8704    fn send_raw(
8705        &self,
8706        mut result: Result<(), fidl_fuchsia_posix::Errno>,
8707    ) -> Result<(), fidl::Error> {
8708        self.control_handle.inner.send::<fidl::encoding::ResultType<
8709            fidl::encoding::EmptyStruct,
8710            fidl_fuchsia_posix::Errno,
8711        >>(
8712            result,
8713            self.tx_id,
8714            0x572df8f0b920d2c7,
8715            fidl::encoding::DynamicFlags::empty(),
8716        )
8717    }
8718}
8719
8720#[must_use = "FIDL methods require a response to be sent"]
8721#[derive(Debug)]
8722pub struct BaseDatagramSocketGetKeepAliveResponder {
8723    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
8724    tx_id: u32,
8725}
8726
8727/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
8728/// if the responder is dropped without sending a response, so that the client
8729/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
8730impl std::ops::Drop for BaseDatagramSocketGetKeepAliveResponder {
8731    fn drop(&mut self) {
8732        self.control_handle.shutdown();
8733        // Safety: drops once, never accessed again
8734        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8735    }
8736}
8737
8738impl fidl::endpoints::Responder for BaseDatagramSocketGetKeepAliveResponder {
8739    type ControlHandle = BaseDatagramSocketControlHandle;
8740
8741    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
8742        &self.control_handle
8743    }
8744
8745    fn drop_without_shutdown(mut self) {
8746        // Safety: drops once, never accessed again due to mem::forget
8747        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8748        // Prevent Drop from running (which would shut down the channel)
8749        std::mem::forget(self);
8750    }
8751}
8752
8753impl BaseDatagramSocketGetKeepAliveResponder {
8754    /// Sends a response to the FIDL transaction.
8755    ///
8756    /// Sets the channel to shutdown if an error occurs.
8757    pub fn send(
8758        self,
8759        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
8760    ) -> Result<(), fidl::Error> {
8761        let _result = self.send_raw(result);
8762        if _result.is_err() {
8763            self.control_handle.shutdown();
8764        }
8765        self.drop_without_shutdown();
8766        _result
8767    }
8768
8769    /// Similar to "send" but does not shutdown the channel if an error occurs.
8770    pub fn send_no_shutdown_on_err(
8771        self,
8772        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
8773    ) -> Result<(), fidl::Error> {
8774        let _result = self.send_raw(result);
8775        self.drop_without_shutdown();
8776        _result
8777    }
8778
8779    fn send_raw(
8780        &self,
8781        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
8782    ) -> Result<(), fidl::Error> {
8783        self.control_handle.inner.send::<fidl::encoding::ResultType<
8784            BaseSocketGetKeepAliveResponse,
8785            fidl_fuchsia_posix::Errno,
8786        >>(
8787            result.map(|value| (value,)),
8788            self.tx_id,
8789            0x2dd29d3215f2c9d2,
8790            fidl::encoding::DynamicFlags::empty(),
8791        )
8792    }
8793}
8794
8795#[must_use = "FIDL methods require a response to be sent"]
8796#[derive(Debug)]
8797pub struct BaseDatagramSocketSetOutOfBandInlineResponder {
8798    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
8799    tx_id: u32,
8800}
8801
8802/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
8803/// if the responder is dropped without sending a response, so that the client
8804/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
8805impl std::ops::Drop for BaseDatagramSocketSetOutOfBandInlineResponder {
8806    fn drop(&mut self) {
8807        self.control_handle.shutdown();
8808        // Safety: drops once, never accessed again
8809        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8810    }
8811}
8812
8813impl fidl::endpoints::Responder for BaseDatagramSocketSetOutOfBandInlineResponder {
8814    type ControlHandle = BaseDatagramSocketControlHandle;
8815
8816    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
8817        &self.control_handle
8818    }
8819
8820    fn drop_without_shutdown(mut self) {
8821        // Safety: drops once, never accessed again due to mem::forget
8822        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8823        // Prevent Drop from running (which would shut down the channel)
8824        std::mem::forget(self);
8825    }
8826}
8827
8828impl BaseDatagramSocketSetOutOfBandInlineResponder {
8829    /// Sends a response to the FIDL transaction.
8830    ///
8831    /// Sets the channel to shutdown if an error occurs.
8832    pub fn send(
8833        self,
8834        mut result: Result<(), fidl_fuchsia_posix::Errno>,
8835    ) -> Result<(), fidl::Error> {
8836        let _result = self.send_raw(result);
8837        if _result.is_err() {
8838            self.control_handle.shutdown();
8839        }
8840        self.drop_without_shutdown();
8841        _result
8842    }
8843
8844    /// Similar to "send" but does not shutdown the channel if an error occurs.
8845    pub fn send_no_shutdown_on_err(
8846        self,
8847        mut result: Result<(), fidl_fuchsia_posix::Errno>,
8848    ) -> Result<(), fidl::Error> {
8849        let _result = self.send_raw(result);
8850        self.drop_without_shutdown();
8851        _result
8852    }
8853
8854    fn send_raw(
8855        &self,
8856        mut result: Result<(), fidl_fuchsia_posix::Errno>,
8857    ) -> Result<(), fidl::Error> {
8858        self.control_handle.inner.send::<fidl::encoding::ResultType<
8859            fidl::encoding::EmptyStruct,
8860            fidl_fuchsia_posix::Errno,
8861        >>(
8862            result,
8863            self.tx_id,
8864            0x3ecb49968bee439,
8865            fidl::encoding::DynamicFlags::empty(),
8866        )
8867    }
8868}
8869
8870#[must_use = "FIDL methods require a response to be sent"]
8871#[derive(Debug)]
8872pub struct BaseDatagramSocketGetOutOfBandInlineResponder {
8873    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
8874    tx_id: u32,
8875}
8876
8877/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
8878/// if the responder is dropped without sending a response, so that the client
8879/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
8880impl std::ops::Drop for BaseDatagramSocketGetOutOfBandInlineResponder {
8881    fn drop(&mut self) {
8882        self.control_handle.shutdown();
8883        // Safety: drops once, never accessed again
8884        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8885    }
8886}
8887
8888impl fidl::endpoints::Responder for BaseDatagramSocketGetOutOfBandInlineResponder {
8889    type ControlHandle = BaseDatagramSocketControlHandle;
8890
8891    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
8892        &self.control_handle
8893    }
8894
8895    fn drop_without_shutdown(mut self) {
8896        // Safety: drops once, never accessed again due to mem::forget
8897        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8898        // Prevent Drop from running (which would shut down the channel)
8899        std::mem::forget(self);
8900    }
8901}
8902
8903impl BaseDatagramSocketGetOutOfBandInlineResponder {
8904    /// Sends a response to the FIDL transaction.
8905    ///
8906    /// Sets the channel to shutdown if an error occurs.
8907    pub fn send(
8908        self,
8909        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
8910    ) -> Result<(), fidl::Error> {
8911        let _result = self.send_raw(result);
8912        if _result.is_err() {
8913            self.control_handle.shutdown();
8914        }
8915        self.drop_without_shutdown();
8916        _result
8917    }
8918
8919    /// Similar to "send" but does not shutdown the channel if an error occurs.
8920    pub fn send_no_shutdown_on_err(
8921        self,
8922        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
8923    ) -> Result<(), fidl::Error> {
8924        let _result = self.send_raw(result);
8925        self.drop_without_shutdown();
8926        _result
8927    }
8928
8929    fn send_raw(
8930        &self,
8931        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
8932    ) -> Result<(), fidl::Error> {
8933        self.control_handle.inner.send::<fidl::encoding::ResultType<
8934            BaseSocketGetOutOfBandInlineResponse,
8935            fidl_fuchsia_posix::Errno,
8936        >>(
8937            result.map(|value| (value,)),
8938            self.tx_id,
8939            0x348c1ab3aeca1745,
8940            fidl::encoding::DynamicFlags::empty(),
8941        )
8942    }
8943}
8944
8945#[must_use = "FIDL methods require a response to be sent"]
8946#[derive(Debug)]
8947pub struct BaseDatagramSocketSetNoCheckResponder {
8948    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
8949    tx_id: u32,
8950}
8951
8952/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
8953/// if the responder is dropped without sending a response, so that the client
8954/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
8955impl std::ops::Drop for BaseDatagramSocketSetNoCheckResponder {
8956    fn drop(&mut self) {
8957        self.control_handle.shutdown();
8958        // Safety: drops once, never accessed again
8959        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8960    }
8961}
8962
8963impl fidl::endpoints::Responder for BaseDatagramSocketSetNoCheckResponder {
8964    type ControlHandle = BaseDatagramSocketControlHandle;
8965
8966    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
8967        &self.control_handle
8968    }
8969
8970    fn drop_without_shutdown(mut self) {
8971        // Safety: drops once, never accessed again due to mem::forget
8972        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
8973        // Prevent Drop from running (which would shut down the channel)
8974        std::mem::forget(self);
8975    }
8976}
8977
8978impl BaseDatagramSocketSetNoCheckResponder {
8979    /// Sends a response to the FIDL transaction.
8980    ///
8981    /// Sets the channel to shutdown if an error occurs.
8982    pub fn send(
8983        self,
8984        mut result: Result<(), fidl_fuchsia_posix::Errno>,
8985    ) -> Result<(), fidl::Error> {
8986        let _result = self.send_raw(result);
8987        if _result.is_err() {
8988            self.control_handle.shutdown();
8989        }
8990        self.drop_without_shutdown();
8991        _result
8992    }
8993
8994    /// Similar to "send" but does not shutdown the channel if an error occurs.
8995    pub fn send_no_shutdown_on_err(
8996        self,
8997        mut result: Result<(), fidl_fuchsia_posix::Errno>,
8998    ) -> Result<(), fidl::Error> {
8999        let _result = self.send_raw(result);
9000        self.drop_without_shutdown();
9001        _result
9002    }
9003
9004    fn send_raw(
9005        &self,
9006        mut result: Result<(), fidl_fuchsia_posix::Errno>,
9007    ) -> Result<(), fidl::Error> {
9008        self.control_handle.inner.send::<fidl::encoding::ResultType<
9009            fidl::encoding::EmptyStruct,
9010            fidl_fuchsia_posix::Errno,
9011        >>(
9012            result,
9013            self.tx_id,
9014            0x6bbf00c53a4c78c2,
9015            fidl::encoding::DynamicFlags::empty(),
9016        )
9017    }
9018}
9019
9020#[must_use = "FIDL methods require a response to be sent"]
9021#[derive(Debug)]
9022pub struct BaseDatagramSocketGetNoCheckResponder {
9023    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
9024    tx_id: u32,
9025}
9026
9027/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
9028/// if the responder is dropped without sending a response, so that the client
9029/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
9030impl std::ops::Drop for BaseDatagramSocketGetNoCheckResponder {
9031    fn drop(&mut self) {
9032        self.control_handle.shutdown();
9033        // Safety: drops once, never accessed again
9034        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9035    }
9036}
9037
9038impl fidl::endpoints::Responder for BaseDatagramSocketGetNoCheckResponder {
9039    type ControlHandle = BaseDatagramSocketControlHandle;
9040
9041    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
9042        &self.control_handle
9043    }
9044
9045    fn drop_without_shutdown(mut self) {
9046        // Safety: drops once, never accessed again due to mem::forget
9047        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9048        // Prevent Drop from running (which would shut down the channel)
9049        std::mem::forget(self);
9050    }
9051}
9052
9053impl BaseDatagramSocketGetNoCheckResponder {
9054    /// Sends a response to the FIDL transaction.
9055    ///
9056    /// Sets the channel to shutdown if an error occurs.
9057    pub fn send(
9058        self,
9059        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
9060    ) -> Result<(), fidl::Error> {
9061        let _result = self.send_raw(result);
9062        if _result.is_err() {
9063            self.control_handle.shutdown();
9064        }
9065        self.drop_without_shutdown();
9066        _result
9067    }
9068
9069    /// Similar to "send" but does not shutdown the channel if an error occurs.
9070    pub fn send_no_shutdown_on_err(
9071        self,
9072        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
9073    ) -> Result<(), fidl::Error> {
9074        let _result = self.send_raw(result);
9075        self.drop_without_shutdown();
9076        _result
9077    }
9078
9079    fn send_raw(
9080        &self,
9081        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
9082    ) -> Result<(), fidl::Error> {
9083        self.control_handle.inner.send::<fidl::encoding::ResultType<
9084            BaseSocketGetNoCheckResponse,
9085            fidl_fuchsia_posix::Errno,
9086        >>(
9087            result.map(|value| (value,)),
9088            self.tx_id,
9089            0x2cd4249286417694,
9090            fidl::encoding::DynamicFlags::empty(),
9091        )
9092    }
9093}
9094
9095#[must_use = "FIDL methods require a response to be sent"]
9096#[derive(Debug)]
9097pub struct BaseDatagramSocketSetLingerResponder {
9098    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
9099    tx_id: u32,
9100}
9101
9102/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
9103/// if the responder is dropped without sending a response, so that the client
9104/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
9105impl std::ops::Drop for BaseDatagramSocketSetLingerResponder {
9106    fn drop(&mut self) {
9107        self.control_handle.shutdown();
9108        // Safety: drops once, never accessed again
9109        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9110    }
9111}
9112
9113impl fidl::endpoints::Responder for BaseDatagramSocketSetLingerResponder {
9114    type ControlHandle = BaseDatagramSocketControlHandle;
9115
9116    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
9117        &self.control_handle
9118    }
9119
9120    fn drop_without_shutdown(mut self) {
9121        // Safety: drops once, never accessed again due to mem::forget
9122        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9123        // Prevent Drop from running (which would shut down the channel)
9124        std::mem::forget(self);
9125    }
9126}
9127
9128impl BaseDatagramSocketSetLingerResponder {
9129    /// Sends a response to the FIDL transaction.
9130    ///
9131    /// Sets the channel to shutdown if an error occurs.
9132    pub fn send(
9133        self,
9134        mut result: Result<(), fidl_fuchsia_posix::Errno>,
9135    ) -> Result<(), fidl::Error> {
9136        let _result = self.send_raw(result);
9137        if _result.is_err() {
9138            self.control_handle.shutdown();
9139        }
9140        self.drop_without_shutdown();
9141        _result
9142    }
9143
9144    /// Similar to "send" but does not shutdown the channel if an error occurs.
9145    pub fn send_no_shutdown_on_err(
9146        self,
9147        mut result: Result<(), fidl_fuchsia_posix::Errno>,
9148    ) -> Result<(), fidl::Error> {
9149        let _result = self.send_raw(result);
9150        self.drop_without_shutdown();
9151        _result
9152    }
9153
9154    fn send_raw(
9155        &self,
9156        mut result: Result<(), fidl_fuchsia_posix::Errno>,
9157    ) -> Result<(), fidl::Error> {
9158        self.control_handle.inner.send::<fidl::encoding::ResultType<
9159            fidl::encoding::EmptyStruct,
9160            fidl_fuchsia_posix::Errno,
9161        >>(
9162            result,
9163            self.tx_id,
9164            0x45386351246e998e,
9165            fidl::encoding::DynamicFlags::empty(),
9166        )
9167    }
9168}
9169
9170#[must_use = "FIDL methods require a response to be sent"]
9171#[derive(Debug)]
9172pub struct BaseDatagramSocketGetLingerResponder {
9173    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
9174    tx_id: u32,
9175}
9176
9177/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
9178/// if the responder is dropped without sending a response, so that the client
9179/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
9180impl std::ops::Drop for BaseDatagramSocketGetLingerResponder {
9181    fn drop(&mut self) {
9182        self.control_handle.shutdown();
9183        // Safety: drops once, never accessed again
9184        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9185    }
9186}
9187
9188impl fidl::endpoints::Responder for BaseDatagramSocketGetLingerResponder {
9189    type ControlHandle = BaseDatagramSocketControlHandle;
9190
9191    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
9192        &self.control_handle
9193    }
9194
9195    fn drop_without_shutdown(mut self) {
9196        // Safety: drops once, never accessed again due to mem::forget
9197        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9198        // Prevent Drop from running (which would shut down the channel)
9199        std::mem::forget(self);
9200    }
9201}
9202
9203impl BaseDatagramSocketGetLingerResponder {
9204    /// Sends a response to the FIDL transaction.
9205    ///
9206    /// Sets the channel to shutdown if an error occurs.
9207    pub fn send(
9208        self,
9209        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
9210    ) -> Result<(), fidl::Error> {
9211        let _result = self.send_raw(result);
9212        if _result.is_err() {
9213            self.control_handle.shutdown();
9214        }
9215        self.drop_without_shutdown();
9216        _result
9217    }
9218
9219    /// Similar to "send" but does not shutdown the channel if an error occurs.
9220    pub fn send_no_shutdown_on_err(
9221        self,
9222        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
9223    ) -> Result<(), fidl::Error> {
9224        let _result = self.send_raw(result);
9225        self.drop_without_shutdown();
9226        _result
9227    }
9228
9229    fn send_raw(
9230        &self,
9231        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
9232    ) -> Result<(), fidl::Error> {
9233        self.control_handle.inner.send::<fidl::encoding::ResultType<
9234            BaseSocketGetLingerResponse,
9235            fidl_fuchsia_posix::Errno,
9236        >>(
9237            result,
9238            self.tx_id,
9239            0x48eb20fc5ccb0e45,
9240            fidl::encoding::DynamicFlags::empty(),
9241        )
9242    }
9243}
9244
9245#[must_use = "FIDL methods require a response to be sent"]
9246#[derive(Debug)]
9247pub struct BaseDatagramSocketSetReusePortResponder {
9248    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
9249    tx_id: u32,
9250}
9251
9252/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
9253/// if the responder is dropped without sending a response, so that the client
9254/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
9255impl std::ops::Drop for BaseDatagramSocketSetReusePortResponder {
9256    fn drop(&mut self) {
9257        self.control_handle.shutdown();
9258        // Safety: drops once, never accessed again
9259        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9260    }
9261}
9262
9263impl fidl::endpoints::Responder for BaseDatagramSocketSetReusePortResponder {
9264    type ControlHandle = BaseDatagramSocketControlHandle;
9265
9266    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
9267        &self.control_handle
9268    }
9269
9270    fn drop_without_shutdown(mut self) {
9271        // Safety: drops once, never accessed again due to mem::forget
9272        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9273        // Prevent Drop from running (which would shut down the channel)
9274        std::mem::forget(self);
9275    }
9276}
9277
9278impl BaseDatagramSocketSetReusePortResponder {
9279    /// Sends a response to the FIDL transaction.
9280    ///
9281    /// Sets the channel to shutdown if an error occurs.
9282    pub fn send(
9283        self,
9284        mut result: Result<(), fidl_fuchsia_posix::Errno>,
9285    ) -> Result<(), fidl::Error> {
9286        let _result = self.send_raw(result);
9287        if _result.is_err() {
9288            self.control_handle.shutdown();
9289        }
9290        self.drop_without_shutdown();
9291        _result
9292    }
9293
9294    /// Similar to "send" but does not shutdown the channel if an error occurs.
9295    pub fn send_no_shutdown_on_err(
9296        self,
9297        mut result: Result<(), fidl_fuchsia_posix::Errno>,
9298    ) -> Result<(), fidl::Error> {
9299        let _result = self.send_raw(result);
9300        self.drop_without_shutdown();
9301        _result
9302    }
9303
9304    fn send_raw(
9305        &self,
9306        mut result: Result<(), fidl_fuchsia_posix::Errno>,
9307    ) -> Result<(), fidl::Error> {
9308        self.control_handle.inner.send::<fidl::encoding::ResultType<
9309            fidl::encoding::EmptyStruct,
9310            fidl_fuchsia_posix::Errno,
9311        >>(
9312            result,
9313            self.tx_id,
9314            0x24dd3e5cb36d9ccb,
9315            fidl::encoding::DynamicFlags::empty(),
9316        )
9317    }
9318}
9319
9320#[must_use = "FIDL methods require a response to be sent"]
9321#[derive(Debug)]
9322pub struct BaseDatagramSocketGetReusePortResponder {
9323    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
9324    tx_id: u32,
9325}
9326
9327/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
9328/// if the responder is dropped without sending a response, so that the client
9329/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
9330impl std::ops::Drop for BaseDatagramSocketGetReusePortResponder {
9331    fn drop(&mut self) {
9332        self.control_handle.shutdown();
9333        // Safety: drops once, never accessed again
9334        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9335    }
9336}
9337
9338impl fidl::endpoints::Responder for BaseDatagramSocketGetReusePortResponder {
9339    type ControlHandle = BaseDatagramSocketControlHandle;
9340
9341    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
9342        &self.control_handle
9343    }
9344
9345    fn drop_without_shutdown(mut self) {
9346        // Safety: drops once, never accessed again due to mem::forget
9347        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9348        // Prevent Drop from running (which would shut down the channel)
9349        std::mem::forget(self);
9350    }
9351}
9352
9353impl BaseDatagramSocketGetReusePortResponder {
9354    /// Sends a response to the FIDL transaction.
9355    ///
9356    /// Sets the channel to shutdown if an error occurs.
9357    pub fn send(
9358        self,
9359        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
9360    ) -> Result<(), fidl::Error> {
9361        let _result = self.send_raw(result);
9362        if _result.is_err() {
9363            self.control_handle.shutdown();
9364        }
9365        self.drop_without_shutdown();
9366        _result
9367    }
9368
9369    /// Similar to "send" but does not shutdown the channel if an error occurs.
9370    pub fn send_no_shutdown_on_err(
9371        self,
9372        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
9373    ) -> Result<(), fidl::Error> {
9374        let _result = self.send_raw(result);
9375        self.drop_without_shutdown();
9376        _result
9377    }
9378
9379    fn send_raw(
9380        &self,
9381        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
9382    ) -> Result<(), fidl::Error> {
9383        self.control_handle.inner.send::<fidl::encoding::ResultType<
9384            BaseSocketGetReusePortResponse,
9385            fidl_fuchsia_posix::Errno,
9386        >>(
9387            result.map(|value| (value,)),
9388            self.tx_id,
9389            0x7a112c1ab54ff828,
9390            fidl::encoding::DynamicFlags::empty(),
9391        )
9392    }
9393}
9394
9395#[must_use = "FIDL methods require a response to be sent"]
9396#[derive(Debug)]
9397pub struct BaseDatagramSocketGetAcceptConnResponder {
9398    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
9399    tx_id: u32,
9400}
9401
9402/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
9403/// if the responder is dropped without sending a response, so that the client
9404/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
9405impl std::ops::Drop for BaseDatagramSocketGetAcceptConnResponder {
9406    fn drop(&mut self) {
9407        self.control_handle.shutdown();
9408        // Safety: drops once, never accessed again
9409        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9410    }
9411}
9412
9413impl fidl::endpoints::Responder for BaseDatagramSocketGetAcceptConnResponder {
9414    type ControlHandle = BaseDatagramSocketControlHandle;
9415
9416    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
9417        &self.control_handle
9418    }
9419
9420    fn drop_without_shutdown(mut self) {
9421        // Safety: drops once, never accessed again due to mem::forget
9422        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9423        // Prevent Drop from running (which would shut down the channel)
9424        std::mem::forget(self);
9425    }
9426}
9427
9428impl BaseDatagramSocketGetAcceptConnResponder {
9429    /// Sends a response to the FIDL transaction.
9430    ///
9431    /// Sets the channel to shutdown if an error occurs.
9432    pub fn send(
9433        self,
9434        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
9435    ) -> Result<(), fidl::Error> {
9436        let _result = self.send_raw(result);
9437        if _result.is_err() {
9438            self.control_handle.shutdown();
9439        }
9440        self.drop_without_shutdown();
9441        _result
9442    }
9443
9444    /// Similar to "send" but does not shutdown the channel if an error occurs.
9445    pub fn send_no_shutdown_on_err(
9446        self,
9447        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
9448    ) -> Result<(), fidl::Error> {
9449        let _result = self.send_raw(result);
9450        self.drop_without_shutdown();
9451        _result
9452    }
9453
9454    fn send_raw(
9455        &self,
9456        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
9457    ) -> Result<(), fidl::Error> {
9458        self.control_handle.inner.send::<fidl::encoding::ResultType<
9459            BaseSocketGetAcceptConnResponse,
9460            fidl_fuchsia_posix::Errno,
9461        >>(
9462            result.map(|value| (value,)),
9463            self.tx_id,
9464            0x67ce6db6c2ec8966,
9465            fidl::encoding::DynamicFlags::empty(),
9466        )
9467    }
9468}
9469
9470#[must_use = "FIDL methods require a response to be sent"]
9471#[derive(Debug)]
9472pub struct BaseDatagramSocketSetBindToDeviceResponder {
9473    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
9474    tx_id: u32,
9475}
9476
9477/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
9478/// if the responder is dropped without sending a response, so that the client
9479/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
9480impl std::ops::Drop for BaseDatagramSocketSetBindToDeviceResponder {
9481    fn drop(&mut self) {
9482        self.control_handle.shutdown();
9483        // Safety: drops once, never accessed again
9484        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9485    }
9486}
9487
9488impl fidl::endpoints::Responder for BaseDatagramSocketSetBindToDeviceResponder {
9489    type ControlHandle = BaseDatagramSocketControlHandle;
9490
9491    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
9492        &self.control_handle
9493    }
9494
9495    fn drop_without_shutdown(mut self) {
9496        // Safety: drops once, never accessed again due to mem::forget
9497        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9498        // Prevent Drop from running (which would shut down the channel)
9499        std::mem::forget(self);
9500    }
9501}
9502
9503impl BaseDatagramSocketSetBindToDeviceResponder {
9504    /// Sends a response to the FIDL transaction.
9505    ///
9506    /// Sets the channel to shutdown if an error occurs.
9507    pub fn send(
9508        self,
9509        mut result: Result<(), fidl_fuchsia_posix::Errno>,
9510    ) -> Result<(), fidl::Error> {
9511        let _result = self.send_raw(result);
9512        if _result.is_err() {
9513            self.control_handle.shutdown();
9514        }
9515        self.drop_without_shutdown();
9516        _result
9517    }
9518
9519    /// Similar to "send" but does not shutdown the channel if an error occurs.
9520    pub fn send_no_shutdown_on_err(
9521        self,
9522        mut result: Result<(), fidl_fuchsia_posix::Errno>,
9523    ) -> Result<(), fidl::Error> {
9524        let _result = self.send_raw(result);
9525        self.drop_without_shutdown();
9526        _result
9527    }
9528
9529    fn send_raw(
9530        &self,
9531        mut result: Result<(), fidl_fuchsia_posix::Errno>,
9532    ) -> Result<(), fidl::Error> {
9533        self.control_handle.inner.send::<fidl::encoding::ResultType<
9534            fidl::encoding::EmptyStruct,
9535            fidl_fuchsia_posix::Errno,
9536        >>(
9537            result,
9538            self.tx_id,
9539            0x2118b483f28aafc4,
9540            fidl::encoding::DynamicFlags::empty(),
9541        )
9542    }
9543}
9544
9545#[must_use = "FIDL methods require a response to be sent"]
9546#[derive(Debug)]
9547pub struct BaseDatagramSocketGetBindToDeviceResponder {
9548    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
9549    tx_id: u32,
9550}
9551
9552/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
9553/// if the responder is dropped without sending a response, so that the client
9554/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
9555impl std::ops::Drop for BaseDatagramSocketGetBindToDeviceResponder {
9556    fn drop(&mut self) {
9557        self.control_handle.shutdown();
9558        // Safety: drops once, never accessed again
9559        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9560    }
9561}
9562
9563impl fidl::endpoints::Responder for BaseDatagramSocketGetBindToDeviceResponder {
9564    type ControlHandle = BaseDatagramSocketControlHandle;
9565
9566    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
9567        &self.control_handle
9568    }
9569
9570    fn drop_without_shutdown(mut self) {
9571        // Safety: drops once, never accessed again due to mem::forget
9572        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9573        // Prevent Drop from running (which would shut down the channel)
9574        std::mem::forget(self);
9575    }
9576}
9577
9578impl BaseDatagramSocketGetBindToDeviceResponder {
9579    /// Sends a response to the FIDL transaction.
9580    ///
9581    /// Sets the channel to shutdown if an error occurs.
9582    pub fn send(
9583        self,
9584        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
9585    ) -> Result<(), fidl::Error> {
9586        let _result = self.send_raw(result);
9587        if _result.is_err() {
9588            self.control_handle.shutdown();
9589        }
9590        self.drop_without_shutdown();
9591        _result
9592    }
9593
9594    /// Similar to "send" but does not shutdown the channel if an error occurs.
9595    pub fn send_no_shutdown_on_err(
9596        self,
9597        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
9598    ) -> Result<(), fidl::Error> {
9599        let _result = self.send_raw(result);
9600        self.drop_without_shutdown();
9601        _result
9602    }
9603
9604    fn send_raw(
9605        &self,
9606        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
9607    ) -> Result<(), fidl::Error> {
9608        self.control_handle.inner.send::<fidl::encoding::ResultType<
9609            BaseSocketGetBindToDeviceResponse,
9610            fidl_fuchsia_posix::Errno,
9611        >>(
9612            result.map(|value| (value,)),
9613            self.tx_id,
9614            0x1ab1fbf0ef7906c8,
9615            fidl::encoding::DynamicFlags::empty(),
9616        )
9617    }
9618}
9619
9620#[must_use = "FIDL methods require a response to be sent"]
9621#[derive(Debug)]
9622pub struct BaseDatagramSocketSetBindToInterfaceIndexResponder {
9623    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
9624    tx_id: u32,
9625}
9626
9627/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
9628/// if the responder is dropped without sending a response, so that the client
9629/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
9630impl std::ops::Drop for BaseDatagramSocketSetBindToInterfaceIndexResponder {
9631    fn drop(&mut self) {
9632        self.control_handle.shutdown();
9633        // Safety: drops once, never accessed again
9634        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9635    }
9636}
9637
9638impl fidl::endpoints::Responder for BaseDatagramSocketSetBindToInterfaceIndexResponder {
9639    type ControlHandle = BaseDatagramSocketControlHandle;
9640
9641    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
9642        &self.control_handle
9643    }
9644
9645    fn drop_without_shutdown(mut self) {
9646        // Safety: drops once, never accessed again due to mem::forget
9647        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9648        // Prevent Drop from running (which would shut down the channel)
9649        std::mem::forget(self);
9650    }
9651}
9652
9653impl BaseDatagramSocketSetBindToInterfaceIndexResponder {
9654    /// Sends a response to the FIDL transaction.
9655    ///
9656    /// Sets the channel to shutdown if an error occurs.
9657    pub fn send(
9658        self,
9659        mut result: Result<(), fidl_fuchsia_posix::Errno>,
9660    ) -> Result<(), fidl::Error> {
9661        let _result = self.send_raw(result);
9662        if _result.is_err() {
9663            self.control_handle.shutdown();
9664        }
9665        self.drop_without_shutdown();
9666        _result
9667    }
9668
9669    /// Similar to "send" but does not shutdown the channel if an error occurs.
9670    pub fn send_no_shutdown_on_err(
9671        self,
9672        mut result: Result<(), fidl_fuchsia_posix::Errno>,
9673    ) -> Result<(), fidl::Error> {
9674        let _result = self.send_raw(result);
9675        self.drop_without_shutdown();
9676        _result
9677    }
9678
9679    fn send_raw(
9680        &self,
9681        mut result: Result<(), fidl_fuchsia_posix::Errno>,
9682    ) -> Result<(), fidl::Error> {
9683        self.control_handle.inner.send::<fidl::encoding::ResultType<
9684            fidl::encoding::EmptyStruct,
9685            fidl_fuchsia_posix::Errno,
9686        >>(
9687            result,
9688            self.tx_id,
9689            0x6e387a0def00821,
9690            fidl::encoding::DynamicFlags::empty(),
9691        )
9692    }
9693}
9694
9695#[must_use = "FIDL methods require a response to be sent"]
9696#[derive(Debug)]
9697pub struct BaseDatagramSocketGetBindToInterfaceIndexResponder {
9698    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
9699    tx_id: u32,
9700}
9701
9702/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
9703/// if the responder is dropped without sending a response, so that the client
9704/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
9705impl std::ops::Drop for BaseDatagramSocketGetBindToInterfaceIndexResponder {
9706    fn drop(&mut self) {
9707        self.control_handle.shutdown();
9708        // Safety: drops once, never accessed again
9709        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9710    }
9711}
9712
9713impl fidl::endpoints::Responder for BaseDatagramSocketGetBindToInterfaceIndexResponder {
9714    type ControlHandle = BaseDatagramSocketControlHandle;
9715
9716    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
9717        &self.control_handle
9718    }
9719
9720    fn drop_without_shutdown(mut self) {
9721        // Safety: drops once, never accessed again due to mem::forget
9722        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9723        // Prevent Drop from running (which would shut down the channel)
9724        std::mem::forget(self);
9725    }
9726}
9727
9728impl BaseDatagramSocketGetBindToInterfaceIndexResponder {
9729    /// Sends a response to the FIDL transaction.
9730    ///
9731    /// Sets the channel to shutdown if an error occurs.
9732    pub fn send(
9733        self,
9734        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
9735    ) -> Result<(), fidl::Error> {
9736        let _result = self.send_raw(result);
9737        if _result.is_err() {
9738            self.control_handle.shutdown();
9739        }
9740        self.drop_without_shutdown();
9741        _result
9742    }
9743
9744    /// Similar to "send" but does not shutdown the channel if an error occurs.
9745    pub fn send_no_shutdown_on_err(
9746        self,
9747        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
9748    ) -> Result<(), fidl::Error> {
9749        let _result = self.send_raw(result);
9750        self.drop_without_shutdown();
9751        _result
9752    }
9753
9754    fn send_raw(
9755        &self,
9756        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
9757    ) -> Result<(), fidl::Error> {
9758        self.control_handle.inner.send::<fidl::encoding::ResultType<
9759            BaseSocketGetBindToInterfaceIndexResponse,
9760            fidl_fuchsia_posix::Errno,
9761        >>(
9762            result.map(|value| (value,)),
9763            self.tx_id,
9764            0x59c31dd3e3078295,
9765            fidl::encoding::DynamicFlags::empty(),
9766        )
9767    }
9768}
9769
9770#[must_use = "FIDL methods require a response to be sent"]
9771#[derive(Debug)]
9772pub struct BaseDatagramSocketSetTimestampResponder {
9773    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
9774    tx_id: u32,
9775}
9776
9777/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
9778/// if the responder is dropped without sending a response, so that the client
9779/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
9780impl std::ops::Drop for BaseDatagramSocketSetTimestampResponder {
9781    fn drop(&mut self) {
9782        self.control_handle.shutdown();
9783        // Safety: drops once, never accessed again
9784        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9785    }
9786}
9787
9788impl fidl::endpoints::Responder for BaseDatagramSocketSetTimestampResponder {
9789    type ControlHandle = BaseDatagramSocketControlHandle;
9790
9791    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
9792        &self.control_handle
9793    }
9794
9795    fn drop_without_shutdown(mut self) {
9796        // Safety: drops once, never accessed again due to mem::forget
9797        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9798        // Prevent Drop from running (which would shut down the channel)
9799        std::mem::forget(self);
9800    }
9801}
9802
9803impl BaseDatagramSocketSetTimestampResponder {
9804    /// Sends a response to the FIDL transaction.
9805    ///
9806    /// Sets the channel to shutdown if an error occurs.
9807    pub fn send(
9808        self,
9809        mut result: Result<(), fidl_fuchsia_posix::Errno>,
9810    ) -> Result<(), fidl::Error> {
9811        let _result = self.send_raw(result);
9812        if _result.is_err() {
9813            self.control_handle.shutdown();
9814        }
9815        self.drop_without_shutdown();
9816        _result
9817    }
9818
9819    /// Similar to "send" but does not shutdown the channel if an error occurs.
9820    pub fn send_no_shutdown_on_err(
9821        self,
9822        mut result: Result<(), fidl_fuchsia_posix::Errno>,
9823    ) -> Result<(), fidl::Error> {
9824        let _result = self.send_raw(result);
9825        self.drop_without_shutdown();
9826        _result
9827    }
9828
9829    fn send_raw(
9830        &self,
9831        mut result: Result<(), fidl_fuchsia_posix::Errno>,
9832    ) -> Result<(), fidl::Error> {
9833        self.control_handle.inner.send::<fidl::encoding::ResultType<
9834            fidl::encoding::EmptyStruct,
9835            fidl_fuchsia_posix::Errno,
9836        >>(
9837            result,
9838            self.tx_id,
9839            0x285d6516c263d839,
9840            fidl::encoding::DynamicFlags::empty(),
9841        )
9842    }
9843}
9844
9845#[must_use = "FIDL methods require a response to be sent"]
9846#[derive(Debug)]
9847pub struct BaseDatagramSocketGetTimestampResponder {
9848    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
9849    tx_id: u32,
9850}
9851
9852/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
9853/// if the responder is dropped without sending a response, so that the client
9854/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
9855impl std::ops::Drop for BaseDatagramSocketGetTimestampResponder {
9856    fn drop(&mut self) {
9857        self.control_handle.shutdown();
9858        // Safety: drops once, never accessed again
9859        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9860    }
9861}
9862
9863impl fidl::endpoints::Responder for BaseDatagramSocketGetTimestampResponder {
9864    type ControlHandle = BaseDatagramSocketControlHandle;
9865
9866    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
9867        &self.control_handle
9868    }
9869
9870    fn drop_without_shutdown(mut self) {
9871        // Safety: drops once, never accessed again due to mem::forget
9872        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9873        // Prevent Drop from running (which would shut down the channel)
9874        std::mem::forget(self);
9875    }
9876}
9877
9878impl BaseDatagramSocketGetTimestampResponder {
9879    /// Sends a response to the FIDL transaction.
9880    ///
9881    /// Sets the channel to shutdown if an error occurs.
9882    pub fn send(
9883        self,
9884        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
9885    ) -> Result<(), fidl::Error> {
9886        let _result = self.send_raw(result);
9887        if _result.is_err() {
9888            self.control_handle.shutdown();
9889        }
9890        self.drop_without_shutdown();
9891        _result
9892    }
9893
9894    /// Similar to "send" but does not shutdown the channel if an error occurs.
9895    pub fn send_no_shutdown_on_err(
9896        self,
9897        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
9898    ) -> Result<(), fidl::Error> {
9899        let _result = self.send_raw(result);
9900        self.drop_without_shutdown();
9901        _result
9902    }
9903
9904    fn send_raw(
9905        &self,
9906        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
9907    ) -> Result<(), fidl::Error> {
9908        self.control_handle.inner.send::<fidl::encoding::ResultType<
9909            BaseSocketGetTimestampResponse,
9910            fidl_fuchsia_posix::Errno,
9911        >>(
9912            result.map(|value| (value,)),
9913            self.tx_id,
9914            0x49f2fffbbcc2bd27,
9915            fidl::encoding::DynamicFlags::empty(),
9916        )
9917    }
9918}
9919
9920#[must_use = "FIDL methods require a response to be sent"]
9921#[derive(Debug)]
9922pub struct BaseDatagramSocketSetMarkResponder {
9923    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
9924    tx_id: u32,
9925}
9926
9927/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
9928/// if the responder is dropped without sending a response, so that the client
9929/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
9930impl std::ops::Drop for BaseDatagramSocketSetMarkResponder {
9931    fn drop(&mut self) {
9932        self.control_handle.shutdown();
9933        // Safety: drops once, never accessed again
9934        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9935    }
9936}
9937
9938impl fidl::endpoints::Responder for BaseDatagramSocketSetMarkResponder {
9939    type ControlHandle = BaseDatagramSocketControlHandle;
9940
9941    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
9942        &self.control_handle
9943    }
9944
9945    fn drop_without_shutdown(mut self) {
9946        // Safety: drops once, never accessed again due to mem::forget
9947        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
9948        // Prevent Drop from running (which would shut down the channel)
9949        std::mem::forget(self);
9950    }
9951}
9952
9953impl BaseDatagramSocketSetMarkResponder {
9954    /// Sends a response to the FIDL transaction.
9955    ///
9956    /// Sets the channel to shutdown if an error occurs.
9957    pub fn send(
9958        self,
9959        mut result: Result<(), fidl_fuchsia_posix::Errno>,
9960    ) -> Result<(), fidl::Error> {
9961        let _result = self.send_raw(result);
9962        if _result.is_err() {
9963            self.control_handle.shutdown();
9964        }
9965        self.drop_without_shutdown();
9966        _result
9967    }
9968
9969    /// Similar to "send" but does not shutdown the channel if an error occurs.
9970    pub fn send_no_shutdown_on_err(
9971        self,
9972        mut result: Result<(), fidl_fuchsia_posix::Errno>,
9973    ) -> Result<(), fidl::Error> {
9974        let _result = self.send_raw(result);
9975        self.drop_without_shutdown();
9976        _result
9977    }
9978
9979    fn send_raw(
9980        &self,
9981        mut result: Result<(), fidl_fuchsia_posix::Errno>,
9982    ) -> Result<(), fidl::Error> {
9983        self.control_handle.inner.send::<fidl::encoding::ResultType<
9984            fidl::encoding::EmptyStruct,
9985            fidl_fuchsia_posix::Errno,
9986        >>(
9987            result,
9988            self.tx_id,
9989            0x6ead6de09f653236,
9990            fidl::encoding::DynamicFlags::empty(),
9991        )
9992    }
9993}
9994
9995#[must_use = "FIDL methods require a response to be sent"]
9996#[derive(Debug)]
9997pub struct BaseDatagramSocketGetMarkResponder {
9998    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
9999    tx_id: u32,
10000}
10001
10002/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
10003/// if the responder is dropped without sending a response, so that the client
10004/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
10005impl std::ops::Drop for BaseDatagramSocketGetMarkResponder {
10006    fn drop(&mut self) {
10007        self.control_handle.shutdown();
10008        // Safety: drops once, never accessed again
10009        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10010    }
10011}
10012
10013impl fidl::endpoints::Responder for BaseDatagramSocketGetMarkResponder {
10014    type ControlHandle = BaseDatagramSocketControlHandle;
10015
10016    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
10017        &self.control_handle
10018    }
10019
10020    fn drop_without_shutdown(mut self) {
10021        // Safety: drops once, never accessed again due to mem::forget
10022        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10023        // Prevent Drop from running (which would shut down the channel)
10024        std::mem::forget(self);
10025    }
10026}
10027
10028impl BaseDatagramSocketGetMarkResponder {
10029    /// Sends a response to the FIDL transaction.
10030    ///
10031    /// Sets the channel to shutdown if an error occurs.
10032    pub fn send(
10033        self,
10034        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
10035    ) -> Result<(), fidl::Error> {
10036        let _result = self.send_raw(result);
10037        if _result.is_err() {
10038            self.control_handle.shutdown();
10039        }
10040        self.drop_without_shutdown();
10041        _result
10042    }
10043
10044    /// Similar to "send" but does not shutdown the channel if an error occurs.
10045    pub fn send_no_shutdown_on_err(
10046        self,
10047        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
10048    ) -> Result<(), fidl::Error> {
10049        let _result = self.send_raw(result);
10050        self.drop_without_shutdown();
10051        _result
10052    }
10053
10054    fn send_raw(
10055        &self,
10056        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
10057    ) -> Result<(), fidl::Error> {
10058        self.control_handle.inner.send::<fidl::encoding::ResultType<
10059            BaseSocketGetMarkResponse,
10060            fidl_fuchsia_posix::Errno,
10061        >>(
10062            result.map(|mark| (mark,)),
10063            self.tx_id,
10064            0x57a2752c61d93d47,
10065            fidl::encoding::DynamicFlags::empty(),
10066        )
10067    }
10068}
10069
10070#[must_use = "FIDL methods require a response to be sent"]
10071#[derive(Debug)]
10072pub struct BaseDatagramSocketBindResponder {
10073    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
10074    tx_id: u32,
10075}
10076
10077/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
10078/// if the responder is dropped without sending a response, so that the client
10079/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
10080impl std::ops::Drop for BaseDatagramSocketBindResponder {
10081    fn drop(&mut self) {
10082        self.control_handle.shutdown();
10083        // Safety: drops once, never accessed again
10084        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10085    }
10086}
10087
10088impl fidl::endpoints::Responder for BaseDatagramSocketBindResponder {
10089    type ControlHandle = BaseDatagramSocketControlHandle;
10090
10091    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
10092        &self.control_handle
10093    }
10094
10095    fn drop_without_shutdown(mut self) {
10096        // Safety: drops once, never accessed again due to mem::forget
10097        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10098        // Prevent Drop from running (which would shut down the channel)
10099        std::mem::forget(self);
10100    }
10101}
10102
10103impl BaseDatagramSocketBindResponder {
10104    /// Sends a response to the FIDL transaction.
10105    ///
10106    /// Sets the channel to shutdown if an error occurs.
10107    pub fn send(
10108        self,
10109        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10110    ) -> Result<(), fidl::Error> {
10111        let _result = self.send_raw(result);
10112        if _result.is_err() {
10113            self.control_handle.shutdown();
10114        }
10115        self.drop_without_shutdown();
10116        _result
10117    }
10118
10119    /// Similar to "send" but does not shutdown the channel if an error occurs.
10120    pub fn send_no_shutdown_on_err(
10121        self,
10122        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10123    ) -> Result<(), fidl::Error> {
10124        let _result = self.send_raw(result);
10125        self.drop_without_shutdown();
10126        _result
10127    }
10128
10129    fn send_raw(
10130        &self,
10131        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10132    ) -> Result<(), fidl::Error> {
10133        self.control_handle.inner.send::<fidl::encoding::ResultType<
10134            fidl::encoding::EmptyStruct,
10135            fidl_fuchsia_posix::Errno,
10136        >>(
10137            result,
10138            self.tx_id,
10139            0x4bc6400ae92125d,
10140            fidl::encoding::DynamicFlags::empty(),
10141        )
10142    }
10143}
10144
10145#[must_use = "FIDL methods require a response to be sent"]
10146#[derive(Debug)]
10147pub struct BaseDatagramSocketConnectResponder {
10148    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
10149    tx_id: u32,
10150}
10151
10152/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
10153/// if the responder is dropped without sending a response, so that the client
10154/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
10155impl std::ops::Drop for BaseDatagramSocketConnectResponder {
10156    fn drop(&mut self) {
10157        self.control_handle.shutdown();
10158        // Safety: drops once, never accessed again
10159        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10160    }
10161}
10162
10163impl fidl::endpoints::Responder for BaseDatagramSocketConnectResponder {
10164    type ControlHandle = BaseDatagramSocketControlHandle;
10165
10166    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
10167        &self.control_handle
10168    }
10169
10170    fn drop_without_shutdown(mut self) {
10171        // Safety: drops once, never accessed again due to mem::forget
10172        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10173        // Prevent Drop from running (which would shut down the channel)
10174        std::mem::forget(self);
10175    }
10176}
10177
10178impl BaseDatagramSocketConnectResponder {
10179    /// Sends a response to the FIDL transaction.
10180    ///
10181    /// Sets the channel to shutdown if an error occurs.
10182    pub fn send(
10183        self,
10184        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10185    ) -> Result<(), fidl::Error> {
10186        let _result = self.send_raw(result);
10187        if _result.is_err() {
10188            self.control_handle.shutdown();
10189        }
10190        self.drop_without_shutdown();
10191        _result
10192    }
10193
10194    /// Similar to "send" but does not shutdown the channel if an error occurs.
10195    pub fn send_no_shutdown_on_err(
10196        self,
10197        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10198    ) -> Result<(), fidl::Error> {
10199        let _result = self.send_raw(result);
10200        self.drop_without_shutdown();
10201        _result
10202    }
10203
10204    fn send_raw(
10205        &self,
10206        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10207    ) -> Result<(), fidl::Error> {
10208        self.control_handle.inner.send::<fidl::encoding::ResultType<
10209            fidl::encoding::EmptyStruct,
10210            fidl_fuchsia_posix::Errno,
10211        >>(
10212            result,
10213            self.tx_id,
10214            0x5f05f19bfdd38871,
10215            fidl::encoding::DynamicFlags::empty(),
10216        )
10217    }
10218}
10219
10220#[must_use = "FIDL methods require a response to be sent"]
10221#[derive(Debug)]
10222pub struct BaseDatagramSocketDisconnectResponder {
10223    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
10224    tx_id: u32,
10225}
10226
10227/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
10228/// if the responder is dropped without sending a response, so that the client
10229/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
10230impl std::ops::Drop for BaseDatagramSocketDisconnectResponder {
10231    fn drop(&mut self) {
10232        self.control_handle.shutdown();
10233        // Safety: drops once, never accessed again
10234        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10235    }
10236}
10237
10238impl fidl::endpoints::Responder for BaseDatagramSocketDisconnectResponder {
10239    type ControlHandle = BaseDatagramSocketControlHandle;
10240
10241    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
10242        &self.control_handle
10243    }
10244
10245    fn drop_without_shutdown(mut self) {
10246        // Safety: drops once, never accessed again due to mem::forget
10247        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10248        // Prevent Drop from running (which would shut down the channel)
10249        std::mem::forget(self);
10250    }
10251}
10252
10253impl BaseDatagramSocketDisconnectResponder {
10254    /// Sends a response to the FIDL transaction.
10255    ///
10256    /// Sets the channel to shutdown if an error occurs.
10257    pub fn send(
10258        self,
10259        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10260    ) -> Result<(), fidl::Error> {
10261        let _result = self.send_raw(result);
10262        if _result.is_err() {
10263            self.control_handle.shutdown();
10264        }
10265        self.drop_without_shutdown();
10266        _result
10267    }
10268
10269    /// Similar to "send" but does not shutdown the channel if an error occurs.
10270    pub fn send_no_shutdown_on_err(
10271        self,
10272        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10273    ) -> Result<(), fidl::Error> {
10274        let _result = self.send_raw(result);
10275        self.drop_without_shutdown();
10276        _result
10277    }
10278
10279    fn send_raw(
10280        &self,
10281        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10282    ) -> Result<(), fidl::Error> {
10283        self.control_handle.inner.send::<fidl::encoding::ResultType<
10284            fidl::encoding::EmptyStruct,
10285            fidl_fuchsia_posix::Errno,
10286        >>(
10287            result,
10288            self.tx_id,
10289            0x74e63b91f7b29b2,
10290            fidl::encoding::DynamicFlags::empty(),
10291        )
10292    }
10293}
10294
10295#[must_use = "FIDL methods require a response to be sent"]
10296#[derive(Debug)]
10297pub struct BaseDatagramSocketGetSockNameResponder {
10298    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
10299    tx_id: u32,
10300}
10301
10302/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
10303/// if the responder is dropped without sending a response, so that the client
10304/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
10305impl std::ops::Drop for BaseDatagramSocketGetSockNameResponder {
10306    fn drop(&mut self) {
10307        self.control_handle.shutdown();
10308        // Safety: drops once, never accessed again
10309        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10310    }
10311}
10312
10313impl fidl::endpoints::Responder for BaseDatagramSocketGetSockNameResponder {
10314    type ControlHandle = BaseDatagramSocketControlHandle;
10315
10316    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
10317        &self.control_handle
10318    }
10319
10320    fn drop_without_shutdown(mut self) {
10321        // Safety: drops once, never accessed again due to mem::forget
10322        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10323        // Prevent Drop from running (which would shut down the channel)
10324        std::mem::forget(self);
10325    }
10326}
10327
10328impl BaseDatagramSocketGetSockNameResponder {
10329    /// Sends a response to the FIDL transaction.
10330    ///
10331    /// Sets the channel to shutdown if an error occurs.
10332    pub fn send(
10333        self,
10334        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
10335    ) -> Result<(), fidl::Error> {
10336        let _result = self.send_raw(result);
10337        if _result.is_err() {
10338            self.control_handle.shutdown();
10339        }
10340        self.drop_without_shutdown();
10341        _result
10342    }
10343
10344    /// Similar to "send" but does not shutdown the channel if an error occurs.
10345    pub fn send_no_shutdown_on_err(
10346        self,
10347        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
10348    ) -> Result<(), fidl::Error> {
10349        let _result = self.send_raw(result);
10350        self.drop_without_shutdown();
10351        _result
10352    }
10353
10354    fn send_raw(
10355        &self,
10356        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
10357    ) -> Result<(), fidl::Error> {
10358        self.control_handle.inner.send::<fidl::encoding::ResultType<
10359            BaseNetworkSocketGetSockNameResponse,
10360            fidl_fuchsia_posix::Errno,
10361        >>(
10362            result.map(|addr| (addr,)),
10363            self.tx_id,
10364            0x475f23f84a1a4f85,
10365            fidl::encoding::DynamicFlags::empty(),
10366        )
10367    }
10368}
10369
10370#[must_use = "FIDL methods require a response to be sent"]
10371#[derive(Debug)]
10372pub struct BaseDatagramSocketGetPeerNameResponder {
10373    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
10374    tx_id: u32,
10375}
10376
10377/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
10378/// if the responder is dropped without sending a response, so that the client
10379/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
10380impl std::ops::Drop for BaseDatagramSocketGetPeerNameResponder {
10381    fn drop(&mut self) {
10382        self.control_handle.shutdown();
10383        // Safety: drops once, never accessed again
10384        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10385    }
10386}
10387
10388impl fidl::endpoints::Responder for BaseDatagramSocketGetPeerNameResponder {
10389    type ControlHandle = BaseDatagramSocketControlHandle;
10390
10391    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
10392        &self.control_handle
10393    }
10394
10395    fn drop_without_shutdown(mut self) {
10396        // Safety: drops once, never accessed again due to mem::forget
10397        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10398        // Prevent Drop from running (which would shut down the channel)
10399        std::mem::forget(self);
10400    }
10401}
10402
10403impl BaseDatagramSocketGetPeerNameResponder {
10404    /// Sends a response to the FIDL transaction.
10405    ///
10406    /// Sets the channel to shutdown if an error occurs.
10407    pub fn send(
10408        self,
10409        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
10410    ) -> Result<(), fidl::Error> {
10411        let _result = self.send_raw(result);
10412        if _result.is_err() {
10413            self.control_handle.shutdown();
10414        }
10415        self.drop_without_shutdown();
10416        _result
10417    }
10418
10419    /// Similar to "send" but does not shutdown the channel if an error occurs.
10420    pub fn send_no_shutdown_on_err(
10421        self,
10422        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
10423    ) -> Result<(), fidl::Error> {
10424        let _result = self.send_raw(result);
10425        self.drop_without_shutdown();
10426        _result
10427    }
10428
10429    fn send_raw(
10430        &self,
10431        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
10432    ) -> Result<(), fidl::Error> {
10433        self.control_handle.inner.send::<fidl::encoding::ResultType<
10434            BaseNetworkSocketGetPeerNameResponse,
10435            fidl_fuchsia_posix::Errno,
10436        >>(
10437            result.map(|addr| (addr,)),
10438            self.tx_id,
10439            0x1ffecf4bd5b6432e,
10440            fidl::encoding::DynamicFlags::empty(),
10441        )
10442    }
10443}
10444
10445#[must_use = "FIDL methods require a response to be sent"]
10446#[derive(Debug)]
10447pub struct BaseDatagramSocketShutdownResponder {
10448    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
10449    tx_id: u32,
10450}
10451
10452/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
10453/// if the responder is dropped without sending a response, so that the client
10454/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
10455impl std::ops::Drop for BaseDatagramSocketShutdownResponder {
10456    fn drop(&mut self) {
10457        self.control_handle.shutdown();
10458        // Safety: drops once, never accessed again
10459        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10460    }
10461}
10462
10463impl fidl::endpoints::Responder for BaseDatagramSocketShutdownResponder {
10464    type ControlHandle = BaseDatagramSocketControlHandle;
10465
10466    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
10467        &self.control_handle
10468    }
10469
10470    fn drop_without_shutdown(mut self) {
10471        // Safety: drops once, never accessed again due to mem::forget
10472        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10473        // Prevent Drop from running (which would shut down the channel)
10474        std::mem::forget(self);
10475    }
10476}
10477
10478impl BaseDatagramSocketShutdownResponder {
10479    /// Sends a response to the FIDL transaction.
10480    ///
10481    /// Sets the channel to shutdown if an error occurs.
10482    pub fn send(
10483        self,
10484        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10485    ) -> Result<(), fidl::Error> {
10486        let _result = self.send_raw(result);
10487        if _result.is_err() {
10488            self.control_handle.shutdown();
10489        }
10490        self.drop_without_shutdown();
10491        _result
10492    }
10493
10494    /// Similar to "send" but does not shutdown the channel if an error occurs.
10495    pub fn send_no_shutdown_on_err(
10496        self,
10497        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10498    ) -> Result<(), fidl::Error> {
10499        let _result = self.send_raw(result);
10500        self.drop_without_shutdown();
10501        _result
10502    }
10503
10504    fn send_raw(
10505        &self,
10506        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10507    ) -> Result<(), fidl::Error> {
10508        self.control_handle.inner.send::<fidl::encoding::ResultType<
10509            fidl::encoding::EmptyStruct,
10510            fidl_fuchsia_posix::Errno,
10511        >>(
10512            result,
10513            self.tx_id,
10514            0x247f38b6db68c336,
10515            fidl::encoding::DynamicFlags::empty(),
10516        )
10517    }
10518}
10519
10520#[must_use = "FIDL methods require a response to be sent"]
10521#[derive(Debug)]
10522pub struct BaseDatagramSocketSetIpTypeOfServiceResponder {
10523    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
10524    tx_id: u32,
10525}
10526
10527/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
10528/// if the responder is dropped without sending a response, so that the client
10529/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
10530impl std::ops::Drop for BaseDatagramSocketSetIpTypeOfServiceResponder {
10531    fn drop(&mut self) {
10532        self.control_handle.shutdown();
10533        // Safety: drops once, never accessed again
10534        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10535    }
10536}
10537
10538impl fidl::endpoints::Responder for BaseDatagramSocketSetIpTypeOfServiceResponder {
10539    type ControlHandle = BaseDatagramSocketControlHandle;
10540
10541    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
10542        &self.control_handle
10543    }
10544
10545    fn drop_without_shutdown(mut self) {
10546        // Safety: drops once, never accessed again due to mem::forget
10547        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10548        // Prevent Drop from running (which would shut down the channel)
10549        std::mem::forget(self);
10550    }
10551}
10552
10553impl BaseDatagramSocketSetIpTypeOfServiceResponder {
10554    /// Sends a response to the FIDL transaction.
10555    ///
10556    /// Sets the channel to shutdown if an error occurs.
10557    pub fn send(
10558        self,
10559        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10560    ) -> Result<(), fidl::Error> {
10561        let _result = self.send_raw(result);
10562        if _result.is_err() {
10563            self.control_handle.shutdown();
10564        }
10565        self.drop_without_shutdown();
10566        _result
10567    }
10568
10569    /// Similar to "send" but does not shutdown the channel if an error occurs.
10570    pub fn send_no_shutdown_on_err(
10571        self,
10572        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10573    ) -> Result<(), fidl::Error> {
10574        let _result = self.send_raw(result);
10575        self.drop_without_shutdown();
10576        _result
10577    }
10578
10579    fn send_raw(
10580        &self,
10581        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10582    ) -> Result<(), fidl::Error> {
10583        self.control_handle.inner.send::<fidl::encoding::ResultType<
10584            fidl::encoding::EmptyStruct,
10585            fidl_fuchsia_posix::Errno,
10586        >>(
10587            result,
10588            self.tx_id,
10589            0x995c600475b6d46,
10590            fidl::encoding::DynamicFlags::empty(),
10591        )
10592    }
10593}
10594
10595#[must_use = "FIDL methods require a response to be sent"]
10596#[derive(Debug)]
10597pub struct BaseDatagramSocketGetIpTypeOfServiceResponder {
10598    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
10599    tx_id: u32,
10600}
10601
10602/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
10603/// if the responder is dropped without sending a response, so that the client
10604/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
10605impl std::ops::Drop for BaseDatagramSocketGetIpTypeOfServiceResponder {
10606    fn drop(&mut self) {
10607        self.control_handle.shutdown();
10608        // Safety: drops once, never accessed again
10609        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10610    }
10611}
10612
10613impl fidl::endpoints::Responder for BaseDatagramSocketGetIpTypeOfServiceResponder {
10614    type ControlHandle = BaseDatagramSocketControlHandle;
10615
10616    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
10617        &self.control_handle
10618    }
10619
10620    fn drop_without_shutdown(mut self) {
10621        // Safety: drops once, never accessed again due to mem::forget
10622        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10623        // Prevent Drop from running (which would shut down the channel)
10624        std::mem::forget(self);
10625    }
10626}
10627
10628impl BaseDatagramSocketGetIpTypeOfServiceResponder {
10629    /// Sends a response to the FIDL transaction.
10630    ///
10631    /// Sets the channel to shutdown if an error occurs.
10632    pub fn send(
10633        self,
10634        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
10635    ) -> Result<(), fidl::Error> {
10636        let _result = self.send_raw(result);
10637        if _result.is_err() {
10638            self.control_handle.shutdown();
10639        }
10640        self.drop_without_shutdown();
10641        _result
10642    }
10643
10644    /// Similar to "send" but does not shutdown the channel if an error occurs.
10645    pub fn send_no_shutdown_on_err(
10646        self,
10647        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
10648    ) -> Result<(), fidl::Error> {
10649        let _result = self.send_raw(result);
10650        self.drop_without_shutdown();
10651        _result
10652    }
10653
10654    fn send_raw(
10655        &self,
10656        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
10657    ) -> Result<(), fidl::Error> {
10658        self.control_handle.inner.send::<fidl::encoding::ResultType<
10659            BaseNetworkSocketGetIpTypeOfServiceResponse,
10660            fidl_fuchsia_posix::Errno,
10661        >>(
10662            result.map(|value| (value,)),
10663            self.tx_id,
10664            0x3814a04259f75fcb,
10665            fidl::encoding::DynamicFlags::empty(),
10666        )
10667    }
10668}
10669
10670#[must_use = "FIDL methods require a response to be sent"]
10671#[derive(Debug)]
10672pub struct BaseDatagramSocketSetIpTtlResponder {
10673    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
10674    tx_id: u32,
10675}
10676
10677/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
10678/// if the responder is dropped without sending a response, so that the client
10679/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
10680impl std::ops::Drop for BaseDatagramSocketSetIpTtlResponder {
10681    fn drop(&mut self) {
10682        self.control_handle.shutdown();
10683        // Safety: drops once, never accessed again
10684        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10685    }
10686}
10687
10688impl fidl::endpoints::Responder for BaseDatagramSocketSetIpTtlResponder {
10689    type ControlHandle = BaseDatagramSocketControlHandle;
10690
10691    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
10692        &self.control_handle
10693    }
10694
10695    fn drop_without_shutdown(mut self) {
10696        // Safety: drops once, never accessed again due to mem::forget
10697        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10698        // Prevent Drop from running (which would shut down the channel)
10699        std::mem::forget(self);
10700    }
10701}
10702
10703impl BaseDatagramSocketSetIpTtlResponder {
10704    /// Sends a response to the FIDL transaction.
10705    ///
10706    /// Sets the channel to shutdown if an error occurs.
10707    pub fn send(
10708        self,
10709        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10710    ) -> Result<(), fidl::Error> {
10711        let _result = self.send_raw(result);
10712        if _result.is_err() {
10713            self.control_handle.shutdown();
10714        }
10715        self.drop_without_shutdown();
10716        _result
10717    }
10718
10719    /// Similar to "send" but does not shutdown the channel if an error occurs.
10720    pub fn send_no_shutdown_on_err(
10721        self,
10722        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10723    ) -> Result<(), fidl::Error> {
10724        let _result = self.send_raw(result);
10725        self.drop_without_shutdown();
10726        _result
10727    }
10728
10729    fn send_raw(
10730        &self,
10731        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10732    ) -> Result<(), fidl::Error> {
10733        self.control_handle.inner.send::<fidl::encoding::ResultType<
10734            fidl::encoding::EmptyStruct,
10735            fidl_fuchsia_posix::Errno,
10736        >>(
10737            result,
10738            self.tx_id,
10739            0x29e2424b433ae1ef,
10740            fidl::encoding::DynamicFlags::empty(),
10741        )
10742    }
10743}
10744
10745#[must_use = "FIDL methods require a response to be sent"]
10746#[derive(Debug)]
10747pub struct BaseDatagramSocketGetIpTtlResponder {
10748    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
10749    tx_id: u32,
10750}
10751
10752/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
10753/// if the responder is dropped without sending a response, so that the client
10754/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
10755impl std::ops::Drop for BaseDatagramSocketGetIpTtlResponder {
10756    fn drop(&mut self) {
10757        self.control_handle.shutdown();
10758        // Safety: drops once, never accessed again
10759        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10760    }
10761}
10762
10763impl fidl::endpoints::Responder for BaseDatagramSocketGetIpTtlResponder {
10764    type ControlHandle = BaseDatagramSocketControlHandle;
10765
10766    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
10767        &self.control_handle
10768    }
10769
10770    fn drop_without_shutdown(mut self) {
10771        // Safety: drops once, never accessed again due to mem::forget
10772        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10773        // Prevent Drop from running (which would shut down the channel)
10774        std::mem::forget(self);
10775    }
10776}
10777
10778impl BaseDatagramSocketGetIpTtlResponder {
10779    /// Sends a response to the FIDL transaction.
10780    ///
10781    /// Sets the channel to shutdown if an error occurs.
10782    pub fn send(
10783        self,
10784        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
10785    ) -> Result<(), fidl::Error> {
10786        let _result = self.send_raw(result);
10787        if _result.is_err() {
10788            self.control_handle.shutdown();
10789        }
10790        self.drop_without_shutdown();
10791        _result
10792    }
10793
10794    /// Similar to "send" but does not shutdown the channel if an error occurs.
10795    pub fn send_no_shutdown_on_err(
10796        self,
10797        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
10798    ) -> Result<(), fidl::Error> {
10799        let _result = self.send_raw(result);
10800        self.drop_without_shutdown();
10801        _result
10802    }
10803
10804    fn send_raw(
10805        &self,
10806        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
10807    ) -> Result<(), fidl::Error> {
10808        self.control_handle.inner.send::<fidl::encoding::ResultType<
10809            BaseNetworkSocketGetIpTtlResponse,
10810            fidl_fuchsia_posix::Errno,
10811        >>(
10812            result.map(|value| (value,)),
10813            self.tx_id,
10814            0x47e47fa1f24da471,
10815            fidl::encoding::DynamicFlags::empty(),
10816        )
10817    }
10818}
10819
10820#[must_use = "FIDL methods require a response to be sent"]
10821#[derive(Debug)]
10822pub struct BaseDatagramSocketSetIpPacketInfoResponder {
10823    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
10824    tx_id: u32,
10825}
10826
10827/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
10828/// if the responder is dropped without sending a response, so that the client
10829/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
10830impl std::ops::Drop for BaseDatagramSocketSetIpPacketInfoResponder {
10831    fn drop(&mut self) {
10832        self.control_handle.shutdown();
10833        // Safety: drops once, never accessed again
10834        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10835    }
10836}
10837
10838impl fidl::endpoints::Responder for BaseDatagramSocketSetIpPacketInfoResponder {
10839    type ControlHandle = BaseDatagramSocketControlHandle;
10840
10841    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
10842        &self.control_handle
10843    }
10844
10845    fn drop_without_shutdown(mut self) {
10846        // Safety: drops once, never accessed again due to mem::forget
10847        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10848        // Prevent Drop from running (which would shut down the channel)
10849        std::mem::forget(self);
10850    }
10851}
10852
10853impl BaseDatagramSocketSetIpPacketInfoResponder {
10854    /// Sends a response to the FIDL transaction.
10855    ///
10856    /// Sets the channel to shutdown if an error occurs.
10857    pub fn send(
10858        self,
10859        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10860    ) -> Result<(), fidl::Error> {
10861        let _result = self.send_raw(result);
10862        if _result.is_err() {
10863            self.control_handle.shutdown();
10864        }
10865        self.drop_without_shutdown();
10866        _result
10867    }
10868
10869    /// Similar to "send" but does not shutdown the channel if an error occurs.
10870    pub fn send_no_shutdown_on_err(
10871        self,
10872        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10873    ) -> Result<(), fidl::Error> {
10874        let _result = self.send_raw(result);
10875        self.drop_without_shutdown();
10876        _result
10877    }
10878
10879    fn send_raw(
10880        &self,
10881        mut result: Result<(), fidl_fuchsia_posix::Errno>,
10882    ) -> Result<(), fidl::Error> {
10883        self.control_handle.inner.send::<fidl::encoding::ResultType<
10884            fidl::encoding::EmptyStruct,
10885            fidl_fuchsia_posix::Errno,
10886        >>(
10887            result,
10888            self.tx_id,
10889            0x392d16bee20c0e16,
10890            fidl::encoding::DynamicFlags::empty(),
10891        )
10892    }
10893}
10894
10895#[must_use = "FIDL methods require a response to be sent"]
10896#[derive(Debug)]
10897pub struct BaseDatagramSocketGetIpPacketInfoResponder {
10898    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
10899    tx_id: u32,
10900}
10901
10902/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
10903/// if the responder is dropped without sending a response, so that the client
10904/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
10905impl std::ops::Drop for BaseDatagramSocketGetIpPacketInfoResponder {
10906    fn drop(&mut self) {
10907        self.control_handle.shutdown();
10908        // Safety: drops once, never accessed again
10909        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10910    }
10911}
10912
10913impl fidl::endpoints::Responder for BaseDatagramSocketGetIpPacketInfoResponder {
10914    type ControlHandle = BaseDatagramSocketControlHandle;
10915
10916    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
10917        &self.control_handle
10918    }
10919
10920    fn drop_without_shutdown(mut self) {
10921        // Safety: drops once, never accessed again due to mem::forget
10922        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10923        // Prevent Drop from running (which would shut down the channel)
10924        std::mem::forget(self);
10925    }
10926}
10927
10928impl BaseDatagramSocketGetIpPacketInfoResponder {
10929    /// Sends a response to the FIDL transaction.
10930    ///
10931    /// Sets the channel to shutdown if an error occurs.
10932    pub fn send(
10933        self,
10934        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
10935    ) -> Result<(), fidl::Error> {
10936        let _result = self.send_raw(result);
10937        if _result.is_err() {
10938            self.control_handle.shutdown();
10939        }
10940        self.drop_without_shutdown();
10941        _result
10942    }
10943
10944    /// Similar to "send" but does not shutdown the channel if an error occurs.
10945    pub fn send_no_shutdown_on_err(
10946        self,
10947        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
10948    ) -> Result<(), fidl::Error> {
10949        let _result = self.send_raw(result);
10950        self.drop_without_shutdown();
10951        _result
10952    }
10953
10954    fn send_raw(
10955        &self,
10956        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
10957    ) -> Result<(), fidl::Error> {
10958        self.control_handle.inner.send::<fidl::encoding::ResultType<
10959            BaseNetworkSocketGetIpPacketInfoResponse,
10960            fidl_fuchsia_posix::Errno,
10961        >>(
10962            result.map(|value| (value,)),
10963            self.tx_id,
10964            0x54b505f242280740,
10965            fidl::encoding::DynamicFlags::empty(),
10966        )
10967    }
10968}
10969
10970#[must_use = "FIDL methods require a response to be sent"]
10971#[derive(Debug)]
10972pub struct BaseDatagramSocketSetIpReceiveTypeOfServiceResponder {
10973    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
10974    tx_id: u32,
10975}
10976
10977/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
10978/// if the responder is dropped without sending a response, so that the client
10979/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
10980impl std::ops::Drop for BaseDatagramSocketSetIpReceiveTypeOfServiceResponder {
10981    fn drop(&mut self) {
10982        self.control_handle.shutdown();
10983        // Safety: drops once, never accessed again
10984        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10985    }
10986}
10987
10988impl fidl::endpoints::Responder for BaseDatagramSocketSetIpReceiveTypeOfServiceResponder {
10989    type ControlHandle = BaseDatagramSocketControlHandle;
10990
10991    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
10992        &self.control_handle
10993    }
10994
10995    fn drop_without_shutdown(mut self) {
10996        // Safety: drops once, never accessed again due to mem::forget
10997        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
10998        // Prevent Drop from running (which would shut down the channel)
10999        std::mem::forget(self);
11000    }
11001}
11002
11003impl BaseDatagramSocketSetIpReceiveTypeOfServiceResponder {
11004    /// Sends a response to the FIDL transaction.
11005    ///
11006    /// Sets the channel to shutdown if an error occurs.
11007    pub fn send(
11008        self,
11009        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11010    ) -> Result<(), fidl::Error> {
11011        let _result = self.send_raw(result);
11012        if _result.is_err() {
11013            self.control_handle.shutdown();
11014        }
11015        self.drop_without_shutdown();
11016        _result
11017    }
11018
11019    /// Similar to "send" but does not shutdown the channel if an error occurs.
11020    pub fn send_no_shutdown_on_err(
11021        self,
11022        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11023    ) -> Result<(), fidl::Error> {
11024        let _result = self.send_raw(result);
11025        self.drop_without_shutdown();
11026        _result
11027    }
11028
11029    fn send_raw(
11030        &self,
11031        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11032    ) -> Result<(), fidl::Error> {
11033        self.control_handle.inner.send::<fidl::encoding::ResultType<
11034            fidl::encoding::EmptyStruct,
11035            fidl_fuchsia_posix::Errno,
11036        >>(
11037            result,
11038            self.tx_id,
11039            0x6c4f6714995f84ef,
11040            fidl::encoding::DynamicFlags::empty(),
11041        )
11042    }
11043}
11044
11045#[must_use = "FIDL methods require a response to be sent"]
11046#[derive(Debug)]
11047pub struct BaseDatagramSocketGetIpReceiveTypeOfServiceResponder {
11048    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
11049    tx_id: u32,
11050}
11051
11052/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
11053/// if the responder is dropped without sending a response, so that the client
11054/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
11055impl std::ops::Drop for BaseDatagramSocketGetIpReceiveTypeOfServiceResponder {
11056    fn drop(&mut self) {
11057        self.control_handle.shutdown();
11058        // Safety: drops once, never accessed again
11059        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11060    }
11061}
11062
11063impl fidl::endpoints::Responder for BaseDatagramSocketGetIpReceiveTypeOfServiceResponder {
11064    type ControlHandle = BaseDatagramSocketControlHandle;
11065
11066    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
11067        &self.control_handle
11068    }
11069
11070    fn drop_without_shutdown(mut self) {
11071        // Safety: drops once, never accessed again due to mem::forget
11072        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11073        // Prevent Drop from running (which would shut down the channel)
11074        std::mem::forget(self);
11075    }
11076}
11077
11078impl BaseDatagramSocketGetIpReceiveTypeOfServiceResponder {
11079    /// Sends a response to the FIDL transaction.
11080    ///
11081    /// Sets the channel to shutdown if an error occurs.
11082    pub fn send(
11083        self,
11084        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11085    ) -> Result<(), fidl::Error> {
11086        let _result = self.send_raw(result);
11087        if _result.is_err() {
11088            self.control_handle.shutdown();
11089        }
11090        self.drop_without_shutdown();
11091        _result
11092    }
11093
11094    /// Similar to "send" but does not shutdown the channel if an error occurs.
11095    pub fn send_no_shutdown_on_err(
11096        self,
11097        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11098    ) -> Result<(), fidl::Error> {
11099        let _result = self.send_raw(result);
11100        self.drop_without_shutdown();
11101        _result
11102    }
11103
11104    fn send_raw(
11105        &self,
11106        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11107    ) -> Result<(), fidl::Error> {
11108        self.control_handle.inner.send::<fidl::encoding::ResultType<
11109            BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
11110            fidl_fuchsia_posix::Errno,
11111        >>(
11112            result.map(|value| (value,)),
11113            self.tx_id,
11114            0x4158ba7dc2795960,
11115            fidl::encoding::DynamicFlags::empty(),
11116        )
11117    }
11118}
11119
11120#[must_use = "FIDL methods require a response to be sent"]
11121#[derive(Debug)]
11122pub struct BaseDatagramSocketSetIpReceiveTtlResponder {
11123    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
11124    tx_id: u32,
11125}
11126
11127/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
11128/// if the responder is dropped without sending a response, so that the client
11129/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
11130impl std::ops::Drop for BaseDatagramSocketSetIpReceiveTtlResponder {
11131    fn drop(&mut self) {
11132        self.control_handle.shutdown();
11133        // Safety: drops once, never accessed again
11134        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11135    }
11136}
11137
11138impl fidl::endpoints::Responder for BaseDatagramSocketSetIpReceiveTtlResponder {
11139    type ControlHandle = BaseDatagramSocketControlHandle;
11140
11141    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
11142        &self.control_handle
11143    }
11144
11145    fn drop_without_shutdown(mut self) {
11146        // Safety: drops once, never accessed again due to mem::forget
11147        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11148        // Prevent Drop from running (which would shut down the channel)
11149        std::mem::forget(self);
11150    }
11151}
11152
11153impl BaseDatagramSocketSetIpReceiveTtlResponder {
11154    /// Sends a response to the FIDL transaction.
11155    ///
11156    /// Sets the channel to shutdown if an error occurs.
11157    pub fn send(
11158        self,
11159        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11160    ) -> Result<(), fidl::Error> {
11161        let _result = self.send_raw(result);
11162        if _result.is_err() {
11163            self.control_handle.shutdown();
11164        }
11165        self.drop_without_shutdown();
11166        _result
11167    }
11168
11169    /// Similar to "send" but does not shutdown the channel if an error occurs.
11170    pub fn send_no_shutdown_on_err(
11171        self,
11172        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11173    ) -> Result<(), fidl::Error> {
11174        let _result = self.send_raw(result);
11175        self.drop_without_shutdown();
11176        _result
11177    }
11178
11179    fn send_raw(
11180        &self,
11181        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11182    ) -> Result<(), fidl::Error> {
11183        self.control_handle.inner.send::<fidl::encoding::ResultType<
11184            fidl::encoding::EmptyStruct,
11185            fidl_fuchsia_posix::Errno,
11186        >>(
11187            result,
11188            self.tx_id,
11189            0x46f15be0ce0ab82b,
11190            fidl::encoding::DynamicFlags::empty(),
11191        )
11192    }
11193}
11194
11195#[must_use = "FIDL methods require a response to be sent"]
11196#[derive(Debug)]
11197pub struct BaseDatagramSocketGetIpReceiveTtlResponder {
11198    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
11199    tx_id: u32,
11200}
11201
11202/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
11203/// if the responder is dropped without sending a response, so that the client
11204/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
11205impl std::ops::Drop for BaseDatagramSocketGetIpReceiveTtlResponder {
11206    fn drop(&mut self) {
11207        self.control_handle.shutdown();
11208        // Safety: drops once, never accessed again
11209        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11210    }
11211}
11212
11213impl fidl::endpoints::Responder for BaseDatagramSocketGetIpReceiveTtlResponder {
11214    type ControlHandle = BaseDatagramSocketControlHandle;
11215
11216    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
11217        &self.control_handle
11218    }
11219
11220    fn drop_without_shutdown(mut self) {
11221        // Safety: drops once, never accessed again due to mem::forget
11222        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11223        // Prevent Drop from running (which would shut down the channel)
11224        std::mem::forget(self);
11225    }
11226}
11227
11228impl BaseDatagramSocketGetIpReceiveTtlResponder {
11229    /// Sends a response to the FIDL transaction.
11230    ///
11231    /// Sets the channel to shutdown if an error occurs.
11232    pub fn send(
11233        self,
11234        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11235    ) -> Result<(), fidl::Error> {
11236        let _result = self.send_raw(result);
11237        if _result.is_err() {
11238            self.control_handle.shutdown();
11239        }
11240        self.drop_without_shutdown();
11241        _result
11242    }
11243
11244    /// Similar to "send" but does not shutdown the channel if an error occurs.
11245    pub fn send_no_shutdown_on_err(
11246        self,
11247        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11248    ) -> Result<(), fidl::Error> {
11249        let _result = self.send_raw(result);
11250        self.drop_without_shutdown();
11251        _result
11252    }
11253
11254    fn send_raw(
11255        &self,
11256        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11257    ) -> Result<(), fidl::Error> {
11258        self.control_handle.inner.send::<fidl::encoding::ResultType<
11259            BaseNetworkSocketGetIpReceiveTtlResponse,
11260            fidl_fuchsia_posix::Errno,
11261        >>(
11262            result.map(|value| (value,)),
11263            self.tx_id,
11264            0x678ddd5a5dfa2eb5,
11265            fidl::encoding::DynamicFlags::empty(),
11266        )
11267    }
11268}
11269
11270#[must_use = "FIDL methods require a response to be sent"]
11271#[derive(Debug)]
11272pub struct BaseDatagramSocketSetIpMulticastInterfaceResponder {
11273    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
11274    tx_id: u32,
11275}
11276
11277/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
11278/// if the responder is dropped without sending a response, so that the client
11279/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
11280impl std::ops::Drop for BaseDatagramSocketSetIpMulticastInterfaceResponder {
11281    fn drop(&mut self) {
11282        self.control_handle.shutdown();
11283        // Safety: drops once, never accessed again
11284        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11285    }
11286}
11287
11288impl fidl::endpoints::Responder for BaseDatagramSocketSetIpMulticastInterfaceResponder {
11289    type ControlHandle = BaseDatagramSocketControlHandle;
11290
11291    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
11292        &self.control_handle
11293    }
11294
11295    fn drop_without_shutdown(mut self) {
11296        // Safety: drops once, never accessed again due to mem::forget
11297        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11298        // Prevent Drop from running (which would shut down the channel)
11299        std::mem::forget(self);
11300    }
11301}
11302
11303impl BaseDatagramSocketSetIpMulticastInterfaceResponder {
11304    /// Sends a response to the FIDL transaction.
11305    ///
11306    /// Sets the channel to shutdown if an error occurs.
11307    pub fn send(
11308        self,
11309        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11310    ) -> Result<(), fidl::Error> {
11311        let _result = self.send_raw(result);
11312        if _result.is_err() {
11313            self.control_handle.shutdown();
11314        }
11315        self.drop_without_shutdown();
11316        _result
11317    }
11318
11319    /// Similar to "send" but does not shutdown the channel if an error occurs.
11320    pub fn send_no_shutdown_on_err(
11321        self,
11322        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11323    ) -> Result<(), fidl::Error> {
11324        let _result = self.send_raw(result);
11325        self.drop_without_shutdown();
11326        _result
11327    }
11328
11329    fn send_raw(
11330        &self,
11331        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11332    ) -> Result<(), fidl::Error> {
11333        self.control_handle.inner.send::<fidl::encoding::ResultType<
11334            fidl::encoding::EmptyStruct,
11335            fidl_fuchsia_posix::Errno,
11336        >>(
11337            result,
11338            self.tx_id,
11339            0x752fbfa9b12befe,
11340            fidl::encoding::DynamicFlags::empty(),
11341        )
11342    }
11343}
11344
11345#[must_use = "FIDL methods require a response to be sent"]
11346#[derive(Debug)]
11347pub struct BaseDatagramSocketGetIpMulticastInterfaceResponder {
11348    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
11349    tx_id: u32,
11350}
11351
11352/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
11353/// if the responder is dropped without sending a response, so that the client
11354/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
11355impl std::ops::Drop for BaseDatagramSocketGetIpMulticastInterfaceResponder {
11356    fn drop(&mut self) {
11357        self.control_handle.shutdown();
11358        // Safety: drops once, never accessed again
11359        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11360    }
11361}
11362
11363impl fidl::endpoints::Responder for BaseDatagramSocketGetIpMulticastInterfaceResponder {
11364    type ControlHandle = BaseDatagramSocketControlHandle;
11365
11366    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
11367        &self.control_handle
11368    }
11369
11370    fn drop_without_shutdown(mut self) {
11371        // Safety: drops once, never accessed again due to mem::forget
11372        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11373        // Prevent Drop from running (which would shut down the channel)
11374        std::mem::forget(self);
11375    }
11376}
11377
11378impl BaseDatagramSocketGetIpMulticastInterfaceResponder {
11379    /// Sends a response to the FIDL transaction.
11380    ///
11381    /// Sets the channel to shutdown if an error occurs.
11382    pub fn send(
11383        self,
11384        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
11385    ) -> Result<(), fidl::Error> {
11386        let _result = self.send_raw(result);
11387        if _result.is_err() {
11388            self.control_handle.shutdown();
11389        }
11390        self.drop_without_shutdown();
11391        _result
11392    }
11393
11394    /// Similar to "send" but does not shutdown the channel if an error occurs.
11395    pub fn send_no_shutdown_on_err(
11396        self,
11397        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
11398    ) -> Result<(), fidl::Error> {
11399        let _result = self.send_raw(result);
11400        self.drop_without_shutdown();
11401        _result
11402    }
11403
11404    fn send_raw(
11405        &self,
11406        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
11407    ) -> Result<(), fidl::Error> {
11408        self.control_handle.inner.send::<fidl::encoding::ResultType<
11409            BaseNetworkSocketGetIpMulticastInterfaceResponse,
11410            fidl_fuchsia_posix::Errno,
11411        >>(
11412            result.map(|value| (value,)),
11413            self.tx_id,
11414            0x320bd14c4df046c4,
11415            fidl::encoding::DynamicFlags::empty(),
11416        )
11417    }
11418}
11419
11420#[must_use = "FIDL methods require a response to be sent"]
11421#[derive(Debug)]
11422pub struct BaseDatagramSocketSetIpMulticastTtlResponder {
11423    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
11424    tx_id: u32,
11425}
11426
11427/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
11428/// if the responder is dropped without sending a response, so that the client
11429/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
11430impl std::ops::Drop for BaseDatagramSocketSetIpMulticastTtlResponder {
11431    fn drop(&mut self) {
11432        self.control_handle.shutdown();
11433        // Safety: drops once, never accessed again
11434        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11435    }
11436}
11437
11438impl fidl::endpoints::Responder for BaseDatagramSocketSetIpMulticastTtlResponder {
11439    type ControlHandle = BaseDatagramSocketControlHandle;
11440
11441    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
11442        &self.control_handle
11443    }
11444
11445    fn drop_without_shutdown(mut self) {
11446        // Safety: drops once, never accessed again due to mem::forget
11447        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11448        // Prevent Drop from running (which would shut down the channel)
11449        std::mem::forget(self);
11450    }
11451}
11452
11453impl BaseDatagramSocketSetIpMulticastTtlResponder {
11454    /// Sends a response to the FIDL transaction.
11455    ///
11456    /// Sets the channel to shutdown if an error occurs.
11457    pub fn send(
11458        self,
11459        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11460    ) -> Result<(), fidl::Error> {
11461        let _result = self.send_raw(result);
11462        if _result.is_err() {
11463            self.control_handle.shutdown();
11464        }
11465        self.drop_without_shutdown();
11466        _result
11467    }
11468
11469    /// Similar to "send" but does not shutdown the channel if an error occurs.
11470    pub fn send_no_shutdown_on_err(
11471        self,
11472        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11473    ) -> Result<(), fidl::Error> {
11474        let _result = self.send_raw(result);
11475        self.drop_without_shutdown();
11476        _result
11477    }
11478
11479    fn send_raw(
11480        &self,
11481        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11482    ) -> Result<(), fidl::Error> {
11483        self.control_handle.inner.send::<fidl::encoding::ResultType<
11484            fidl::encoding::EmptyStruct,
11485            fidl_fuchsia_posix::Errno,
11486        >>(
11487            result,
11488            self.tx_id,
11489            0x63134d53772916a1,
11490            fidl::encoding::DynamicFlags::empty(),
11491        )
11492    }
11493}
11494
11495#[must_use = "FIDL methods require a response to be sent"]
11496#[derive(Debug)]
11497pub struct BaseDatagramSocketGetIpMulticastTtlResponder {
11498    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
11499    tx_id: u32,
11500}
11501
11502/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
11503/// if the responder is dropped without sending a response, so that the client
11504/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
11505impl std::ops::Drop for BaseDatagramSocketGetIpMulticastTtlResponder {
11506    fn drop(&mut self) {
11507        self.control_handle.shutdown();
11508        // Safety: drops once, never accessed again
11509        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11510    }
11511}
11512
11513impl fidl::endpoints::Responder for BaseDatagramSocketGetIpMulticastTtlResponder {
11514    type ControlHandle = BaseDatagramSocketControlHandle;
11515
11516    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
11517        &self.control_handle
11518    }
11519
11520    fn drop_without_shutdown(mut self) {
11521        // Safety: drops once, never accessed again due to mem::forget
11522        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11523        // Prevent Drop from running (which would shut down the channel)
11524        std::mem::forget(self);
11525    }
11526}
11527
11528impl BaseDatagramSocketGetIpMulticastTtlResponder {
11529    /// Sends a response to the FIDL transaction.
11530    ///
11531    /// Sets the channel to shutdown if an error occurs.
11532    pub fn send(
11533        self,
11534        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
11535    ) -> Result<(), fidl::Error> {
11536        let _result = self.send_raw(result);
11537        if _result.is_err() {
11538            self.control_handle.shutdown();
11539        }
11540        self.drop_without_shutdown();
11541        _result
11542    }
11543
11544    /// Similar to "send" but does not shutdown the channel if an error occurs.
11545    pub fn send_no_shutdown_on_err(
11546        self,
11547        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
11548    ) -> Result<(), fidl::Error> {
11549        let _result = self.send_raw(result);
11550        self.drop_without_shutdown();
11551        _result
11552    }
11553
11554    fn send_raw(
11555        &self,
11556        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
11557    ) -> Result<(), fidl::Error> {
11558        self.control_handle.inner.send::<fidl::encoding::ResultType<
11559            BaseNetworkSocketGetIpMulticastTtlResponse,
11560            fidl_fuchsia_posix::Errno,
11561        >>(
11562            result.map(|value| (value,)),
11563            self.tx_id,
11564            0x4665cd378f39e1a,
11565            fidl::encoding::DynamicFlags::empty(),
11566        )
11567    }
11568}
11569
11570#[must_use = "FIDL methods require a response to be sent"]
11571#[derive(Debug)]
11572pub struct BaseDatagramSocketSetIpMulticastLoopbackResponder {
11573    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
11574    tx_id: u32,
11575}
11576
11577/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
11578/// if the responder is dropped without sending a response, so that the client
11579/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
11580impl std::ops::Drop for BaseDatagramSocketSetIpMulticastLoopbackResponder {
11581    fn drop(&mut self) {
11582        self.control_handle.shutdown();
11583        // Safety: drops once, never accessed again
11584        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11585    }
11586}
11587
11588impl fidl::endpoints::Responder for BaseDatagramSocketSetIpMulticastLoopbackResponder {
11589    type ControlHandle = BaseDatagramSocketControlHandle;
11590
11591    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
11592        &self.control_handle
11593    }
11594
11595    fn drop_without_shutdown(mut self) {
11596        // Safety: drops once, never accessed again due to mem::forget
11597        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11598        // Prevent Drop from running (which would shut down the channel)
11599        std::mem::forget(self);
11600    }
11601}
11602
11603impl BaseDatagramSocketSetIpMulticastLoopbackResponder {
11604    /// Sends a response to the FIDL transaction.
11605    ///
11606    /// Sets the channel to shutdown if an error occurs.
11607    pub fn send(
11608        self,
11609        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11610    ) -> Result<(), fidl::Error> {
11611        let _result = self.send_raw(result);
11612        if _result.is_err() {
11613            self.control_handle.shutdown();
11614        }
11615        self.drop_without_shutdown();
11616        _result
11617    }
11618
11619    /// Similar to "send" but does not shutdown the channel if an error occurs.
11620    pub fn send_no_shutdown_on_err(
11621        self,
11622        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11623    ) -> Result<(), fidl::Error> {
11624        let _result = self.send_raw(result);
11625        self.drop_without_shutdown();
11626        _result
11627    }
11628
11629    fn send_raw(
11630        &self,
11631        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11632    ) -> Result<(), fidl::Error> {
11633        self.control_handle.inner.send::<fidl::encoding::ResultType<
11634            fidl::encoding::EmptyStruct,
11635            fidl_fuchsia_posix::Errno,
11636        >>(
11637            result,
11638            self.tx_id,
11639            0x20c55c11f00943ea,
11640            fidl::encoding::DynamicFlags::empty(),
11641        )
11642    }
11643}
11644
11645#[must_use = "FIDL methods require a response to be sent"]
11646#[derive(Debug)]
11647pub struct BaseDatagramSocketGetIpMulticastLoopbackResponder {
11648    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
11649    tx_id: u32,
11650}
11651
11652/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
11653/// if the responder is dropped without sending a response, so that the client
11654/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
11655impl std::ops::Drop for BaseDatagramSocketGetIpMulticastLoopbackResponder {
11656    fn drop(&mut self) {
11657        self.control_handle.shutdown();
11658        // Safety: drops once, never accessed again
11659        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11660    }
11661}
11662
11663impl fidl::endpoints::Responder for BaseDatagramSocketGetIpMulticastLoopbackResponder {
11664    type ControlHandle = BaseDatagramSocketControlHandle;
11665
11666    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
11667        &self.control_handle
11668    }
11669
11670    fn drop_without_shutdown(mut self) {
11671        // Safety: drops once, never accessed again due to mem::forget
11672        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11673        // Prevent Drop from running (which would shut down the channel)
11674        std::mem::forget(self);
11675    }
11676}
11677
11678impl BaseDatagramSocketGetIpMulticastLoopbackResponder {
11679    /// Sends a response to the FIDL transaction.
11680    ///
11681    /// Sets the channel to shutdown if an error occurs.
11682    pub fn send(
11683        self,
11684        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11685    ) -> Result<(), fidl::Error> {
11686        let _result = self.send_raw(result);
11687        if _result.is_err() {
11688            self.control_handle.shutdown();
11689        }
11690        self.drop_without_shutdown();
11691        _result
11692    }
11693
11694    /// Similar to "send" but does not shutdown the channel if an error occurs.
11695    pub fn send_no_shutdown_on_err(
11696        self,
11697        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11698    ) -> Result<(), fidl::Error> {
11699        let _result = self.send_raw(result);
11700        self.drop_without_shutdown();
11701        _result
11702    }
11703
11704    fn send_raw(
11705        &self,
11706        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11707    ) -> Result<(), fidl::Error> {
11708        self.control_handle.inner.send::<fidl::encoding::ResultType<
11709            BaseNetworkSocketGetIpMulticastLoopbackResponse,
11710            fidl_fuchsia_posix::Errno,
11711        >>(
11712            result.map(|value| (value,)),
11713            self.tx_id,
11714            0x3b6b26ff558298f2,
11715            fidl::encoding::DynamicFlags::empty(),
11716        )
11717    }
11718}
11719
11720#[must_use = "FIDL methods require a response to be sent"]
11721#[derive(Debug)]
11722pub struct BaseDatagramSocketAddIpMembershipResponder {
11723    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
11724    tx_id: u32,
11725}
11726
11727/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
11728/// if the responder is dropped without sending a response, so that the client
11729/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
11730impl std::ops::Drop for BaseDatagramSocketAddIpMembershipResponder {
11731    fn drop(&mut self) {
11732        self.control_handle.shutdown();
11733        // Safety: drops once, never accessed again
11734        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11735    }
11736}
11737
11738impl fidl::endpoints::Responder for BaseDatagramSocketAddIpMembershipResponder {
11739    type ControlHandle = BaseDatagramSocketControlHandle;
11740
11741    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
11742        &self.control_handle
11743    }
11744
11745    fn drop_without_shutdown(mut self) {
11746        // Safety: drops once, never accessed again due to mem::forget
11747        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11748        // Prevent Drop from running (which would shut down the channel)
11749        std::mem::forget(self);
11750    }
11751}
11752
11753impl BaseDatagramSocketAddIpMembershipResponder {
11754    /// Sends a response to the FIDL transaction.
11755    ///
11756    /// Sets the channel to shutdown if an error occurs.
11757    pub fn send(
11758        self,
11759        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11760    ) -> Result<(), fidl::Error> {
11761        let _result = self.send_raw(result);
11762        if _result.is_err() {
11763            self.control_handle.shutdown();
11764        }
11765        self.drop_without_shutdown();
11766        _result
11767    }
11768
11769    /// Similar to "send" but does not shutdown the channel if an error occurs.
11770    pub fn send_no_shutdown_on_err(
11771        self,
11772        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11773    ) -> Result<(), fidl::Error> {
11774        let _result = self.send_raw(result);
11775        self.drop_without_shutdown();
11776        _result
11777    }
11778
11779    fn send_raw(
11780        &self,
11781        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11782    ) -> Result<(), fidl::Error> {
11783        self.control_handle.inner.send::<fidl::encoding::ResultType<
11784            fidl::encoding::EmptyStruct,
11785            fidl_fuchsia_posix::Errno,
11786        >>(
11787            result,
11788            self.tx_id,
11789            0x76bc7df115a3b4d0,
11790            fidl::encoding::DynamicFlags::empty(),
11791        )
11792    }
11793}
11794
11795#[must_use = "FIDL methods require a response to be sent"]
11796#[derive(Debug)]
11797pub struct BaseDatagramSocketDropIpMembershipResponder {
11798    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
11799    tx_id: u32,
11800}
11801
11802/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
11803/// if the responder is dropped without sending a response, so that the client
11804/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
11805impl std::ops::Drop for BaseDatagramSocketDropIpMembershipResponder {
11806    fn drop(&mut self) {
11807        self.control_handle.shutdown();
11808        // Safety: drops once, never accessed again
11809        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11810    }
11811}
11812
11813impl fidl::endpoints::Responder for BaseDatagramSocketDropIpMembershipResponder {
11814    type ControlHandle = BaseDatagramSocketControlHandle;
11815
11816    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
11817        &self.control_handle
11818    }
11819
11820    fn drop_without_shutdown(mut self) {
11821        // Safety: drops once, never accessed again due to mem::forget
11822        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11823        // Prevent Drop from running (which would shut down the channel)
11824        std::mem::forget(self);
11825    }
11826}
11827
11828impl BaseDatagramSocketDropIpMembershipResponder {
11829    /// Sends a response to the FIDL transaction.
11830    ///
11831    /// Sets the channel to shutdown if an error occurs.
11832    pub fn send(
11833        self,
11834        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11835    ) -> Result<(), fidl::Error> {
11836        let _result = self.send_raw(result);
11837        if _result.is_err() {
11838            self.control_handle.shutdown();
11839        }
11840        self.drop_without_shutdown();
11841        _result
11842    }
11843
11844    /// Similar to "send" but does not shutdown the channel if an error occurs.
11845    pub fn send_no_shutdown_on_err(
11846        self,
11847        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11848    ) -> Result<(), fidl::Error> {
11849        let _result = self.send_raw(result);
11850        self.drop_without_shutdown();
11851        _result
11852    }
11853
11854    fn send_raw(
11855        &self,
11856        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11857    ) -> Result<(), fidl::Error> {
11858        self.control_handle.inner.send::<fidl::encoding::ResultType<
11859            fidl::encoding::EmptyStruct,
11860            fidl_fuchsia_posix::Errno,
11861        >>(
11862            result,
11863            self.tx_id,
11864            0x2888f3099188d03,
11865            fidl::encoding::DynamicFlags::empty(),
11866        )
11867    }
11868}
11869
11870#[must_use = "FIDL methods require a response to be sent"]
11871#[derive(Debug)]
11872pub struct BaseDatagramSocketSetIpTransparentResponder {
11873    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
11874    tx_id: u32,
11875}
11876
11877/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
11878/// if the responder is dropped without sending a response, so that the client
11879/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
11880impl std::ops::Drop for BaseDatagramSocketSetIpTransparentResponder {
11881    fn drop(&mut self) {
11882        self.control_handle.shutdown();
11883        // Safety: drops once, never accessed again
11884        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11885    }
11886}
11887
11888impl fidl::endpoints::Responder for BaseDatagramSocketSetIpTransparentResponder {
11889    type ControlHandle = BaseDatagramSocketControlHandle;
11890
11891    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
11892        &self.control_handle
11893    }
11894
11895    fn drop_without_shutdown(mut self) {
11896        // Safety: drops once, never accessed again due to mem::forget
11897        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11898        // Prevent Drop from running (which would shut down the channel)
11899        std::mem::forget(self);
11900    }
11901}
11902
11903impl BaseDatagramSocketSetIpTransparentResponder {
11904    /// Sends a response to the FIDL transaction.
11905    ///
11906    /// Sets the channel to shutdown if an error occurs.
11907    pub fn send(
11908        self,
11909        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11910    ) -> Result<(), fidl::Error> {
11911        let _result = self.send_raw(result);
11912        if _result.is_err() {
11913            self.control_handle.shutdown();
11914        }
11915        self.drop_without_shutdown();
11916        _result
11917    }
11918
11919    /// Similar to "send" but does not shutdown the channel if an error occurs.
11920    pub fn send_no_shutdown_on_err(
11921        self,
11922        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11923    ) -> Result<(), fidl::Error> {
11924        let _result = self.send_raw(result);
11925        self.drop_without_shutdown();
11926        _result
11927    }
11928
11929    fn send_raw(
11930        &self,
11931        mut result: Result<(), fidl_fuchsia_posix::Errno>,
11932    ) -> Result<(), fidl::Error> {
11933        self.control_handle.inner.send::<fidl::encoding::ResultType<
11934            fidl::encoding::EmptyStruct,
11935            fidl_fuchsia_posix::Errno,
11936        >>(
11937            result,
11938            self.tx_id,
11939            0x1ae532b0c066e3a0,
11940            fidl::encoding::DynamicFlags::empty(),
11941        )
11942    }
11943}
11944
11945#[must_use = "FIDL methods require a response to be sent"]
11946#[derive(Debug)]
11947pub struct BaseDatagramSocketGetIpTransparentResponder {
11948    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
11949    tx_id: u32,
11950}
11951
11952/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
11953/// if the responder is dropped without sending a response, so that the client
11954/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
11955impl std::ops::Drop for BaseDatagramSocketGetIpTransparentResponder {
11956    fn drop(&mut self) {
11957        self.control_handle.shutdown();
11958        // Safety: drops once, never accessed again
11959        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11960    }
11961}
11962
11963impl fidl::endpoints::Responder for BaseDatagramSocketGetIpTransparentResponder {
11964    type ControlHandle = BaseDatagramSocketControlHandle;
11965
11966    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
11967        &self.control_handle
11968    }
11969
11970    fn drop_without_shutdown(mut self) {
11971        // Safety: drops once, never accessed again due to mem::forget
11972        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
11973        // Prevent Drop from running (which would shut down the channel)
11974        std::mem::forget(self);
11975    }
11976}
11977
11978impl BaseDatagramSocketGetIpTransparentResponder {
11979    /// Sends a response to the FIDL transaction.
11980    ///
11981    /// Sets the channel to shutdown if an error occurs.
11982    pub fn send(
11983        self,
11984        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11985    ) -> Result<(), fidl::Error> {
11986        let _result = self.send_raw(result);
11987        if _result.is_err() {
11988            self.control_handle.shutdown();
11989        }
11990        self.drop_without_shutdown();
11991        _result
11992    }
11993
11994    /// Similar to "send" but does not shutdown the channel if an error occurs.
11995    pub fn send_no_shutdown_on_err(
11996        self,
11997        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
11998    ) -> Result<(), fidl::Error> {
11999        let _result = self.send_raw(result);
12000        self.drop_without_shutdown();
12001        _result
12002    }
12003
12004    fn send_raw(
12005        &self,
12006        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
12007    ) -> Result<(), fidl::Error> {
12008        self.control_handle.inner.send::<fidl::encoding::ResultType<
12009            BaseNetworkSocketGetIpTransparentResponse,
12010            fidl_fuchsia_posix::Errno,
12011        >>(
12012            result.map(|value| (value,)),
12013            self.tx_id,
12014            0x51d43695962ebfb5,
12015            fidl::encoding::DynamicFlags::empty(),
12016        )
12017    }
12018}
12019
12020#[must_use = "FIDL methods require a response to be sent"]
12021#[derive(Debug)]
12022pub struct BaseDatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
12023    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
12024    tx_id: u32,
12025}
12026
12027/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
12028/// if the responder is dropped without sending a response, so that the client
12029/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
12030impl std::ops::Drop for BaseDatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
12031    fn drop(&mut self) {
12032        self.control_handle.shutdown();
12033        // Safety: drops once, never accessed again
12034        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12035    }
12036}
12037
12038impl fidl::endpoints::Responder
12039    for BaseDatagramSocketSetIpReceiveOriginalDestinationAddressResponder
12040{
12041    type ControlHandle = BaseDatagramSocketControlHandle;
12042
12043    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
12044        &self.control_handle
12045    }
12046
12047    fn drop_without_shutdown(mut self) {
12048        // Safety: drops once, never accessed again due to mem::forget
12049        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12050        // Prevent Drop from running (which would shut down the channel)
12051        std::mem::forget(self);
12052    }
12053}
12054
12055impl BaseDatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
12056    /// Sends a response to the FIDL transaction.
12057    ///
12058    /// Sets the channel to shutdown if an error occurs.
12059    pub fn send(
12060        self,
12061        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12062    ) -> Result<(), fidl::Error> {
12063        let _result = self.send_raw(result);
12064        if _result.is_err() {
12065            self.control_handle.shutdown();
12066        }
12067        self.drop_without_shutdown();
12068        _result
12069    }
12070
12071    /// Similar to "send" but does not shutdown the channel if an error occurs.
12072    pub fn send_no_shutdown_on_err(
12073        self,
12074        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12075    ) -> Result<(), fidl::Error> {
12076        let _result = self.send_raw(result);
12077        self.drop_without_shutdown();
12078        _result
12079    }
12080
12081    fn send_raw(
12082        &self,
12083        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12084    ) -> Result<(), fidl::Error> {
12085        self.control_handle.inner.send::<fidl::encoding::ResultType<
12086            fidl::encoding::EmptyStruct,
12087            fidl_fuchsia_posix::Errno,
12088        >>(
12089            result,
12090            self.tx_id,
12091            0x4722b4ce52f7840,
12092            fidl::encoding::DynamicFlags::empty(),
12093        )
12094    }
12095}
12096
12097#[must_use = "FIDL methods require a response to be sent"]
12098#[derive(Debug)]
12099pub struct BaseDatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
12100    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
12101    tx_id: u32,
12102}
12103
12104/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
12105/// if the responder is dropped without sending a response, so that the client
12106/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
12107impl std::ops::Drop for BaseDatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
12108    fn drop(&mut self) {
12109        self.control_handle.shutdown();
12110        // Safety: drops once, never accessed again
12111        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12112    }
12113}
12114
12115impl fidl::endpoints::Responder
12116    for BaseDatagramSocketGetIpReceiveOriginalDestinationAddressResponder
12117{
12118    type ControlHandle = BaseDatagramSocketControlHandle;
12119
12120    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
12121        &self.control_handle
12122    }
12123
12124    fn drop_without_shutdown(mut self) {
12125        // Safety: drops once, never accessed again due to mem::forget
12126        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12127        // Prevent Drop from running (which would shut down the channel)
12128        std::mem::forget(self);
12129    }
12130}
12131
12132impl BaseDatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
12133    /// Sends a response to the FIDL transaction.
12134    ///
12135    /// Sets the channel to shutdown if an error occurs.
12136    pub fn send(
12137        self,
12138        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
12139    ) -> Result<(), fidl::Error> {
12140        let _result = self.send_raw(result);
12141        if _result.is_err() {
12142            self.control_handle.shutdown();
12143        }
12144        self.drop_without_shutdown();
12145        _result
12146    }
12147
12148    /// Similar to "send" but does not shutdown the channel if an error occurs.
12149    pub fn send_no_shutdown_on_err(
12150        self,
12151        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
12152    ) -> Result<(), fidl::Error> {
12153        let _result = self.send_raw(result);
12154        self.drop_without_shutdown();
12155        _result
12156    }
12157
12158    fn send_raw(
12159        &self,
12160        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
12161    ) -> Result<(), fidl::Error> {
12162        self.control_handle.inner.send::<fidl::encoding::ResultType<
12163            BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
12164            fidl_fuchsia_posix::Errno,
12165        >>(
12166            result.map(|value| (value,)),
12167            self.tx_id,
12168            0x2a0e7dc5d6bfdfe9,
12169            fidl::encoding::DynamicFlags::empty(),
12170        )
12171    }
12172}
12173
12174#[must_use = "FIDL methods require a response to be sent"]
12175#[derive(Debug)]
12176pub struct BaseDatagramSocketAddIpv6MembershipResponder {
12177    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
12178    tx_id: u32,
12179}
12180
12181/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
12182/// if the responder is dropped without sending a response, so that the client
12183/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
12184impl std::ops::Drop for BaseDatagramSocketAddIpv6MembershipResponder {
12185    fn drop(&mut self) {
12186        self.control_handle.shutdown();
12187        // Safety: drops once, never accessed again
12188        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12189    }
12190}
12191
12192impl fidl::endpoints::Responder for BaseDatagramSocketAddIpv6MembershipResponder {
12193    type ControlHandle = BaseDatagramSocketControlHandle;
12194
12195    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
12196        &self.control_handle
12197    }
12198
12199    fn drop_without_shutdown(mut self) {
12200        // Safety: drops once, never accessed again due to mem::forget
12201        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12202        // Prevent Drop from running (which would shut down the channel)
12203        std::mem::forget(self);
12204    }
12205}
12206
12207impl BaseDatagramSocketAddIpv6MembershipResponder {
12208    /// Sends a response to the FIDL transaction.
12209    ///
12210    /// Sets the channel to shutdown if an error occurs.
12211    pub fn send(
12212        self,
12213        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12214    ) -> Result<(), fidl::Error> {
12215        let _result = self.send_raw(result);
12216        if _result.is_err() {
12217            self.control_handle.shutdown();
12218        }
12219        self.drop_without_shutdown();
12220        _result
12221    }
12222
12223    /// Similar to "send" but does not shutdown the channel if an error occurs.
12224    pub fn send_no_shutdown_on_err(
12225        self,
12226        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12227    ) -> Result<(), fidl::Error> {
12228        let _result = self.send_raw(result);
12229        self.drop_without_shutdown();
12230        _result
12231    }
12232
12233    fn send_raw(
12234        &self,
12235        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12236    ) -> Result<(), fidl::Error> {
12237        self.control_handle.inner.send::<fidl::encoding::ResultType<
12238            fidl::encoding::EmptyStruct,
12239            fidl_fuchsia_posix::Errno,
12240        >>(
12241            result,
12242            self.tx_id,
12243            0x7c94727acb4ea4b3,
12244            fidl::encoding::DynamicFlags::empty(),
12245        )
12246    }
12247}
12248
12249#[must_use = "FIDL methods require a response to be sent"]
12250#[derive(Debug)]
12251pub struct BaseDatagramSocketDropIpv6MembershipResponder {
12252    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
12253    tx_id: u32,
12254}
12255
12256/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
12257/// if the responder is dropped without sending a response, so that the client
12258/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
12259impl std::ops::Drop for BaseDatagramSocketDropIpv6MembershipResponder {
12260    fn drop(&mut self) {
12261        self.control_handle.shutdown();
12262        // Safety: drops once, never accessed again
12263        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12264    }
12265}
12266
12267impl fidl::endpoints::Responder for BaseDatagramSocketDropIpv6MembershipResponder {
12268    type ControlHandle = BaseDatagramSocketControlHandle;
12269
12270    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
12271        &self.control_handle
12272    }
12273
12274    fn drop_without_shutdown(mut self) {
12275        // Safety: drops once, never accessed again due to mem::forget
12276        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12277        // Prevent Drop from running (which would shut down the channel)
12278        std::mem::forget(self);
12279    }
12280}
12281
12282impl BaseDatagramSocketDropIpv6MembershipResponder {
12283    /// Sends a response to the FIDL transaction.
12284    ///
12285    /// Sets the channel to shutdown if an error occurs.
12286    pub fn send(
12287        self,
12288        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12289    ) -> Result<(), fidl::Error> {
12290        let _result = self.send_raw(result);
12291        if _result.is_err() {
12292            self.control_handle.shutdown();
12293        }
12294        self.drop_without_shutdown();
12295        _result
12296    }
12297
12298    /// Similar to "send" but does not shutdown the channel if an error occurs.
12299    pub fn send_no_shutdown_on_err(
12300        self,
12301        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12302    ) -> Result<(), fidl::Error> {
12303        let _result = self.send_raw(result);
12304        self.drop_without_shutdown();
12305        _result
12306    }
12307
12308    fn send_raw(
12309        &self,
12310        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12311    ) -> Result<(), fidl::Error> {
12312        self.control_handle.inner.send::<fidl::encoding::ResultType<
12313            fidl::encoding::EmptyStruct,
12314            fidl_fuchsia_posix::Errno,
12315        >>(
12316            result,
12317            self.tx_id,
12318            0x42104c70ccaba304,
12319            fidl::encoding::DynamicFlags::empty(),
12320        )
12321    }
12322}
12323
12324#[must_use = "FIDL methods require a response to be sent"]
12325#[derive(Debug)]
12326pub struct BaseDatagramSocketSetIpv6MulticastInterfaceResponder {
12327    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
12328    tx_id: u32,
12329}
12330
12331/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
12332/// if the responder is dropped without sending a response, so that the client
12333/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
12334impl std::ops::Drop for BaseDatagramSocketSetIpv6MulticastInterfaceResponder {
12335    fn drop(&mut self) {
12336        self.control_handle.shutdown();
12337        // Safety: drops once, never accessed again
12338        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12339    }
12340}
12341
12342impl fidl::endpoints::Responder for BaseDatagramSocketSetIpv6MulticastInterfaceResponder {
12343    type ControlHandle = BaseDatagramSocketControlHandle;
12344
12345    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
12346        &self.control_handle
12347    }
12348
12349    fn drop_without_shutdown(mut self) {
12350        // Safety: drops once, never accessed again due to mem::forget
12351        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12352        // Prevent Drop from running (which would shut down the channel)
12353        std::mem::forget(self);
12354    }
12355}
12356
12357impl BaseDatagramSocketSetIpv6MulticastInterfaceResponder {
12358    /// Sends a response to the FIDL transaction.
12359    ///
12360    /// Sets the channel to shutdown if an error occurs.
12361    pub fn send(
12362        self,
12363        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12364    ) -> Result<(), fidl::Error> {
12365        let _result = self.send_raw(result);
12366        if _result.is_err() {
12367            self.control_handle.shutdown();
12368        }
12369        self.drop_without_shutdown();
12370        _result
12371    }
12372
12373    /// Similar to "send" but does not shutdown the channel if an error occurs.
12374    pub fn send_no_shutdown_on_err(
12375        self,
12376        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12377    ) -> Result<(), fidl::Error> {
12378        let _result = self.send_raw(result);
12379        self.drop_without_shutdown();
12380        _result
12381    }
12382
12383    fn send_raw(
12384        &self,
12385        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12386    ) -> Result<(), fidl::Error> {
12387        self.control_handle.inner.send::<fidl::encoding::ResultType<
12388            fidl::encoding::EmptyStruct,
12389            fidl_fuchsia_posix::Errno,
12390        >>(
12391            result,
12392            self.tx_id,
12393            0x135f76db3774ab3b,
12394            fidl::encoding::DynamicFlags::empty(),
12395        )
12396    }
12397}
12398
12399#[must_use = "FIDL methods require a response to be sent"]
12400#[derive(Debug)]
12401pub struct BaseDatagramSocketGetIpv6MulticastInterfaceResponder {
12402    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
12403    tx_id: u32,
12404}
12405
12406/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
12407/// if the responder is dropped without sending a response, so that the client
12408/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
12409impl std::ops::Drop for BaseDatagramSocketGetIpv6MulticastInterfaceResponder {
12410    fn drop(&mut self) {
12411        self.control_handle.shutdown();
12412        // Safety: drops once, never accessed again
12413        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12414    }
12415}
12416
12417impl fidl::endpoints::Responder for BaseDatagramSocketGetIpv6MulticastInterfaceResponder {
12418    type ControlHandle = BaseDatagramSocketControlHandle;
12419
12420    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
12421        &self.control_handle
12422    }
12423
12424    fn drop_without_shutdown(mut self) {
12425        // Safety: drops once, never accessed again due to mem::forget
12426        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12427        // Prevent Drop from running (which would shut down the channel)
12428        std::mem::forget(self);
12429    }
12430}
12431
12432impl BaseDatagramSocketGetIpv6MulticastInterfaceResponder {
12433    /// Sends a response to the FIDL transaction.
12434    ///
12435    /// Sets the channel to shutdown if an error occurs.
12436    pub fn send(
12437        self,
12438        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
12439    ) -> Result<(), fidl::Error> {
12440        let _result = self.send_raw(result);
12441        if _result.is_err() {
12442            self.control_handle.shutdown();
12443        }
12444        self.drop_without_shutdown();
12445        _result
12446    }
12447
12448    /// Similar to "send" but does not shutdown the channel if an error occurs.
12449    pub fn send_no_shutdown_on_err(
12450        self,
12451        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
12452    ) -> Result<(), fidl::Error> {
12453        let _result = self.send_raw(result);
12454        self.drop_without_shutdown();
12455        _result
12456    }
12457
12458    fn send_raw(
12459        &self,
12460        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
12461    ) -> Result<(), fidl::Error> {
12462        self.control_handle.inner.send::<fidl::encoding::ResultType<
12463            BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
12464            fidl_fuchsia_posix::Errno,
12465        >>(
12466            result.map(|value| (value,)),
12467            self.tx_id,
12468            0x1f26fcdd348f1882,
12469            fidl::encoding::DynamicFlags::empty(),
12470        )
12471    }
12472}
12473
12474#[must_use = "FIDL methods require a response to be sent"]
12475#[derive(Debug)]
12476pub struct BaseDatagramSocketSetIpv6UnicastHopsResponder {
12477    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
12478    tx_id: u32,
12479}
12480
12481/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
12482/// if the responder is dropped without sending a response, so that the client
12483/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
12484impl std::ops::Drop for BaseDatagramSocketSetIpv6UnicastHopsResponder {
12485    fn drop(&mut self) {
12486        self.control_handle.shutdown();
12487        // Safety: drops once, never accessed again
12488        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12489    }
12490}
12491
12492impl fidl::endpoints::Responder for BaseDatagramSocketSetIpv6UnicastHopsResponder {
12493    type ControlHandle = BaseDatagramSocketControlHandle;
12494
12495    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
12496        &self.control_handle
12497    }
12498
12499    fn drop_without_shutdown(mut self) {
12500        // Safety: drops once, never accessed again due to mem::forget
12501        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12502        // Prevent Drop from running (which would shut down the channel)
12503        std::mem::forget(self);
12504    }
12505}
12506
12507impl BaseDatagramSocketSetIpv6UnicastHopsResponder {
12508    /// Sends a response to the FIDL transaction.
12509    ///
12510    /// Sets the channel to shutdown if an error occurs.
12511    pub fn send(
12512        self,
12513        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12514    ) -> Result<(), fidl::Error> {
12515        let _result = self.send_raw(result);
12516        if _result.is_err() {
12517            self.control_handle.shutdown();
12518        }
12519        self.drop_without_shutdown();
12520        _result
12521    }
12522
12523    /// Similar to "send" but does not shutdown the channel if an error occurs.
12524    pub fn send_no_shutdown_on_err(
12525        self,
12526        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12527    ) -> Result<(), fidl::Error> {
12528        let _result = self.send_raw(result);
12529        self.drop_without_shutdown();
12530        _result
12531    }
12532
12533    fn send_raw(
12534        &self,
12535        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12536    ) -> Result<(), fidl::Error> {
12537        self.control_handle.inner.send::<fidl::encoding::ResultType<
12538            fidl::encoding::EmptyStruct,
12539            fidl_fuchsia_posix::Errno,
12540        >>(
12541            result,
12542            self.tx_id,
12543            0x157d51e98f462859,
12544            fidl::encoding::DynamicFlags::empty(),
12545        )
12546    }
12547}
12548
12549#[must_use = "FIDL methods require a response to be sent"]
12550#[derive(Debug)]
12551pub struct BaseDatagramSocketGetIpv6UnicastHopsResponder {
12552    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
12553    tx_id: u32,
12554}
12555
12556/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
12557/// if the responder is dropped without sending a response, so that the client
12558/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
12559impl std::ops::Drop for BaseDatagramSocketGetIpv6UnicastHopsResponder {
12560    fn drop(&mut self) {
12561        self.control_handle.shutdown();
12562        // Safety: drops once, never accessed again
12563        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12564    }
12565}
12566
12567impl fidl::endpoints::Responder for BaseDatagramSocketGetIpv6UnicastHopsResponder {
12568    type ControlHandle = BaseDatagramSocketControlHandle;
12569
12570    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
12571        &self.control_handle
12572    }
12573
12574    fn drop_without_shutdown(mut self) {
12575        // Safety: drops once, never accessed again due to mem::forget
12576        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12577        // Prevent Drop from running (which would shut down the channel)
12578        std::mem::forget(self);
12579    }
12580}
12581
12582impl BaseDatagramSocketGetIpv6UnicastHopsResponder {
12583    /// Sends a response to the FIDL transaction.
12584    ///
12585    /// Sets the channel to shutdown if an error occurs.
12586    pub fn send(
12587        self,
12588        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
12589    ) -> Result<(), fidl::Error> {
12590        let _result = self.send_raw(result);
12591        if _result.is_err() {
12592            self.control_handle.shutdown();
12593        }
12594        self.drop_without_shutdown();
12595        _result
12596    }
12597
12598    /// Similar to "send" but does not shutdown the channel if an error occurs.
12599    pub fn send_no_shutdown_on_err(
12600        self,
12601        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
12602    ) -> Result<(), fidl::Error> {
12603        let _result = self.send_raw(result);
12604        self.drop_without_shutdown();
12605        _result
12606    }
12607
12608    fn send_raw(
12609        &self,
12610        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
12611    ) -> Result<(), fidl::Error> {
12612        self.control_handle.inner.send::<fidl::encoding::ResultType<
12613            BaseNetworkSocketGetIpv6UnicastHopsResponse,
12614            fidl_fuchsia_posix::Errno,
12615        >>(
12616            result.map(|value| (value,)),
12617            self.tx_id,
12618            0x21f4641cad8bd8d2,
12619            fidl::encoding::DynamicFlags::empty(),
12620        )
12621    }
12622}
12623
12624#[must_use = "FIDL methods require a response to be sent"]
12625#[derive(Debug)]
12626pub struct BaseDatagramSocketSetIpv6ReceiveHopLimitResponder {
12627    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
12628    tx_id: u32,
12629}
12630
12631/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
12632/// if the responder is dropped without sending a response, so that the client
12633/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
12634impl std::ops::Drop for BaseDatagramSocketSetIpv6ReceiveHopLimitResponder {
12635    fn drop(&mut self) {
12636        self.control_handle.shutdown();
12637        // Safety: drops once, never accessed again
12638        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12639    }
12640}
12641
12642impl fidl::endpoints::Responder for BaseDatagramSocketSetIpv6ReceiveHopLimitResponder {
12643    type ControlHandle = BaseDatagramSocketControlHandle;
12644
12645    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
12646        &self.control_handle
12647    }
12648
12649    fn drop_without_shutdown(mut self) {
12650        // Safety: drops once, never accessed again due to mem::forget
12651        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12652        // Prevent Drop from running (which would shut down the channel)
12653        std::mem::forget(self);
12654    }
12655}
12656
12657impl BaseDatagramSocketSetIpv6ReceiveHopLimitResponder {
12658    /// Sends a response to the FIDL transaction.
12659    ///
12660    /// Sets the channel to shutdown if an error occurs.
12661    pub fn send(
12662        self,
12663        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12664    ) -> Result<(), fidl::Error> {
12665        let _result = self.send_raw(result);
12666        if _result.is_err() {
12667            self.control_handle.shutdown();
12668        }
12669        self.drop_without_shutdown();
12670        _result
12671    }
12672
12673    /// Similar to "send" but does not shutdown the channel if an error occurs.
12674    pub fn send_no_shutdown_on_err(
12675        self,
12676        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12677    ) -> Result<(), fidl::Error> {
12678        let _result = self.send_raw(result);
12679        self.drop_without_shutdown();
12680        _result
12681    }
12682
12683    fn send_raw(
12684        &self,
12685        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12686    ) -> Result<(), fidl::Error> {
12687        self.control_handle.inner.send::<fidl::encoding::ResultType<
12688            fidl::encoding::EmptyStruct,
12689            fidl_fuchsia_posix::Errno,
12690        >>(
12691            result,
12692            self.tx_id,
12693            0x5c24808ed2e84a1e,
12694            fidl::encoding::DynamicFlags::empty(),
12695        )
12696    }
12697}
12698
12699#[must_use = "FIDL methods require a response to be sent"]
12700#[derive(Debug)]
12701pub struct BaseDatagramSocketGetIpv6ReceiveHopLimitResponder {
12702    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
12703    tx_id: u32,
12704}
12705
12706/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
12707/// if the responder is dropped without sending a response, so that the client
12708/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
12709impl std::ops::Drop for BaseDatagramSocketGetIpv6ReceiveHopLimitResponder {
12710    fn drop(&mut self) {
12711        self.control_handle.shutdown();
12712        // Safety: drops once, never accessed again
12713        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12714    }
12715}
12716
12717impl fidl::endpoints::Responder for BaseDatagramSocketGetIpv6ReceiveHopLimitResponder {
12718    type ControlHandle = BaseDatagramSocketControlHandle;
12719
12720    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
12721        &self.control_handle
12722    }
12723
12724    fn drop_without_shutdown(mut self) {
12725        // Safety: drops once, never accessed again due to mem::forget
12726        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12727        // Prevent Drop from running (which would shut down the channel)
12728        std::mem::forget(self);
12729    }
12730}
12731
12732impl BaseDatagramSocketGetIpv6ReceiveHopLimitResponder {
12733    /// Sends a response to the FIDL transaction.
12734    ///
12735    /// Sets the channel to shutdown if an error occurs.
12736    pub fn send(
12737        self,
12738        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
12739    ) -> Result<(), fidl::Error> {
12740        let _result = self.send_raw(result);
12741        if _result.is_err() {
12742            self.control_handle.shutdown();
12743        }
12744        self.drop_without_shutdown();
12745        _result
12746    }
12747
12748    /// Similar to "send" but does not shutdown the channel if an error occurs.
12749    pub fn send_no_shutdown_on_err(
12750        self,
12751        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
12752    ) -> Result<(), fidl::Error> {
12753        let _result = self.send_raw(result);
12754        self.drop_without_shutdown();
12755        _result
12756    }
12757
12758    fn send_raw(
12759        &self,
12760        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
12761    ) -> Result<(), fidl::Error> {
12762        self.control_handle.inner.send::<fidl::encoding::ResultType<
12763            BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
12764            fidl_fuchsia_posix::Errno,
12765        >>(
12766            result.map(|value| (value,)),
12767            self.tx_id,
12768            0x341e06689885b4c0,
12769            fidl::encoding::DynamicFlags::empty(),
12770        )
12771    }
12772}
12773
12774#[must_use = "FIDL methods require a response to be sent"]
12775#[derive(Debug)]
12776pub struct BaseDatagramSocketSetIpv6MulticastHopsResponder {
12777    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
12778    tx_id: u32,
12779}
12780
12781/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
12782/// if the responder is dropped without sending a response, so that the client
12783/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
12784impl std::ops::Drop for BaseDatagramSocketSetIpv6MulticastHopsResponder {
12785    fn drop(&mut self) {
12786        self.control_handle.shutdown();
12787        // Safety: drops once, never accessed again
12788        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12789    }
12790}
12791
12792impl fidl::endpoints::Responder for BaseDatagramSocketSetIpv6MulticastHopsResponder {
12793    type ControlHandle = BaseDatagramSocketControlHandle;
12794
12795    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
12796        &self.control_handle
12797    }
12798
12799    fn drop_without_shutdown(mut self) {
12800        // Safety: drops once, never accessed again due to mem::forget
12801        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12802        // Prevent Drop from running (which would shut down the channel)
12803        std::mem::forget(self);
12804    }
12805}
12806
12807impl BaseDatagramSocketSetIpv6MulticastHopsResponder {
12808    /// Sends a response to the FIDL transaction.
12809    ///
12810    /// Sets the channel to shutdown if an error occurs.
12811    pub fn send(
12812        self,
12813        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12814    ) -> Result<(), fidl::Error> {
12815        let _result = self.send_raw(result);
12816        if _result.is_err() {
12817            self.control_handle.shutdown();
12818        }
12819        self.drop_without_shutdown();
12820        _result
12821    }
12822
12823    /// Similar to "send" but does not shutdown the channel if an error occurs.
12824    pub fn send_no_shutdown_on_err(
12825        self,
12826        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12827    ) -> Result<(), fidl::Error> {
12828        let _result = self.send_raw(result);
12829        self.drop_without_shutdown();
12830        _result
12831    }
12832
12833    fn send_raw(
12834        &self,
12835        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12836    ) -> Result<(), fidl::Error> {
12837        self.control_handle.inner.send::<fidl::encoding::ResultType<
12838            fidl::encoding::EmptyStruct,
12839            fidl_fuchsia_posix::Errno,
12840        >>(
12841            result,
12842            self.tx_id,
12843            0x25b9cd4d181f82c1,
12844            fidl::encoding::DynamicFlags::empty(),
12845        )
12846    }
12847}
12848
12849#[must_use = "FIDL methods require a response to be sent"]
12850#[derive(Debug)]
12851pub struct BaseDatagramSocketGetIpv6MulticastHopsResponder {
12852    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
12853    tx_id: u32,
12854}
12855
12856/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
12857/// if the responder is dropped without sending a response, so that the client
12858/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
12859impl std::ops::Drop for BaseDatagramSocketGetIpv6MulticastHopsResponder {
12860    fn drop(&mut self) {
12861        self.control_handle.shutdown();
12862        // Safety: drops once, never accessed again
12863        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12864    }
12865}
12866
12867impl fidl::endpoints::Responder for BaseDatagramSocketGetIpv6MulticastHopsResponder {
12868    type ControlHandle = BaseDatagramSocketControlHandle;
12869
12870    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
12871        &self.control_handle
12872    }
12873
12874    fn drop_without_shutdown(mut self) {
12875        // Safety: drops once, never accessed again due to mem::forget
12876        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12877        // Prevent Drop from running (which would shut down the channel)
12878        std::mem::forget(self);
12879    }
12880}
12881
12882impl BaseDatagramSocketGetIpv6MulticastHopsResponder {
12883    /// Sends a response to the FIDL transaction.
12884    ///
12885    /// Sets the channel to shutdown if an error occurs.
12886    pub fn send(
12887        self,
12888        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
12889    ) -> Result<(), fidl::Error> {
12890        let _result = self.send_raw(result);
12891        if _result.is_err() {
12892            self.control_handle.shutdown();
12893        }
12894        self.drop_without_shutdown();
12895        _result
12896    }
12897
12898    /// Similar to "send" but does not shutdown the channel if an error occurs.
12899    pub fn send_no_shutdown_on_err(
12900        self,
12901        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
12902    ) -> Result<(), fidl::Error> {
12903        let _result = self.send_raw(result);
12904        self.drop_without_shutdown();
12905        _result
12906    }
12907
12908    fn send_raw(
12909        &self,
12910        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
12911    ) -> Result<(), fidl::Error> {
12912        self.control_handle.inner.send::<fidl::encoding::ResultType<
12913            BaseNetworkSocketGetIpv6MulticastHopsResponse,
12914            fidl_fuchsia_posix::Errno,
12915        >>(
12916            result.map(|value| (value,)),
12917            self.tx_id,
12918            0x52916948a365012a,
12919            fidl::encoding::DynamicFlags::empty(),
12920        )
12921    }
12922}
12923
12924#[must_use = "FIDL methods require a response to be sent"]
12925#[derive(Debug)]
12926pub struct BaseDatagramSocketSetIpv6MulticastLoopbackResponder {
12927    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
12928    tx_id: u32,
12929}
12930
12931/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
12932/// if the responder is dropped without sending a response, so that the client
12933/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
12934impl std::ops::Drop for BaseDatagramSocketSetIpv6MulticastLoopbackResponder {
12935    fn drop(&mut self) {
12936        self.control_handle.shutdown();
12937        // Safety: drops once, never accessed again
12938        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12939    }
12940}
12941
12942impl fidl::endpoints::Responder for BaseDatagramSocketSetIpv6MulticastLoopbackResponder {
12943    type ControlHandle = BaseDatagramSocketControlHandle;
12944
12945    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
12946        &self.control_handle
12947    }
12948
12949    fn drop_without_shutdown(mut self) {
12950        // Safety: drops once, never accessed again due to mem::forget
12951        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
12952        // Prevent Drop from running (which would shut down the channel)
12953        std::mem::forget(self);
12954    }
12955}
12956
12957impl BaseDatagramSocketSetIpv6MulticastLoopbackResponder {
12958    /// Sends a response to the FIDL transaction.
12959    ///
12960    /// Sets the channel to shutdown if an error occurs.
12961    pub fn send(
12962        self,
12963        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12964    ) -> Result<(), fidl::Error> {
12965        let _result = self.send_raw(result);
12966        if _result.is_err() {
12967            self.control_handle.shutdown();
12968        }
12969        self.drop_without_shutdown();
12970        _result
12971    }
12972
12973    /// Similar to "send" but does not shutdown the channel if an error occurs.
12974    pub fn send_no_shutdown_on_err(
12975        self,
12976        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12977    ) -> Result<(), fidl::Error> {
12978        let _result = self.send_raw(result);
12979        self.drop_without_shutdown();
12980        _result
12981    }
12982
12983    fn send_raw(
12984        &self,
12985        mut result: Result<(), fidl_fuchsia_posix::Errno>,
12986    ) -> Result<(), fidl::Error> {
12987        self.control_handle.inner.send::<fidl::encoding::ResultType<
12988            fidl::encoding::EmptyStruct,
12989            fidl_fuchsia_posix::Errno,
12990        >>(
12991            result,
12992            self.tx_id,
12993            0x55701c409ff41b40,
12994            fidl::encoding::DynamicFlags::empty(),
12995        )
12996    }
12997}
12998
12999#[must_use = "FIDL methods require a response to be sent"]
13000#[derive(Debug)]
13001pub struct BaseDatagramSocketGetIpv6MulticastLoopbackResponder {
13002    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
13003    tx_id: u32,
13004}
13005
13006/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
13007/// if the responder is dropped without sending a response, so that the client
13008/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
13009impl std::ops::Drop for BaseDatagramSocketGetIpv6MulticastLoopbackResponder {
13010    fn drop(&mut self) {
13011        self.control_handle.shutdown();
13012        // Safety: drops once, never accessed again
13013        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13014    }
13015}
13016
13017impl fidl::endpoints::Responder for BaseDatagramSocketGetIpv6MulticastLoopbackResponder {
13018    type ControlHandle = BaseDatagramSocketControlHandle;
13019
13020    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
13021        &self.control_handle
13022    }
13023
13024    fn drop_without_shutdown(mut self) {
13025        // Safety: drops once, never accessed again due to mem::forget
13026        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13027        // Prevent Drop from running (which would shut down the channel)
13028        std::mem::forget(self);
13029    }
13030}
13031
13032impl BaseDatagramSocketGetIpv6MulticastLoopbackResponder {
13033    /// Sends a response to the FIDL transaction.
13034    ///
13035    /// Sets the channel to shutdown if an error occurs.
13036    pub fn send(
13037        self,
13038        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13039    ) -> Result<(), fidl::Error> {
13040        let _result = self.send_raw(result);
13041        if _result.is_err() {
13042            self.control_handle.shutdown();
13043        }
13044        self.drop_without_shutdown();
13045        _result
13046    }
13047
13048    /// Similar to "send" but does not shutdown the channel if an error occurs.
13049    pub fn send_no_shutdown_on_err(
13050        self,
13051        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13052    ) -> Result<(), fidl::Error> {
13053        let _result = self.send_raw(result);
13054        self.drop_without_shutdown();
13055        _result
13056    }
13057
13058    fn send_raw(
13059        &self,
13060        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13061    ) -> Result<(), fidl::Error> {
13062        self.control_handle.inner.send::<fidl::encoding::ResultType<
13063            BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
13064            fidl_fuchsia_posix::Errno,
13065        >>(
13066            result.map(|value| (value,)),
13067            self.tx_id,
13068            0x4415b701fde319c3,
13069            fidl::encoding::DynamicFlags::empty(),
13070        )
13071    }
13072}
13073
13074#[must_use = "FIDL methods require a response to be sent"]
13075#[derive(Debug)]
13076pub struct BaseDatagramSocketSetIpv6OnlyResponder {
13077    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
13078    tx_id: u32,
13079}
13080
13081/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
13082/// if the responder is dropped without sending a response, so that the client
13083/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
13084impl std::ops::Drop for BaseDatagramSocketSetIpv6OnlyResponder {
13085    fn drop(&mut self) {
13086        self.control_handle.shutdown();
13087        // Safety: drops once, never accessed again
13088        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13089    }
13090}
13091
13092impl fidl::endpoints::Responder for BaseDatagramSocketSetIpv6OnlyResponder {
13093    type ControlHandle = BaseDatagramSocketControlHandle;
13094
13095    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
13096        &self.control_handle
13097    }
13098
13099    fn drop_without_shutdown(mut self) {
13100        // Safety: drops once, never accessed again due to mem::forget
13101        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13102        // Prevent Drop from running (which would shut down the channel)
13103        std::mem::forget(self);
13104    }
13105}
13106
13107impl BaseDatagramSocketSetIpv6OnlyResponder {
13108    /// Sends a response to the FIDL transaction.
13109    ///
13110    /// Sets the channel to shutdown if an error occurs.
13111    pub fn send(
13112        self,
13113        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13114    ) -> Result<(), fidl::Error> {
13115        let _result = self.send_raw(result);
13116        if _result.is_err() {
13117            self.control_handle.shutdown();
13118        }
13119        self.drop_without_shutdown();
13120        _result
13121    }
13122
13123    /// Similar to "send" but does not shutdown the channel if an error occurs.
13124    pub fn send_no_shutdown_on_err(
13125        self,
13126        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13127    ) -> Result<(), fidl::Error> {
13128        let _result = self.send_raw(result);
13129        self.drop_without_shutdown();
13130        _result
13131    }
13132
13133    fn send_raw(
13134        &self,
13135        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13136    ) -> Result<(), fidl::Error> {
13137        self.control_handle.inner.send::<fidl::encoding::ResultType<
13138            fidl::encoding::EmptyStruct,
13139            fidl_fuchsia_posix::Errno,
13140        >>(
13141            result,
13142            self.tx_id,
13143            0x4873f1364758cbba,
13144            fidl::encoding::DynamicFlags::empty(),
13145        )
13146    }
13147}
13148
13149#[must_use = "FIDL methods require a response to be sent"]
13150#[derive(Debug)]
13151pub struct BaseDatagramSocketGetIpv6OnlyResponder {
13152    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
13153    tx_id: u32,
13154}
13155
13156/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
13157/// if the responder is dropped without sending a response, so that the client
13158/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
13159impl std::ops::Drop for BaseDatagramSocketGetIpv6OnlyResponder {
13160    fn drop(&mut self) {
13161        self.control_handle.shutdown();
13162        // Safety: drops once, never accessed again
13163        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13164    }
13165}
13166
13167impl fidl::endpoints::Responder for BaseDatagramSocketGetIpv6OnlyResponder {
13168    type ControlHandle = BaseDatagramSocketControlHandle;
13169
13170    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
13171        &self.control_handle
13172    }
13173
13174    fn drop_without_shutdown(mut self) {
13175        // Safety: drops once, never accessed again due to mem::forget
13176        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13177        // Prevent Drop from running (which would shut down the channel)
13178        std::mem::forget(self);
13179    }
13180}
13181
13182impl BaseDatagramSocketGetIpv6OnlyResponder {
13183    /// Sends a response to the FIDL transaction.
13184    ///
13185    /// Sets the channel to shutdown if an error occurs.
13186    pub fn send(
13187        self,
13188        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13189    ) -> Result<(), fidl::Error> {
13190        let _result = self.send_raw(result);
13191        if _result.is_err() {
13192            self.control_handle.shutdown();
13193        }
13194        self.drop_without_shutdown();
13195        _result
13196    }
13197
13198    /// Similar to "send" but does not shutdown the channel if an error occurs.
13199    pub fn send_no_shutdown_on_err(
13200        self,
13201        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13202    ) -> Result<(), fidl::Error> {
13203        let _result = self.send_raw(result);
13204        self.drop_without_shutdown();
13205        _result
13206    }
13207
13208    fn send_raw(
13209        &self,
13210        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13211    ) -> Result<(), fidl::Error> {
13212        self.control_handle.inner.send::<fidl::encoding::ResultType<
13213            BaseNetworkSocketGetIpv6OnlyResponse,
13214            fidl_fuchsia_posix::Errno,
13215        >>(
13216            result.map(|value| (value,)),
13217            self.tx_id,
13218            0x4aa3340a1a26b89c,
13219            fidl::encoding::DynamicFlags::empty(),
13220        )
13221    }
13222}
13223
13224#[must_use = "FIDL methods require a response to be sent"]
13225#[derive(Debug)]
13226pub struct BaseDatagramSocketSetIpv6ReceiveTrafficClassResponder {
13227    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
13228    tx_id: u32,
13229}
13230
13231/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
13232/// if the responder is dropped without sending a response, so that the client
13233/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
13234impl std::ops::Drop for BaseDatagramSocketSetIpv6ReceiveTrafficClassResponder {
13235    fn drop(&mut self) {
13236        self.control_handle.shutdown();
13237        // Safety: drops once, never accessed again
13238        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13239    }
13240}
13241
13242impl fidl::endpoints::Responder for BaseDatagramSocketSetIpv6ReceiveTrafficClassResponder {
13243    type ControlHandle = BaseDatagramSocketControlHandle;
13244
13245    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
13246        &self.control_handle
13247    }
13248
13249    fn drop_without_shutdown(mut self) {
13250        // Safety: drops once, never accessed again due to mem::forget
13251        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13252        // Prevent Drop from running (which would shut down the channel)
13253        std::mem::forget(self);
13254    }
13255}
13256
13257impl BaseDatagramSocketSetIpv6ReceiveTrafficClassResponder {
13258    /// Sends a response to the FIDL transaction.
13259    ///
13260    /// Sets the channel to shutdown if an error occurs.
13261    pub fn send(
13262        self,
13263        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13264    ) -> Result<(), fidl::Error> {
13265        let _result = self.send_raw(result);
13266        if _result.is_err() {
13267            self.control_handle.shutdown();
13268        }
13269        self.drop_without_shutdown();
13270        _result
13271    }
13272
13273    /// Similar to "send" but does not shutdown the channel if an error occurs.
13274    pub fn send_no_shutdown_on_err(
13275        self,
13276        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13277    ) -> Result<(), fidl::Error> {
13278        let _result = self.send_raw(result);
13279        self.drop_without_shutdown();
13280        _result
13281    }
13282
13283    fn send_raw(
13284        &self,
13285        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13286    ) -> Result<(), fidl::Error> {
13287        self.control_handle.inner.send::<fidl::encoding::ResultType<
13288            fidl::encoding::EmptyStruct,
13289            fidl_fuchsia_posix::Errno,
13290        >>(
13291            result,
13292            self.tx_id,
13293            0x58f07c8788d099a0,
13294            fidl::encoding::DynamicFlags::empty(),
13295        )
13296    }
13297}
13298
13299#[must_use = "FIDL methods require a response to be sent"]
13300#[derive(Debug)]
13301pub struct BaseDatagramSocketGetIpv6ReceiveTrafficClassResponder {
13302    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
13303    tx_id: u32,
13304}
13305
13306/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
13307/// if the responder is dropped without sending a response, so that the client
13308/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
13309impl std::ops::Drop for BaseDatagramSocketGetIpv6ReceiveTrafficClassResponder {
13310    fn drop(&mut self) {
13311        self.control_handle.shutdown();
13312        // Safety: drops once, never accessed again
13313        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13314    }
13315}
13316
13317impl fidl::endpoints::Responder for BaseDatagramSocketGetIpv6ReceiveTrafficClassResponder {
13318    type ControlHandle = BaseDatagramSocketControlHandle;
13319
13320    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
13321        &self.control_handle
13322    }
13323
13324    fn drop_without_shutdown(mut self) {
13325        // Safety: drops once, never accessed again due to mem::forget
13326        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13327        // Prevent Drop from running (which would shut down the channel)
13328        std::mem::forget(self);
13329    }
13330}
13331
13332impl BaseDatagramSocketGetIpv6ReceiveTrafficClassResponder {
13333    /// Sends a response to the FIDL transaction.
13334    ///
13335    /// Sets the channel to shutdown if an error occurs.
13336    pub fn send(
13337        self,
13338        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13339    ) -> Result<(), fidl::Error> {
13340        let _result = self.send_raw(result);
13341        if _result.is_err() {
13342            self.control_handle.shutdown();
13343        }
13344        self.drop_without_shutdown();
13345        _result
13346    }
13347
13348    /// Similar to "send" but does not shutdown the channel if an error occurs.
13349    pub fn send_no_shutdown_on_err(
13350        self,
13351        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13352    ) -> Result<(), fidl::Error> {
13353        let _result = self.send_raw(result);
13354        self.drop_without_shutdown();
13355        _result
13356    }
13357
13358    fn send_raw(
13359        &self,
13360        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13361    ) -> Result<(), fidl::Error> {
13362        self.control_handle.inner.send::<fidl::encoding::ResultType<
13363            BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
13364            fidl_fuchsia_posix::Errno,
13365        >>(
13366            result.map(|value| (value,)),
13367            self.tx_id,
13368            0x2e334df1da553ffa,
13369            fidl::encoding::DynamicFlags::empty(),
13370        )
13371    }
13372}
13373
13374#[must_use = "FIDL methods require a response to be sent"]
13375#[derive(Debug)]
13376pub struct BaseDatagramSocketSetIpv6TrafficClassResponder {
13377    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
13378    tx_id: u32,
13379}
13380
13381/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
13382/// if the responder is dropped without sending a response, so that the client
13383/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
13384impl std::ops::Drop for BaseDatagramSocketSetIpv6TrafficClassResponder {
13385    fn drop(&mut self) {
13386        self.control_handle.shutdown();
13387        // Safety: drops once, never accessed again
13388        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13389    }
13390}
13391
13392impl fidl::endpoints::Responder for BaseDatagramSocketSetIpv6TrafficClassResponder {
13393    type ControlHandle = BaseDatagramSocketControlHandle;
13394
13395    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
13396        &self.control_handle
13397    }
13398
13399    fn drop_without_shutdown(mut self) {
13400        // Safety: drops once, never accessed again due to mem::forget
13401        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13402        // Prevent Drop from running (which would shut down the channel)
13403        std::mem::forget(self);
13404    }
13405}
13406
13407impl BaseDatagramSocketSetIpv6TrafficClassResponder {
13408    /// Sends a response to the FIDL transaction.
13409    ///
13410    /// Sets the channel to shutdown if an error occurs.
13411    pub fn send(
13412        self,
13413        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13414    ) -> Result<(), fidl::Error> {
13415        let _result = self.send_raw(result);
13416        if _result.is_err() {
13417            self.control_handle.shutdown();
13418        }
13419        self.drop_without_shutdown();
13420        _result
13421    }
13422
13423    /// Similar to "send" but does not shutdown the channel if an error occurs.
13424    pub fn send_no_shutdown_on_err(
13425        self,
13426        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13427    ) -> Result<(), fidl::Error> {
13428        let _result = self.send_raw(result);
13429        self.drop_without_shutdown();
13430        _result
13431    }
13432
13433    fn send_raw(
13434        &self,
13435        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13436    ) -> Result<(), fidl::Error> {
13437        self.control_handle.inner.send::<fidl::encoding::ResultType<
13438            fidl::encoding::EmptyStruct,
13439            fidl_fuchsia_posix::Errno,
13440        >>(
13441            result,
13442            self.tx_id,
13443            0x6af077800c5a0b4f,
13444            fidl::encoding::DynamicFlags::empty(),
13445        )
13446    }
13447}
13448
13449#[must_use = "FIDL methods require a response to be sent"]
13450#[derive(Debug)]
13451pub struct BaseDatagramSocketGetIpv6TrafficClassResponder {
13452    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
13453    tx_id: u32,
13454}
13455
13456/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
13457/// if the responder is dropped without sending a response, so that the client
13458/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
13459impl std::ops::Drop for BaseDatagramSocketGetIpv6TrafficClassResponder {
13460    fn drop(&mut self) {
13461        self.control_handle.shutdown();
13462        // Safety: drops once, never accessed again
13463        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13464    }
13465}
13466
13467impl fidl::endpoints::Responder for BaseDatagramSocketGetIpv6TrafficClassResponder {
13468    type ControlHandle = BaseDatagramSocketControlHandle;
13469
13470    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
13471        &self.control_handle
13472    }
13473
13474    fn drop_without_shutdown(mut self) {
13475        // Safety: drops once, never accessed again due to mem::forget
13476        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13477        // Prevent Drop from running (which would shut down the channel)
13478        std::mem::forget(self);
13479    }
13480}
13481
13482impl BaseDatagramSocketGetIpv6TrafficClassResponder {
13483    /// Sends a response to the FIDL transaction.
13484    ///
13485    /// Sets the channel to shutdown if an error occurs.
13486    pub fn send(
13487        self,
13488        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
13489    ) -> Result<(), fidl::Error> {
13490        let _result = self.send_raw(result);
13491        if _result.is_err() {
13492            self.control_handle.shutdown();
13493        }
13494        self.drop_without_shutdown();
13495        _result
13496    }
13497
13498    /// Similar to "send" but does not shutdown the channel if an error occurs.
13499    pub fn send_no_shutdown_on_err(
13500        self,
13501        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
13502    ) -> Result<(), fidl::Error> {
13503        let _result = self.send_raw(result);
13504        self.drop_without_shutdown();
13505        _result
13506    }
13507
13508    fn send_raw(
13509        &self,
13510        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
13511    ) -> Result<(), fidl::Error> {
13512        self.control_handle.inner.send::<fidl::encoding::ResultType<
13513            BaseNetworkSocketGetIpv6TrafficClassResponse,
13514            fidl_fuchsia_posix::Errno,
13515        >>(
13516            result.map(|value| (value,)),
13517            self.tx_id,
13518            0x6baf6eed8fc2f04,
13519            fidl::encoding::DynamicFlags::empty(),
13520        )
13521    }
13522}
13523
13524#[must_use = "FIDL methods require a response to be sent"]
13525#[derive(Debug)]
13526pub struct BaseDatagramSocketSetIpv6ReceivePacketInfoResponder {
13527    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
13528    tx_id: u32,
13529}
13530
13531/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
13532/// if the responder is dropped without sending a response, so that the client
13533/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
13534impl std::ops::Drop for BaseDatagramSocketSetIpv6ReceivePacketInfoResponder {
13535    fn drop(&mut self) {
13536        self.control_handle.shutdown();
13537        // Safety: drops once, never accessed again
13538        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13539    }
13540}
13541
13542impl fidl::endpoints::Responder for BaseDatagramSocketSetIpv6ReceivePacketInfoResponder {
13543    type ControlHandle = BaseDatagramSocketControlHandle;
13544
13545    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
13546        &self.control_handle
13547    }
13548
13549    fn drop_without_shutdown(mut self) {
13550        // Safety: drops once, never accessed again due to mem::forget
13551        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13552        // Prevent Drop from running (which would shut down the channel)
13553        std::mem::forget(self);
13554    }
13555}
13556
13557impl BaseDatagramSocketSetIpv6ReceivePacketInfoResponder {
13558    /// Sends a response to the FIDL transaction.
13559    ///
13560    /// Sets the channel to shutdown if an error occurs.
13561    pub fn send(
13562        self,
13563        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13564    ) -> Result<(), fidl::Error> {
13565        let _result = self.send_raw(result);
13566        if _result.is_err() {
13567            self.control_handle.shutdown();
13568        }
13569        self.drop_without_shutdown();
13570        _result
13571    }
13572
13573    /// Similar to "send" but does not shutdown the channel if an error occurs.
13574    pub fn send_no_shutdown_on_err(
13575        self,
13576        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13577    ) -> Result<(), fidl::Error> {
13578        let _result = self.send_raw(result);
13579        self.drop_without_shutdown();
13580        _result
13581    }
13582
13583    fn send_raw(
13584        &self,
13585        mut result: Result<(), fidl_fuchsia_posix::Errno>,
13586    ) -> Result<(), fidl::Error> {
13587        self.control_handle.inner.send::<fidl::encoding::ResultType<
13588            fidl::encoding::EmptyStruct,
13589            fidl_fuchsia_posix::Errno,
13590        >>(
13591            result,
13592            self.tx_id,
13593            0x19259775b1a92768,
13594            fidl::encoding::DynamicFlags::empty(),
13595        )
13596    }
13597}
13598
13599#[must_use = "FIDL methods require a response to be sent"]
13600#[derive(Debug)]
13601pub struct BaseDatagramSocketGetIpv6ReceivePacketInfoResponder {
13602    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
13603    tx_id: u32,
13604}
13605
13606/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
13607/// if the responder is dropped without sending a response, so that the client
13608/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
13609impl std::ops::Drop for BaseDatagramSocketGetIpv6ReceivePacketInfoResponder {
13610    fn drop(&mut self) {
13611        self.control_handle.shutdown();
13612        // Safety: drops once, never accessed again
13613        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13614    }
13615}
13616
13617impl fidl::endpoints::Responder for BaseDatagramSocketGetIpv6ReceivePacketInfoResponder {
13618    type ControlHandle = BaseDatagramSocketControlHandle;
13619
13620    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
13621        &self.control_handle
13622    }
13623
13624    fn drop_without_shutdown(mut self) {
13625        // Safety: drops once, never accessed again due to mem::forget
13626        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13627        // Prevent Drop from running (which would shut down the channel)
13628        std::mem::forget(self);
13629    }
13630}
13631
13632impl BaseDatagramSocketGetIpv6ReceivePacketInfoResponder {
13633    /// Sends a response to the FIDL transaction.
13634    ///
13635    /// Sets the channel to shutdown if an error occurs.
13636    pub fn send(
13637        self,
13638        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13639    ) -> Result<(), fidl::Error> {
13640        let _result = self.send_raw(result);
13641        if _result.is_err() {
13642            self.control_handle.shutdown();
13643        }
13644        self.drop_without_shutdown();
13645        _result
13646    }
13647
13648    /// Similar to "send" but does not shutdown the channel if an error occurs.
13649    pub fn send_no_shutdown_on_err(
13650        self,
13651        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13652    ) -> Result<(), fidl::Error> {
13653        let _result = self.send_raw(result);
13654        self.drop_without_shutdown();
13655        _result
13656    }
13657
13658    fn send_raw(
13659        &self,
13660        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
13661    ) -> Result<(), fidl::Error> {
13662        self.control_handle.inner.send::<fidl::encoding::ResultType<
13663            BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
13664            fidl_fuchsia_posix::Errno,
13665        >>(
13666            result.map(|value| (value,)),
13667            self.tx_id,
13668            0x7acd4a2775baec75,
13669            fidl::encoding::DynamicFlags::empty(),
13670        )
13671    }
13672}
13673
13674#[must_use = "FIDL methods require a response to be sent"]
13675#[derive(Debug)]
13676pub struct BaseDatagramSocketGetOriginalDestinationResponder {
13677    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
13678    tx_id: u32,
13679}
13680
13681/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
13682/// if the responder is dropped without sending a response, so that the client
13683/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
13684impl std::ops::Drop for BaseDatagramSocketGetOriginalDestinationResponder {
13685    fn drop(&mut self) {
13686        self.control_handle.shutdown();
13687        // Safety: drops once, never accessed again
13688        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13689    }
13690}
13691
13692impl fidl::endpoints::Responder for BaseDatagramSocketGetOriginalDestinationResponder {
13693    type ControlHandle = BaseDatagramSocketControlHandle;
13694
13695    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
13696        &self.control_handle
13697    }
13698
13699    fn drop_without_shutdown(mut self) {
13700        // Safety: drops once, never accessed again due to mem::forget
13701        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13702        // Prevent Drop from running (which would shut down the channel)
13703        std::mem::forget(self);
13704    }
13705}
13706
13707impl BaseDatagramSocketGetOriginalDestinationResponder {
13708    /// Sends a response to the FIDL transaction.
13709    ///
13710    /// Sets the channel to shutdown if an error occurs.
13711    pub fn send(
13712        self,
13713        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
13714    ) -> Result<(), fidl::Error> {
13715        let _result = self.send_raw(result);
13716        if _result.is_err() {
13717            self.control_handle.shutdown();
13718        }
13719        self.drop_without_shutdown();
13720        _result
13721    }
13722
13723    /// Similar to "send" but does not shutdown the channel if an error occurs.
13724    pub fn send_no_shutdown_on_err(
13725        self,
13726        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
13727    ) -> Result<(), fidl::Error> {
13728        let _result = self.send_raw(result);
13729        self.drop_without_shutdown();
13730        _result
13731    }
13732
13733    fn send_raw(
13734        &self,
13735        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
13736    ) -> Result<(), fidl::Error> {
13737        self.control_handle.inner.send::<fidl::encoding::ResultType<
13738            BaseNetworkSocketGetOriginalDestinationResponse,
13739            fidl_fuchsia_posix::Errno,
13740        >>(
13741            result.map(|value| (value,)),
13742            self.tx_id,
13743            0x38bf28f0dafdbac0,
13744            fidl::encoding::DynamicFlags::empty(),
13745        )
13746    }
13747}
13748
13749#[must_use = "FIDL methods require a response to be sent"]
13750#[derive(Debug)]
13751pub struct BaseDatagramSocketGetInfoResponder {
13752    control_handle: std::mem::ManuallyDrop<BaseDatagramSocketControlHandle>,
13753    tx_id: u32,
13754}
13755
13756/// Set the the channel to be shutdown (see [`BaseDatagramSocketControlHandle::shutdown`])
13757/// if the responder is dropped without sending a response, so that the client
13758/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
13759impl std::ops::Drop for BaseDatagramSocketGetInfoResponder {
13760    fn drop(&mut self) {
13761        self.control_handle.shutdown();
13762        // Safety: drops once, never accessed again
13763        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13764    }
13765}
13766
13767impl fidl::endpoints::Responder for BaseDatagramSocketGetInfoResponder {
13768    type ControlHandle = BaseDatagramSocketControlHandle;
13769
13770    fn control_handle(&self) -> &BaseDatagramSocketControlHandle {
13771        &self.control_handle
13772    }
13773
13774    fn drop_without_shutdown(mut self) {
13775        // Safety: drops once, never accessed again due to mem::forget
13776        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
13777        // Prevent Drop from running (which would shut down the channel)
13778        std::mem::forget(self);
13779    }
13780}
13781
13782impl BaseDatagramSocketGetInfoResponder {
13783    /// Sends a response to the FIDL transaction.
13784    ///
13785    /// Sets the channel to shutdown if an error occurs.
13786    pub fn send(
13787        self,
13788        mut result: Result<(Domain, DatagramSocketProtocol), fidl_fuchsia_posix::Errno>,
13789    ) -> Result<(), fidl::Error> {
13790        let _result = self.send_raw(result);
13791        if _result.is_err() {
13792            self.control_handle.shutdown();
13793        }
13794        self.drop_without_shutdown();
13795        _result
13796    }
13797
13798    /// Similar to "send" but does not shutdown the channel if an error occurs.
13799    pub fn send_no_shutdown_on_err(
13800        self,
13801        mut result: Result<(Domain, DatagramSocketProtocol), fidl_fuchsia_posix::Errno>,
13802    ) -> Result<(), fidl::Error> {
13803        let _result = self.send_raw(result);
13804        self.drop_without_shutdown();
13805        _result
13806    }
13807
13808    fn send_raw(
13809        &self,
13810        mut result: Result<(Domain, DatagramSocketProtocol), fidl_fuchsia_posix::Errno>,
13811    ) -> Result<(), fidl::Error> {
13812        self.control_handle.inner.send::<fidl::encoding::ResultType<
13813            BaseDatagramSocketGetInfoResponse,
13814            fidl_fuchsia_posix::Errno,
13815        >>(
13816            result,
13817            self.tx_id,
13818            0x48aa0a1f6a32d2ed,
13819            fidl::encoding::DynamicFlags::empty(),
13820        )
13821    }
13822}
13823
13824#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
13825pub struct BaseNetworkSocketMarker;
13826
13827impl fidl::endpoints::ProtocolMarker for BaseNetworkSocketMarker {
13828    type Proxy = BaseNetworkSocketProxy;
13829    type RequestStream = BaseNetworkSocketRequestStream;
13830    #[cfg(target_os = "fuchsia")]
13831    type SynchronousProxy = BaseNetworkSocketSynchronousProxy;
13832
13833    const DEBUG_NAME: &'static str = "(anonymous) BaseNetworkSocket";
13834}
13835pub type BaseNetworkSocketBindResult = Result<(), fidl_fuchsia_posix::Errno>;
13836pub type BaseNetworkSocketConnectResult = Result<(), fidl_fuchsia_posix::Errno>;
13837pub type BaseNetworkSocketDisconnectResult = Result<(), fidl_fuchsia_posix::Errno>;
13838pub type BaseNetworkSocketGetSockNameResult =
13839    Result<fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>;
13840pub type BaseNetworkSocketGetPeerNameResult =
13841    Result<fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>;
13842pub type BaseNetworkSocketShutdownResult = Result<(), fidl_fuchsia_posix::Errno>;
13843pub type BaseNetworkSocketSetIpTypeOfServiceResult = Result<(), fidl_fuchsia_posix::Errno>;
13844pub type BaseNetworkSocketGetIpTypeOfServiceResult = Result<u8, fidl_fuchsia_posix::Errno>;
13845pub type BaseNetworkSocketSetIpTtlResult = Result<(), fidl_fuchsia_posix::Errno>;
13846pub type BaseNetworkSocketGetIpTtlResult = Result<u8, fidl_fuchsia_posix::Errno>;
13847pub type BaseNetworkSocketSetIpPacketInfoResult = Result<(), fidl_fuchsia_posix::Errno>;
13848pub type BaseNetworkSocketGetIpPacketInfoResult = Result<bool, fidl_fuchsia_posix::Errno>;
13849pub type BaseNetworkSocketSetIpReceiveTypeOfServiceResult = Result<(), fidl_fuchsia_posix::Errno>;
13850pub type BaseNetworkSocketGetIpReceiveTypeOfServiceResult = Result<bool, fidl_fuchsia_posix::Errno>;
13851pub type BaseNetworkSocketSetIpReceiveTtlResult = Result<(), fidl_fuchsia_posix::Errno>;
13852pub type BaseNetworkSocketGetIpReceiveTtlResult = Result<bool, fidl_fuchsia_posix::Errno>;
13853pub type BaseNetworkSocketSetIpMulticastInterfaceResult = Result<(), fidl_fuchsia_posix::Errno>;
13854pub type BaseNetworkSocketGetIpMulticastInterfaceResult =
13855    Result<fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>;
13856pub type BaseNetworkSocketSetIpMulticastTtlResult = Result<(), fidl_fuchsia_posix::Errno>;
13857pub type BaseNetworkSocketGetIpMulticastTtlResult = Result<u8, fidl_fuchsia_posix::Errno>;
13858pub type BaseNetworkSocketSetIpMulticastLoopbackResult = Result<(), fidl_fuchsia_posix::Errno>;
13859pub type BaseNetworkSocketGetIpMulticastLoopbackResult = Result<bool, fidl_fuchsia_posix::Errno>;
13860pub type BaseNetworkSocketAddIpMembershipResult = Result<(), fidl_fuchsia_posix::Errno>;
13861pub type BaseNetworkSocketDropIpMembershipResult = Result<(), fidl_fuchsia_posix::Errno>;
13862pub type BaseNetworkSocketSetIpTransparentResult = Result<(), fidl_fuchsia_posix::Errno>;
13863pub type BaseNetworkSocketGetIpTransparentResult = Result<bool, fidl_fuchsia_posix::Errno>;
13864pub type BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult =
13865    Result<(), fidl_fuchsia_posix::Errno>;
13866pub type BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult =
13867    Result<bool, fidl_fuchsia_posix::Errno>;
13868pub type BaseNetworkSocketAddIpv6MembershipResult = Result<(), fidl_fuchsia_posix::Errno>;
13869pub type BaseNetworkSocketDropIpv6MembershipResult = Result<(), fidl_fuchsia_posix::Errno>;
13870pub type BaseNetworkSocketSetIpv6MulticastInterfaceResult = Result<(), fidl_fuchsia_posix::Errno>;
13871pub type BaseNetworkSocketGetIpv6MulticastInterfaceResult = Result<u64, fidl_fuchsia_posix::Errno>;
13872pub type BaseNetworkSocketSetIpv6UnicastHopsResult = Result<(), fidl_fuchsia_posix::Errno>;
13873pub type BaseNetworkSocketGetIpv6UnicastHopsResult = Result<u8, fidl_fuchsia_posix::Errno>;
13874pub type BaseNetworkSocketSetIpv6ReceiveHopLimitResult = Result<(), fidl_fuchsia_posix::Errno>;
13875pub type BaseNetworkSocketGetIpv6ReceiveHopLimitResult = Result<bool, fidl_fuchsia_posix::Errno>;
13876pub type BaseNetworkSocketSetIpv6MulticastHopsResult = Result<(), fidl_fuchsia_posix::Errno>;
13877pub type BaseNetworkSocketGetIpv6MulticastHopsResult = Result<u8, fidl_fuchsia_posix::Errno>;
13878pub type BaseNetworkSocketSetIpv6MulticastLoopbackResult = Result<(), fidl_fuchsia_posix::Errno>;
13879pub type BaseNetworkSocketGetIpv6MulticastLoopbackResult = Result<bool, fidl_fuchsia_posix::Errno>;
13880pub type BaseNetworkSocketSetIpv6OnlyResult = Result<(), fidl_fuchsia_posix::Errno>;
13881pub type BaseNetworkSocketGetIpv6OnlyResult = Result<bool, fidl_fuchsia_posix::Errno>;
13882pub type BaseNetworkSocketSetIpv6ReceiveTrafficClassResult = Result<(), fidl_fuchsia_posix::Errno>;
13883pub type BaseNetworkSocketGetIpv6ReceiveTrafficClassResult =
13884    Result<bool, fidl_fuchsia_posix::Errno>;
13885pub type BaseNetworkSocketSetIpv6TrafficClassResult = Result<(), fidl_fuchsia_posix::Errno>;
13886pub type BaseNetworkSocketGetIpv6TrafficClassResult = Result<u8, fidl_fuchsia_posix::Errno>;
13887pub type BaseNetworkSocketSetIpv6ReceivePacketInfoResult = Result<(), fidl_fuchsia_posix::Errno>;
13888pub type BaseNetworkSocketGetIpv6ReceivePacketInfoResult = Result<bool, fidl_fuchsia_posix::Errno>;
13889pub type BaseNetworkSocketGetOriginalDestinationResult =
13890    Result<fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>;
13891
13892pub trait BaseNetworkSocketProxyInterface: Send + Sync {
13893    fn r#clone(
13894        &self,
13895        request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
13896    ) -> Result<(), fidl::Error>;
13897    type CloseResponseFut: std::future::Future<
13898            Output = Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error>,
13899        > + Send;
13900    fn r#close(&self) -> Self::CloseResponseFut;
13901    type QueryResponseFut: std::future::Future<Output = Result<Vec<u8>, fidl::Error>> + Send;
13902    fn r#query(&self) -> Self::QueryResponseFut;
13903    type SetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketSetReuseAddressResult, fidl::Error>>
13904        + Send;
13905    fn r#set_reuse_address(&self, value: bool) -> Self::SetReuseAddressResponseFut;
13906    type GetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketGetReuseAddressResult, fidl::Error>>
13907        + Send;
13908    fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut;
13909    type GetErrorResponseFut: std::future::Future<Output = Result<BaseSocketGetErrorResult, fidl::Error>>
13910        + Send;
13911    fn r#get_error(&self) -> Self::GetErrorResponseFut;
13912    type SetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketSetBroadcastResult, fidl::Error>>
13913        + Send;
13914    fn r#set_broadcast(&self, value: bool) -> Self::SetBroadcastResponseFut;
13915    type GetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketGetBroadcastResult, fidl::Error>>
13916        + Send;
13917    fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut;
13918    type SetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetSendBufferResult, fidl::Error>>
13919        + Send;
13920    fn r#set_send_buffer(&self, value_bytes: u64) -> Self::SetSendBufferResponseFut;
13921    type GetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetSendBufferResult, fidl::Error>>
13922        + Send;
13923    fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut;
13924    type SetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetReceiveBufferResult, fidl::Error>>
13925        + Send;
13926    fn r#set_receive_buffer(&self, value_bytes: u64) -> Self::SetReceiveBufferResponseFut;
13927    type GetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetReceiveBufferResult, fidl::Error>>
13928        + Send;
13929    fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut;
13930    type SetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketSetKeepAliveResult, fidl::Error>>
13931        + Send;
13932    fn r#set_keep_alive(&self, value: bool) -> Self::SetKeepAliveResponseFut;
13933    type GetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketGetKeepAliveResult, fidl::Error>>
13934        + Send;
13935    fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut;
13936    type SetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketSetOutOfBandInlineResult, fidl::Error>>
13937        + Send;
13938    fn r#set_out_of_band_inline(&self, value: bool) -> Self::SetOutOfBandInlineResponseFut;
13939    type GetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketGetOutOfBandInlineResult, fidl::Error>>
13940        + Send;
13941    fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut;
13942    type SetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketSetNoCheckResult, fidl::Error>>
13943        + Send;
13944    fn r#set_no_check(&self, value: bool) -> Self::SetNoCheckResponseFut;
13945    type GetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketGetNoCheckResult, fidl::Error>>
13946        + Send;
13947    fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut;
13948    type SetLingerResponseFut: std::future::Future<Output = Result<BaseSocketSetLingerResult, fidl::Error>>
13949        + Send;
13950    fn r#set_linger(&self, linger: bool, length_secs: u32) -> Self::SetLingerResponseFut;
13951    type GetLingerResponseFut: std::future::Future<Output = Result<BaseSocketGetLingerResult, fidl::Error>>
13952        + Send;
13953    fn r#get_linger(&self) -> Self::GetLingerResponseFut;
13954    type SetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketSetReusePortResult, fidl::Error>>
13955        + Send;
13956    fn r#set_reuse_port(&self, value: bool) -> Self::SetReusePortResponseFut;
13957    type GetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketGetReusePortResult, fidl::Error>>
13958        + Send;
13959    fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut;
13960    type GetAcceptConnResponseFut: std::future::Future<Output = Result<BaseSocketGetAcceptConnResult, fidl::Error>>
13961        + Send;
13962    fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut;
13963    type SetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToDeviceResult, fidl::Error>>
13964        + Send;
13965    fn r#set_bind_to_device(&self, value: &str) -> Self::SetBindToDeviceResponseFut;
13966    type GetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToDeviceResult, fidl::Error>>
13967        + Send;
13968    fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut;
13969    type SetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error>>
13970        + Send;
13971    fn r#set_bind_to_interface_index(&self, value: u64)
13972        -> Self::SetBindToInterfaceIndexResponseFut;
13973    type GetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error>>
13974        + Send;
13975    fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut;
13976    type SetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketSetTimestampResult, fidl::Error>>
13977        + Send;
13978    fn r#set_timestamp(&self, value: TimestampOption) -> Self::SetTimestampResponseFut;
13979    type GetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketGetTimestampResult, fidl::Error>>
13980        + Send;
13981    fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut;
13982    type SetMarkResponseFut: std::future::Future<Output = Result<BaseSocketSetMarkResult, fidl::Error>>
13983        + Send;
13984    fn r#set_mark(
13985        &self,
13986        domain: fidl_fuchsia_net::MarkDomain,
13987        mark: &OptionalUint32,
13988    ) -> Self::SetMarkResponseFut;
13989    type GetMarkResponseFut: std::future::Future<Output = Result<BaseSocketGetMarkResult, fidl::Error>>
13990        + Send;
13991    fn r#get_mark(&self, domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut;
13992    type BindResponseFut: std::future::Future<Output = Result<BaseNetworkSocketBindResult, fidl::Error>>
13993        + Send;
13994    fn r#bind(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut;
13995    type ConnectResponseFut: std::future::Future<Output = Result<BaseNetworkSocketConnectResult, fidl::Error>>
13996        + Send;
13997    fn r#connect(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut;
13998    type DisconnectResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDisconnectResult, fidl::Error>>
13999        + Send;
14000    fn r#disconnect(&self) -> Self::DisconnectResponseFut;
14001    type GetSockNameResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetSockNameResult, fidl::Error>>
14002        + Send;
14003    fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut;
14004    type GetPeerNameResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetPeerNameResult, fidl::Error>>
14005        + Send;
14006    fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut;
14007    type ShutdownResponseFut: std::future::Future<Output = Result<BaseNetworkSocketShutdownResult, fidl::Error>>
14008        + Send;
14009    fn r#shutdown(&self, mode: ShutdownMode) -> Self::ShutdownResponseFut;
14010    type SetIpTypeOfServiceResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error>>
14011        + Send;
14012    fn r#set_ip_type_of_service(&self, value: u8) -> Self::SetIpTypeOfServiceResponseFut;
14013    type GetIpTypeOfServiceResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error>>
14014        + Send;
14015    fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut;
14016    type SetIpTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTtlResult, fidl::Error>>
14017        + Send;
14018    fn r#set_ip_ttl(&self, value: &OptionalUint8) -> Self::SetIpTtlResponseFut;
14019    type GetIpTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTtlResult, fidl::Error>>
14020        + Send;
14021    fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut;
14022    type SetIpPacketInfoResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error>>
14023        + Send;
14024    fn r#set_ip_packet_info(&self, value: bool) -> Self::SetIpPacketInfoResponseFut;
14025    type GetIpPacketInfoResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error>>
14026        + Send;
14027    fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut;
14028    type SetIpReceiveTypeOfServiceResponseFut: std::future::Future<
14029            Output = Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error>,
14030        > + Send;
14031    fn r#set_ip_receive_type_of_service(
14032        &self,
14033        value: bool,
14034    ) -> Self::SetIpReceiveTypeOfServiceResponseFut;
14035    type GetIpReceiveTypeOfServiceResponseFut: std::future::Future<
14036            Output = Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error>,
14037        > + Send;
14038    fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut;
14039    type SetIpReceiveTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error>>
14040        + Send;
14041    fn r#set_ip_receive_ttl(&self, value: bool) -> Self::SetIpReceiveTtlResponseFut;
14042    type GetIpReceiveTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error>>
14043        + Send;
14044    fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut;
14045    type SetIpMulticastInterfaceResponseFut: std::future::Future<
14046            Output = Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error>,
14047        > + Send;
14048    fn r#set_ip_multicast_interface(
14049        &self,
14050        iface: u64,
14051        address: &fidl_fuchsia_net::Ipv4Address,
14052    ) -> Self::SetIpMulticastInterfaceResponseFut;
14053    type GetIpMulticastInterfaceResponseFut: std::future::Future<
14054            Output = Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error>,
14055        > + Send;
14056    fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut;
14057    type SetIpMulticastTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error>>
14058        + Send;
14059    fn r#set_ip_multicast_ttl(&self, value: &OptionalUint8) -> Self::SetIpMulticastTtlResponseFut;
14060    type GetIpMulticastTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error>>
14061        + Send;
14062    fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut;
14063    type SetIpMulticastLoopbackResponseFut: std::future::Future<
14064            Output = Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error>,
14065        > + Send;
14066    fn r#set_ip_multicast_loopback(&self, value: bool) -> Self::SetIpMulticastLoopbackResponseFut;
14067    type GetIpMulticastLoopbackResponseFut: std::future::Future<
14068            Output = Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error>,
14069        > + Send;
14070    fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut;
14071    type AddIpMembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error>>
14072        + Send;
14073    fn r#add_ip_membership(
14074        &self,
14075        membership: &IpMulticastMembership,
14076    ) -> Self::AddIpMembershipResponseFut;
14077    type DropIpMembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error>>
14078        + Send;
14079    fn r#drop_ip_membership(
14080        &self,
14081        membership: &IpMulticastMembership,
14082    ) -> Self::DropIpMembershipResponseFut;
14083    type SetIpTransparentResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error>>
14084        + Send;
14085    fn r#set_ip_transparent(&self, value: bool) -> Self::SetIpTransparentResponseFut;
14086    type GetIpTransparentResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error>>
14087        + Send;
14088    fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut;
14089    type SetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<
14090            Output = Result<
14091                BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
14092                fidl::Error,
14093            >,
14094        > + Send;
14095    fn r#set_ip_receive_original_destination_address(
14096        &self,
14097        value: bool,
14098    ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut;
14099    type GetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<
14100            Output = Result<
14101                BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
14102                fidl::Error,
14103            >,
14104        > + Send;
14105    fn r#get_ip_receive_original_destination_address(
14106        &self,
14107    ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut;
14108    type AddIpv6MembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error>>
14109        + Send;
14110    fn r#add_ipv6_membership(
14111        &self,
14112        membership: &Ipv6MulticastMembership,
14113    ) -> Self::AddIpv6MembershipResponseFut;
14114    type DropIpv6MembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error>>
14115        + Send;
14116    fn r#drop_ipv6_membership(
14117        &self,
14118        membership: &Ipv6MulticastMembership,
14119    ) -> Self::DropIpv6MembershipResponseFut;
14120    type SetIpv6MulticastInterfaceResponseFut: std::future::Future<
14121            Output = Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error>,
14122        > + Send;
14123    fn r#set_ipv6_multicast_interface(
14124        &self,
14125        value: u64,
14126    ) -> Self::SetIpv6MulticastInterfaceResponseFut;
14127    type GetIpv6MulticastInterfaceResponseFut: std::future::Future<
14128            Output = Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error>,
14129        > + Send;
14130    fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut;
14131    type SetIpv6UnicastHopsResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error>>
14132        + Send;
14133    fn r#set_ipv6_unicast_hops(&self, value: &OptionalUint8)
14134        -> Self::SetIpv6UnicastHopsResponseFut;
14135    type GetIpv6UnicastHopsResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error>>
14136        + Send;
14137    fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut;
14138    type SetIpv6ReceiveHopLimitResponseFut: std::future::Future<
14139            Output = Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error>,
14140        > + Send;
14141    fn r#set_ipv6_receive_hop_limit(&self, value: bool) -> Self::SetIpv6ReceiveHopLimitResponseFut;
14142    type GetIpv6ReceiveHopLimitResponseFut: std::future::Future<
14143            Output = Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error>,
14144        > + Send;
14145    fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut;
14146    type SetIpv6MulticastHopsResponseFut: std::future::Future<
14147            Output = Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error>,
14148        > + Send;
14149    fn r#set_ipv6_multicast_hops(
14150        &self,
14151        value: &OptionalUint8,
14152    ) -> Self::SetIpv6MulticastHopsResponseFut;
14153    type GetIpv6MulticastHopsResponseFut: std::future::Future<
14154            Output = Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error>,
14155        > + Send;
14156    fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut;
14157    type SetIpv6MulticastLoopbackResponseFut: std::future::Future<
14158            Output = Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error>,
14159        > + Send;
14160    fn r#set_ipv6_multicast_loopback(
14161        &self,
14162        value: bool,
14163    ) -> Self::SetIpv6MulticastLoopbackResponseFut;
14164    type GetIpv6MulticastLoopbackResponseFut: std::future::Future<
14165            Output = Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error>,
14166        > + Send;
14167    fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut;
14168    type SetIpv6OnlyResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error>>
14169        + Send;
14170    fn r#set_ipv6_only(&self, value: bool) -> Self::SetIpv6OnlyResponseFut;
14171    type GetIpv6OnlyResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error>>
14172        + Send;
14173    fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut;
14174    type SetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
14175            Output = Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error>,
14176        > + Send;
14177    fn r#set_ipv6_receive_traffic_class(
14178        &self,
14179        value: bool,
14180    ) -> Self::SetIpv6ReceiveTrafficClassResponseFut;
14181    type GetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
14182            Output = Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error>,
14183        > + Send;
14184    fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut;
14185    type SetIpv6TrafficClassResponseFut: std::future::Future<
14186            Output = Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error>,
14187        > + Send;
14188    fn r#set_ipv6_traffic_class(
14189        &self,
14190        value: &OptionalUint8,
14191    ) -> Self::SetIpv6TrafficClassResponseFut;
14192    type GetIpv6TrafficClassResponseFut: std::future::Future<
14193            Output = Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error>,
14194        > + Send;
14195    fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut;
14196    type SetIpv6ReceivePacketInfoResponseFut: std::future::Future<
14197            Output = Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error>,
14198        > + Send;
14199    fn r#set_ipv6_receive_packet_info(
14200        &self,
14201        value: bool,
14202    ) -> Self::SetIpv6ReceivePacketInfoResponseFut;
14203    type GetIpv6ReceivePacketInfoResponseFut: std::future::Future<
14204            Output = Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error>,
14205        > + Send;
14206    fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut;
14207    type GetOriginalDestinationResponseFut: std::future::Future<
14208            Output = Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error>,
14209        > + Send;
14210    fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut;
14211}
14212#[derive(Debug)]
14213#[cfg(target_os = "fuchsia")]
14214pub struct BaseNetworkSocketSynchronousProxy {
14215    client: fidl::client::sync::Client,
14216}
14217
14218#[cfg(target_os = "fuchsia")]
14219impl fidl::endpoints::SynchronousProxy for BaseNetworkSocketSynchronousProxy {
14220    type Proxy = BaseNetworkSocketProxy;
14221    type Protocol = BaseNetworkSocketMarker;
14222
14223    fn from_channel(inner: fidl::Channel) -> Self {
14224        Self::new(inner)
14225    }
14226
14227    fn into_channel(self) -> fidl::Channel {
14228        self.client.into_channel()
14229    }
14230
14231    fn as_channel(&self) -> &fidl::Channel {
14232        self.client.as_channel()
14233    }
14234}
14235
14236#[cfg(target_os = "fuchsia")]
14237impl BaseNetworkSocketSynchronousProxy {
14238    pub fn new(channel: fidl::Channel) -> Self {
14239        let protocol_name =
14240            <BaseNetworkSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
14241        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
14242    }
14243
14244    pub fn into_channel(self) -> fidl::Channel {
14245        self.client.into_channel()
14246    }
14247
14248    /// Waits until an event arrives and returns it. It is safe for other
14249    /// threads to make concurrent requests while waiting for an event.
14250    pub fn wait_for_event(
14251        &self,
14252        deadline: zx::MonotonicInstant,
14253    ) -> Result<BaseNetworkSocketEvent, fidl::Error> {
14254        BaseNetworkSocketEvent::decode(self.client.wait_for_event(deadline)?)
14255    }
14256
14257    pub fn r#clone(
14258        &self,
14259        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
14260    ) -> Result<(), fidl::Error> {
14261        self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
14262            (request,),
14263            0x20d8a7aba2168a79,
14264            fidl::encoding::DynamicFlags::empty(),
14265        )
14266    }
14267
14268    /// Terminates the connection.
14269    ///
14270    /// After calling `Close`, the client must not send any other requests.
14271    ///
14272    /// Servers, after sending the status response, should close the connection
14273    /// regardless of status and without sending an epitaph.
14274    ///
14275    /// Closing the client end of the channel should be semantically equivalent
14276    /// to calling `Close` without knowing when the close has completed or its
14277    /// status.
14278    pub fn r#close(
14279        &self,
14280        ___deadline: zx::MonotonicInstant,
14281    ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
14282        let _response = self.client.send_query::<
14283            fidl::encoding::EmptyPayload,
14284            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
14285        >(
14286            (),
14287            0x5ac5d459ad7f657e,
14288            fidl::encoding::DynamicFlags::empty(),
14289            ___deadline,
14290        )?;
14291        Ok(_response.map(|x| x))
14292    }
14293
14294    pub fn r#query(&self, ___deadline: zx::MonotonicInstant) -> Result<Vec<u8>, fidl::Error> {
14295        let _response = self.client.send_query::<
14296            fidl::encoding::EmptyPayload,
14297            fidl_fuchsia_unknown::QueryableQueryResponse,
14298        >(
14299            (),
14300            0x2658edee9decfc06,
14301            fidl::encoding::DynamicFlags::empty(),
14302            ___deadline,
14303        )?;
14304        Ok(_response.protocol)
14305    }
14306
14307    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
14308    pub fn r#set_reuse_address(
14309        &self,
14310        mut value: bool,
14311        ___deadline: zx::MonotonicInstant,
14312    ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
14313        let _response =
14314            self.client.send_query::<BaseSocketSetReuseAddressRequest, fidl::encoding::ResultType<
14315                fidl::encoding::EmptyStruct,
14316                fidl_fuchsia_posix::Errno,
14317            >>(
14318                (value,),
14319                0x1fd74ee8b9a4a876,
14320                fidl::encoding::DynamicFlags::empty(),
14321                ___deadline,
14322            )?;
14323        Ok(_response.map(|x| x))
14324    }
14325
14326    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
14327    pub fn r#get_reuse_address(
14328        &self,
14329        ___deadline: zx::MonotonicInstant,
14330    ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
14331        let _response = self
14332            .client
14333            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14334                BaseSocketGetReuseAddressResponse,
14335                fidl_fuchsia_posix::Errno,
14336            >>(
14337                (), 0x67b7206b8d1bc0a5, fidl::encoding::DynamicFlags::empty(), ___deadline
14338            )?;
14339        Ok(_response.map(|x| x.value))
14340    }
14341
14342    /// Get `SOL_SOCKET` -> `SO_ERROR`.
14343    /// Returns the last error if there is an error set on the socket.
14344    pub fn r#get_error(
14345        &self,
14346        ___deadline: zx::MonotonicInstant,
14347    ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
14348        let _response =
14349            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14350                fidl::encoding::EmptyStruct,
14351                fidl_fuchsia_posix::Errno,
14352            >>(
14353                (),
14354                0x5aad39b33e5f6ebb,
14355                fidl::encoding::DynamicFlags::empty(),
14356                ___deadline,
14357            )?;
14358        Ok(_response.map(|x| x))
14359    }
14360
14361    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
14362    pub fn r#set_broadcast(
14363        &self,
14364        mut value: bool,
14365        ___deadline: zx::MonotonicInstant,
14366    ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
14367        let _response =
14368            self.client.send_query::<BaseSocketSetBroadcastRequest, fidl::encoding::ResultType<
14369                fidl::encoding::EmptyStruct,
14370                fidl_fuchsia_posix::Errno,
14371            >>(
14372                (value,),
14373                0x6023e081ce3cd947,
14374                fidl::encoding::DynamicFlags::empty(),
14375                ___deadline,
14376            )?;
14377        Ok(_response.map(|x| x))
14378    }
14379
14380    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
14381    pub fn r#get_broadcast(
14382        &self,
14383        ___deadline: zx::MonotonicInstant,
14384    ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
14385        let _response =
14386            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14387                BaseSocketGetBroadcastResponse,
14388                fidl_fuchsia_posix::Errno,
14389            >>(
14390                (),
14391                0x68796fc556f9780d,
14392                fidl::encoding::DynamicFlags::empty(),
14393                ___deadline,
14394            )?;
14395        Ok(_response.map(|x| x.value))
14396    }
14397
14398    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
14399    pub fn r#set_send_buffer(
14400        &self,
14401        mut value_bytes: u64,
14402        ___deadline: zx::MonotonicInstant,
14403    ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
14404        let _response =
14405            self.client.send_query::<BaseSocketSetSendBufferRequest, fidl::encoding::ResultType<
14406                fidl::encoding::EmptyStruct,
14407                fidl_fuchsia_posix::Errno,
14408            >>(
14409                (value_bytes,),
14410                0x756eac32d73a7a70,
14411                fidl::encoding::DynamicFlags::empty(),
14412                ___deadline,
14413            )?;
14414        Ok(_response.map(|x| x))
14415    }
14416
14417    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
14418    pub fn r#get_send_buffer(
14419        &self,
14420        ___deadline: zx::MonotonicInstant,
14421    ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
14422        let _response = self
14423            .client
14424            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14425                BaseSocketGetSendBufferResponse,
14426                fidl_fuchsia_posix::Errno,
14427            >>(
14428                (), 0x78a52fd9c7b2410b, fidl::encoding::DynamicFlags::empty(), ___deadline
14429            )?;
14430        Ok(_response.map(|x| x.value_bytes))
14431    }
14432
14433    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
14434    pub fn r#set_receive_buffer(
14435        &self,
14436        mut value_bytes: u64,
14437        ___deadline: zx::MonotonicInstant,
14438    ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
14439        let _response =
14440            self.client
14441                .send_query::<BaseSocketSetReceiveBufferRequest, fidl::encoding::ResultType<
14442                    fidl::encoding::EmptyStruct,
14443                    fidl_fuchsia_posix::Errno,
14444                >>(
14445                    (value_bytes,),
14446                    0x6b0cf2f1919c7001,
14447                    fidl::encoding::DynamicFlags::empty(),
14448                    ___deadline,
14449                )?;
14450        Ok(_response.map(|x| x))
14451    }
14452
14453    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
14454    pub fn r#get_receive_buffer(
14455        &self,
14456        ___deadline: zx::MonotonicInstant,
14457    ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
14458        let _response = self
14459            .client
14460            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14461                BaseSocketGetReceiveBufferResponse,
14462                fidl_fuchsia_posix::Errno,
14463            >>(
14464                (), 0x14c1a4b64f709e5c, fidl::encoding::DynamicFlags::empty(), ___deadline
14465            )?;
14466        Ok(_response.map(|x| x.value_bytes))
14467    }
14468
14469    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
14470    pub fn r#set_keep_alive(
14471        &self,
14472        mut value: bool,
14473        ___deadline: zx::MonotonicInstant,
14474    ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
14475        let _response =
14476            self.client.send_query::<BaseSocketSetKeepAliveRequest, fidl::encoding::ResultType<
14477                fidl::encoding::EmptyStruct,
14478                fidl_fuchsia_posix::Errno,
14479            >>(
14480                (value,),
14481                0x572df8f0b920d2c7,
14482                fidl::encoding::DynamicFlags::empty(),
14483                ___deadline,
14484            )?;
14485        Ok(_response.map(|x| x))
14486    }
14487
14488    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
14489    pub fn r#get_keep_alive(
14490        &self,
14491        ___deadline: zx::MonotonicInstant,
14492    ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
14493        let _response =
14494            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14495                BaseSocketGetKeepAliveResponse,
14496                fidl_fuchsia_posix::Errno,
14497            >>(
14498                (),
14499                0x2dd29d3215f2c9d2,
14500                fidl::encoding::DynamicFlags::empty(),
14501                ___deadline,
14502            )?;
14503        Ok(_response.map(|x| x.value))
14504    }
14505
14506    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
14507    pub fn r#set_out_of_band_inline(
14508        &self,
14509        mut value: bool,
14510        ___deadline: zx::MonotonicInstant,
14511    ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
14512        let _response =
14513            self.client
14514                .send_query::<BaseSocketSetOutOfBandInlineRequest, fidl::encoding::ResultType<
14515                    fidl::encoding::EmptyStruct,
14516                    fidl_fuchsia_posix::Errno,
14517                >>(
14518                    (value,),
14519                    0x3ecb49968bee439,
14520                    fidl::encoding::DynamicFlags::empty(),
14521                    ___deadline,
14522                )?;
14523        Ok(_response.map(|x| x))
14524    }
14525
14526    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
14527    pub fn r#get_out_of_band_inline(
14528        &self,
14529        ___deadline: zx::MonotonicInstant,
14530    ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
14531        let _response = self
14532            .client
14533            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14534                BaseSocketGetOutOfBandInlineResponse,
14535                fidl_fuchsia_posix::Errno,
14536            >>(
14537                (), 0x348c1ab3aeca1745, fidl::encoding::DynamicFlags::empty(), ___deadline
14538            )?;
14539        Ok(_response.map(|x| x.value))
14540    }
14541
14542    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
14543    pub fn r#set_no_check(
14544        &self,
14545        mut value: bool,
14546        ___deadline: zx::MonotonicInstant,
14547    ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
14548        let _response =
14549            self.client.send_query::<BaseSocketSetNoCheckRequest, fidl::encoding::ResultType<
14550                fidl::encoding::EmptyStruct,
14551                fidl_fuchsia_posix::Errno,
14552            >>(
14553                (value,),
14554                0x6bbf00c53a4c78c2,
14555                fidl::encoding::DynamicFlags::empty(),
14556                ___deadline,
14557            )?;
14558        Ok(_response.map(|x| x))
14559    }
14560
14561    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
14562    pub fn r#get_no_check(
14563        &self,
14564        ___deadline: zx::MonotonicInstant,
14565    ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
14566        let _response =
14567            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14568                BaseSocketGetNoCheckResponse,
14569                fidl_fuchsia_posix::Errno,
14570            >>(
14571                (),
14572                0x2cd4249286417694,
14573                fidl::encoding::DynamicFlags::empty(),
14574                ___deadline,
14575            )?;
14576        Ok(_response.map(|x| x.value))
14577    }
14578
14579    /// Set `SOL_SOCKET` -> `SO_LINGER`.
14580    pub fn r#set_linger(
14581        &self,
14582        mut linger: bool,
14583        mut length_secs: u32,
14584        ___deadline: zx::MonotonicInstant,
14585    ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
14586        let _response =
14587            self.client.send_query::<BaseSocketSetLingerRequest, fidl::encoding::ResultType<
14588                fidl::encoding::EmptyStruct,
14589                fidl_fuchsia_posix::Errno,
14590            >>(
14591                (linger, length_secs),
14592                0x45386351246e998e,
14593                fidl::encoding::DynamicFlags::empty(),
14594                ___deadline,
14595            )?;
14596        Ok(_response.map(|x| x))
14597    }
14598
14599    /// Get `SOL_SOCKET` -> `SO_LINGER`.
14600    pub fn r#get_linger(
14601        &self,
14602        ___deadline: zx::MonotonicInstant,
14603    ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
14604        let _response =
14605            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14606                BaseSocketGetLingerResponse,
14607                fidl_fuchsia_posix::Errno,
14608            >>(
14609                (),
14610                0x48eb20fc5ccb0e45,
14611                fidl::encoding::DynamicFlags::empty(),
14612                ___deadline,
14613            )?;
14614        Ok(_response.map(|x| (x.linger, x.length_secs)))
14615    }
14616
14617    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
14618    pub fn r#set_reuse_port(
14619        &self,
14620        mut value: bool,
14621        ___deadline: zx::MonotonicInstant,
14622    ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
14623        let _response =
14624            self.client.send_query::<BaseSocketSetReusePortRequest, fidl::encoding::ResultType<
14625                fidl::encoding::EmptyStruct,
14626                fidl_fuchsia_posix::Errno,
14627            >>(
14628                (value,),
14629                0x24dd3e5cb36d9ccb,
14630                fidl::encoding::DynamicFlags::empty(),
14631                ___deadline,
14632            )?;
14633        Ok(_response.map(|x| x))
14634    }
14635
14636    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
14637    pub fn r#get_reuse_port(
14638        &self,
14639        ___deadline: zx::MonotonicInstant,
14640    ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
14641        let _response =
14642            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14643                BaseSocketGetReusePortResponse,
14644                fidl_fuchsia_posix::Errno,
14645            >>(
14646                (),
14647                0x7a112c1ab54ff828,
14648                fidl::encoding::DynamicFlags::empty(),
14649                ___deadline,
14650            )?;
14651        Ok(_response.map(|x| x.value))
14652    }
14653
14654    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
14655    pub fn r#get_accept_conn(
14656        &self,
14657        ___deadline: zx::MonotonicInstant,
14658    ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
14659        let _response = self
14660            .client
14661            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14662                BaseSocketGetAcceptConnResponse,
14663                fidl_fuchsia_posix::Errno,
14664            >>(
14665                (), 0x67ce6db6c2ec8966, fidl::encoding::DynamicFlags::empty(), ___deadline
14666            )?;
14667        Ok(_response.map(|x| x.value))
14668    }
14669
14670    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
14671    pub fn r#set_bind_to_device(
14672        &self,
14673        mut value: &str,
14674        ___deadline: zx::MonotonicInstant,
14675    ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
14676        let _response =
14677            self.client.send_query::<BaseSocketSetBindToDeviceRequest, fidl::encoding::ResultType<
14678                fidl::encoding::EmptyStruct,
14679                fidl_fuchsia_posix::Errno,
14680            >>(
14681                (value,),
14682                0x2118b483f28aafc4,
14683                fidl::encoding::DynamicFlags::empty(),
14684                ___deadline,
14685            )?;
14686        Ok(_response.map(|x| x))
14687    }
14688
14689    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
14690    pub fn r#get_bind_to_device(
14691        &self,
14692        ___deadline: zx::MonotonicInstant,
14693    ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
14694        let _response = self
14695            .client
14696            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14697                BaseSocketGetBindToDeviceResponse,
14698                fidl_fuchsia_posix::Errno,
14699            >>(
14700                (), 0x1ab1fbf0ef7906c8, fidl::encoding::DynamicFlags::empty(), ___deadline
14701            )?;
14702        Ok(_response.map(|x| x.value))
14703    }
14704
14705    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
14706    /// If `value` is 0, this clears the bound interface.
14707    pub fn r#set_bind_to_interface_index(
14708        &self,
14709        mut value: u64,
14710        ___deadline: zx::MonotonicInstant,
14711    ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
14712        let _response =
14713            self.client
14714                .send_query::<BaseSocketSetBindToInterfaceIndexRequest, fidl::encoding::ResultType<
14715                    fidl::encoding::EmptyStruct,
14716                    fidl_fuchsia_posix::Errno,
14717                >>(
14718                    (value,),
14719                    0x6e387a0def00821,
14720                    fidl::encoding::DynamicFlags::empty(),
14721                    ___deadline,
14722                )?;
14723        Ok(_response.map(|x| x))
14724    }
14725
14726    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
14727    pub fn r#get_bind_to_interface_index(
14728        &self,
14729        ___deadline: zx::MonotonicInstant,
14730    ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
14731        let _response = self
14732            .client
14733            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14734                BaseSocketGetBindToInterfaceIndexResponse,
14735                fidl_fuchsia_posix::Errno,
14736            >>(
14737                (), 0x59c31dd3e3078295, fidl::encoding::DynamicFlags::empty(), ___deadline
14738            )?;
14739        Ok(_response.map(|x| x.value))
14740    }
14741
14742    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
14743    pub fn r#set_timestamp(
14744        &self,
14745        mut value: TimestampOption,
14746        ___deadline: zx::MonotonicInstant,
14747    ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
14748        let _response =
14749            self.client.send_query::<BaseSocketSetTimestampRequest, fidl::encoding::ResultType<
14750                fidl::encoding::EmptyStruct,
14751                fidl_fuchsia_posix::Errno,
14752            >>(
14753                (value,),
14754                0x285d6516c263d839,
14755                fidl::encoding::DynamicFlags::empty(),
14756                ___deadline,
14757            )?;
14758        Ok(_response.map(|x| x))
14759    }
14760
14761    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
14762    pub fn r#get_timestamp(
14763        &self,
14764        ___deadline: zx::MonotonicInstant,
14765    ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
14766        let _response =
14767            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14768                BaseSocketGetTimestampResponse,
14769                fidl_fuchsia_posix::Errno,
14770            >>(
14771                (),
14772                0x49f2fffbbcc2bd27,
14773                fidl::encoding::DynamicFlags::empty(),
14774                ___deadline,
14775            )?;
14776        Ok(_response.map(|x| x.value))
14777    }
14778
14779    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
14780    /// unlike the standard SO_MARK, this API has multiple mark domains and each
14781    /// mark can be set independently in each domain.
14782    pub fn r#set_mark(
14783        &self,
14784        mut domain: fidl_fuchsia_net::MarkDomain,
14785        mut mark: &OptionalUint32,
14786        ___deadline: zx::MonotonicInstant,
14787    ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
14788        let _response =
14789            self.client.send_query::<BaseSocketSetMarkRequest, fidl::encoding::ResultType<
14790                fidl::encoding::EmptyStruct,
14791                fidl_fuchsia_posix::Errno,
14792            >>(
14793                (domain, mark),
14794                0x6ead6de09f653236,
14795                fidl::encoding::DynamicFlags::empty(),
14796                ___deadline,
14797            )?;
14798        Ok(_response.map(|x| x))
14799    }
14800
14801    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
14802    /// unlike the standard SO_MARK, this API has multiple mark domains and each
14803    /// mark can be retrieved independently in each domain.
14804    pub fn r#get_mark(
14805        &self,
14806        mut domain: fidl_fuchsia_net::MarkDomain,
14807        ___deadline: zx::MonotonicInstant,
14808    ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
14809        let _response =
14810            self.client.send_query::<BaseSocketGetMarkRequest, fidl::encoding::ResultType<
14811                BaseSocketGetMarkResponse,
14812                fidl_fuchsia_posix::Errno,
14813            >>(
14814                (domain,),
14815                0x57a2752c61d93d47,
14816                fidl::encoding::DynamicFlags::empty(),
14817                ___deadline,
14818            )?;
14819        Ok(_response.map(|x| x.mark))
14820    }
14821
14822    /// Sets the local address used for the socket.
14823    pub fn r#bind(
14824        &self,
14825        mut addr: &fidl_fuchsia_net::SocketAddress,
14826        ___deadline: zx::MonotonicInstant,
14827    ) -> Result<BaseNetworkSocketBindResult, fidl::Error> {
14828        let _response =
14829            self.client.send_query::<BaseNetworkSocketBindRequest, fidl::encoding::ResultType<
14830                fidl::encoding::EmptyStruct,
14831                fidl_fuchsia_posix::Errno,
14832            >>(
14833                (addr,),
14834                0x4bc6400ae92125d,
14835                fidl::encoding::DynamicFlags::empty(),
14836                ___deadline,
14837            )?;
14838        Ok(_response.map(|x| x))
14839    }
14840
14841    /// Initiates a connection to a remote address.
14842    pub fn r#connect(
14843        &self,
14844        mut addr: &fidl_fuchsia_net::SocketAddress,
14845        ___deadline: zx::MonotonicInstant,
14846    ) -> Result<BaseNetworkSocketConnectResult, fidl::Error> {
14847        let _response =
14848            self.client.send_query::<BaseNetworkSocketConnectRequest, fidl::encoding::ResultType<
14849                fidl::encoding::EmptyStruct,
14850                fidl_fuchsia_posix::Errno,
14851            >>(
14852                (addr,),
14853                0x5f05f19bfdd38871,
14854                fidl::encoding::DynamicFlags::empty(),
14855                ___deadline,
14856            )?;
14857        Ok(_response.map(|x| x))
14858    }
14859
14860    /// Clears connection information from this socket.
14861    pub fn r#disconnect(
14862        &self,
14863        ___deadline: zx::MonotonicInstant,
14864    ) -> Result<BaseNetworkSocketDisconnectResult, fidl::Error> {
14865        let _response =
14866            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14867                fidl::encoding::EmptyStruct,
14868                fidl_fuchsia_posix::Errno,
14869            >>(
14870                (),
14871                0x74e63b91f7b29b2,
14872                fidl::encoding::DynamicFlags::empty(),
14873                ___deadline,
14874            )?;
14875        Ok(_response.map(|x| x))
14876    }
14877
14878    /// Retrieves the local socket address.
14879    pub fn r#get_sock_name(
14880        &self,
14881        ___deadline: zx::MonotonicInstant,
14882    ) -> Result<BaseNetworkSocketGetSockNameResult, fidl::Error> {
14883        let _response = self
14884            .client
14885            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14886                BaseNetworkSocketGetSockNameResponse,
14887                fidl_fuchsia_posix::Errno,
14888            >>(
14889                (), 0x475f23f84a1a4f85, fidl::encoding::DynamicFlags::empty(), ___deadline
14890            )?;
14891        Ok(_response.map(|x| x.addr))
14892    }
14893
14894    /// Retrieves the remote socket address.
14895    pub fn r#get_peer_name(
14896        &self,
14897        ___deadline: zx::MonotonicInstant,
14898    ) -> Result<BaseNetworkSocketGetPeerNameResult, fidl::Error> {
14899        let _response = self
14900            .client
14901            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14902                BaseNetworkSocketGetPeerNameResponse,
14903                fidl_fuchsia_posix::Errno,
14904            >>(
14905                (), 0x1ffecf4bd5b6432e, fidl::encoding::DynamicFlags::empty(), ___deadline
14906            )?;
14907        Ok(_response.map(|x| x.addr))
14908    }
14909
14910    /// Shuts down part of the socket.
14911    pub fn r#shutdown(
14912        &self,
14913        mut mode: ShutdownMode,
14914        ___deadline: zx::MonotonicInstant,
14915    ) -> Result<BaseNetworkSocketShutdownResult, fidl::Error> {
14916        let _response =
14917            self.client.send_query::<BaseNetworkSocketShutdownRequest, fidl::encoding::ResultType<
14918                fidl::encoding::EmptyStruct,
14919                fidl_fuchsia_posix::Errno,
14920            >>(
14921                (mode,),
14922                0x247f38b6db68c336,
14923                fidl::encoding::DynamicFlags::empty(),
14924                ___deadline,
14925            )?;
14926        Ok(_response.map(|x| x))
14927    }
14928
14929    /// Set `SOL_IP` -> `IP_TOS`.
14930    pub fn r#set_ip_type_of_service(
14931        &self,
14932        mut value: u8,
14933        ___deadline: zx::MonotonicInstant,
14934    ) -> Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error> {
14935        let _response = self.client.send_query::<
14936            BaseNetworkSocketSetIpTypeOfServiceRequest,
14937            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
14938        >(
14939            (value,),
14940            0x995c600475b6d46,
14941            fidl::encoding::DynamicFlags::empty(),
14942            ___deadline,
14943        )?;
14944        Ok(_response.map(|x| x))
14945    }
14946
14947    /// Get `SOL_IP` -> `IP_TOS`.
14948    pub fn r#get_ip_type_of_service(
14949        &self,
14950        ___deadline: zx::MonotonicInstant,
14951    ) -> Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error> {
14952        let _response = self
14953            .client
14954            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14955                BaseNetworkSocketGetIpTypeOfServiceResponse,
14956                fidl_fuchsia_posix::Errno,
14957            >>(
14958                (), 0x3814a04259f75fcb, fidl::encoding::DynamicFlags::empty(), ___deadline
14959            )?;
14960        Ok(_response.map(|x| x.value))
14961    }
14962
14963    /// Set `SOL_IP` -> `IP_TTL`.
14964    pub fn r#set_ip_ttl(
14965        &self,
14966        mut value: &OptionalUint8,
14967        ___deadline: zx::MonotonicInstant,
14968    ) -> Result<BaseNetworkSocketSetIpTtlResult, fidl::Error> {
14969        let _response =
14970            self.client.send_query::<BaseNetworkSocketSetIpTtlRequest, fidl::encoding::ResultType<
14971                fidl::encoding::EmptyStruct,
14972                fidl_fuchsia_posix::Errno,
14973            >>(
14974                (value,),
14975                0x29e2424b433ae1ef,
14976                fidl::encoding::DynamicFlags::empty(),
14977                ___deadline,
14978            )?;
14979        Ok(_response.map(|x| x))
14980    }
14981
14982    /// Get `SOL_IP` -> `IP_TTL`.
14983    pub fn r#get_ip_ttl(
14984        &self,
14985        ___deadline: zx::MonotonicInstant,
14986    ) -> Result<BaseNetworkSocketGetIpTtlResult, fidl::Error> {
14987        let _response = self
14988            .client
14989            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
14990                BaseNetworkSocketGetIpTtlResponse,
14991                fidl_fuchsia_posix::Errno,
14992            >>(
14993                (), 0x47e47fa1f24da471, fidl::encoding::DynamicFlags::empty(), ___deadline
14994            )?;
14995        Ok(_response.map(|x| x.value))
14996    }
14997
14998    /// Set `SOL_IP` -> `IP_PKTINFO`.
14999    pub fn r#set_ip_packet_info(
15000        &self,
15001        mut value: bool,
15002        ___deadline: zx::MonotonicInstant,
15003    ) -> Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error> {
15004        let _response =
15005            self.client
15006                .send_query::<BaseNetworkSocketSetIpPacketInfoRequest, fidl::encoding::ResultType<
15007                    fidl::encoding::EmptyStruct,
15008                    fidl_fuchsia_posix::Errno,
15009                >>(
15010                    (value,),
15011                    0x392d16bee20c0e16,
15012                    fidl::encoding::DynamicFlags::empty(),
15013                    ___deadline,
15014                )?;
15015        Ok(_response.map(|x| x))
15016    }
15017
15018    /// Get `SOL_IP` -> `IP_PKTINFO`.
15019    pub fn r#get_ip_packet_info(
15020        &self,
15021        ___deadline: zx::MonotonicInstant,
15022    ) -> Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error> {
15023        let _response = self
15024            .client
15025            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15026                BaseNetworkSocketGetIpPacketInfoResponse,
15027                fidl_fuchsia_posix::Errno,
15028            >>(
15029                (), 0x54b505f242280740, fidl::encoding::DynamicFlags::empty(), ___deadline
15030            )?;
15031        Ok(_response.map(|x| x.value))
15032    }
15033
15034    /// Set `SOL_IP` -> `IP_RECVTOS`.
15035    pub fn r#set_ip_receive_type_of_service(
15036        &self,
15037        mut value: bool,
15038        ___deadline: zx::MonotonicInstant,
15039    ) -> Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error> {
15040        let _response = self.client.send_query::<
15041            BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
15042            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
15043        >(
15044            (value,),
15045            0x6c4f6714995f84ef,
15046            fidl::encoding::DynamicFlags::empty(),
15047            ___deadline,
15048        )?;
15049        Ok(_response.map(|x| x))
15050    }
15051
15052    /// Get `SOL_IP` -> `IP_RECVTOS`.
15053    pub fn r#get_ip_receive_type_of_service(
15054        &self,
15055        ___deadline: zx::MonotonicInstant,
15056    ) -> Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error> {
15057        let _response = self
15058            .client
15059            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15060                BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
15061                fidl_fuchsia_posix::Errno,
15062            >>(
15063                (), 0x4158ba7dc2795960, fidl::encoding::DynamicFlags::empty(), ___deadline
15064            )?;
15065        Ok(_response.map(|x| x.value))
15066    }
15067
15068    /// Set `SOL_IP` -> `IP_RECVTTL`.
15069    pub fn r#set_ip_receive_ttl(
15070        &self,
15071        mut value: bool,
15072        ___deadline: zx::MonotonicInstant,
15073    ) -> Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error> {
15074        let _response =
15075            self.client
15076                .send_query::<BaseNetworkSocketSetIpReceiveTtlRequest, fidl::encoding::ResultType<
15077                    fidl::encoding::EmptyStruct,
15078                    fidl_fuchsia_posix::Errno,
15079                >>(
15080                    (value,),
15081                    0x46f15be0ce0ab82b,
15082                    fidl::encoding::DynamicFlags::empty(),
15083                    ___deadline,
15084                )?;
15085        Ok(_response.map(|x| x))
15086    }
15087
15088    /// Get `SOL_IP` -> `IP_RECVTTL`.
15089    pub fn r#get_ip_receive_ttl(
15090        &self,
15091        ___deadline: zx::MonotonicInstant,
15092    ) -> Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error> {
15093        let _response = self
15094            .client
15095            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15096                BaseNetworkSocketGetIpReceiveTtlResponse,
15097                fidl_fuchsia_posix::Errno,
15098            >>(
15099                (), 0x678ddd5a5dfa2eb5, fidl::encoding::DynamicFlags::empty(), ___deadline
15100            )?;
15101        Ok(_response.map(|x| x.value))
15102    }
15103
15104    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
15105    pub fn r#set_ip_multicast_interface(
15106        &self,
15107        mut iface: u64,
15108        mut address: &fidl_fuchsia_net::Ipv4Address,
15109        ___deadline: zx::MonotonicInstant,
15110    ) -> Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error> {
15111        let _response = self.client.send_query::<
15112            BaseNetworkSocketSetIpMulticastInterfaceRequest,
15113            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
15114        >(
15115            (iface, address,),
15116            0x752fbfa9b12befe,
15117            fidl::encoding::DynamicFlags::empty(),
15118            ___deadline,
15119        )?;
15120        Ok(_response.map(|x| x))
15121    }
15122
15123    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
15124    pub fn r#get_ip_multicast_interface(
15125        &self,
15126        ___deadline: zx::MonotonicInstant,
15127    ) -> Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error> {
15128        let _response = self
15129            .client
15130            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15131                BaseNetworkSocketGetIpMulticastInterfaceResponse,
15132                fidl_fuchsia_posix::Errno,
15133            >>(
15134                (), 0x320bd14c4df046c4, fidl::encoding::DynamicFlags::empty(), ___deadline
15135            )?;
15136        Ok(_response.map(|x| x.value))
15137    }
15138
15139    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
15140    pub fn r#set_ip_multicast_ttl(
15141        &self,
15142        mut value: &OptionalUint8,
15143        ___deadline: zx::MonotonicInstant,
15144    ) -> Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error> {
15145        let _response =
15146            self.client
15147                .send_query::<BaseNetworkSocketSetIpMulticastTtlRequest, fidl::encoding::ResultType<
15148                    fidl::encoding::EmptyStruct,
15149                    fidl_fuchsia_posix::Errno,
15150                >>(
15151                    (value,),
15152                    0x63134d53772916a1,
15153                    fidl::encoding::DynamicFlags::empty(),
15154                    ___deadline,
15155                )?;
15156        Ok(_response.map(|x| x))
15157    }
15158
15159    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
15160    pub fn r#get_ip_multicast_ttl(
15161        &self,
15162        ___deadline: zx::MonotonicInstant,
15163    ) -> Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error> {
15164        let _response = self
15165            .client
15166            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15167                BaseNetworkSocketGetIpMulticastTtlResponse,
15168                fidl_fuchsia_posix::Errno,
15169            >>(
15170                (), 0x4665cd378f39e1a, fidl::encoding::DynamicFlags::empty(), ___deadline
15171            )?;
15172        Ok(_response.map(|x| x.value))
15173    }
15174
15175    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
15176    pub fn r#set_ip_multicast_loopback(
15177        &self,
15178        mut value: bool,
15179        ___deadline: zx::MonotonicInstant,
15180    ) -> Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error> {
15181        let _response = self.client.send_query::<
15182            BaseNetworkSocketSetIpMulticastLoopbackRequest,
15183            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
15184        >(
15185            (value,),
15186            0x20c55c11f00943ea,
15187            fidl::encoding::DynamicFlags::empty(),
15188            ___deadline,
15189        )?;
15190        Ok(_response.map(|x| x))
15191    }
15192
15193    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
15194    pub fn r#get_ip_multicast_loopback(
15195        &self,
15196        ___deadline: zx::MonotonicInstant,
15197    ) -> Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error> {
15198        let _response = self
15199            .client
15200            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15201                BaseNetworkSocketGetIpMulticastLoopbackResponse,
15202                fidl_fuchsia_posix::Errno,
15203            >>(
15204                (), 0x3b6b26ff558298f2, fidl::encoding::DynamicFlags::empty(), ___deadline
15205            )?;
15206        Ok(_response.map(|x| x.value))
15207    }
15208
15209    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
15210    pub fn r#add_ip_membership(
15211        &self,
15212        mut membership: &IpMulticastMembership,
15213        ___deadline: zx::MonotonicInstant,
15214    ) -> Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error> {
15215        let _response =
15216            self.client
15217                .send_query::<BaseNetworkSocketAddIpMembershipRequest, fidl::encoding::ResultType<
15218                    fidl::encoding::EmptyStruct,
15219                    fidl_fuchsia_posix::Errno,
15220                >>(
15221                    (membership,),
15222                    0x76bc7df115a3b4d0,
15223                    fidl::encoding::DynamicFlags::empty(),
15224                    ___deadline,
15225                )?;
15226        Ok(_response.map(|x| x))
15227    }
15228
15229    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
15230    pub fn r#drop_ip_membership(
15231        &self,
15232        mut membership: &IpMulticastMembership,
15233        ___deadline: zx::MonotonicInstant,
15234    ) -> Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error> {
15235        let _response =
15236            self.client
15237                .send_query::<BaseNetworkSocketDropIpMembershipRequest, fidl::encoding::ResultType<
15238                    fidl::encoding::EmptyStruct,
15239                    fidl_fuchsia_posix::Errno,
15240                >>(
15241                    (membership,),
15242                    0x2888f3099188d03,
15243                    fidl::encoding::DynamicFlags::empty(),
15244                    ___deadline,
15245                )?;
15246        Ok(_response.map(|x| x))
15247    }
15248
15249    /// Set `SOL_IP` -> `IP_TRANSPARENT`
15250    pub fn r#set_ip_transparent(
15251        &self,
15252        mut value: bool,
15253        ___deadline: zx::MonotonicInstant,
15254    ) -> Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error> {
15255        let _response =
15256            self.client
15257                .send_query::<BaseNetworkSocketSetIpTransparentRequest, fidl::encoding::ResultType<
15258                    fidl::encoding::EmptyStruct,
15259                    fidl_fuchsia_posix::Errno,
15260                >>(
15261                    (value,),
15262                    0x1ae532b0c066e3a0,
15263                    fidl::encoding::DynamicFlags::empty(),
15264                    ___deadline,
15265                )?;
15266        Ok(_response.map(|x| x))
15267    }
15268
15269    /// Get `SOL_IP` -> `IP_TRANSPARENT`
15270    pub fn r#get_ip_transparent(
15271        &self,
15272        ___deadline: zx::MonotonicInstant,
15273    ) -> Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error> {
15274        let _response = self
15275            .client
15276            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15277                BaseNetworkSocketGetIpTransparentResponse,
15278                fidl_fuchsia_posix::Errno,
15279            >>(
15280                (), 0x51d43695962ebfb5, fidl::encoding::DynamicFlags::empty(), ___deadline
15281            )?;
15282        Ok(_response.map(|x| x.value))
15283    }
15284
15285    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
15286    pub fn r#set_ip_receive_original_destination_address(
15287        &self,
15288        mut value: bool,
15289        ___deadline: zx::MonotonicInstant,
15290    ) -> Result<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error> {
15291        let _response = self.client.send_query::<
15292            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
15293            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
15294        >(
15295            (value,),
15296            0x4722b4ce52f7840,
15297            fidl::encoding::DynamicFlags::empty(),
15298            ___deadline,
15299        )?;
15300        Ok(_response.map(|x| x))
15301    }
15302
15303    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
15304    pub fn r#get_ip_receive_original_destination_address(
15305        &self,
15306        ___deadline: zx::MonotonicInstant,
15307    ) -> Result<BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error> {
15308        let _response = self
15309            .client
15310            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15311                BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
15312                fidl_fuchsia_posix::Errno,
15313            >>(
15314                (), 0x2a0e7dc5d6bfdfe9, fidl::encoding::DynamicFlags::empty(), ___deadline
15315            )?;
15316        Ok(_response.map(|x| x.value))
15317    }
15318
15319    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
15320    pub fn r#add_ipv6_membership(
15321        &self,
15322        mut membership: &Ipv6MulticastMembership,
15323        ___deadline: zx::MonotonicInstant,
15324    ) -> Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error> {
15325        let _response =
15326            self.client
15327                .send_query::<BaseNetworkSocketAddIpv6MembershipRequest, fidl::encoding::ResultType<
15328                    fidl::encoding::EmptyStruct,
15329                    fidl_fuchsia_posix::Errno,
15330                >>(
15331                    (membership,),
15332                    0x7c94727acb4ea4b3,
15333                    fidl::encoding::DynamicFlags::empty(),
15334                    ___deadline,
15335                )?;
15336        Ok(_response.map(|x| x))
15337    }
15338
15339    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
15340    pub fn r#drop_ipv6_membership(
15341        &self,
15342        mut membership: &Ipv6MulticastMembership,
15343        ___deadline: zx::MonotonicInstant,
15344    ) -> Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error> {
15345        let _response = self.client.send_query::<
15346            BaseNetworkSocketDropIpv6MembershipRequest,
15347            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
15348        >(
15349            (membership,),
15350            0x42104c70ccaba304,
15351            fidl::encoding::DynamicFlags::empty(),
15352            ___deadline,
15353        )?;
15354        Ok(_response.map(|x| x))
15355    }
15356
15357    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
15358    pub fn r#set_ipv6_multicast_interface(
15359        &self,
15360        mut value: u64,
15361        ___deadline: zx::MonotonicInstant,
15362    ) -> Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error> {
15363        let _response = self.client.send_query::<
15364            BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
15365            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
15366        >(
15367            (value,),
15368            0x135f76db3774ab3b,
15369            fidl::encoding::DynamicFlags::empty(),
15370            ___deadline,
15371        )?;
15372        Ok(_response.map(|x| x))
15373    }
15374
15375    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
15376    pub fn r#get_ipv6_multicast_interface(
15377        &self,
15378        ___deadline: zx::MonotonicInstant,
15379    ) -> Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error> {
15380        let _response = self
15381            .client
15382            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15383                BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
15384                fidl_fuchsia_posix::Errno,
15385            >>(
15386                (), 0x1f26fcdd348f1882, fidl::encoding::DynamicFlags::empty(), ___deadline
15387            )?;
15388        Ok(_response.map(|x| x.value))
15389    }
15390
15391    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
15392    pub fn r#set_ipv6_unicast_hops(
15393        &self,
15394        mut value: &OptionalUint8,
15395        ___deadline: zx::MonotonicInstant,
15396    ) -> Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error> {
15397        let _response = self.client.send_query::<
15398            BaseNetworkSocketSetIpv6UnicastHopsRequest,
15399            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
15400        >(
15401            (value,),
15402            0x157d51e98f462859,
15403            fidl::encoding::DynamicFlags::empty(),
15404            ___deadline,
15405        )?;
15406        Ok(_response.map(|x| x))
15407    }
15408
15409    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
15410    pub fn r#get_ipv6_unicast_hops(
15411        &self,
15412        ___deadline: zx::MonotonicInstant,
15413    ) -> Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error> {
15414        let _response = self
15415            .client
15416            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15417                BaseNetworkSocketGetIpv6UnicastHopsResponse,
15418                fidl_fuchsia_posix::Errno,
15419            >>(
15420                (), 0x21f4641cad8bd8d2, fidl::encoding::DynamicFlags::empty(), ___deadline
15421            )?;
15422        Ok(_response.map(|x| x.value))
15423    }
15424
15425    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
15426    pub fn r#set_ipv6_receive_hop_limit(
15427        &self,
15428        mut value: bool,
15429        ___deadline: zx::MonotonicInstant,
15430    ) -> Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error> {
15431        let _response = self.client.send_query::<
15432            BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
15433            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
15434        >(
15435            (value,),
15436            0x5c24808ed2e84a1e,
15437            fidl::encoding::DynamicFlags::empty(),
15438            ___deadline,
15439        )?;
15440        Ok(_response.map(|x| x))
15441    }
15442
15443    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
15444    pub fn r#get_ipv6_receive_hop_limit(
15445        &self,
15446        ___deadline: zx::MonotonicInstant,
15447    ) -> Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error> {
15448        let _response = self
15449            .client
15450            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15451                BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
15452                fidl_fuchsia_posix::Errno,
15453            >>(
15454                (), 0x341e06689885b4c0, fidl::encoding::DynamicFlags::empty(), ___deadline
15455            )?;
15456        Ok(_response.map(|x| x.value))
15457    }
15458
15459    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
15460    pub fn r#set_ipv6_multicast_hops(
15461        &self,
15462        mut value: &OptionalUint8,
15463        ___deadline: zx::MonotonicInstant,
15464    ) -> Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error> {
15465        let _response = self.client.send_query::<
15466            BaseNetworkSocketSetIpv6MulticastHopsRequest,
15467            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
15468        >(
15469            (value,),
15470            0x25b9cd4d181f82c1,
15471            fidl::encoding::DynamicFlags::empty(),
15472            ___deadline,
15473        )?;
15474        Ok(_response.map(|x| x))
15475    }
15476
15477    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
15478    pub fn r#get_ipv6_multicast_hops(
15479        &self,
15480        ___deadline: zx::MonotonicInstant,
15481    ) -> Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error> {
15482        let _response = self
15483            .client
15484            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15485                BaseNetworkSocketGetIpv6MulticastHopsResponse,
15486                fidl_fuchsia_posix::Errno,
15487            >>(
15488                (), 0x52916948a365012a, fidl::encoding::DynamicFlags::empty(), ___deadline
15489            )?;
15490        Ok(_response.map(|x| x.value))
15491    }
15492
15493    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
15494    pub fn r#set_ipv6_multicast_loopback(
15495        &self,
15496        mut value: bool,
15497        ___deadline: zx::MonotonicInstant,
15498    ) -> Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error> {
15499        let _response = self.client.send_query::<
15500            BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
15501            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
15502        >(
15503            (value,),
15504            0x55701c409ff41b40,
15505            fidl::encoding::DynamicFlags::empty(),
15506            ___deadline,
15507        )?;
15508        Ok(_response.map(|x| x))
15509    }
15510
15511    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
15512    pub fn r#get_ipv6_multicast_loopback(
15513        &self,
15514        ___deadline: zx::MonotonicInstant,
15515    ) -> Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error> {
15516        let _response = self
15517            .client
15518            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15519                BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
15520                fidl_fuchsia_posix::Errno,
15521            >>(
15522                (), 0x4415b701fde319c3, fidl::encoding::DynamicFlags::empty(), ___deadline
15523            )?;
15524        Ok(_response.map(|x| x.value))
15525    }
15526
15527    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
15528    pub fn r#set_ipv6_only(
15529        &self,
15530        mut value: bool,
15531        ___deadline: zx::MonotonicInstant,
15532    ) -> Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
15533        let _response =
15534            self.client
15535                .send_query::<BaseNetworkSocketSetIpv6OnlyRequest, fidl::encoding::ResultType<
15536                    fidl::encoding::EmptyStruct,
15537                    fidl_fuchsia_posix::Errno,
15538                >>(
15539                    (value,),
15540                    0x4873f1364758cbba,
15541                    fidl::encoding::DynamicFlags::empty(),
15542                    ___deadline,
15543                )?;
15544        Ok(_response.map(|x| x))
15545    }
15546
15547    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
15548    pub fn r#get_ipv6_only(
15549        &self,
15550        ___deadline: zx::MonotonicInstant,
15551    ) -> Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
15552        let _response = self
15553            .client
15554            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15555                BaseNetworkSocketGetIpv6OnlyResponse,
15556                fidl_fuchsia_posix::Errno,
15557            >>(
15558                (), 0x4aa3340a1a26b89c, fidl::encoding::DynamicFlags::empty(), ___deadline
15559            )?;
15560        Ok(_response.map(|x| x.value))
15561    }
15562
15563    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
15564    pub fn r#set_ipv6_receive_traffic_class(
15565        &self,
15566        mut value: bool,
15567        ___deadline: zx::MonotonicInstant,
15568    ) -> Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error> {
15569        let _response = self.client.send_query::<
15570            BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
15571            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
15572        >(
15573            (value,),
15574            0x58f07c8788d099a0,
15575            fidl::encoding::DynamicFlags::empty(),
15576            ___deadline,
15577        )?;
15578        Ok(_response.map(|x| x))
15579    }
15580
15581    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
15582    pub fn r#get_ipv6_receive_traffic_class(
15583        &self,
15584        ___deadline: zx::MonotonicInstant,
15585    ) -> Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error> {
15586        let _response = self
15587            .client
15588            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15589                BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
15590                fidl_fuchsia_posix::Errno,
15591            >>(
15592                (), 0x2e334df1da553ffa, fidl::encoding::DynamicFlags::empty(), ___deadline
15593            )?;
15594        Ok(_response.map(|x| x.value))
15595    }
15596
15597    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
15598    pub fn r#set_ipv6_traffic_class(
15599        &self,
15600        mut value: &OptionalUint8,
15601        ___deadline: zx::MonotonicInstant,
15602    ) -> Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error> {
15603        let _response = self.client.send_query::<
15604            BaseNetworkSocketSetIpv6TrafficClassRequest,
15605            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
15606        >(
15607            (value,),
15608            0x6af077800c5a0b4f,
15609            fidl::encoding::DynamicFlags::empty(),
15610            ___deadline,
15611        )?;
15612        Ok(_response.map(|x| x))
15613    }
15614
15615    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
15616    pub fn r#get_ipv6_traffic_class(
15617        &self,
15618        ___deadline: zx::MonotonicInstant,
15619    ) -> Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error> {
15620        let _response = self
15621            .client
15622            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15623                BaseNetworkSocketGetIpv6TrafficClassResponse,
15624                fidl_fuchsia_posix::Errno,
15625            >>(
15626                (), 0x6baf6eed8fc2f04, fidl::encoding::DynamicFlags::empty(), ___deadline
15627            )?;
15628        Ok(_response.map(|x| x.value))
15629    }
15630
15631    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
15632    pub fn r#set_ipv6_receive_packet_info(
15633        &self,
15634        mut value: bool,
15635        ___deadline: zx::MonotonicInstant,
15636    ) -> Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error> {
15637        let _response = self.client.send_query::<
15638            BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
15639            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
15640        >(
15641            (value,),
15642            0x19259775b1a92768,
15643            fidl::encoding::DynamicFlags::empty(),
15644            ___deadline,
15645        )?;
15646        Ok(_response.map(|x| x))
15647    }
15648
15649    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
15650    pub fn r#get_ipv6_receive_packet_info(
15651        &self,
15652        ___deadline: zx::MonotonicInstant,
15653    ) -> Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error> {
15654        let _response = self
15655            .client
15656            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15657                BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
15658                fidl_fuchsia_posix::Errno,
15659            >>(
15660                (), 0x7acd4a2775baec75, fidl::encoding::DynamicFlags::empty(), ___deadline
15661            )?;
15662        Ok(_response.map(|x| x.value))
15663    }
15664
15665    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
15666    pub fn r#get_original_destination(
15667        &self,
15668        ___deadline: zx::MonotonicInstant,
15669    ) -> Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error> {
15670        let _response = self
15671            .client
15672            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
15673                BaseNetworkSocketGetOriginalDestinationResponse,
15674                fidl_fuchsia_posix::Errno,
15675            >>(
15676                (), 0x38bf28f0dafdbac0, fidl::encoding::DynamicFlags::empty(), ___deadline
15677            )?;
15678        Ok(_response.map(|x| x.value))
15679    }
15680}
15681
15682#[cfg(target_os = "fuchsia")]
15683impl From<BaseNetworkSocketSynchronousProxy> for zx::Handle {
15684    fn from(value: BaseNetworkSocketSynchronousProxy) -> Self {
15685        value.into_channel().into()
15686    }
15687}
15688
15689#[cfg(target_os = "fuchsia")]
15690impl From<fidl::Channel> for BaseNetworkSocketSynchronousProxy {
15691    fn from(value: fidl::Channel) -> Self {
15692        Self::new(value)
15693    }
15694}
15695
15696#[derive(Debug, Clone)]
15697pub struct BaseNetworkSocketProxy {
15698    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
15699}
15700
15701impl fidl::endpoints::Proxy for BaseNetworkSocketProxy {
15702    type Protocol = BaseNetworkSocketMarker;
15703
15704    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
15705        Self::new(inner)
15706    }
15707
15708    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
15709        self.client.into_channel().map_err(|client| Self { client })
15710    }
15711
15712    fn as_channel(&self) -> &::fidl::AsyncChannel {
15713        self.client.as_channel()
15714    }
15715}
15716
15717impl BaseNetworkSocketProxy {
15718    /// Create a new Proxy for fuchsia.posix.socket/BaseNetworkSocket.
15719    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
15720        let protocol_name =
15721            <BaseNetworkSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
15722        Self { client: fidl::client::Client::new(channel, protocol_name) }
15723    }
15724
15725    /// Get a Stream of events from the remote end of the protocol.
15726    ///
15727    /// # Panics
15728    ///
15729    /// Panics if the event stream was already taken.
15730    pub fn take_event_stream(&self) -> BaseNetworkSocketEventStream {
15731        BaseNetworkSocketEventStream { event_receiver: self.client.take_event_receiver() }
15732    }
15733
15734    pub fn r#clone(
15735        &self,
15736        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
15737    ) -> Result<(), fidl::Error> {
15738        BaseNetworkSocketProxyInterface::r#clone(self, request)
15739    }
15740
15741    /// Terminates the connection.
15742    ///
15743    /// After calling `Close`, the client must not send any other requests.
15744    ///
15745    /// Servers, after sending the status response, should close the connection
15746    /// regardless of status and without sending an epitaph.
15747    ///
15748    /// Closing the client end of the channel should be semantically equivalent
15749    /// to calling `Close` without knowing when the close has completed or its
15750    /// status.
15751    pub fn r#close(
15752        &self,
15753    ) -> fidl::client::QueryResponseFut<
15754        fidl_fuchsia_unknown::CloseableCloseResult,
15755        fidl::encoding::DefaultFuchsiaResourceDialect,
15756    > {
15757        BaseNetworkSocketProxyInterface::r#close(self)
15758    }
15759
15760    pub fn r#query(
15761        &self,
15762    ) -> fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>
15763    {
15764        BaseNetworkSocketProxyInterface::r#query(self)
15765    }
15766
15767    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
15768    pub fn r#set_reuse_address(
15769        &self,
15770        mut value: bool,
15771    ) -> fidl::client::QueryResponseFut<
15772        BaseSocketSetReuseAddressResult,
15773        fidl::encoding::DefaultFuchsiaResourceDialect,
15774    > {
15775        BaseNetworkSocketProxyInterface::r#set_reuse_address(self, value)
15776    }
15777
15778    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
15779    pub fn r#get_reuse_address(
15780        &self,
15781    ) -> fidl::client::QueryResponseFut<
15782        BaseSocketGetReuseAddressResult,
15783        fidl::encoding::DefaultFuchsiaResourceDialect,
15784    > {
15785        BaseNetworkSocketProxyInterface::r#get_reuse_address(self)
15786    }
15787
15788    /// Get `SOL_SOCKET` -> `SO_ERROR`.
15789    /// Returns the last error if there is an error set on the socket.
15790    pub fn r#get_error(
15791        &self,
15792    ) -> fidl::client::QueryResponseFut<
15793        BaseSocketGetErrorResult,
15794        fidl::encoding::DefaultFuchsiaResourceDialect,
15795    > {
15796        BaseNetworkSocketProxyInterface::r#get_error(self)
15797    }
15798
15799    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
15800    pub fn r#set_broadcast(
15801        &self,
15802        mut value: bool,
15803    ) -> fidl::client::QueryResponseFut<
15804        BaseSocketSetBroadcastResult,
15805        fidl::encoding::DefaultFuchsiaResourceDialect,
15806    > {
15807        BaseNetworkSocketProxyInterface::r#set_broadcast(self, value)
15808    }
15809
15810    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
15811    pub fn r#get_broadcast(
15812        &self,
15813    ) -> fidl::client::QueryResponseFut<
15814        BaseSocketGetBroadcastResult,
15815        fidl::encoding::DefaultFuchsiaResourceDialect,
15816    > {
15817        BaseNetworkSocketProxyInterface::r#get_broadcast(self)
15818    }
15819
15820    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
15821    pub fn r#set_send_buffer(
15822        &self,
15823        mut value_bytes: u64,
15824    ) -> fidl::client::QueryResponseFut<
15825        BaseSocketSetSendBufferResult,
15826        fidl::encoding::DefaultFuchsiaResourceDialect,
15827    > {
15828        BaseNetworkSocketProxyInterface::r#set_send_buffer(self, value_bytes)
15829    }
15830
15831    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
15832    pub fn r#get_send_buffer(
15833        &self,
15834    ) -> fidl::client::QueryResponseFut<
15835        BaseSocketGetSendBufferResult,
15836        fidl::encoding::DefaultFuchsiaResourceDialect,
15837    > {
15838        BaseNetworkSocketProxyInterface::r#get_send_buffer(self)
15839    }
15840
15841    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
15842    pub fn r#set_receive_buffer(
15843        &self,
15844        mut value_bytes: u64,
15845    ) -> fidl::client::QueryResponseFut<
15846        BaseSocketSetReceiveBufferResult,
15847        fidl::encoding::DefaultFuchsiaResourceDialect,
15848    > {
15849        BaseNetworkSocketProxyInterface::r#set_receive_buffer(self, value_bytes)
15850    }
15851
15852    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
15853    pub fn r#get_receive_buffer(
15854        &self,
15855    ) -> fidl::client::QueryResponseFut<
15856        BaseSocketGetReceiveBufferResult,
15857        fidl::encoding::DefaultFuchsiaResourceDialect,
15858    > {
15859        BaseNetworkSocketProxyInterface::r#get_receive_buffer(self)
15860    }
15861
15862    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
15863    pub fn r#set_keep_alive(
15864        &self,
15865        mut value: bool,
15866    ) -> fidl::client::QueryResponseFut<
15867        BaseSocketSetKeepAliveResult,
15868        fidl::encoding::DefaultFuchsiaResourceDialect,
15869    > {
15870        BaseNetworkSocketProxyInterface::r#set_keep_alive(self, value)
15871    }
15872
15873    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
15874    pub fn r#get_keep_alive(
15875        &self,
15876    ) -> fidl::client::QueryResponseFut<
15877        BaseSocketGetKeepAliveResult,
15878        fidl::encoding::DefaultFuchsiaResourceDialect,
15879    > {
15880        BaseNetworkSocketProxyInterface::r#get_keep_alive(self)
15881    }
15882
15883    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
15884    pub fn r#set_out_of_band_inline(
15885        &self,
15886        mut value: bool,
15887    ) -> fidl::client::QueryResponseFut<
15888        BaseSocketSetOutOfBandInlineResult,
15889        fidl::encoding::DefaultFuchsiaResourceDialect,
15890    > {
15891        BaseNetworkSocketProxyInterface::r#set_out_of_band_inline(self, value)
15892    }
15893
15894    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
15895    pub fn r#get_out_of_band_inline(
15896        &self,
15897    ) -> fidl::client::QueryResponseFut<
15898        BaseSocketGetOutOfBandInlineResult,
15899        fidl::encoding::DefaultFuchsiaResourceDialect,
15900    > {
15901        BaseNetworkSocketProxyInterface::r#get_out_of_band_inline(self)
15902    }
15903
15904    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
15905    pub fn r#set_no_check(
15906        &self,
15907        mut value: bool,
15908    ) -> fidl::client::QueryResponseFut<
15909        BaseSocketSetNoCheckResult,
15910        fidl::encoding::DefaultFuchsiaResourceDialect,
15911    > {
15912        BaseNetworkSocketProxyInterface::r#set_no_check(self, value)
15913    }
15914
15915    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
15916    pub fn r#get_no_check(
15917        &self,
15918    ) -> fidl::client::QueryResponseFut<
15919        BaseSocketGetNoCheckResult,
15920        fidl::encoding::DefaultFuchsiaResourceDialect,
15921    > {
15922        BaseNetworkSocketProxyInterface::r#get_no_check(self)
15923    }
15924
15925    /// Set `SOL_SOCKET` -> `SO_LINGER`.
15926    pub fn r#set_linger(
15927        &self,
15928        mut linger: bool,
15929        mut length_secs: u32,
15930    ) -> fidl::client::QueryResponseFut<
15931        BaseSocketSetLingerResult,
15932        fidl::encoding::DefaultFuchsiaResourceDialect,
15933    > {
15934        BaseNetworkSocketProxyInterface::r#set_linger(self, linger, length_secs)
15935    }
15936
15937    /// Get `SOL_SOCKET` -> `SO_LINGER`.
15938    pub fn r#get_linger(
15939        &self,
15940    ) -> fidl::client::QueryResponseFut<
15941        BaseSocketGetLingerResult,
15942        fidl::encoding::DefaultFuchsiaResourceDialect,
15943    > {
15944        BaseNetworkSocketProxyInterface::r#get_linger(self)
15945    }
15946
15947    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
15948    pub fn r#set_reuse_port(
15949        &self,
15950        mut value: bool,
15951    ) -> fidl::client::QueryResponseFut<
15952        BaseSocketSetReusePortResult,
15953        fidl::encoding::DefaultFuchsiaResourceDialect,
15954    > {
15955        BaseNetworkSocketProxyInterface::r#set_reuse_port(self, value)
15956    }
15957
15958    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
15959    pub fn r#get_reuse_port(
15960        &self,
15961    ) -> fidl::client::QueryResponseFut<
15962        BaseSocketGetReusePortResult,
15963        fidl::encoding::DefaultFuchsiaResourceDialect,
15964    > {
15965        BaseNetworkSocketProxyInterface::r#get_reuse_port(self)
15966    }
15967
15968    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
15969    pub fn r#get_accept_conn(
15970        &self,
15971    ) -> fidl::client::QueryResponseFut<
15972        BaseSocketGetAcceptConnResult,
15973        fidl::encoding::DefaultFuchsiaResourceDialect,
15974    > {
15975        BaseNetworkSocketProxyInterface::r#get_accept_conn(self)
15976    }
15977
15978    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
15979    pub fn r#set_bind_to_device(
15980        &self,
15981        mut value: &str,
15982    ) -> fidl::client::QueryResponseFut<
15983        BaseSocketSetBindToDeviceResult,
15984        fidl::encoding::DefaultFuchsiaResourceDialect,
15985    > {
15986        BaseNetworkSocketProxyInterface::r#set_bind_to_device(self, value)
15987    }
15988
15989    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
15990    pub fn r#get_bind_to_device(
15991        &self,
15992    ) -> fidl::client::QueryResponseFut<
15993        BaseSocketGetBindToDeviceResult,
15994        fidl::encoding::DefaultFuchsiaResourceDialect,
15995    > {
15996        BaseNetworkSocketProxyInterface::r#get_bind_to_device(self)
15997    }
15998
15999    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
16000    /// If `value` is 0, this clears the bound interface.
16001    pub fn r#set_bind_to_interface_index(
16002        &self,
16003        mut value: u64,
16004    ) -> fidl::client::QueryResponseFut<
16005        BaseSocketSetBindToInterfaceIndexResult,
16006        fidl::encoding::DefaultFuchsiaResourceDialect,
16007    > {
16008        BaseNetworkSocketProxyInterface::r#set_bind_to_interface_index(self, value)
16009    }
16010
16011    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
16012    pub fn r#get_bind_to_interface_index(
16013        &self,
16014    ) -> fidl::client::QueryResponseFut<
16015        BaseSocketGetBindToInterfaceIndexResult,
16016        fidl::encoding::DefaultFuchsiaResourceDialect,
16017    > {
16018        BaseNetworkSocketProxyInterface::r#get_bind_to_interface_index(self)
16019    }
16020
16021    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
16022    pub fn r#set_timestamp(
16023        &self,
16024        mut value: TimestampOption,
16025    ) -> fidl::client::QueryResponseFut<
16026        BaseSocketSetTimestampResult,
16027        fidl::encoding::DefaultFuchsiaResourceDialect,
16028    > {
16029        BaseNetworkSocketProxyInterface::r#set_timestamp(self, value)
16030    }
16031
16032    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
16033    pub fn r#get_timestamp(
16034        &self,
16035    ) -> fidl::client::QueryResponseFut<
16036        BaseSocketGetTimestampResult,
16037        fidl::encoding::DefaultFuchsiaResourceDialect,
16038    > {
16039        BaseNetworkSocketProxyInterface::r#get_timestamp(self)
16040    }
16041
16042    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
16043    /// unlike the standard SO_MARK, this API has multiple mark domains and each
16044    /// mark can be set independently in each domain.
16045    pub fn r#set_mark(
16046        &self,
16047        mut domain: fidl_fuchsia_net::MarkDomain,
16048        mut mark: &OptionalUint32,
16049    ) -> fidl::client::QueryResponseFut<
16050        BaseSocketSetMarkResult,
16051        fidl::encoding::DefaultFuchsiaResourceDialect,
16052    > {
16053        BaseNetworkSocketProxyInterface::r#set_mark(self, domain, mark)
16054    }
16055
16056    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
16057    /// unlike the standard SO_MARK, this API has multiple mark domains and each
16058    /// mark can be retrieved independently in each domain.
16059    pub fn r#get_mark(
16060        &self,
16061        mut domain: fidl_fuchsia_net::MarkDomain,
16062    ) -> fidl::client::QueryResponseFut<
16063        BaseSocketGetMarkResult,
16064        fidl::encoding::DefaultFuchsiaResourceDialect,
16065    > {
16066        BaseNetworkSocketProxyInterface::r#get_mark(self, domain)
16067    }
16068
16069    /// Sets the local address used for the socket.
16070    pub fn r#bind(
16071        &self,
16072        mut addr: &fidl_fuchsia_net::SocketAddress,
16073    ) -> fidl::client::QueryResponseFut<
16074        BaseNetworkSocketBindResult,
16075        fidl::encoding::DefaultFuchsiaResourceDialect,
16076    > {
16077        BaseNetworkSocketProxyInterface::r#bind(self, addr)
16078    }
16079
16080    /// Initiates a connection to a remote address.
16081    pub fn r#connect(
16082        &self,
16083        mut addr: &fidl_fuchsia_net::SocketAddress,
16084    ) -> fidl::client::QueryResponseFut<
16085        BaseNetworkSocketConnectResult,
16086        fidl::encoding::DefaultFuchsiaResourceDialect,
16087    > {
16088        BaseNetworkSocketProxyInterface::r#connect(self, addr)
16089    }
16090
16091    /// Clears connection information from this socket.
16092    pub fn r#disconnect(
16093        &self,
16094    ) -> fidl::client::QueryResponseFut<
16095        BaseNetworkSocketDisconnectResult,
16096        fidl::encoding::DefaultFuchsiaResourceDialect,
16097    > {
16098        BaseNetworkSocketProxyInterface::r#disconnect(self)
16099    }
16100
16101    /// Retrieves the local socket address.
16102    pub fn r#get_sock_name(
16103        &self,
16104    ) -> fidl::client::QueryResponseFut<
16105        BaseNetworkSocketGetSockNameResult,
16106        fidl::encoding::DefaultFuchsiaResourceDialect,
16107    > {
16108        BaseNetworkSocketProxyInterface::r#get_sock_name(self)
16109    }
16110
16111    /// Retrieves the remote socket address.
16112    pub fn r#get_peer_name(
16113        &self,
16114    ) -> fidl::client::QueryResponseFut<
16115        BaseNetworkSocketGetPeerNameResult,
16116        fidl::encoding::DefaultFuchsiaResourceDialect,
16117    > {
16118        BaseNetworkSocketProxyInterface::r#get_peer_name(self)
16119    }
16120
16121    /// Shuts down part of the socket.
16122    pub fn r#shutdown(
16123        &self,
16124        mut mode: ShutdownMode,
16125    ) -> fidl::client::QueryResponseFut<
16126        BaseNetworkSocketShutdownResult,
16127        fidl::encoding::DefaultFuchsiaResourceDialect,
16128    > {
16129        BaseNetworkSocketProxyInterface::r#shutdown(self, mode)
16130    }
16131
16132    /// Set `SOL_IP` -> `IP_TOS`.
16133    pub fn r#set_ip_type_of_service(
16134        &self,
16135        mut value: u8,
16136    ) -> fidl::client::QueryResponseFut<
16137        BaseNetworkSocketSetIpTypeOfServiceResult,
16138        fidl::encoding::DefaultFuchsiaResourceDialect,
16139    > {
16140        BaseNetworkSocketProxyInterface::r#set_ip_type_of_service(self, value)
16141    }
16142
16143    /// Get `SOL_IP` -> `IP_TOS`.
16144    pub fn r#get_ip_type_of_service(
16145        &self,
16146    ) -> fidl::client::QueryResponseFut<
16147        BaseNetworkSocketGetIpTypeOfServiceResult,
16148        fidl::encoding::DefaultFuchsiaResourceDialect,
16149    > {
16150        BaseNetworkSocketProxyInterface::r#get_ip_type_of_service(self)
16151    }
16152
16153    /// Set `SOL_IP` -> `IP_TTL`.
16154    pub fn r#set_ip_ttl(
16155        &self,
16156        mut value: &OptionalUint8,
16157    ) -> fidl::client::QueryResponseFut<
16158        BaseNetworkSocketSetIpTtlResult,
16159        fidl::encoding::DefaultFuchsiaResourceDialect,
16160    > {
16161        BaseNetworkSocketProxyInterface::r#set_ip_ttl(self, value)
16162    }
16163
16164    /// Get `SOL_IP` -> `IP_TTL`.
16165    pub fn r#get_ip_ttl(
16166        &self,
16167    ) -> fidl::client::QueryResponseFut<
16168        BaseNetworkSocketGetIpTtlResult,
16169        fidl::encoding::DefaultFuchsiaResourceDialect,
16170    > {
16171        BaseNetworkSocketProxyInterface::r#get_ip_ttl(self)
16172    }
16173
16174    /// Set `SOL_IP` -> `IP_PKTINFO`.
16175    pub fn r#set_ip_packet_info(
16176        &self,
16177        mut value: bool,
16178    ) -> fidl::client::QueryResponseFut<
16179        BaseNetworkSocketSetIpPacketInfoResult,
16180        fidl::encoding::DefaultFuchsiaResourceDialect,
16181    > {
16182        BaseNetworkSocketProxyInterface::r#set_ip_packet_info(self, value)
16183    }
16184
16185    /// Get `SOL_IP` -> `IP_PKTINFO`.
16186    pub fn r#get_ip_packet_info(
16187        &self,
16188    ) -> fidl::client::QueryResponseFut<
16189        BaseNetworkSocketGetIpPacketInfoResult,
16190        fidl::encoding::DefaultFuchsiaResourceDialect,
16191    > {
16192        BaseNetworkSocketProxyInterface::r#get_ip_packet_info(self)
16193    }
16194
16195    /// Set `SOL_IP` -> `IP_RECVTOS`.
16196    pub fn r#set_ip_receive_type_of_service(
16197        &self,
16198        mut value: bool,
16199    ) -> fidl::client::QueryResponseFut<
16200        BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
16201        fidl::encoding::DefaultFuchsiaResourceDialect,
16202    > {
16203        BaseNetworkSocketProxyInterface::r#set_ip_receive_type_of_service(self, value)
16204    }
16205
16206    /// Get `SOL_IP` -> `IP_RECVTOS`.
16207    pub fn r#get_ip_receive_type_of_service(
16208        &self,
16209    ) -> fidl::client::QueryResponseFut<
16210        BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
16211        fidl::encoding::DefaultFuchsiaResourceDialect,
16212    > {
16213        BaseNetworkSocketProxyInterface::r#get_ip_receive_type_of_service(self)
16214    }
16215
16216    /// Set `SOL_IP` -> `IP_RECVTTL`.
16217    pub fn r#set_ip_receive_ttl(
16218        &self,
16219        mut value: bool,
16220    ) -> fidl::client::QueryResponseFut<
16221        BaseNetworkSocketSetIpReceiveTtlResult,
16222        fidl::encoding::DefaultFuchsiaResourceDialect,
16223    > {
16224        BaseNetworkSocketProxyInterface::r#set_ip_receive_ttl(self, value)
16225    }
16226
16227    /// Get `SOL_IP` -> `IP_RECVTTL`.
16228    pub fn r#get_ip_receive_ttl(
16229        &self,
16230    ) -> fidl::client::QueryResponseFut<
16231        BaseNetworkSocketGetIpReceiveTtlResult,
16232        fidl::encoding::DefaultFuchsiaResourceDialect,
16233    > {
16234        BaseNetworkSocketProxyInterface::r#get_ip_receive_ttl(self)
16235    }
16236
16237    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
16238    pub fn r#set_ip_multicast_interface(
16239        &self,
16240        mut iface: u64,
16241        mut address: &fidl_fuchsia_net::Ipv4Address,
16242    ) -> fidl::client::QueryResponseFut<
16243        BaseNetworkSocketSetIpMulticastInterfaceResult,
16244        fidl::encoding::DefaultFuchsiaResourceDialect,
16245    > {
16246        BaseNetworkSocketProxyInterface::r#set_ip_multicast_interface(self, iface, address)
16247    }
16248
16249    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
16250    pub fn r#get_ip_multicast_interface(
16251        &self,
16252    ) -> fidl::client::QueryResponseFut<
16253        BaseNetworkSocketGetIpMulticastInterfaceResult,
16254        fidl::encoding::DefaultFuchsiaResourceDialect,
16255    > {
16256        BaseNetworkSocketProxyInterface::r#get_ip_multicast_interface(self)
16257    }
16258
16259    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
16260    pub fn r#set_ip_multicast_ttl(
16261        &self,
16262        mut value: &OptionalUint8,
16263    ) -> fidl::client::QueryResponseFut<
16264        BaseNetworkSocketSetIpMulticastTtlResult,
16265        fidl::encoding::DefaultFuchsiaResourceDialect,
16266    > {
16267        BaseNetworkSocketProxyInterface::r#set_ip_multicast_ttl(self, value)
16268    }
16269
16270    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
16271    pub fn r#get_ip_multicast_ttl(
16272        &self,
16273    ) -> fidl::client::QueryResponseFut<
16274        BaseNetworkSocketGetIpMulticastTtlResult,
16275        fidl::encoding::DefaultFuchsiaResourceDialect,
16276    > {
16277        BaseNetworkSocketProxyInterface::r#get_ip_multicast_ttl(self)
16278    }
16279
16280    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
16281    pub fn r#set_ip_multicast_loopback(
16282        &self,
16283        mut value: bool,
16284    ) -> fidl::client::QueryResponseFut<
16285        BaseNetworkSocketSetIpMulticastLoopbackResult,
16286        fidl::encoding::DefaultFuchsiaResourceDialect,
16287    > {
16288        BaseNetworkSocketProxyInterface::r#set_ip_multicast_loopback(self, value)
16289    }
16290
16291    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
16292    pub fn r#get_ip_multicast_loopback(
16293        &self,
16294    ) -> fidl::client::QueryResponseFut<
16295        BaseNetworkSocketGetIpMulticastLoopbackResult,
16296        fidl::encoding::DefaultFuchsiaResourceDialect,
16297    > {
16298        BaseNetworkSocketProxyInterface::r#get_ip_multicast_loopback(self)
16299    }
16300
16301    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
16302    pub fn r#add_ip_membership(
16303        &self,
16304        mut membership: &IpMulticastMembership,
16305    ) -> fidl::client::QueryResponseFut<
16306        BaseNetworkSocketAddIpMembershipResult,
16307        fidl::encoding::DefaultFuchsiaResourceDialect,
16308    > {
16309        BaseNetworkSocketProxyInterface::r#add_ip_membership(self, membership)
16310    }
16311
16312    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
16313    pub fn r#drop_ip_membership(
16314        &self,
16315        mut membership: &IpMulticastMembership,
16316    ) -> fidl::client::QueryResponseFut<
16317        BaseNetworkSocketDropIpMembershipResult,
16318        fidl::encoding::DefaultFuchsiaResourceDialect,
16319    > {
16320        BaseNetworkSocketProxyInterface::r#drop_ip_membership(self, membership)
16321    }
16322
16323    /// Set `SOL_IP` -> `IP_TRANSPARENT`
16324    pub fn r#set_ip_transparent(
16325        &self,
16326        mut value: bool,
16327    ) -> fidl::client::QueryResponseFut<
16328        BaseNetworkSocketSetIpTransparentResult,
16329        fidl::encoding::DefaultFuchsiaResourceDialect,
16330    > {
16331        BaseNetworkSocketProxyInterface::r#set_ip_transparent(self, value)
16332    }
16333
16334    /// Get `SOL_IP` -> `IP_TRANSPARENT`
16335    pub fn r#get_ip_transparent(
16336        &self,
16337    ) -> fidl::client::QueryResponseFut<
16338        BaseNetworkSocketGetIpTransparentResult,
16339        fidl::encoding::DefaultFuchsiaResourceDialect,
16340    > {
16341        BaseNetworkSocketProxyInterface::r#get_ip_transparent(self)
16342    }
16343
16344    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
16345    pub fn r#set_ip_receive_original_destination_address(
16346        &self,
16347        mut value: bool,
16348    ) -> fidl::client::QueryResponseFut<
16349        BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
16350        fidl::encoding::DefaultFuchsiaResourceDialect,
16351    > {
16352        BaseNetworkSocketProxyInterface::r#set_ip_receive_original_destination_address(self, value)
16353    }
16354
16355    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
16356    pub fn r#get_ip_receive_original_destination_address(
16357        &self,
16358    ) -> fidl::client::QueryResponseFut<
16359        BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
16360        fidl::encoding::DefaultFuchsiaResourceDialect,
16361    > {
16362        BaseNetworkSocketProxyInterface::r#get_ip_receive_original_destination_address(self)
16363    }
16364
16365    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
16366    pub fn r#add_ipv6_membership(
16367        &self,
16368        mut membership: &Ipv6MulticastMembership,
16369    ) -> fidl::client::QueryResponseFut<
16370        BaseNetworkSocketAddIpv6MembershipResult,
16371        fidl::encoding::DefaultFuchsiaResourceDialect,
16372    > {
16373        BaseNetworkSocketProxyInterface::r#add_ipv6_membership(self, membership)
16374    }
16375
16376    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
16377    pub fn r#drop_ipv6_membership(
16378        &self,
16379        mut membership: &Ipv6MulticastMembership,
16380    ) -> fidl::client::QueryResponseFut<
16381        BaseNetworkSocketDropIpv6MembershipResult,
16382        fidl::encoding::DefaultFuchsiaResourceDialect,
16383    > {
16384        BaseNetworkSocketProxyInterface::r#drop_ipv6_membership(self, membership)
16385    }
16386
16387    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
16388    pub fn r#set_ipv6_multicast_interface(
16389        &self,
16390        mut value: u64,
16391    ) -> fidl::client::QueryResponseFut<
16392        BaseNetworkSocketSetIpv6MulticastInterfaceResult,
16393        fidl::encoding::DefaultFuchsiaResourceDialect,
16394    > {
16395        BaseNetworkSocketProxyInterface::r#set_ipv6_multicast_interface(self, value)
16396    }
16397
16398    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
16399    pub fn r#get_ipv6_multicast_interface(
16400        &self,
16401    ) -> fidl::client::QueryResponseFut<
16402        BaseNetworkSocketGetIpv6MulticastInterfaceResult,
16403        fidl::encoding::DefaultFuchsiaResourceDialect,
16404    > {
16405        BaseNetworkSocketProxyInterface::r#get_ipv6_multicast_interface(self)
16406    }
16407
16408    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
16409    pub fn r#set_ipv6_unicast_hops(
16410        &self,
16411        mut value: &OptionalUint8,
16412    ) -> fidl::client::QueryResponseFut<
16413        BaseNetworkSocketSetIpv6UnicastHopsResult,
16414        fidl::encoding::DefaultFuchsiaResourceDialect,
16415    > {
16416        BaseNetworkSocketProxyInterface::r#set_ipv6_unicast_hops(self, value)
16417    }
16418
16419    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
16420    pub fn r#get_ipv6_unicast_hops(
16421        &self,
16422    ) -> fidl::client::QueryResponseFut<
16423        BaseNetworkSocketGetIpv6UnicastHopsResult,
16424        fidl::encoding::DefaultFuchsiaResourceDialect,
16425    > {
16426        BaseNetworkSocketProxyInterface::r#get_ipv6_unicast_hops(self)
16427    }
16428
16429    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
16430    pub fn r#set_ipv6_receive_hop_limit(
16431        &self,
16432        mut value: bool,
16433    ) -> fidl::client::QueryResponseFut<
16434        BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
16435        fidl::encoding::DefaultFuchsiaResourceDialect,
16436    > {
16437        BaseNetworkSocketProxyInterface::r#set_ipv6_receive_hop_limit(self, value)
16438    }
16439
16440    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
16441    pub fn r#get_ipv6_receive_hop_limit(
16442        &self,
16443    ) -> fidl::client::QueryResponseFut<
16444        BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
16445        fidl::encoding::DefaultFuchsiaResourceDialect,
16446    > {
16447        BaseNetworkSocketProxyInterface::r#get_ipv6_receive_hop_limit(self)
16448    }
16449
16450    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
16451    pub fn r#set_ipv6_multicast_hops(
16452        &self,
16453        mut value: &OptionalUint8,
16454    ) -> fidl::client::QueryResponseFut<
16455        BaseNetworkSocketSetIpv6MulticastHopsResult,
16456        fidl::encoding::DefaultFuchsiaResourceDialect,
16457    > {
16458        BaseNetworkSocketProxyInterface::r#set_ipv6_multicast_hops(self, value)
16459    }
16460
16461    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
16462    pub fn r#get_ipv6_multicast_hops(
16463        &self,
16464    ) -> fidl::client::QueryResponseFut<
16465        BaseNetworkSocketGetIpv6MulticastHopsResult,
16466        fidl::encoding::DefaultFuchsiaResourceDialect,
16467    > {
16468        BaseNetworkSocketProxyInterface::r#get_ipv6_multicast_hops(self)
16469    }
16470
16471    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
16472    pub fn r#set_ipv6_multicast_loopback(
16473        &self,
16474        mut value: bool,
16475    ) -> fidl::client::QueryResponseFut<
16476        BaseNetworkSocketSetIpv6MulticastLoopbackResult,
16477        fidl::encoding::DefaultFuchsiaResourceDialect,
16478    > {
16479        BaseNetworkSocketProxyInterface::r#set_ipv6_multicast_loopback(self, value)
16480    }
16481
16482    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
16483    pub fn r#get_ipv6_multicast_loopback(
16484        &self,
16485    ) -> fidl::client::QueryResponseFut<
16486        BaseNetworkSocketGetIpv6MulticastLoopbackResult,
16487        fidl::encoding::DefaultFuchsiaResourceDialect,
16488    > {
16489        BaseNetworkSocketProxyInterface::r#get_ipv6_multicast_loopback(self)
16490    }
16491
16492    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
16493    pub fn r#set_ipv6_only(
16494        &self,
16495        mut value: bool,
16496    ) -> fidl::client::QueryResponseFut<
16497        BaseNetworkSocketSetIpv6OnlyResult,
16498        fidl::encoding::DefaultFuchsiaResourceDialect,
16499    > {
16500        BaseNetworkSocketProxyInterface::r#set_ipv6_only(self, value)
16501    }
16502
16503    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
16504    pub fn r#get_ipv6_only(
16505        &self,
16506    ) -> fidl::client::QueryResponseFut<
16507        BaseNetworkSocketGetIpv6OnlyResult,
16508        fidl::encoding::DefaultFuchsiaResourceDialect,
16509    > {
16510        BaseNetworkSocketProxyInterface::r#get_ipv6_only(self)
16511    }
16512
16513    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
16514    pub fn r#set_ipv6_receive_traffic_class(
16515        &self,
16516        mut value: bool,
16517    ) -> fidl::client::QueryResponseFut<
16518        BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
16519        fidl::encoding::DefaultFuchsiaResourceDialect,
16520    > {
16521        BaseNetworkSocketProxyInterface::r#set_ipv6_receive_traffic_class(self, value)
16522    }
16523
16524    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
16525    pub fn r#get_ipv6_receive_traffic_class(
16526        &self,
16527    ) -> fidl::client::QueryResponseFut<
16528        BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
16529        fidl::encoding::DefaultFuchsiaResourceDialect,
16530    > {
16531        BaseNetworkSocketProxyInterface::r#get_ipv6_receive_traffic_class(self)
16532    }
16533
16534    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
16535    pub fn r#set_ipv6_traffic_class(
16536        &self,
16537        mut value: &OptionalUint8,
16538    ) -> fidl::client::QueryResponseFut<
16539        BaseNetworkSocketSetIpv6TrafficClassResult,
16540        fidl::encoding::DefaultFuchsiaResourceDialect,
16541    > {
16542        BaseNetworkSocketProxyInterface::r#set_ipv6_traffic_class(self, value)
16543    }
16544
16545    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
16546    pub fn r#get_ipv6_traffic_class(
16547        &self,
16548    ) -> fidl::client::QueryResponseFut<
16549        BaseNetworkSocketGetIpv6TrafficClassResult,
16550        fidl::encoding::DefaultFuchsiaResourceDialect,
16551    > {
16552        BaseNetworkSocketProxyInterface::r#get_ipv6_traffic_class(self)
16553    }
16554
16555    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
16556    pub fn r#set_ipv6_receive_packet_info(
16557        &self,
16558        mut value: bool,
16559    ) -> fidl::client::QueryResponseFut<
16560        BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
16561        fidl::encoding::DefaultFuchsiaResourceDialect,
16562    > {
16563        BaseNetworkSocketProxyInterface::r#set_ipv6_receive_packet_info(self, value)
16564    }
16565
16566    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
16567    pub fn r#get_ipv6_receive_packet_info(
16568        &self,
16569    ) -> fidl::client::QueryResponseFut<
16570        BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
16571        fidl::encoding::DefaultFuchsiaResourceDialect,
16572    > {
16573        BaseNetworkSocketProxyInterface::r#get_ipv6_receive_packet_info(self)
16574    }
16575
16576    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
16577    pub fn r#get_original_destination(
16578        &self,
16579    ) -> fidl::client::QueryResponseFut<
16580        BaseNetworkSocketGetOriginalDestinationResult,
16581        fidl::encoding::DefaultFuchsiaResourceDialect,
16582    > {
16583        BaseNetworkSocketProxyInterface::r#get_original_destination(self)
16584    }
16585}
16586
16587impl BaseNetworkSocketProxyInterface for BaseNetworkSocketProxy {
16588    fn r#clone(
16589        &self,
16590        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
16591    ) -> Result<(), fidl::Error> {
16592        self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
16593            (request,),
16594            0x20d8a7aba2168a79,
16595            fidl::encoding::DynamicFlags::empty(),
16596        )
16597    }
16598
16599    type CloseResponseFut = fidl::client::QueryResponseFut<
16600        fidl_fuchsia_unknown::CloseableCloseResult,
16601        fidl::encoding::DefaultFuchsiaResourceDialect,
16602    >;
16603    fn r#close(&self) -> Self::CloseResponseFut {
16604        fn _decode(
16605            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16606        ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
16607            let _response = fidl::client::decode_transaction_body::<
16608                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
16609                fidl::encoding::DefaultFuchsiaResourceDialect,
16610                0x5ac5d459ad7f657e,
16611            >(_buf?)?;
16612            Ok(_response.map(|x| x))
16613        }
16614        self.client.send_query_and_decode::<
16615            fidl::encoding::EmptyPayload,
16616            fidl_fuchsia_unknown::CloseableCloseResult,
16617        >(
16618            (),
16619            0x5ac5d459ad7f657e,
16620            fidl::encoding::DynamicFlags::empty(),
16621            _decode,
16622        )
16623    }
16624
16625    type QueryResponseFut =
16626        fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>;
16627    fn r#query(&self) -> Self::QueryResponseFut {
16628        fn _decode(
16629            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16630        ) -> Result<Vec<u8>, fidl::Error> {
16631            let _response = fidl::client::decode_transaction_body::<
16632                fidl_fuchsia_unknown::QueryableQueryResponse,
16633                fidl::encoding::DefaultFuchsiaResourceDialect,
16634                0x2658edee9decfc06,
16635            >(_buf?)?;
16636            Ok(_response.protocol)
16637        }
16638        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<u8>>(
16639            (),
16640            0x2658edee9decfc06,
16641            fidl::encoding::DynamicFlags::empty(),
16642            _decode,
16643        )
16644    }
16645
16646    type SetReuseAddressResponseFut = fidl::client::QueryResponseFut<
16647        BaseSocketSetReuseAddressResult,
16648        fidl::encoding::DefaultFuchsiaResourceDialect,
16649    >;
16650    fn r#set_reuse_address(&self, mut value: bool) -> Self::SetReuseAddressResponseFut {
16651        fn _decode(
16652            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16653        ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
16654            let _response = fidl::client::decode_transaction_body::<
16655                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
16656                fidl::encoding::DefaultFuchsiaResourceDialect,
16657                0x1fd74ee8b9a4a876,
16658            >(_buf?)?;
16659            Ok(_response.map(|x| x))
16660        }
16661        self.client.send_query_and_decode::<
16662            BaseSocketSetReuseAddressRequest,
16663            BaseSocketSetReuseAddressResult,
16664        >(
16665            (value,),
16666            0x1fd74ee8b9a4a876,
16667            fidl::encoding::DynamicFlags::empty(),
16668            _decode,
16669        )
16670    }
16671
16672    type GetReuseAddressResponseFut = fidl::client::QueryResponseFut<
16673        BaseSocketGetReuseAddressResult,
16674        fidl::encoding::DefaultFuchsiaResourceDialect,
16675    >;
16676    fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut {
16677        fn _decode(
16678            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16679        ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
16680            let _response = fidl::client::decode_transaction_body::<
16681                fidl::encoding::ResultType<
16682                    BaseSocketGetReuseAddressResponse,
16683                    fidl_fuchsia_posix::Errno,
16684                >,
16685                fidl::encoding::DefaultFuchsiaResourceDialect,
16686                0x67b7206b8d1bc0a5,
16687            >(_buf?)?;
16688            Ok(_response.map(|x| x.value))
16689        }
16690        self.client
16691            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReuseAddressResult>(
16692                (),
16693                0x67b7206b8d1bc0a5,
16694                fidl::encoding::DynamicFlags::empty(),
16695                _decode,
16696            )
16697    }
16698
16699    type GetErrorResponseFut = fidl::client::QueryResponseFut<
16700        BaseSocketGetErrorResult,
16701        fidl::encoding::DefaultFuchsiaResourceDialect,
16702    >;
16703    fn r#get_error(&self) -> Self::GetErrorResponseFut {
16704        fn _decode(
16705            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16706        ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
16707            let _response = fidl::client::decode_transaction_body::<
16708                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
16709                fidl::encoding::DefaultFuchsiaResourceDialect,
16710                0x5aad39b33e5f6ebb,
16711            >(_buf?)?;
16712            Ok(_response.map(|x| x))
16713        }
16714        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetErrorResult>(
16715            (),
16716            0x5aad39b33e5f6ebb,
16717            fidl::encoding::DynamicFlags::empty(),
16718            _decode,
16719        )
16720    }
16721
16722    type SetBroadcastResponseFut = fidl::client::QueryResponseFut<
16723        BaseSocketSetBroadcastResult,
16724        fidl::encoding::DefaultFuchsiaResourceDialect,
16725    >;
16726    fn r#set_broadcast(&self, mut value: bool) -> Self::SetBroadcastResponseFut {
16727        fn _decode(
16728            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16729        ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
16730            let _response = fidl::client::decode_transaction_body::<
16731                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
16732                fidl::encoding::DefaultFuchsiaResourceDialect,
16733                0x6023e081ce3cd947,
16734            >(_buf?)?;
16735            Ok(_response.map(|x| x))
16736        }
16737        self.client
16738            .send_query_and_decode::<BaseSocketSetBroadcastRequest, BaseSocketSetBroadcastResult>(
16739                (value,),
16740                0x6023e081ce3cd947,
16741                fidl::encoding::DynamicFlags::empty(),
16742                _decode,
16743            )
16744    }
16745
16746    type GetBroadcastResponseFut = fidl::client::QueryResponseFut<
16747        BaseSocketGetBroadcastResult,
16748        fidl::encoding::DefaultFuchsiaResourceDialect,
16749    >;
16750    fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut {
16751        fn _decode(
16752            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16753        ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
16754            let _response = fidl::client::decode_transaction_body::<
16755                fidl::encoding::ResultType<
16756                    BaseSocketGetBroadcastResponse,
16757                    fidl_fuchsia_posix::Errno,
16758                >,
16759                fidl::encoding::DefaultFuchsiaResourceDialect,
16760                0x68796fc556f9780d,
16761            >(_buf?)?;
16762            Ok(_response.map(|x| x.value))
16763        }
16764        self.client
16765            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBroadcastResult>(
16766                (),
16767                0x68796fc556f9780d,
16768                fidl::encoding::DynamicFlags::empty(),
16769                _decode,
16770            )
16771    }
16772
16773    type SetSendBufferResponseFut = fidl::client::QueryResponseFut<
16774        BaseSocketSetSendBufferResult,
16775        fidl::encoding::DefaultFuchsiaResourceDialect,
16776    >;
16777    fn r#set_send_buffer(&self, mut value_bytes: u64) -> Self::SetSendBufferResponseFut {
16778        fn _decode(
16779            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16780        ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
16781            let _response = fidl::client::decode_transaction_body::<
16782                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
16783                fidl::encoding::DefaultFuchsiaResourceDialect,
16784                0x756eac32d73a7a70,
16785            >(_buf?)?;
16786            Ok(_response.map(|x| x))
16787        }
16788        self.client
16789            .send_query_and_decode::<BaseSocketSetSendBufferRequest, BaseSocketSetSendBufferResult>(
16790                (value_bytes,),
16791                0x756eac32d73a7a70,
16792                fidl::encoding::DynamicFlags::empty(),
16793                _decode,
16794            )
16795    }
16796
16797    type GetSendBufferResponseFut = fidl::client::QueryResponseFut<
16798        BaseSocketGetSendBufferResult,
16799        fidl::encoding::DefaultFuchsiaResourceDialect,
16800    >;
16801    fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut {
16802        fn _decode(
16803            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16804        ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
16805            let _response = fidl::client::decode_transaction_body::<
16806                fidl::encoding::ResultType<
16807                    BaseSocketGetSendBufferResponse,
16808                    fidl_fuchsia_posix::Errno,
16809                >,
16810                fidl::encoding::DefaultFuchsiaResourceDialect,
16811                0x78a52fd9c7b2410b,
16812            >(_buf?)?;
16813            Ok(_response.map(|x| x.value_bytes))
16814        }
16815        self.client
16816            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetSendBufferResult>(
16817                (),
16818                0x78a52fd9c7b2410b,
16819                fidl::encoding::DynamicFlags::empty(),
16820                _decode,
16821            )
16822    }
16823
16824    type SetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
16825        BaseSocketSetReceiveBufferResult,
16826        fidl::encoding::DefaultFuchsiaResourceDialect,
16827    >;
16828    fn r#set_receive_buffer(&self, mut value_bytes: u64) -> Self::SetReceiveBufferResponseFut {
16829        fn _decode(
16830            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16831        ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
16832            let _response = fidl::client::decode_transaction_body::<
16833                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
16834                fidl::encoding::DefaultFuchsiaResourceDialect,
16835                0x6b0cf2f1919c7001,
16836            >(_buf?)?;
16837            Ok(_response.map(|x| x))
16838        }
16839        self.client.send_query_and_decode::<
16840            BaseSocketSetReceiveBufferRequest,
16841            BaseSocketSetReceiveBufferResult,
16842        >(
16843            (value_bytes,),
16844            0x6b0cf2f1919c7001,
16845            fidl::encoding::DynamicFlags::empty(),
16846            _decode,
16847        )
16848    }
16849
16850    type GetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
16851        BaseSocketGetReceiveBufferResult,
16852        fidl::encoding::DefaultFuchsiaResourceDialect,
16853    >;
16854    fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut {
16855        fn _decode(
16856            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16857        ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
16858            let _response = fidl::client::decode_transaction_body::<
16859                fidl::encoding::ResultType<
16860                    BaseSocketGetReceiveBufferResponse,
16861                    fidl_fuchsia_posix::Errno,
16862                >,
16863                fidl::encoding::DefaultFuchsiaResourceDialect,
16864                0x14c1a4b64f709e5c,
16865            >(_buf?)?;
16866            Ok(_response.map(|x| x.value_bytes))
16867        }
16868        self.client.send_query_and_decode::<
16869            fidl::encoding::EmptyPayload,
16870            BaseSocketGetReceiveBufferResult,
16871        >(
16872            (),
16873            0x14c1a4b64f709e5c,
16874            fidl::encoding::DynamicFlags::empty(),
16875            _decode,
16876        )
16877    }
16878
16879    type SetKeepAliveResponseFut = fidl::client::QueryResponseFut<
16880        BaseSocketSetKeepAliveResult,
16881        fidl::encoding::DefaultFuchsiaResourceDialect,
16882    >;
16883    fn r#set_keep_alive(&self, mut value: bool) -> Self::SetKeepAliveResponseFut {
16884        fn _decode(
16885            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16886        ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
16887            let _response = fidl::client::decode_transaction_body::<
16888                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
16889                fidl::encoding::DefaultFuchsiaResourceDialect,
16890                0x572df8f0b920d2c7,
16891            >(_buf?)?;
16892            Ok(_response.map(|x| x))
16893        }
16894        self.client
16895            .send_query_and_decode::<BaseSocketSetKeepAliveRequest, BaseSocketSetKeepAliveResult>(
16896                (value,),
16897                0x572df8f0b920d2c7,
16898                fidl::encoding::DynamicFlags::empty(),
16899                _decode,
16900            )
16901    }
16902
16903    type GetKeepAliveResponseFut = fidl::client::QueryResponseFut<
16904        BaseSocketGetKeepAliveResult,
16905        fidl::encoding::DefaultFuchsiaResourceDialect,
16906    >;
16907    fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut {
16908        fn _decode(
16909            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16910        ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
16911            let _response = fidl::client::decode_transaction_body::<
16912                fidl::encoding::ResultType<
16913                    BaseSocketGetKeepAliveResponse,
16914                    fidl_fuchsia_posix::Errno,
16915                >,
16916                fidl::encoding::DefaultFuchsiaResourceDialect,
16917                0x2dd29d3215f2c9d2,
16918            >(_buf?)?;
16919            Ok(_response.map(|x| x.value))
16920        }
16921        self.client
16922            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetKeepAliveResult>(
16923                (),
16924                0x2dd29d3215f2c9d2,
16925                fidl::encoding::DynamicFlags::empty(),
16926                _decode,
16927            )
16928    }
16929
16930    type SetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
16931        BaseSocketSetOutOfBandInlineResult,
16932        fidl::encoding::DefaultFuchsiaResourceDialect,
16933    >;
16934    fn r#set_out_of_band_inline(&self, mut value: bool) -> Self::SetOutOfBandInlineResponseFut {
16935        fn _decode(
16936            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16937        ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
16938            let _response = fidl::client::decode_transaction_body::<
16939                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
16940                fidl::encoding::DefaultFuchsiaResourceDialect,
16941                0x3ecb49968bee439,
16942            >(_buf?)?;
16943            Ok(_response.map(|x| x))
16944        }
16945        self.client.send_query_and_decode::<
16946            BaseSocketSetOutOfBandInlineRequest,
16947            BaseSocketSetOutOfBandInlineResult,
16948        >(
16949            (value,),
16950            0x3ecb49968bee439,
16951            fidl::encoding::DynamicFlags::empty(),
16952            _decode,
16953        )
16954    }
16955
16956    type GetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
16957        BaseSocketGetOutOfBandInlineResult,
16958        fidl::encoding::DefaultFuchsiaResourceDialect,
16959    >;
16960    fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut {
16961        fn _decode(
16962            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16963        ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
16964            let _response = fidl::client::decode_transaction_body::<
16965                fidl::encoding::ResultType<
16966                    BaseSocketGetOutOfBandInlineResponse,
16967                    fidl_fuchsia_posix::Errno,
16968                >,
16969                fidl::encoding::DefaultFuchsiaResourceDialect,
16970                0x348c1ab3aeca1745,
16971            >(_buf?)?;
16972            Ok(_response.map(|x| x.value))
16973        }
16974        self.client.send_query_and_decode::<
16975            fidl::encoding::EmptyPayload,
16976            BaseSocketGetOutOfBandInlineResult,
16977        >(
16978            (),
16979            0x348c1ab3aeca1745,
16980            fidl::encoding::DynamicFlags::empty(),
16981            _decode,
16982        )
16983    }
16984
16985    type SetNoCheckResponseFut = fidl::client::QueryResponseFut<
16986        BaseSocketSetNoCheckResult,
16987        fidl::encoding::DefaultFuchsiaResourceDialect,
16988    >;
16989    fn r#set_no_check(&self, mut value: bool) -> Self::SetNoCheckResponseFut {
16990        fn _decode(
16991            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
16992        ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
16993            let _response = fidl::client::decode_transaction_body::<
16994                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
16995                fidl::encoding::DefaultFuchsiaResourceDialect,
16996                0x6bbf00c53a4c78c2,
16997            >(_buf?)?;
16998            Ok(_response.map(|x| x))
16999        }
17000        self.client
17001            .send_query_and_decode::<BaseSocketSetNoCheckRequest, BaseSocketSetNoCheckResult>(
17002                (value,),
17003                0x6bbf00c53a4c78c2,
17004                fidl::encoding::DynamicFlags::empty(),
17005                _decode,
17006            )
17007    }
17008
17009    type GetNoCheckResponseFut = fidl::client::QueryResponseFut<
17010        BaseSocketGetNoCheckResult,
17011        fidl::encoding::DefaultFuchsiaResourceDialect,
17012    >;
17013    fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut {
17014        fn _decode(
17015            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17016        ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
17017            let _response = fidl::client::decode_transaction_body::<
17018                fidl::encoding::ResultType<BaseSocketGetNoCheckResponse, fidl_fuchsia_posix::Errno>,
17019                fidl::encoding::DefaultFuchsiaResourceDialect,
17020                0x2cd4249286417694,
17021            >(_buf?)?;
17022            Ok(_response.map(|x| x.value))
17023        }
17024        self.client
17025            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetNoCheckResult>(
17026                (),
17027                0x2cd4249286417694,
17028                fidl::encoding::DynamicFlags::empty(),
17029                _decode,
17030            )
17031    }
17032
17033    type SetLingerResponseFut = fidl::client::QueryResponseFut<
17034        BaseSocketSetLingerResult,
17035        fidl::encoding::DefaultFuchsiaResourceDialect,
17036    >;
17037    fn r#set_linger(&self, mut linger: bool, mut length_secs: u32) -> Self::SetLingerResponseFut {
17038        fn _decode(
17039            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17040        ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
17041            let _response = fidl::client::decode_transaction_body::<
17042                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17043                fidl::encoding::DefaultFuchsiaResourceDialect,
17044                0x45386351246e998e,
17045            >(_buf?)?;
17046            Ok(_response.map(|x| x))
17047        }
17048        self.client.send_query_and_decode::<BaseSocketSetLingerRequest, BaseSocketSetLingerResult>(
17049            (linger, length_secs),
17050            0x45386351246e998e,
17051            fidl::encoding::DynamicFlags::empty(),
17052            _decode,
17053        )
17054    }
17055
17056    type GetLingerResponseFut = fidl::client::QueryResponseFut<
17057        BaseSocketGetLingerResult,
17058        fidl::encoding::DefaultFuchsiaResourceDialect,
17059    >;
17060    fn r#get_linger(&self) -> Self::GetLingerResponseFut {
17061        fn _decode(
17062            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17063        ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
17064            let _response = fidl::client::decode_transaction_body::<
17065                fidl::encoding::ResultType<BaseSocketGetLingerResponse, fidl_fuchsia_posix::Errno>,
17066                fidl::encoding::DefaultFuchsiaResourceDialect,
17067                0x48eb20fc5ccb0e45,
17068            >(_buf?)?;
17069            Ok(_response.map(|x| (x.linger, x.length_secs)))
17070        }
17071        self.client
17072            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetLingerResult>(
17073                (),
17074                0x48eb20fc5ccb0e45,
17075                fidl::encoding::DynamicFlags::empty(),
17076                _decode,
17077            )
17078    }
17079
17080    type SetReusePortResponseFut = fidl::client::QueryResponseFut<
17081        BaseSocketSetReusePortResult,
17082        fidl::encoding::DefaultFuchsiaResourceDialect,
17083    >;
17084    fn r#set_reuse_port(&self, mut value: bool) -> Self::SetReusePortResponseFut {
17085        fn _decode(
17086            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17087        ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
17088            let _response = fidl::client::decode_transaction_body::<
17089                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17090                fidl::encoding::DefaultFuchsiaResourceDialect,
17091                0x24dd3e5cb36d9ccb,
17092            >(_buf?)?;
17093            Ok(_response.map(|x| x))
17094        }
17095        self.client
17096            .send_query_and_decode::<BaseSocketSetReusePortRequest, BaseSocketSetReusePortResult>(
17097                (value,),
17098                0x24dd3e5cb36d9ccb,
17099                fidl::encoding::DynamicFlags::empty(),
17100                _decode,
17101            )
17102    }
17103
17104    type GetReusePortResponseFut = fidl::client::QueryResponseFut<
17105        BaseSocketGetReusePortResult,
17106        fidl::encoding::DefaultFuchsiaResourceDialect,
17107    >;
17108    fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut {
17109        fn _decode(
17110            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17111        ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
17112            let _response = fidl::client::decode_transaction_body::<
17113                fidl::encoding::ResultType<
17114                    BaseSocketGetReusePortResponse,
17115                    fidl_fuchsia_posix::Errno,
17116                >,
17117                fidl::encoding::DefaultFuchsiaResourceDialect,
17118                0x7a112c1ab54ff828,
17119            >(_buf?)?;
17120            Ok(_response.map(|x| x.value))
17121        }
17122        self.client
17123            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReusePortResult>(
17124                (),
17125                0x7a112c1ab54ff828,
17126                fidl::encoding::DynamicFlags::empty(),
17127                _decode,
17128            )
17129    }
17130
17131    type GetAcceptConnResponseFut = fidl::client::QueryResponseFut<
17132        BaseSocketGetAcceptConnResult,
17133        fidl::encoding::DefaultFuchsiaResourceDialect,
17134    >;
17135    fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut {
17136        fn _decode(
17137            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17138        ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
17139            let _response = fidl::client::decode_transaction_body::<
17140                fidl::encoding::ResultType<
17141                    BaseSocketGetAcceptConnResponse,
17142                    fidl_fuchsia_posix::Errno,
17143                >,
17144                fidl::encoding::DefaultFuchsiaResourceDialect,
17145                0x67ce6db6c2ec8966,
17146            >(_buf?)?;
17147            Ok(_response.map(|x| x.value))
17148        }
17149        self.client
17150            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetAcceptConnResult>(
17151                (),
17152                0x67ce6db6c2ec8966,
17153                fidl::encoding::DynamicFlags::empty(),
17154                _decode,
17155            )
17156    }
17157
17158    type SetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
17159        BaseSocketSetBindToDeviceResult,
17160        fidl::encoding::DefaultFuchsiaResourceDialect,
17161    >;
17162    fn r#set_bind_to_device(&self, mut value: &str) -> Self::SetBindToDeviceResponseFut {
17163        fn _decode(
17164            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17165        ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
17166            let _response = fidl::client::decode_transaction_body::<
17167                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17168                fidl::encoding::DefaultFuchsiaResourceDialect,
17169                0x2118b483f28aafc4,
17170            >(_buf?)?;
17171            Ok(_response.map(|x| x))
17172        }
17173        self.client.send_query_and_decode::<
17174            BaseSocketSetBindToDeviceRequest,
17175            BaseSocketSetBindToDeviceResult,
17176        >(
17177            (value,),
17178            0x2118b483f28aafc4,
17179            fidl::encoding::DynamicFlags::empty(),
17180            _decode,
17181        )
17182    }
17183
17184    type GetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
17185        BaseSocketGetBindToDeviceResult,
17186        fidl::encoding::DefaultFuchsiaResourceDialect,
17187    >;
17188    fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut {
17189        fn _decode(
17190            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17191        ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
17192            let _response = fidl::client::decode_transaction_body::<
17193                fidl::encoding::ResultType<
17194                    BaseSocketGetBindToDeviceResponse,
17195                    fidl_fuchsia_posix::Errno,
17196                >,
17197                fidl::encoding::DefaultFuchsiaResourceDialect,
17198                0x1ab1fbf0ef7906c8,
17199            >(_buf?)?;
17200            Ok(_response.map(|x| x.value))
17201        }
17202        self.client
17203            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBindToDeviceResult>(
17204                (),
17205                0x1ab1fbf0ef7906c8,
17206                fidl::encoding::DynamicFlags::empty(),
17207                _decode,
17208            )
17209    }
17210
17211    type SetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
17212        BaseSocketSetBindToInterfaceIndexResult,
17213        fidl::encoding::DefaultFuchsiaResourceDialect,
17214    >;
17215    fn r#set_bind_to_interface_index(
17216        &self,
17217        mut value: u64,
17218    ) -> Self::SetBindToInterfaceIndexResponseFut {
17219        fn _decode(
17220            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17221        ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
17222            let _response = fidl::client::decode_transaction_body::<
17223                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17224                fidl::encoding::DefaultFuchsiaResourceDialect,
17225                0x6e387a0def00821,
17226            >(_buf?)?;
17227            Ok(_response.map(|x| x))
17228        }
17229        self.client.send_query_and_decode::<
17230            BaseSocketSetBindToInterfaceIndexRequest,
17231            BaseSocketSetBindToInterfaceIndexResult,
17232        >(
17233            (value,),
17234            0x6e387a0def00821,
17235            fidl::encoding::DynamicFlags::empty(),
17236            _decode,
17237        )
17238    }
17239
17240    type GetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
17241        BaseSocketGetBindToInterfaceIndexResult,
17242        fidl::encoding::DefaultFuchsiaResourceDialect,
17243    >;
17244    fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut {
17245        fn _decode(
17246            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17247        ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
17248            let _response = fidl::client::decode_transaction_body::<
17249                fidl::encoding::ResultType<
17250                    BaseSocketGetBindToInterfaceIndexResponse,
17251                    fidl_fuchsia_posix::Errno,
17252                >,
17253                fidl::encoding::DefaultFuchsiaResourceDialect,
17254                0x59c31dd3e3078295,
17255            >(_buf?)?;
17256            Ok(_response.map(|x| x.value))
17257        }
17258        self.client.send_query_and_decode::<
17259            fidl::encoding::EmptyPayload,
17260            BaseSocketGetBindToInterfaceIndexResult,
17261        >(
17262            (),
17263            0x59c31dd3e3078295,
17264            fidl::encoding::DynamicFlags::empty(),
17265            _decode,
17266        )
17267    }
17268
17269    type SetTimestampResponseFut = fidl::client::QueryResponseFut<
17270        BaseSocketSetTimestampResult,
17271        fidl::encoding::DefaultFuchsiaResourceDialect,
17272    >;
17273    fn r#set_timestamp(&self, mut value: TimestampOption) -> Self::SetTimestampResponseFut {
17274        fn _decode(
17275            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17276        ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
17277            let _response = fidl::client::decode_transaction_body::<
17278                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17279                fidl::encoding::DefaultFuchsiaResourceDialect,
17280                0x285d6516c263d839,
17281            >(_buf?)?;
17282            Ok(_response.map(|x| x))
17283        }
17284        self.client
17285            .send_query_and_decode::<BaseSocketSetTimestampRequest, BaseSocketSetTimestampResult>(
17286                (value,),
17287                0x285d6516c263d839,
17288                fidl::encoding::DynamicFlags::empty(),
17289                _decode,
17290            )
17291    }
17292
17293    type GetTimestampResponseFut = fidl::client::QueryResponseFut<
17294        BaseSocketGetTimestampResult,
17295        fidl::encoding::DefaultFuchsiaResourceDialect,
17296    >;
17297    fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut {
17298        fn _decode(
17299            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17300        ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
17301            let _response = fidl::client::decode_transaction_body::<
17302                fidl::encoding::ResultType<
17303                    BaseSocketGetTimestampResponse,
17304                    fidl_fuchsia_posix::Errno,
17305                >,
17306                fidl::encoding::DefaultFuchsiaResourceDialect,
17307                0x49f2fffbbcc2bd27,
17308            >(_buf?)?;
17309            Ok(_response.map(|x| x.value))
17310        }
17311        self.client
17312            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetTimestampResult>(
17313                (),
17314                0x49f2fffbbcc2bd27,
17315                fidl::encoding::DynamicFlags::empty(),
17316                _decode,
17317            )
17318    }
17319
17320    type SetMarkResponseFut = fidl::client::QueryResponseFut<
17321        BaseSocketSetMarkResult,
17322        fidl::encoding::DefaultFuchsiaResourceDialect,
17323    >;
17324    fn r#set_mark(
17325        &self,
17326        mut domain: fidl_fuchsia_net::MarkDomain,
17327        mut mark: &OptionalUint32,
17328    ) -> Self::SetMarkResponseFut {
17329        fn _decode(
17330            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17331        ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
17332            let _response = fidl::client::decode_transaction_body::<
17333                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17334                fidl::encoding::DefaultFuchsiaResourceDialect,
17335                0x6ead6de09f653236,
17336            >(_buf?)?;
17337            Ok(_response.map(|x| x))
17338        }
17339        self.client.send_query_and_decode::<BaseSocketSetMarkRequest, BaseSocketSetMarkResult>(
17340            (domain, mark),
17341            0x6ead6de09f653236,
17342            fidl::encoding::DynamicFlags::empty(),
17343            _decode,
17344        )
17345    }
17346
17347    type GetMarkResponseFut = fidl::client::QueryResponseFut<
17348        BaseSocketGetMarkResult,
17349        fidl::encoding::DefaultFuchsiaResourceDialect,
17350    >;
17351    fn r#get_mark(&self, mut domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut {
17352        fn _decode(
17353            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17354        ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
17355            let _response = fidl::client::decode_transaction_body::<
17356                fidl::encoding::ResultType<BaseSocketGetMarkResponse, fidl_fuchsia_posix::Errno>,
17357                fidl::encoding::DefaultFuchsiaResourceDialect,
17358                0x57a2752c61d93d47,
17359            >(_buf?)?;
17360            Ok(_response.map(|x| x.mark))
17361        }
17362        self.client.send_query_and_decode::<BaseSocketGetMarkRequest, BaseSocketGetMarkResult>(
17363            (domain,),
17364            0x57a2752c61d93d47,
17365            fidl::encoding::DynamicFlags::empty(),
17366            _decode,
17367        )
17368    }
17369
17370    type BindResponseFut = fidl::client::QueryResponseFut<
17371        BaseNetworkSocketBindResult,
17372        fidl::encoding::DefaultFuchsiaResourceDialect,
17373    >;
17374    fn r#bind(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut {
17375        fn _decode(
17376            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17377        ) -> Result<BaseNetworkSocketBindResult, fidl::Error> {
17378            let _response = fidl::client::decode_transaction_body::<
17379                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17380                fidl::encoding::DefaultFuchsiaResourceDialect,
17381                0x4bc6400ae92125d,
17382            >(_buf?)?;
17383            Ok(_response.map(|x| x))
17384        }
17385        self.client
17386            .send_query_and_decode::<BaseNetworkSocketBindRequest, BaseNetworkSocketBindResult>(
17387                (addr,),
17388                0x4bc6400ae92125d,
17389                fidl::encoding::DynamicFlags::empty(),
17390                _decode,
17391            )
17392    }
17393
17394    type ConnectResponseFut = fidl::client::QueryResponseFut<
17395        BaseNetworkSocketConnectResult,
17396        fidl::encoding::DefaultFuchsiaResourceDialect,
17397    >;
17398    fn r#connect(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut {
17399        fn _decode(
17400            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17401        ) -> Result<BaseNetworkSocketConnectResult, fidl::Error> {
17402            let _response = fidl::client::decode_transaction_body::<
17403                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17404                fidl::encoding::DefaultFuchsiaResourceDialect,
17405                0x5f05f19bfdd38871,
17406            >(_buf?)?;
17407            Ok(_response.map(|x| x))
17408        }
17409        self.client.send_query_and_decode::<
17410            BaseNetworkSocketConnectRequest,
17411            BaseNetworkSocketConnectResult,
17412        >(
17413            (addr,),
17414            0x5f05f19bfdd38871,
17415            fidl::encoding::DynamicFlags::empty(),
17416            _decode,
17417        )
17418    }
17419
17420    type DisconnectResponseFut = fidl::client::QueryResponseFut<
17421        BaseNetworkSocketDisconnectResult,
17422        fidl::encoding::DefaultFuchsiaResourceDialect,
17423    >;
17424    fn r#disconnect(&self) -> Self::DisconnectResponseFut {
17425        fn _decode(
17426            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17427        ) -> Result<BaseNetworkSocketDisconnectResult, fidl::Error> {
17428            let _response = fidl::client::decode_transaction_body::<
17429                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17430                fidl::encoding::DefaultFuchsiaResourceDialect,
17431                0x74e63b91f7b29b2,
17432            >(_buf?)?;
17433            Ok(_response.map(|x| x))
17434        }
17435        self.client.send_query_and_decode::<
17436            fidl::encoding::EmptyPayload,
17437            BaseNetworkSocketDisconnectResult,
17438        >(
17439            (),
17440            0x74e63b91f7b29b2,
17441            fidl::encoding::DynamicFlags::empty(),
17442            _decode,
17443        )
17444    }
17445
17446    type GetSockNameResponseFut = fidl::client::QueryResponseFut<
17447        BaseNetworkSocketGetSockNameResult,
17448        fidl::encoding::DefaultFuchsiaResourceDialect,
17449    >;
17450    fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut {
17451        fn _decode(
17452            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17453        ) -> Result<BaseNetworkSocketGetSockNameResult, fidl::Error> {
17454            let _response = fidl::client::decode_transaction_body::<
17455                fidl::encoding::ResultType<
17456                    BaseNetworkSocketGetSockNameResponse,
17457                    fidl_fuchsia_posix::Errno,
17458                >,
17459                fidl::encoding::DefaultFuchsiaResourceDialect,
17460                0x475f23f84a1a4f85,
17461            >(_buf?)?;
17462            Ok(_response.map(|x| x.addr))
17463        }
17464        self.client.send_query_and_decode::<
17465            fidl::encoding::EmptyPayload,
17466            BaseNetworkSocketGetSockNameResult,
17467        >(
17468            (),
17469            0x475f23f84a1a4f85,
17470            fidl::encoding::DynamicFlags::empty(),
17471            _decode,
17472        )
17473    }
17474
17475    type GetPeerNameResponseFut = fidl::client::QueryResponseFut<
17476        BaseNetworkSocketGetPeerNameResult,
17477        fidl::encoding::DefaultFuchsiaResourceDialect,
17478    >;
17479    fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut {
17480        fn _decode(
17481            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17482        ) -> Result<BaseNetworkSocketGetPeerNameResult, fidl::Error> {
17483            let _response = fidl::client::decode_transaction_body::<
17484                fidl::encoding::ResultType<
17485                    BaseNetworkSocketGetPeerNameResponse,
17486                    fidl_fuchsia_posix::Errno,
17487                >,
17488                fidl::encoding::DefaultFuchsiaResourceDialect,
17489                0x1ffecf4bd5b6432e,
17490            >(_buf?)?;
17491            Ok(_response.map(|x| x.addr))
17492        }
17493        self.client.send_query_and_decode::<
17494            fidl::encoding::EmptyPayload,
17495            BaseNetworkSocketGetPeerNameResult,
17496        >(
17497            (),
17498            0x1ffecf4bd5b6432e,
17499            fidl::encoding::DynamicFlags::empty(),
17500            _decode,
17501        )
17502    }
17503
17504    type ShutdownResponseFut = fidl::client::QueryResponseFut<
17505        BaseNetworkSocketShutdownResult,
17506        fidl::encoding::DefaultFuchsiaResourceDialect,
17507    >;
17508    fn r#shutdown(&self, mut mode: ShutdownMode) -> Self::ShutdownResponseFut {
17509        fn _decode(
17510            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17511        ) -> Result<BaseNetworkSocketShutdownResult, fidl::Error> {
17512            let _response = fidl::client::decode_transaction_body::<
17513                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17514                fidl::encoding::DefaultFuchsiaResourceDialect,
17515                0x247f38b6db68c336,
17516            >(_buf?)?;
17517            Ok(_response.map(|x| x))
17518        }
17519        self.client.send_query_and_decode::<
17520            BaseNetworkSocketShutdownRequest,
17521            BaseNetworkSocketShutdownResult,
17522        >(
17523            (mode,),
17524            0x247f38b6db68c336,
17525            fidl::encoding::DynamicFlags::empty(),
17526            _decode,
17527        )
17528    }
17529
17530    type SetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
17531        BaseNetworkSocketSetIpTypeOfServiceResult,
17532        fidl::encoding::DefaultFuchsiaResourceDialect,
17533    >;
17534    fn r#set_ip_type_of_service(&self, mut value: u8) -> Self::SetIpTypeOfServiceResponseFut {
17535        fn _decode(
17536            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17537        ) -> Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error> {
17538            let _response = fidl::client::decode_transaction_body::<
17539                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17540                fidl::encoding::DefaultFuchsiaResourceDialect,
17541                0x995c600475b6d46,
17542            >(_buf?)?;
17543            Ok(_response.map(|x| x))
17544        }
17545        self.client.send_query_and_decode::<
17546            BaseNetworkSocketSetIpTypeOfServiceRequest,
17547            BaseNetworkSocketSetIpTypeOfServiceResult,
17548        >(
17549            (value,),
17550            0x995c600475b6d46,
17551            fidl::encoding::DynamicFlags::empty(),
17552            _decode,
17553        )
17554    }
17555
17556    type GetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
17557        BaseNetworkSocketGetIpTypeOfServiceResult,
17558        fidl::encoding::DefaultFuchsiaResourceDialect,
17559    >;
17560    fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut {
17561        fn _decode(
17562            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17563        ) -> Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error> {
17564            let _response = fidl::client::decode_transaction_body::<
17565                fidl::encoding::ResultType<
17566                    BaseNetworkSocketGetIpTypeOfServiceResponse,
17567                    fidl_fuchsia_posix::Errno,
17568                >,
17569                fidl::encoding::DefaultFuchsiaResourceDialect,
17570                0x3814a04259f75fcb,
17571            >(_buf?)?;
17572            Ok(_response.map(|x| x.value))
17573        }
17574        self.client.send_query_and_decode::<
17575            fidl::encoding::EmptyPayload,
17576            BaseNetworkSocketGetIpTypeOfServiceResult,
17577        >(
17578            (),
17579            0x3814a04259f75fcb,
17580            fidl::encoding::DynamicFlags::empty(),
17581            _decode,
17582        )
17583    }
17584
17585    type SetIpTtlResponseFut = fidl::client::QueryResponseFut<
17586        BaseNetworkSocketSetIpTtlResult,
17587        fidl::encoding::DefaultFuchsiaResourceDialect,
17588    >;
17589    fn r#set_ip_ttl(&self, mut value: &OptionalUint8) -> Self::SetIpTtlResponseFut {
17590        fn _decode(
17591            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17592        ) -> Result<BaseNetworkSocketSetIpTtlResult, fidl::Error> {
17593            let _response = fidl::client::decode_transaction_body::<
17594                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17595                fidl::encoding::DefaultFuchsiaResourceDialect,
17596                0x29e2424b433ae1ef,
17597            >(_buf?)?;
17598            Ok(_response.map(|x| x))
17599        }
17600        self.client.send_query_and_decode::<
17601            BaseNetworkSocketSetIpTtlRequest,
17602            BaseNetworkSocketSetIpTtlResult,
17603        >(
17604            (value,),
17605            0x29e2424b433ae1ef,
17606            fidl::encoding::DynamicFlags::empty(),
17607            _decode,
17608        )
17609    }
17610
17611    type GetIpTtlResponseFut = fidl::client::QueryResponseFut<
17612        BaseNetworkSocketGetIpTtlResult,
17613        fidl::encoding::DefaultFuchsiaResourceDialect,
17614    >;
17615    fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut {
17616        fn _decode(
17617            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17618        ) -> Result<BaseNetworkSocketGetIpTtlResult, fidl::Error> {
17619            let _response = fidl::client::decode_transaction_body::<
17620                fidl::encoding::ResultType<
17621                    BaseNetworkSocketGetIpTtlResponse,
17622                    fidl_fuchsia_posix::Errno,
17623                >,
17624                fidl::encoding::DefaultFuchsiaResourceDialect,
17625                0x47e47fa1f24da471,
17626            >(_buf?)?;
17627            Ok(_response.map(|x| x.value))
17628        }
17629        self.client
17630            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseNetworkSocketGetIpTtlResult>(
17631                (),
17632                0x47e47fa1f24da471,
17633                fidl::encoding::DynamicFlags::empty(),
17634                _decode,
17635            )
17636    }
17637
17638    type SetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
17639        BaseNetworkSocketSetIpPacketInfoResult,
17640        fidl::encoding::DefaultFuchsiaResourceDialect,
17641    >;
17642    fn r#set_ip_packet_info(&self, mut value: bool) -> Self::SetIpPacketInfoResponseFut {
17643        fn _decode(
17644            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17645        ) -> Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error> {
17646            let _response = fidl::client::decode_transaction_body::<
17647                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17648                fidl::encoding::DefaultFuchsiaResourceDialect,
17649                0x392d16bee20c0e16,
17650            >(_buf?)?;
17651            Ok(_response.map(|x| x))
17652        }
17653        self.client.send_query_and_decode::<
17654            BaseNetworkSocketSetIpPacketInfoRequest,
17655            BaseNetworkSocketSetIpPacketInfoResult,
17656        >(
17657            (value,),
17658            0x392d16bee20c0e16,
17659            fidl::encoding::DynamicFlags::empty(),
17660            _decode,
17661        )
17662    }
17663
17664    type GetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
17665        BaseNetworkSocketGetIpPacketInfoResult,
17666        fidl::encoding::DefaultFuchsiaResourceDialect,
17667    >;
17668    fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut {
17669        fn _decode(
17670            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17671        ) -> Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error> {
17672            let _response = fidl::client::decode_transaction_body::<
17673                fidl::encoding::ResultType<
17674                    BaseNetworkSocketGetIpPacketInfoResponse,
17675                    fidl_fuchsia_posix::Errno,
17676                >,
17677                fidl::encoding::DefaultFuchsiaResourceDialect,
17678                0x54b505f242280740,
17679            >(_buf?)?;
17680            Ok(_response.map(|x| x.value))
17681        }
17682        self.client.send_query_and_decode::<
17683            fidl::encoding::EmptyPayload,
17684            BaseNetworkSocketGetIpPacketInfoResult,
17685        >(
17686            (),
17687            0x54b505f242280740,
17688            fidl::encoding::DynamicFlags::empty(),
17689            _decode,
17690        )
17691    }
17692
17693    type SetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
17694        BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
17695        fidl::encoding::DefaultFuchsiaResourceDialect,
17696    >;
17697    fn r#set_ip_receive_type_of_service(
17698        &self,
17699        mut value: bool,
17700    ) -> Self::SetIpReceiveTypeOfServiceResponseFut {
17701        fn _decode(
17702            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17703        ) -> Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error> {
17704            let _response = fidl::client::decode_transaction_body::<
17705                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17706                fidl::encoding::DefaultFuchsiaResourceDialect,
17707                0x6c4f6714995f84ef,
17708            >(_buf?)?;
17709            Ok(_response.map(|x| x))
17710        }
17711        self.client.send_query_and_decode::<
17712            BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
17713            BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
17714        >(
17715            (value,),
17716            0x6c4f6714995f84ef,
17717            fidl::encoding::DynamicFlags::empty(),
17718            _decode,
17719        )
17720    }
17721
17722    type GetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
17723        BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
17724        fidl::encoding::DefaultFuchsiaResourceDialect,
17725    >;
17726    fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut {
17727        fn _decode(
17728            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17729        ) -> Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error> {
17730            let _response = fidl::client::decode_transaction_body::<
17731                fidl::encoding::ResultType<
17732                    BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
17733                    fidl_fuchsia_posix::Errno,
17734                >,
17735                fidl::encoding::DefaultFuchsiaResourceDialect,
17736                0x4158ba7dc2795960,
17737            >(_buf?)?;
17738            Ok(_response.map(|x| x.value))
17739        }
17740        self.client.send_query_and_decode::<
17741            fidl::encoding::EmptyPayload,
17742            BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
17743        >(
17744            (),
17745            0x4158ba7dc2795960,
17746            fidl::encoding::DynamicFlags::empty(),
17747            _decode,
17748        )
17749    }
17750
17751    type SetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
17752        BaseNetworkSocketSetIpReceiveTtlResult,
17753        fidl::encoding::DefaultFuchsiaResourceDialect,
17754    >;
17755    fn r#set_ip_receive_ttl(&self, mut value: bool) -> Self::SetIpReceiveTtlResponseFut {
17756        fn _decode(
17757            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17758        ) -> Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error> {
17759            let _response = fidl::client::decode_transaction_body::<
17760                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17761                fidl::encoding::DefaultFuchsiaResourceDialect,
17762                0x46f15be0ce0ab82b,
17763            >(_buf?)?;
17764            Ok(_response.map(|x| x))
17765        }
17766        self.client.send_query_and_decode::<
17767            BaseNetworkSocketSetIpReceiveTtlRequest,
17768            BaseNetworkSocketSetIpReceiveTtlResult,
17769        >(
17770            (value,),
17771            0x46f15be0ce0ab82b,
17772            fidl::encoding::DynamicFlags::empty(),
17773            _decode,
17774        )
17775    }
17776
17777    type GetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
17778        BaseNetworkSocketGetIpReceiveTtlResult,
17779        fidl::encoding::DefaultFuchsiaResourceDialect,
17780    >;
17781    fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut {
17782        fn _decode(
17783            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17784        ) -> Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error> {
17785            let _response = fidl::client::decode_transaction_body::<
17786                fidl::encoding::ResultType<
17787                    BaseNetworkSocketGetIpReceiveTtlResponse,
17788                    fidl_fuchsia_posix::Errno,
17789                >,
17790                fidl::encoding::DefaultFuchsiaResourceDialect,
17791                0x678ddd5a5dfa2eb5,
17792            >(_buf?)?;
17793            Ok(_response.map(|x| x.value))
17794        }
17795        self.client.send_query_and_decode::<
17796            fidl::encoding::EmptyPayload,
17797            BaseNetworkSocketGetIpReceiveTtlResult,
17798        >(
17799            (),
17800            0x678ddd5a5dfa2eb5,
17801            fidl::encoding::DynamicFlags::empty(),
17802            _decode,
17803        )
17804    }
17805
17806    type SetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
17807        BaseNetworkSocketSetIpMulticastInterfaceResult,
17808        fidl::encoding::DefaultFuchsiaResourceDialect,
17809    >;
17810    fn r#set_ip_multicast_interface(
17811        &self,
17812        mut iface: u64,
17813        mut address: &fidl_fuchsia_net::Ipv4Address,
17814    ) -> Self::SetIpMulticastInterfaceResponseFut {
17815        fn _decode(
17816            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17817        ) -> Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error> {
17818            let _response = fidl::client::decode_transaction_body::<
17819                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17820                fidl::encoding::DefaultFuchsiaResourceDialect,
17821                0x752fbfa9b12befe,
17822            >(_buf?)?;
17823            Ok(_response.map(|x| x))
17824        }
17825        self.client.send_query_and_decode::<
17826            BaseNetworkSocketSetIpMulticastInterfaceRequest,
17827            BaseNetworkSocketSetIpMulticastInterfaceResult,
17828        >(
17829            (iface, address,),
17830            0x752fbfa9b12befe,
17831            fidl::encoding::DynamicFlags::empty(),
17832            _decode,
17833        )
17834    }
17835
17836    type GetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
17837        BaseNetworkSocketGetIpMulticastInterfaceResult,
17838        fidl::encoding::DefaultFuchsiaResourceDialect,
17839    >;
17840    fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut {
17841        fn _decode(
17842            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17843        ) -> Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error> {
17844            let _response = fidl::client::decode_transaction_body::<
17845                fidl::encoding::ResultType<
17846                    BaseNetworkSocketGetIpMulticastInterfaceResponse,
17847                    fidl_fuchsia_posix::Errno,
17848                >,
17849                fidl::encoding::DefaultFuchsiaResourceDialect,
17850                0x320bd14c4df046c4,
17851            >(_buf?)?;
17852            Ok(_response.map(|x| x.value))
17853        }
17854        self.client.send_query_and_decode::<
17855            fidl::encoding::EmptyPayload,
17856            BaseNetworkSocketGetIpMulticastInterfaceResult,
17857        >(
17858            (),
17859            0x320bd14c4df046c4,
17860            fidl::encoding::DynamicFlags::empty(),
17861            _decode,
17862        )
17863    }
17864
17865    type SetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
17866        BaseNetworkSocketSetIpMulticastTtlResult,
17867        fidl::encoding::DefaultFuchsiaResourceDialect,
17868    >;
17869    fn r#set_ip_multicast_ttl(
17870        &self,
17871        mut value: &OptionalUint8,
17872    ) -> Self::SetIpMulticastTtlResponseFut {
17873        fn _decode(
17874            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17875        ) -> Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error> {
17876            let _response = fidl::client::decode_transaction_body::<
17877                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17878                fidl::encoding::DefaultFuchsiaResourceDialect,
17879                0x63134d53772916a1,
17880            >(_buf?)?;
17881            Ok(_response.map(|x| x))
17882        }
17883        self.client.send_query_and_decode::<
17884            BaseNetworkSocketSetIpMulticastTtlRequest,
17885            BaseNetworkSocketSetIpMulticastTtlResult,
17886        >(
17887            (value,),
17888            0x63134d53772916a1,
17889            fidl::encoding::DynamicFlags::empty(),
17890            _decode,
17891        )
17892    }
17893
17894    type GetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
17895        BaseNetworkSocketGetIpMulticastTtlResult,
17896        fidl::encoding::DefaultFuchsiaResourceDialect,
17897    >;
17898    fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut {
17899        fn _decode(
17900            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17901        ) -> Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error> {
17902            let _response = fidl::client::decode_transaction_body::<
17903                fidl::encoding::ResultType<
17904                    BaseNetworkSocketGetIpMulticastTtlResponse,
17905                    fidl_fuchsia_posix::Errno,
17906                >,
17907                fidl::encoding::DefaultFuchsiaResourceDialect,
17908                0x4665cd378f39e1a,
17909            >(_buf?)?;
17910            Ok(_response.map(|x| x.value))
17911        }
17912        self.client.send_query_and_decode::<
17913            fidl::encoding::EmptyPayload,
17914            BaseNetworkSocketGetIpMulticastTtlResult,
17915        >(
17916            (),
17917            0x4665cd378f39e1a,
17918            fidl::encoding::DynamicFlags::empty(),
17919            _decode,
17920        )
17921    }
17922
17923    type SetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
17924        BaseNetworkSocketSetIpMulticastLoopbackResult,
17925        fidl::encoding::DefaultFuchsiaResourceDialect,
17926    >;
17927    fn r#set_ip_multicast_loopback(
17928        &self,
17929        mut value: bool,
17930    ) -> Self::SetIpMulticastLoopbackResponseFut {
17931        fn _decode(
17932            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17933        ) -> Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error> {
17934            let _response = fidl::client::decode_transaction_body::<
17935                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17936                fidl::encoding::DefaultFuchsiaResourceDialect,
17937                0x20c55c11f00943ea,
17938            >(_buf?)?;
17939            Ok(_response.map(|x| x))
17940        }
17941        self.client.send_query_and_decode::<
17942            BaseNetworkSocketSetIpMulticastLoopbackRequest,
17943            BaseNetworkSocketSetIpMulticastLoopbackResult,
17944        >(
17945            (value,),
17946            0x20c55c11f00943ea,
17947            fidl::encoding::DynamicFlags::empty(),
17948            _decode,
17949        )
17950    }
17951
17952    type GetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
17953        BaseNetworkSocketGetIpMulticastLoopbackResult,
17954        fidl::encoding::DefaultFuchsiaResourceDialect,
17955    >;
17956    fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut {
17957        fn _decode(
17958            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17959        ) -> Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error> {
17960            let _response = fidl::client::decode_transaction_body::<
17961                fidl::encoding::ResultType<
17962                    BaseNetworkSocketGetIpMulticastLoopbackResponse,
17963                    fidl_fuchsia_posix::Errno,
17964                >,
17965                fidl::encoding::DefaultFuchsiaResourceDialect,
17966                0x3b6b26ff558298f2,
17967            >(_buf?)?;
17968            Ok(_response.map(|x| x.value))
17969        }
17970        self.client.send_query_and_decode::<
17971            fidl::encoding::EmptyPayload,
17972            BaseNetworkSocketGetIpMulticastLoopbackResult,
17973        >(
17974            (),
17975            0x3b6b26ff558298f2,
17976            fidl::encoding::DynamicFlags::empty(),
17977            _decode,
17978        )
17979    }
17980
17981    type AddIpMembershipResponseFut = fidl::client::QueryResponseFut<
17982        BaseNetworkSocketAddIpMembershipResult,
17983        fidl::encoding::DefaultFuchsiaResourceDialect,
17984    >;
17985    fn r#add_ip_membership(
17986        &self,
17987        mut membership: &IpMulticastMembership,
17988    ) -> Self::AddIpMembershipResponseFut {
17989        fn _decode(
17990            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
17991        ) -> Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error> {
17992            let _response = fidl::client::decode_transaction_body::<
17993                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
17994                fidl::encoding::DefaultFuchsiaResourceDialect,
17995                0x76bc7df115a3b4d0,
17996            >(_buf?)?;
17997            Ok(_response.map(|x| x))
17998        }
17999        self.client.send_query_and_decode::<
18000            BaseNetworkSocketAddIpMembershipRequest,
18001            BaseNetworkSocketAddIpMembershipResult,
18002        >(
18003            (membership,),
18004            0x76bc7df115a3b4d0,
18005            fidl::encoding::DynamicFlags::empty(),
18006            _decode,
18007        )
18008    }
18009
18010    type DropIpMembershipResponseFut = fidl::client::QueryResponseFut<
18011        BaseNetworkSocketDropIpMembershipResult,
18012        fidl::encoding::DefaultFuchsiaResourceDialect,
18013    >;
18014    fn r#drop_ip_membership(
18015        &self,
18016        mut membership: &IpMulticastMembership,
18017    ) -> Self::DropIpMembershipResponseFut {
18018        fn _decode(
18019            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18020        ) -> Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error> {
18021            let _response = fidl::client::decode_transaction_body::<
18022                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
18023                fidl::encoding::DefaultFuchsiaResourceDialect,
18024                0x2888f3099188d03,
18025            >(_buf?)?;
18026            Ok(_response.map(|x| x))
18027        }
18028        self.client.send_query_and_decode::<
18029            BaseNetworkSocketDropIpMembershipRequest,
18030            BaseNetworkSocketDropIpMembershipResult,
18031        >(
18032            (membership,),
18033            0x2888f3099188d03,
18034            fidl::encoding::DynamicFlags::empty(),
18035            _decode,
18036        )
18037    }
18038
18039    type SetIpTransparentResponseFut = fidl::client::QueryResponseFut<
18040        BaseNetworkSocketSetIpTransparentResult,
18041        fidl::encoding::DefaultFuchsiaResourceDialect,
18042    >;
18043    fn r#set_ip_transparent(&self, mut value: bool) -> Self::SetIpTransparentResponseFut {
18044        fn _decode(
18045            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18046        ) -> Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error> {
18047            let _response = fidl::client::decode_transaction_body::<
18048                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
18049                fidl::encoding::DefaultFuchsiaResourceDialect,
18050                0x1ae532b0c066e3a0,
18051            >(_buf?)?;
18052            Ok(_response.map(|x| x))
18053        }
18054        self.client.send_query_and_decode::<
18055            BaseNetworkSocketSetIpTransparentRequest,
18056            BaseNetworkSocketSetIpTransparentResult,
18057        >(
18058            (value,),
18059            0x1ae532b0c066e3a0,
18060            fidl::encoding::DynamicFlags::empty(),
18061            _decode,
18062        )
18063    }
18064
18065    type GetIpTransparentResponseFut = fidl::client::QueryResponseFut<
18066        BaseNetworkSocketGetIpTransparentResult,
18067        fidl::encoding::DefaultFuchsiaResourceDialect,
18068    >;
18069    fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut {
18070        fn _decode(
18071            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18072        ) -> Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error> {
18073            let _response = fidl::client::decode_transaction_body::<
18074                fidl::encoding::ResultType<
18075                    BaseNetworkSocketGetIpTransparentResponse,
18076                    fidl_fuchsia_posix::Errno,
18077                >,
18078                fidl::encoding::DefaultFuchsiaResourceDialect,
18079                0x51d43695962ebfb5,
18080            >(_buf?)?;
18081            Ok(_response.map(|x| x.value))
18082        }
18083        self.client.send_query_and_decode::<
18084            fidl::encoding::EmptyPayload,
18085            BaseNetworkSocketGetIpTransparentResult,
18086        >(
18087            (),
18088            0x51d43695962ebfb5,
18089            fidl::encoding::DynamicFlags::empty(),
18090            _decode,
18091        )
18092    }
18093
18094    type SetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
18095        BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
18096        fidl::encoding::DefaultFuchsiaResourceDialect,
18097    >;
18098    fn r#set_ip_receive_original_destination_address(
18099        &self,
18100        mut value: bool,
18101    ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut {
18102        fn _decode(
18103            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18104        ) -> Result<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error>
18105        {
18106            let _response = fidl::client::decode_transaction_body::<
18107                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
18108                fidl::encoding::DefaultFuchsiaResourceDialect,
18109                0x4722b4ce52f7840,
18110            >(_buf?)?;
18111            Ok(_response.map(|x| x))
18112        }
18113        self.client.send_query_and_decode::<
18114            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
18115            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
18116        >(
18117            (value,),
18118            0x4722b4ce52f7840,
18119            fidl::encoding::DynamicFlags::empty(),
18120            _decode,
18121        )
18122    }
18123
18124    type GetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
18125        BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
18126        fidl::encoding::DefaultFuchsiaResourceDialect,
18127    >;
18128    fn r#get_ip_receive_original_destination_address(
18129        &self,
18130    ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut {
18131        fn _decode(
18132            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18133        ) -> Result<BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error>
18134        {
18135            let _response = fidl::client::decode_transaction_body::<
18136                fidl::encoding::ResultType<
18137                    BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
18138                    fidl_fuchsia_posix::Errno,
18139                >,
18140                fidl::encoding::DefaultFuchsiaResourceDialect,
18141                0x2a0e7dc5d6bfdfe9,
18142            >(_buf?)?;
18143            Ok(_response.map(|x| x.value))
18144        }
18145        self.client.send_query_and_decode::<
18146            fidl::encoding::EmptyPayload,
18147            BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
18148        >(
18149            (),
18150            0x2a0e7dc5d6bfdfe9,
18151            fidl::encoding::DynamicFlags::empty(),
18152            _decode,
18153        )
18154    }
18155
18156    type AddIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
18157        BaseNetworkSocketAddIpv6MembershipResult,
18158        fidl::encoding::DefaultFuchsiaResourceDialect,
18159    >;
18160    fn r#add_ipv6_membership(
18161        &self,
18162        mut membership: &Ipv6MulticastMembership,
18163    ) -> Self::AddIpv6MembershipResponseFut {
18164        fn _decode(
18165            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18166        ) -> Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error> {
18167            let _response = fidl::client::decode_transaction_body::<
18168                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
18169                fidl::encoding::DefaultFuchsiaResourceDialect,
18170                0x7c94727acb4ea4b3,
18171            >(_buf?)?;
18172            Ok(_response.map(|x| x))
18173        }
18174        self.client.send_query_and_decode::<
18175            BaseNetworkSocketAddIpv6MembershipRequest,
18176            BaseNetworkSocketAddIpv6MembershipResult,
18177        >(
18178            (membership,),
18179            0x7c94727acb4ea4b3,
18180            fidl::encoding::DynamicFlags::empty(),
18181            _decode,
18182        )
18183    }
18184
18185    type DropIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
18186        BaseNetworkSocketDropIpv6MembershipResult,
18187        fidl::encoding::DefaultFuchsiaResourceDialect,
18188    >;
18189    fn r#drop_ipv6_membership(
18190        &self,
18191        mut membership: &Ipv6MulticastMembership,
18192    ) -> Self::DropIpv6MembershipResponseFut {
18193        fn _decode(
18194            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18195        ) -> Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error> {
18196            let _response = fidl::client::decode_transaction_body::<
18197                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
18198                fidl::encoding::DefaultFuchsiaResourceDialect,
18199                0x42104c70ccaba304,
18200            >(_buf?)?;
18201            Ok(_response.map(|x| x))
18202        }
18203        self.client.send_query_and_decode::<
18204            BaseNetworkSocketDropIpv6MembershipRequest,
18205            BaseNetworkSocketDropIpv6MembershipResult,
18206        >(
18207            (membership,),
18208            0x42104c70ccaba304,
18209            fidl::encoding::DynamicFlags::empty(),
18210            _decode,
18211        )
18212    }
18213
18214    type SetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
18215        BaseNetworkSocketSetIpv6MulticastInterfaceResult,
18216        fidl::encoding::DefaultFuchsiaResourceDialect,
18217    >;
18218    fn r#set_ipv6_multicast_interface(
18219        &self,
18220        mut value: u64,
18221    ) -> Self::SetIpv6MulticastInterfaceResponseFut {
18222        fn _decode(
18223            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18224        ) -> Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error> {
18225            let _response = fidl::client::decode_transaction_body::<
18226                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
18227                fidl::encoding::DefaultFuchsiaResourceDialect,
18228                0x135f76db3774ab3b,
18229            >(_buf?)?;
18230            Ok(_response.map(|x| x))
18231        }
18232        self.client.send_query_and_decode::<
18233            BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
18234            BaseNetworkSocketSetIpv6MulticastInterfaceResult,
18235        >(
18236            (value,),
18237            0x135f76db3774ab3b,
18238            fidl::encoding::DynamicFlags::empty(),
18239            _decode,
18240        )
18241    }
18242
18243    type GetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
18244        BaseNetworkSocketGetIpv6MulticastInterfaceResult,
18245        fidl::encoding::DefaultFuchsiaResourceDialect,
18246    >;
18247    fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut {
18248        fn _decode(
18249            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18250        ) -> Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error> {
18251            let _response = fidl::client::decode_transaction_body::<
18252                fidl::encoding::ResultType<
18253                    BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
18254                    fidl_fuchsia_posix::Errno,
18255                >,
18256                fidl::encoding::DefaultFuchsiaResourceDialect,
18257                0x1f26fcdd348f1882,
18258            >(_buf?)?;
18259            Ok(_response.map(|x| x.value))
18260        }
18261        self.client.send_query_and_decode::<
18262            fidl::encoding::EmptyPayload,
18263            BaseNetworkSocketGetIpv6MulticastInterfaceResult,
18264        >(
18265            (),
18266            0x1f26fcdd348f1882,
18267            fidl::encoding::DynamicFlags::empty(),
18268            _decode,
18269        )
18270    }
18271
18272    type SetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
18273        BaseNetworkSocketSetIpv6UnicastHopsResult,
18274        fidl::encoding::DefaultFuchsiaResourceDialect,
18275    >;
18276    fn r#set_ipv6_unicast_hops(
18277        &self,
18278        mut value: &OptionalUint8,
18279    ) -> Self::SetIpv6UnicastHopsResponseFut {
18280        fn _decode(
18281            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18282        ) -> Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error> {
18283            let _response = fidl::client::decode_transaction_body::<
18284                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
18285                fidl::encoding::DefaultFuchsiaResourceDialect,
18286                0x157d51e98f462859,
18287            >(_buf?)?;
18288            Ok(_response.map(|x| x))
18289        }
18290        self.client.send_query_and_decode::<
18291            BaseNetworkSocketSetIpv6UnicastHopsRequest,
18292            BaseNetworkSocketSetIpv6UnicastHopsResult,
18293        >(
18294            (value,),
18295            0x157d51e98f462859,
18296            fidl::encoding::DynamicFlags::empty(),
18297            _decode,
18298        )
18299    }
18300
18301    type GetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
18302        BaseNetworkSocketGetIpv6UnicastHopsResult,
18303        fidl::encoding::DefaultFuchsiaResourceDialect,
18304    >;
18305    fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut {
18306        fn _decode(
18307            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18308        ) -> Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error> {
18309            let _response = fidl::client::decode_transaction_body::<
18310                fidl::encoding::ResultType<
18311                    BaseNetworkSocketGetIpv6UnicastHopsResponse,
18312                    fidl_fuchsia_posix::Errno,
18313                >,
18314                fidl::encoding::DefaultFuchsiaResourceDialect,
18315                0x21f4641cad8bd8d2,
18316            >(_buf?)?;
18317            Ok(_response.map(|x| x.value))
18318        }
18319        self.client.send_query_and_decode::<
18320            fidl::encoding::EmptyPayload,
18321            BaseNetworkSocketGetIpv6UnicastHopsResult,
18322        >(
18323            (),
18324            0x21f4641cad8bd8d2,
18325            fidl::encoding::DynamicFlags::empty(),
18326            _decode,
18327        )
18328    }
18329
18330    type SetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
18331        BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
18332        fidl::encoding::DefaultFuchsiaResourceDialect,
18333    >;
18334    fn r#set_ipv6_receive_hop_limit(
18335        &self,
18336        mut value: bool,
18337    ) -> Self::SetIpv6ReceiveHopLimitResponseFut {
18338        fn _decode(
18339            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18340        ) -> Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error> {
18341            let _response = fidl::client::decode_transaction_body::<
18342                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
18343                fidl::encoding::DefaultFuchsiaResourceDialect,
18344                0x5c24808ed2e84a1e,
18345            >(_buf?)?;
18346            Ok(_response.map(|x| x))
18347        }
18348        self.client.send_query_and_decode::<
18349            BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
18350            BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
18351        >(
18352            (value,),
18353            0x5c24808ed2e84a1e,
18354            fidl::encoding::DynamicFlags::empty(),
18355            _decode,
18356        )
18357    }
18358
18359    type GetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
18360        BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
18361        fidl::encoding::DefaultFuchsiaResourceDialect,
18362    >;
18363    fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut {
18364        fn _decode(
18365            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18366        ) -> Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error> {
18367            let _response = fidl::client::decode_transaction_body::<
18368                fidl::encoding::ResultType<
18369                    BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
18370                    fidl_fuchsia_posix::Errno,
18371                >,
18372                fidl::encoding::DefaultFuchsiaResourceDialect,
18373                0x341e06689885b4c0,
18374            >(_buf?)?;
18375            Ok(_response.map(|x| x.value))
18376        }
18377        self.client.send_query_and_decode::<
18378            fidl::encoding::EmptyPayload,
18379            BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
18380        >(
18381            (),
18382            0x341e06689885b4c0,
18383            fidl::encoding::DynamicFlags::empty(),
18384            _decode,
18385        )
18386    }
18387
18388    type SetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
18389        BaseNetworkSocketSetIpv6MulticastHopsResult,
18390        fidl::encoding::DefaultFuchsiaResourceDialect,
18391    >;
18392    fn r#set_ipv6_multicast_hops(
18393        &self,
18394        mut value: &OptionalUint8,
18395    ) -> Self::SetIpv6MulticastHopsResponseFut {
18396        fn _decode(
18397            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18398        ) -> Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error> {
18399            let _response = fidl::client::decode_transaction_body::<
18400                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
18401                fidl::encoding::DefaultFuchsiaResourceDialect,
18402                0x25b9cd4d181f82c1,
18403            >(_buf?)?;
18404            Ok(_response.map(|x| x))
18405        }
18406        self.client.send_query_and_decode::<
18407            BaseNetworkSocketSetIpv6MulticastHopsRequest,
18408            BaseNetworkSocketSetIpv6MulticastHopsResult,
18409        >(
18410            (value,),
18411            0x25b9cd4d181f82c1,
18412            fidl::encoding::DynamicFlags::empty(),
18413            _decode,
18414        )
18415    }
18416
18417    type GetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
18418        BaseNetworkSocketGetIpv6MulticastHopsResult,
18419        fidl::encoding::DefaultFuchsiaResourceDialect,
18420    >;
18421    fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut {
18422        fn _decode(
18423            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18424        ) -> Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error> {
18425            let _response = fidl::client::decode_transaction_body::<
18426                fidl::encoding::ResultType<
18427                    BaseNetworkSocketGetIpv6MulticastHopsResponse,
18428                    fidl_fuchsia_posix::Errno,
18429                >,
18430                fidl::encoding::DefaultFuchsiaResourceDialect,
18431                0x52916948a365012a,
18432            >(_buf?)?;
18433            Ok(_response.map(|x| x.value))
18434        }
18435        self.client.send_query_and_decode::<
18436            fidl::encoding::EmptyPayload,
18437            BaseNetworkSocketGetIpv6MulticastHopsResult,
18438        >(
18439            (),
18440            0x52916948a365012a,
18441            fidl::encoding::DynamicFlags::empty(),
18442            _decode,
18443        )
18444    }
18445
18446    type SetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
18447        BaseNetworkSocketSetIpv6MulticastLoopbackResult,
18448        fidl::encoding::DefaultFuchsiaResourceDialect,
18449    >;
18450    fn r#set_ipv6_multicast_loopback(
18451        &self,
18452        mut value: bool,
18453    ) -> Self::SetIpv6MulticastLoopbackResponseFut {
18454        fn _decode(
18455            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18456        ) -> Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error> {
18457            let _response = fidl::client::decode_transaction_body::<
18458                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
18459                fidl::encoding::DefaultFuchsiaResourceDialect,
18460                0x55701c409ff41b40,
18461            >(_buf?)?;
18462            Ok(_response.map(|x| x))
18463        }
18464        self.client.send_query_and_decode::<
18465            BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
18466            BaseNetworkSocketSetIpv6MulticastLoopbackResult,
18467        >(
18468            (value,),
18469            0x55701c409ff41b40,
18470            fidl::encoding::DynamicFlags::empty(),
18471            _decode,
18472        )
18473    }
18474
18475    type GetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
18476        BaseNetworkSocketGetIpv6MulticastLoopbackResult,
18477        fidl::encoding::DefaultFuchsiaResourceDialect,
18478    >;
18479    fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut {
18480        fn _decode(
18481            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18482        ) -> Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error> {
18483            let _response = fidl::client::decode_transaction_body::<
18484                fidl::encoding::ResultType<
18485                    BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
18486                    fidl_fuchsia_posix::Errno,
18487                >,
18488                fidl::encoding::DefaultFuchsiaResourceDialect,
18489                0x4415b701fde319c3,
18490            >(_buf?)?;
18491            Ok(_response.map(|x| x.value))
18492        }
18493        self.client.send_query_and_decode::<
18494            fidl::encoding::EmptyPayload,
18495            BaseNetworkSocketGetIpv6MulticastLoopbackResult,
18496        >(
18497            (),
18498            0x4415b701fde319c3,
18499            fidl::encoding::DynamicFlags::empty(),
18500            _decode,
18501        )
18502    }
18503
18504    type SetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
18505        BaseNetworkSocketSetIpv6OnlyResult,
18506        fidl::encoding::DefaultFuchsiaResourceDialect,
18507    >;
18508    fn r#set_ipv6_only(&self, mut value: bool) -> Self::SetIpv6OnlyResponseFut {
18509        fn _decode(
18510            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18511        ) -> Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
18512            let _response = fidl::client::decode_transaction_body::<
18513                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
18514                fidl::encoding::DefaultFuchsiaResourceDialect,
18515                0x4873f1364758cbba,
18516            >(_buf?)?;
18517            Ok(_response.map(|x| x))
18518        }
18519        self.client.send_query_and_decode::<
18520            BaseNetworkSocketSetIpv6OnlyRequest,
18521            BaseNetworkSocketSetIpv6OnlyResult,
18522        >(
18523            (value,),
18524            0x4873f1364758cbba,
18525            fidl::encoding::DynamicFlags::empty(),
18526            _decode,
18527        )
18528    }
18529
18530    type GetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
18531        BaseNetworkSocketGetIpv6OnlyResult,
18532        fidl::encoding::DefaultFuchsiaResourceDialect,
18533    >;
18534    fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut {
18535        fn _decode(
18536            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18537        ) -> Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
18538            let _response = fidl::client::decode_transaction_body::<
18539                fidl::encoding::ResultType<
18540                    BaseNetworkSocketGetIpv6OnlyResponse,
18541                    fidl_fuchsia_posix::Errno,
18542                >,
18543                fidl::encoding::DefaultFuchsiaResourceDialect,
18544                0x4aa3340a1a26b89c,
18545            >(_buf?)?;
18546            Ok(_response.map(|x| x.value))
18547        }
18548        self.client.send_query_and_decode::<
18549            fidl::encoding::EmptyPayload,
18550            BaseNetworkSocketGetIpv6OnlyResult,
18551        >(
18552            (),
18553            0x4aa3340a1a26b89c,
18554            fidl::encoding::DynamicFlags::empty(),
18555            _decode,
18556        )
18557    }
18558
18559    type SetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
18560        BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
18561        fidl::encoding::DefaultFuchsiaResourceDialect,
18562    >;
18563    fn r#set_ipv6_receive_traffic_class(
18564        &self,
18565        mut value: bool,
18566    ) -> Self::SetIpv6ReceiveTrafficClassResponseFut {
18567        fn _decode(
18568            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18569        ) -> Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error> {
18570            let _response = fidl::client::decode_transaction_body::<
18571                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
18572                fidl::encoding::DefaultFuchsiaResourceDialect,
18573                0x58f07c8788d099a0,
18574            >(_buf?)?;
18575            Ok(_response.map(|x| x))
18576        }
18577        self.client.send_query_and_decode::<
18578            BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
18579            BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
18580        >(
18581            (value,),
18582            0x58f07c8788d099a0,
18583            fidl::encoding::DynamicFlags::empty(),
18584            _decode,
18585        )
18586    }
18587
18588    type GetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
18589        BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
18590        fidl::encoding::DefaultFuchsiaResourceDialect,
18591    >;
18592    fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut {
18593        fn _decode(
18594            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18595        ) -> Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error> {
18596            let _response = fidl::client::decode_transaction_body::<
18597                fidl::encoding::ResultType<
18598                    BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
18599                    fidl_fuchsia_posix::Errno,
18600                >,
18601                fidl::encoding::DefaultFuchsiaResourceDialect,
18602                0x2e334df1da553ffa,
18603            >(_buf?)?;
18604            Ok(_response.map(|x| x.value))
18605        }
18606        self.client.send_query_and_decode::<
18607            fidl::encoding::EmptyPayload,
18608            BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
18609        >(
18610            (),
18611            0x2e334df1da553ffa,
18612            fidl::encoding::DynamicFlags::empty(),
18613            _decode,
18614        )
18615    }
18616
18617    type SetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
18618        BaseNetworkSocketSetIpv6TrafficClassResult,
18619        fidl::encoding::DefaultFuchsiaResourceDialect,
18620    >;
18621    fn r#set_ipv6_traffic_class(
18622        &self,
18623        mut value: &OptionalUint8,
18624    ) -> Self::SetIpv6TrafficClassResponseFut {
18625        fn _decode(
18626            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18627        ) -> Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error> {
18628            let _response = fidl::client::decode_transaction_body::<
18629                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
18630                fidl::encoding::DefaultFuchsiaResourceDialect,
18631                0x6af077800c5a0b4f,
18632            >(_buf?)?;
18633            Ok(_response.map(|x| x))
18634        }
18635        self.client.send_query_and_decode::<
18636            BaseNetworkSocketSetIpv6TrafficClassRequest,
18637            BaseNetworkSocketSetIpv6TrafficClassResult,
18638        >(
18639            (value,),
18640            0x6af077800c5a0b4f,
18641            fidl::encoding::DynamicFlags::empty(),
18642            _decode,
18643        )
18644    }
18645
18646    type GetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
18647        BaseNetworkSocketGetIpv6TrafficClassResult,
18648        fidl::encoding::DefaultFuchsiaResourceDialect,
18649    >;
18650    fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut {
18651        fn _decode(
18652            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18653        ) -> Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error> {
18654            let _response = fidl::client::decode_transaction_body::<
18655                fidl::encoding::ResultType<
18656                    BaseNetworkSocketGetIpv6TrafficClassResponse,
18657                    fidl_fuchsia_posix::Errno,
18658                >,
18659                fidl::encoding::DefaultFuchsiaResourceDialect,
18660                0x6baf6eed8fc2f04,
18661            >(_buf?)?;
18662            Ok(_response.map(|x| x.value))
18663        }
18664        self.client.send_query_and_decode::<
18665            fidl::encoding::EmptyPayload,
18666            BaseNetworkSocketGetIpv6TrafficClassResult,
18667        >(
18668            (),
18669            0x6baf6eed8fc2f04,
18670            fidl::encoding::DynamicFlags::empty(),
18671            _decode,
18672        )
18673    }
18674
18675    type SetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
18676        BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
18677        fidl::encoding::DefaultFuchsiaResourceDialect,
18678    >;
18679    fn r#set_ipv6_receive_packet_info(
18680        &self,
18681        mut value: bool,
18682    ) -> Self::SetIpv6ReceivePacketInfoResponseFut {
18683        fn _decode(
18684            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18685        ) -> Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error> {
18686            let _response = fidl::client::decode_transaction_body::<
18687                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
18688                fidl::encoding::DefaultFuchsiaResourceDialect,
18689                0x19259775b1a92768,
18690            >(_buf?)?;
18691            Ok(_response.map(|x| x))
18692        }
18693        self.client.send_query_and_decode::<
18694            BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
18695            BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
18696        >(
18697            (value,),
18698            0x19259775b1a92768,
18699            fidl::encoding::DynamicFlags::empty(),
18700            _decode,
18701        )
18702    }
18703
18704    type GetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
18705        BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
18706        fidl::encoding::DefaultFuchsiaResourceDialect,
18707    >;
18708    fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut {
18709        fn _decode(
18710            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18711        ) -> Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error> {
18712            let _response = fidl::client::decode_transaction_body::<
18713                fidl::encoding::ResultType<
18714                    BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
18715                    fidl_fuchsia_posix::Errno,
18716                >,
18717                fidl::encoding::DefaultFuchsiaResourceDialect,
18718                0x7acd4a2775baec75,
18719            >(_buf?)?;
18720            Ok(_response.map(|x| x.value))
18721        }
18722        self.client.send_query_and_decode::<
18723            fidl::encoding::EmptyPayload,
18724            BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
18725        >(
18726            (),
18727            0x7acd4a2775baec75,
18728            fidl::encoding::DynamicFlags::empty(),
18729            _decode,
18730        )
18731    }
18732
18733    type GetOriginalDestinationResponseFut = fidl::client::QueryResponseFut<
18734        BaseNetworkSocketGetOriginalDestinationResult,
18735        fidl::encoding::DefaultFuchsiaResourceDialect,
18736    >;
18737    fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut {
18738        fn _decode(
18739            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
18740        ) -> Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error> {
18741            let _response = fidl::client::decode_transaction_body::<
18742                fidl::encoding::ResultType<
18743                    BaseNetworkSocketGetOriginalDestinationResponse,
18744                    fidl_fuchsia_posix::Errno,
18745                >,
18746                fidl::encoding::DefaultFuchsiaResourceDialect,
18747                0x38bf28f0dafdbac0,
18748            >(_buf?)?;
18749            Ok(_response.map(|x| x.value))
18750        }
18751        self.client.send_query_and_decode::<
18752            fidl::encoding::EmptyPayload,
18753            BaseNetworkSocketGetOriginalDestinationResult,
18754        >(
18755            (),
18756            0x38bf28f0dafdbac0,
18757            fidl::encoding::DynamicFlags::empty(),
18758            _decode,
18759        )
18760    }
18761}
18762
18763pub struct BaseNetworkSocketEventStream {
18764    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
18765}
18766
18767impl std::marker::Unpin for BaseNetworkSocketEventStream {}
18768
18769impl futures::stream::FusedStream for BaseNetworkSocketEventStream {
18770    fn is_terminated(&self) -> bool {
18771        self.event_receiver.is_terminated()
18772    }
18773}
18774
18775impl futures::Stream for BaseNetworkSocketEventStream {
18776    type Item = Result<BaseNetworkSocketEvent, fidl::Error>;
18777
18778    fn poll_next(
18779        mut self: std::pin::Pin<&mut Self>,
18780        cx: &mut std::task::Context<'_>,
18781    ) -> std::task::Poll<Option<Self::Item>> {
18782        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
18783            &mut self.event_receiver,
18784            cx
18785        )?) {
18786            Some(buf) => std::task::Poll::Ready(Some(BaseNetworkSocketEvent::decode(buf))),
18787            None => std::task::Poll::Ready(None),
18788        }
18789    }
18790}
18791
18792#[derive(Debug)]
18793pub enum BaseNetworkSocketEvent {}
18794
18795impl BaseNetworkSocketEvent {
18796    /// Decodes a message buffer as a [`BaseNetworkSocketEvent`].
18797    fn decode(
18798        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
18799    ) -> Result<BaseNetworkSocketEvent, fidl::Error> {
18800        let (bytes, _handles) = buf.split_mut();
18801        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
18802        debug_assert_eq!(tx_header.tx_id, 0);
18803        match tx_header.ordinal {
18804            _ => Err(fidl::Error::UnknownOrdinal {
18805                ordinal: tx_header.ordinal,
18806                protocol_name:
18807                    <BaseNetworkSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
18808            }),
18809        }
18810    }
18811}
18812
18813/// A Stream of incoming requests for fuchsia.posix.socket/BaseNetworkSocket.
18814pub struct BaseNetworkSocketRequestStream {
18815    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
18816    is_terminated: bool,
18817}
18818
18819impl std::marker::Unpin for BaseNetworkSocketRequestStream {}
18820
18821impl futures::stream::FusedStream for BaseNetworkSocketRequestStream {
18822    fn is_terminated(&self) -> bool {
18823        self.is_terminated
18824    }
18825}
18826
18827impl fidl::endpoints::RequestStream for BaseNetworkSocketRequestStream {
18828    type Protocol = BaseNetworkSocketMarker;
18829    type ControlHandle = BaseNetworkSocketControlHandle;
18830
18831    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
18832        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
18833    }
18834
18835    fn control_handle(&self) -> Self::ControlHandle {
18836        BaseNetworkSocketControlHandle { inner: self.inner.clone() }
18837    }
18838
18839    fn into_inner(
18840        self,
18841    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
18842    {
18843        (self.inner, self.is_terminated)
18844    }
18845
18846    fn from_inner(
18847        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
18848        is_terminated: bool,
18849    ) -> Self {
18850        Self { inner, is_terminated }
18851    }
18852}
18853
18854impl futures::Stream for BaseNetworkSocketRequestStream {
18855    type Item = Result<BaseNetworkSocketRequest, fidl::Error>;
18856
18857    fn poll_next(
18858        mut self: std::pin::Pin<&mut Self>,
18859        cx: &mut std::task::Context<'_>,
18860    ) -> std::task::Poll<Option<Self::Item>> {
18861        let this = &mut *self;
18862        if this.inner.check_shutdown(cx) {
18863            this.is_terminated = true;
18864            return std::task::Poll::Ready(None);
18865        }
18866        if this.is_terminated {
18867            panic!("polled BaseNetworkSocketRequestStream after completion");
18868        }
18869        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
18870            |bytes, handles| {
18871                match this.inner.channel().read_etc(cx, bytes, handles) {
18872                    std::task::Poll::Ready(Ok(())) => {}
18873                    std::task::Poll::Pending => return std::task::Poll::Pending,
18874                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
18875                        this.is_terminated = true;
18876                        return std::task::Poll::Ready(None);
18877                    }
18878                    std::task::Poll::Ready(Err(e)) => {
18879                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
18880                            e.into(),
18881                        ))))
18882                    }
18883                }
18884
18885                // A message has been received from the channel
18886                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
18887
18888                std::task::Poll::Ready(Some(match header.ordinal {
18889                    0x20d8a7aba2168a79 => {
18890                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
18891                        let mut req = fidl::new_empty!(
18892                            fidl_fuchsia_unknown::CloneableCloneRequest,
18893                            fidl::encoding::DefaultFuchsiaResourceDialect
18894                        );
18895                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_unknown::CloneableCloneRequest>(&header, _body_bytes, handles, &mut req)?;
18896                        let control_handle =
18897                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
18898                        Ok(BaseNetworkSocketRequest::Clone { request: req.request, control_handle })
18899                    }
18900                    0x5ac5d459ad7f657e => {
18901                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
18902                        let mut req = fidl::new_empty!(
18903                            fidl::encoding::EmptyPayload,
18904                            fidl::encoding::DefaultFuchsiaResourceDialect
18905                        );
18906                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
18907                        let control_handle =
18908                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
18909                        Ok(BaseNetworkSocketRequest::Close {
18910                            responder: BaseNetworkSocketCloseResponder {
18911                                control_handle: std::mem::ManuallyDrop::new(control_handle),
18912                                tx_id: header.tx_id,
18913                            },
18914                        })
18915                    }
18916                    0x2658edee9decfc06 => {
18917                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
18918                        let mut req = fidl::new_empty!(
18919                            fidl::encoding::EmptyPayload,
18920                            fidl::encoding::DefaultFuchsiaResourceDialect
18921                        );
18922                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
18923                        let control_handle =
18924                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
18925                        Ok(BaseNetworkSocketRequest::Query {
18926                            responder: BaseNetworkSocketQueryResponder {
18927                                control_handle: std::mem::ManuallyDrop::new(control_handle),
18928                                tx_id: header.tx_id,
18929                            },
18930                        })
18931                    }
18932                    0x1fd74ee8b9a4a876 => {
18933                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
18934                        let mut req = fidl::new_empty!(
18935                            BaseSocketSetReuseAddressRequest,
18936                            fidl::encoding::DefaultFuchsiaResourceDialect
18937                        );
18938                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReuseAddressRequest>(&header, _body_bytes, handles, &mut req)?;
18939                        let control_handle =
18940                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
18941                        Ok(BaseNetworkSocketRequest::SetReuseAddress {
18942                            value: req.value,
18943
18944                            responder: BaseNetworkSocketSetReuseAddressResponder {
18945                                control_handle: std::mem::ManuallyDrop::new(control_handle),
18946                                tx_id: header.tx_id,
18947                            },
18948                        })
18949                    }
18950                    0x67b7206b8d1bc0a5 => {
18951                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
18952                        let mut req = fidl::new_empty!(
18953                            fidl::encoding::EmptyPayload,
18954                            fidl::encoding::DefaultFuchsiaResourceDialect
18955                        );
18956                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
18957                        let control_handle =
18958                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
18959                        Ok(BaseNetworkSocketRequest::GetReuseAddress {
18960                            responder: BaseNetworkSocketGetReuseAddressResponder {
18961                                control_handle: std::mem::ManuallyDrop::new(control_handle),
18962                                tx_id: header.tx_id,
18963                            },
18964                        })
18965                    }
18966                    0x5aad39b33e5f6ebb => {
18967                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
18968                        let mut req = fidl::new_empty!(
18969                            fidl::encoding::EmptyPayload,
18970                            fidl::encoding::DefaultFuchsiaResourceDialect
18971                        );
18972                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
18973                        let control_handle =
18974                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
18975                        Ok(BaseNetworkSocketRequest::GetError {
18976                            responder: BaseNetworkSocketGetErrorResponder {
18977                                control_handle: std::mem::ManuallyDrop::new(control_handle),
18978                                tx_id: header.tx_id,
18979                            },
18980                        })
18981                    }
18982                    0x6023e081ce3cd947 => {
18983                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
18984                        let mut req = fidl::new_empty!(
18985                            BaseSocketSetBroadcastRequest,
18986                            fidl::encoding::DefaultFuchsiaResourceDialect
18987                        );
18988                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBroadcastRequest>(&header, _body_bytes, handles, &mut req)?;
18989                        let control_handle =
18990                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
18991                        Ok(BaseNetworkSocketRequest::SetBroadcast {
18992                            value: req.value,
18993
18994                            responder: BaseNetworkSocketSetBroadcastResponder {
18995                                control_handle: std::mem::ManuallyDrop::new(control_handle),
18996                                tx_id: header.tx_id,
18997                            },
18998                        })
18999                    }
19000                    0x68796fc556f9780d => {
19001                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19002                        let mut req = fidl::new_empty!(
19003                            fidl::encoding::EmptyPayload,
19004                            fidl::encoding::DefaultFuchsiaResourceDialect
19005                        );
19006                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19007                        let control_handle =
19008                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19009                        Ok(BaseNetworkSocketRequest::GetBroadcast {
19010                            responder: BaseNetworkSocketGetBroadcastResponder {
19011                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19012                                tx_id: header.tx_id,
19013                            },
19014                        })
19015                    }
19016                    0x756eac32d73a7a70 => {
19017                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19018                        let mut req = fidl::new_empty!(
19019                            BaseSocketSetSendBufferRequest,
19020                            fidl::encoding::DefaultFuchsiaResourceDialect
19021                        );
19022                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetSendBufferRequest>(&header, _body_bytes, handles, &mut req)?;
19023                        let control_handle =
19024                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19025                        Ok(BaseNetworkSocketRequest::SetSendBuffer {
19026                            value_bytes: req.value_bytes,
19027
19028                            responder: BaseNetworkSocketSetSendBufferResponder {
19029                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19030                                tx_id: header.tx_id,
19031                            },
19032                        })
19033                    }
19034                    0x78a52fd9c7b2410b => {
19035                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19036                        let mut req = fidl::new_empty!(
19037                            fidl::encoding::EmptyPayload,
19038                            fidl::encoding::DefaultFuchsiaResourceDialect
19039                        );
19040                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19041                        let control_handle =
19042                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19043                        Ok(BaseNetworkSocketRequest::GetSendBuffer {
19044                            responder: BaseNetworkSocketGetSendBufferResponder {
19045                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19046                                tx_id: header.tx_id,
19047                            },
19048                        })
19049                    }
19050                    0x6b0cf2f1919c7001 => {
19051                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19052                        let mut req = fidl::new_empty!(
19053                            BaseSocketSetReceiveBufferRequest,
19054                            fidl::encoding::DefaultFuchsiaResourceDialect
19055                        );
19056                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReceiveBufferRequest>(&header, _body_bytes, handles, &mut req)?;
19057                        let control_handle =
19058                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19059                        Ok(BaseNetworkSocketRequest::SetReceiveBuffer {
19060                            value_bytes: req.value_bytes,
19061
19062                            responder: BaseNetworkSocketSetReceiveBufferResponder {
19063                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19064                                tx_id: header.tx_id,
19065                            },
19066                        })
19067                    }
19068                    0x14c1a4b64f709e5c => {
19069                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19070                        let mut req = fidl::new_empty!(
19071                            fidl::encoding::EmptyPayload,
19072                            fidl::encoding::DefaultFuchsiaResourceDialect
19073                        );
19074                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19075                        let control_handle =
19076                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19077                        Ok(BaseNetworkSocketRequest::GetReceiveBuffer {
19078                            responder: BaseNetworkSocketGetReceiveBufferResponder {
19079                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19080                                tx_id: header.tx_id,
19081                            },
19082                        })
19083                    }
19084                    0x572df8f0b920d2c7 => {
19085                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19086                        let mut req = fidl::new_empty!(
19087                            BaseSocketSetKeepAliveRequest,
19088                            fidl::encoding::DefaultFuchsiaResourceDialect
19089                        );
19090                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetKeepAliveRequest>(&header, _body_bytes, handles, &mut req)?;
19091                        let control_handle =
19092                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19093                        Ok(BaseNetworkSocketRequest::SetKeepAlive {
19094                            value: req.value,
19095
19096                            responder: BaseNetworkSocketSetKeepAliveResponder {
19097                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19098                                tx_id: header.tx_id,
19099                            },
19100                        })
19101                    }
19102                    0x2dd29d3215f2c9d2 => {
19103                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19104                        let mut req = fidl::new_empty!(
19105                            fidl::encoding::EmptyPayload,
19106                            fidl::encoding::DefaultFuchsiaResourceDialect
19107                        );
19108                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19109                        let control_handle =
19110                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19111                        Ok(BaseNetworkSocketRequest::GetKeepAlive {
19112                            responder: BaseNetworkSocketGetKeepAliveResponder {
19113                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19114                                tx_id: header.tx_id,
19115                            },
19116                        })
19117                    }
19118                    0x3ecb49968bee439 => {
19119                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19120                        let mut req = fidl::new_empty!(
19121                            BaseSocketSetOutOfBandInlineRequest,
19122                            fidl::encoding::DefaultFuchsiaResourceDialect
19123                        );
19124                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetOutOfBandInlineRequest>(&header, _body_bytes, handles, &mut req)?;
19125                        let control_handle =
19126                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19127                        Ok(BaseNetworkSocketRequest::SetOutOfBandInline {
19128                            value: req.value,
19129
19130                            responder: BaseNetworkSocketSetOutOfBandInlineResponder {
19131                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19132                                tx_id: header.tx_id,
19133                            },
19134                        })
19135                    }
19136                    0x348c1ab3aeca1745 => {
19137                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19138                        let mut req = fidl::new_empty!(
19139                            fidl::encoding::EmptyPayload,
19140                            fidl::encoding::DefaultFuchsiaResourceDialect
19141                        );
19142                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19143                        let control_handle =
19144                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19145                        Ok(BaseNetworkSocketRequest::GetOutOfBandInline {
19146                            responder: BaseNetworkSocketGetOutOfBandInlineResponder {
19147                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19148                                tx_id: header.tx_id,
19149                            },
19150                        })
19151                    }
19152                    0x6bbf00c53a4c78c2 => {
19153                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19154                        let mut req = fidl::new_empty!(
19155                            BaseSocketSetNoCheckRequest,
19156                            fidl::encoding::DefaultFuchsiaResourceDialect
19157                        );
19158                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetNoCheckRequest>(&header, _body_bytes, handles, &mut req)?;
19159                        let control_handle =
19160                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19161                        Ok(BaseNetworkSocketRequest::SetNoCheck {
19162                            value: req.value,
19163
19164                            responder: BaseNetworkSocketSetNoCheckResponder {
19165                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19166                                tx_id: header.tx_id,
19167                            },
19168                        })
19169                    }
19170                    0x2cd4249286417694 => {
19171                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19172                        let mut req = fidl::new_empty!(
19173                            fidl::encoding::EmptyPayload,
19174                            fidl::encoding::DefaultFuchsiaResourceDialect
19175                        );
19176                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19177                        let control_handle =
19178                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19179                        Ok(BaseNetworkSocketRequest::GetNoCheck {
19180                            responder: BaseNetworkSocketGetNoCheckResponder {
19181                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19182                                tx_id: header.tx_id,
19183                            },
19184                        })
19185                    }
19186                    0x45386351246e998e => {
19187                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19188                        let mut req = fidl::new_empty!(
19189                            BaseSocketSetLingerRequest,
19190                            fidl::encoding::DefaultFuchsiaResourceDialect
19191                        );
19192                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetLingerRequest>(&header, _body_bytes, handles, &mut req)?;
19193                        let control_handle =
19194                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19195                        Ok(BaseNetworkSocketRequest::SetLinger {
19196                            linger: req.linger,
19197                            length_secs: req.length_secs,
19198
19199                            responder: BaseNetworkSocketSetLingerResponder {
19200                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19201                                tx_id: header.tx_id,
19202                            },
19203                        })
19204                    }
19205                    0x48eb20fc5ccb0e45 => {
19206                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19207                        let mut req = fidl::new_empty!(
19208                            fidl::encoding::EmptyPayload,
19209                            fidl::encoding::DefaultFuchsiaResourceDialect
19210                        );
19211                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19212                        let control_handle =
19213                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19214                        Ok(BaseNetworkSocketRequest::GetLinger {
19215                            responder: BaseNetworkSocketGetLingerResponder {
19216                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19217                                tx_id: header.tx_id,
19218                            },
19219                        })
19220                    }
19221                    0x24dd3e5cb36d9ccb => {
19222                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19223                        let mut req = fidl::new_empty!(
19224                            BaseSocketSetReusePortRequest,
19225                            fidl::encoding::DefaultFuchsiaResourceDialect
19226                        );
19227                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReusePortRequest>(&header, _body_bytes, handles, &mut req)?;
19228                        let control_handle =
19229                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19230                        Ok(BaseNetworkSocketRequest::SetReusePort {
19231                            value: req.value,
19232
19233                            responder: BaseNetworkSocketSetReusePortResponder {
19234                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19235                                tx_id: header.tx_id,
19236                            },
19237                        })
19238                    }
19239                    0x7a112c1ab54ff828 => {
19240                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19241                        let mut req = fidl::new_empty!(
19242                            fidl::encoding::EmptyPayload,
19243                            fidl::encoding::DefaultFuchsiaResourceDialect
19244                        );
19245                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19246                        let control_handle =
19247                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19248                        Ok(BaseNetworkSocketRequest::GetReusePort {
19249                            responder: BaseNetworkSocketGetReusePortResponder {
19250                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19251                                tx_id: header.tx_id,
19252                            },
19253                        })
19254                    }
19255                    0x67ce6db6c2ec8966 => {
19256                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19257                        let mut req = fidl::new_empty!(
19258                            fidl::encoding::EmptyPayload,
19259                            fidl::encoding::DefaultFuchsiaResourceDialect
19260                        );
19261                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19262                        let control_handle =
19263                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19264                        Ok(BaseNetworkSocketRequest::GetAcceptConn {
19265                            responder: BaseNetworkSocketGetAcceptConnResponder {
19266                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19267                                tx_id: header.tx_id,
19268                            },
19269                        })
19270                    }
19271                    0x2118b483f28aafc4 => {
19272                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19273                        let mut req = fidl::new_empty!(
19274                            BaseSocketSetBindToDeviceRequest,
19275                            fidl::encoding::DefaultFuchsiaResourceDialect
19276                        );
19277                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToDeviceRequest>(&header, _body_bytes, handles, &mut req)?;
19278                        let control_handle =
19279                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19280                        Ok(BaseNetworkSocketRequest::SetBindToDevice {
19281                            value: req.value,
19282
19283                            responder: BaseNetworkSocketSetBindToDeviceResponder {
19284                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19285                                tx_id: header.tx_id,
19286                            },
19287                        })
19288                    }
19289                    0x1ab1fbf0ef7906c8 => {
19290                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19291                        let mut req = fidl::new_empty!(
19292                            fidl::encoding::EmptyPayload,
19293                            fidl::encoding::DefaultFuchsiaResourceDialect
19294                        );
19295                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19296                        let control_handle =
19297                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19298                        Ok(BaseNetworkSocketRequest::GetBindToDevice {
19299                            responder: BaseNetworkSocketGetBindToDeviceResponder {
19300                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19301                                tx_id: header.tx_id,
19302                            },
19303                        })
19304                    }
19305                    0x6e387a0def00821 => {
19306                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19307                        let mut req = fidl::new_empty!(
19308                            BaseSocketSetBindToInterfaceIndexRequest,
19309                            fidl::encoding::DefaultFuchsiaResourceDialect
19310                        );
19311                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToInterfaceIndexRequest>(&header, _body_bytes, handles, &mut req)?;
19312                        let control_handle =
19313                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19314                        Ok(BaseNetworkSocketRequest::SetBindToInterfaceIndex {
19315                            value: req.value,
19316
19317                            responder: BaseNetworkSocketSetBindToInterfaceIndexResponder {
19318                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19319                                tx_id: header.tx_id,
19320                            },
19321                        })
19322                    }
19323                    0x59c31dd3e3078295 => {
19324                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19325                        let mut req = fidl::new_empty!(
19326                            fidl::encoding::EmptyPayload,
19327                            fidl::encoding::DefaultFuchsiaResourceDialect
19328                        );
19329                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19330                        let control_handle =
19331                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19332                        Ok(BaseNetworkSocketRequest::GetBindToInterfaceIndex {
19333                            responder: BaseNetworkSocketGetBindToInterfaceIndexResponder {
19334                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19335                                tx_id: header.tx_id,
19336                            },
19337                        })
19338                    }
19339                    0x285d6516c263d839 => {
19340                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19341                        let mut req = fidl::new_empty!(
19342                            BaseSocketSetTimestampRequest,
19343                            fidl::encoding::DefaultFuchsiaResourceDialect
19344                        );
19345                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetTimestampRequest>(&header, _body_bytes, handles, &mut req)?;
19346                        let control_handle =
19347                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19348                        Ok(BaseNetworkSocketRequest::SetTimestamp {
19349                            value: req.value,
19350
19351                            responder: BaseNetworkSocketSetTimestampResponder {
19352                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19353                                tx_id: header.tx_id,
19354                            },
19355                        })
19356                    }
19357                    0x49f2fffbbcc2bd27 => {
19358                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19359                        let mut req = fidl::new_empty!(
19360                            fidl::encoding::EmptyPayload,
19361                            fidl::encoding::DefaultFuchsiaResourceDialect
19362                        );
19363                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19364                        let control_handle =
19365                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19366                        Ok(BaseNetworkSocketRequest::GetTimestamp {
19367                            responder: BaseNetworkSocketGetTimestampResponder {
19368                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19369                                tx_id: header.tx_id,
19370                            },
19371                        })
19372                    }
19373                    0x6ead6de09f653236 => {
19374                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19375                        let mut req = fidl::new_empty!(
19376                            BaseSocketSetMarkRequest,
19377                            fidl::encoding::DefaultFuchsiaResourceDialect
19378                        );
19379                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
19380                        let control_handle =
19381                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19382                        Ok(BaseNetworkSocketRequest::SetMark {
19383                            domain: req.domain,
19384                            mark: req.mark,
19385
19386                            responder: BaseNetworkSocketSetMarkResponder {
19387                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19388                                tx_id: header.tx_id,
19389                            },
19390                        })
19391                    }
19392                    0x57a2752c61d93d47 => {
19393                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19394                        let mut req = fidl::new_empty!(
19395                            BaseSocketGetMarkRequest,
19396                            fidl::encoding::DefaultFuchsiaResourceDialect
19397                        );
19398                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketGetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
19399                        let control_handle =
19400                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19401                        Ok(BaseNetworkSocketRequest::GetMark {
19402                            domain: req.domain,
19403
19404                            responder: BaseNetworkSocketGetMarkResponder {
19405                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19406                                tx_id: header.tx_id,
19407                            },
19408                        })
19409                    }
19410                    0x4bc6400ae92125d => {
19411                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19412                        let mut req = fidl::new_empty!(
19413                            BaseNetworkSocketBindRequest,
19414                            fidl::encoding::DefaultFuchsiaResourceDialect
19415                        );
19416                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketBindRequest>(&header, _body_bytes, handles, &mut req)?;
19417                        let control_handle =
19418                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19419                        Ok(BaseNetworkSocketRequest::Bind {
19420                            addr: req.addr,
19421
19422                            responder: BaseNetworkSocketBindResponder {
19423                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19424                                tx_id: header.tx_id,
19425                            },
19426                        })
19427                    }
19428                    0x5f05f19bfdd38871 => {
19429                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19430                        let mut req = fidl::new_empty!(
19431                            BaseNetworkSocketConnectRequest,
19432                            fidl::encoding::DefaultFuchsiaResourceDialect
19433                        );
19434                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketConnectRequest>(&header, _body_bytes, handles, &mut req)?;
19435                        let control_handle =
19436                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19437                        Ok(BaseNetworkSocketRequest::Connect {
19438                            addr: req.addr,
19439
19440                            responder: BaseNetworkSocketConnectResponder {
19441                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19442                                tx_id: header.tx_id,
19443                            },
19444                        })
19445                    }
19446                    0x74e63b91f7b29b2 => {
19447                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19448                        let mut req = fidl::new_empty!(
19449                            fidl::encoding::EmptyPayload,
19450                            fidl::encoding::DefaultFuchsiaResourceDialect
19451                        );
19452                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19453                        let control_handle =
19454                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19455                        Ok(BaseNetworkSocketRequest::Disconnect {
19456                            responder: BaseNetworkSocketDisconnectResponder {
19457                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19458                                tx_id: header.tx_id,
19459                            },
19460                        })
19461                    }
19462                    0x475f23f84a1a4f85 => {
19463                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19464                        let mut req = fidl::new_empty!(
19465                            fidl::encoding::EmptyPayload,
19466                            fidl::encoding::DefaultFuchsiaResourceDialect
19467                        );
19468                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19469                        let control_handle =
19470                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19471                        Ok(BaseNetworkSocketRequest::GetSockName {
19472                            responder: BaseNetworkSocketGetSockNameResponder {
19473                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19474                                tx_id: header.tx_id,
19475                            },
19476                        })
19477                    }
19478                    0x1ffecf4bd5b6432e => {
19479                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19480                        let mut req = fidl::new_empty!(
19481                            fidl::encoding::EmptyPayload,
19482                            fidl::encoding::DefaultFuchsiaResourceDialect
19483                        );
19484                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19485                        let control_handle =
19486                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19487                        Ok(BaseNetworkSocketRequest::GetPeerName {
19488                            responder: BaseNetworkSocketGetPeerNameResponder {
19489                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19490                                tx_id: header.tx_id,
19491                            },
19492                        })
19493                    }
19494                    0x247f38b6db68c336 => {
19495                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19496                        let mut req = fidl::new_empty!(
19497                            BaseNetworkSocketShutdownRequest,
19498                            fidl::encoding::DefaultFuchsiaResourceDialect
19499                        );
19500                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketShutdownRequest>(&header, _body_bytes, handles, &mut req)?;
19501                        let control_handle =
19502                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19503                        Ok(BaseNetworkSocketRequest::Shutdown {
19504                            mode: req.mode,
19505
19506                            responder: BaseNetworkSocketShutdownResponder {
19507                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19508                                tx_id: header.tx_id,
19509                            },
19510                        })
19511                    }
19512                    0x995c600475b6d46 => {
19513                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19514                        let mut req = fidl::new_empty!(
19515                            BaseNetworkSocketSetIpTypeOfServiceRequest,
19516                            fidl::encoding::DefaultFuchsiaResourceDialect
19517                        );
19518                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
19519                        let control_handle =
19520                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19521                        Ok(BaseNetworkSocketRequest::SetIpTypeOfService {
19522                            value: req.value,
19523
19524                            responder: BaseNetworkSocketSetIpTypeOfServiceResponder {
19525                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19526                                tx_id: header.tx_id,
19527                            },
19528                        })
19529                    }
19530                    0x3814a04259f75fcb => {
19531                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19532                        let mut req = fidl::new_empty!(
19533                            fidl::encoding::EmptyPayload,
19534                            fidl::encoding::DefaultFuchsiaResourceDialect
19535                        );
19536                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19537                        let control_handle =
19538                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19539                        Ok(BaseNetworkSocketRequest::GetIpTypeOfService {
19540                            responder: BaseNetworkSocketGetIpTypeOfServiceResponder {
19541                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19542                                tx_id: header.tx_id,
19543                            },
19544                        })
19545                    }
19546                    0x29e2424b433ae1ef => {
19547                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19548                        let mut req = fidl::new_empty!(
19549                            BaseNetworkSocketSetIpTtlRequest,
19550                            fidl::encoding::DefaultFuchsiaResourceDialect
19551                        );
19552                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTtlRequest>(&header, _body_bytes, handles, &mut req)?;
19553                        let control_handle =
19554                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19555                        Ok(BaseNetworkSocketRequest::SetIpTtl {
19556                            value: req.value,
19557
19558                            responder: BaseNetworkSocketSetIpTtlResponder {
19559                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19560                                tx_id: header.tx_id,
19561                            },
19562                        })
19563                    }
19564                    0x47e47fa1f24da471 => {
19565                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19566                        let mut req = fidl::new_empty!(
19567                            fidl::encoding::EmptyPayload,
19568                            fidl::encoding::DefaultFuchsiaResourceDialect
19569                        );
19570                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19571                        let control_handle =
19572                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19573                        Ok(BaseNetworkSocketRequest::GetIpTtl {
19574                            responder: BaseNetworkSocketGetIpTtlResponder {
19575                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19576                                tx_id: header.tx_id,
19577                            },
19578                        })
19579                    }
19580                    0x392d16bee20c0e16 => {
19581                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19582                        let mut req = fidl::new_empty!(
19583                            BaseNetworkSocketSetIpPacketInfoRequest,
19584                            fidl::encoding::DefaultFuchsiaResourceDialect
19585                        );
19586                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpPacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
19587                        let control_handle =
19588                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19589                        Ok(BaseNetworkSocketRequest::SetIpPacketInfo {
19590                            value: req.value,
19591
19592                            responder: BaseNetworkSocketSetIpPacketInfoResponder {
19593                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19594                                tx_id: header.tx_id,
19595                            },
19596                        })
19597                    }
19598                    0x54b505f242280740 => {
19599                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19600                        let mut req = fidl::new_empty!(
19601                            fidl::encoding::EmptyPayload,
19602                            fidl::encoding::DefaultFuchsiaResourceDialect
19603                        );
19604                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19605                        let control_handle =
19606                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19607                        Ok(BaseNetworkSocketRequest::GetIpPacketInfo {
19608                            responder: BaseNetworkSocketGetIpPacketInfoResponder {
19609                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19610                                tx_id: header.tx_id,
19611                            },
19612                        })
19613                    }
19614                    0x6c4f6714995f84ef => {
19615                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19616                        let mut req = fidl::new_empty!(
19617                            BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
19618                            fidl::encoding::DefaultFuchsiaResourceDialect
19619                        );
19620                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
19621                        let control_handle =
19622                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19623                        Ok(BaseNetworkSocketRequest::SetIpReceiveTypeOfService {
19624                            value: req.value,
19625
19626                            responder: BaseNetworkSocketSetIpReceiveTypeOfServiceResponder {
19627                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19628                                tx_id: header.tx_id,
19629                            },
19630                        })
19631                    }
19632                    0x4158ba7dc2795960 => {
19633                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19634                        let mut req = fidl::new_empty!(
19635                            fidl::encoding::EmptyPayload,
19636                            fidl::encoding::DefaultFuchsiaResourceDialect
19637                        );
19638                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19639                        let control_handle =
19640                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19641                        Ok(BaseNetworkSocketRequest::GetIpReceiveTypeOfService {
19642                            responder: BaseNetworkSocketGetIpReceiveTypeOfServiceResponder {
19643                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19644                                tx_id: header.tx_id,
19645                            },
19646                        })
19647                    }
19648                    0x46f15be0ce0ab82b => {
19649                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19650                        let mut req = fidl::new_empty!(
19651                            BaseNetworkSocketSetIpReceiveTtlRequest,
19652                            fidl::encoding::DefaultFuchsiaResourceDialect
19653                        );
19654                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveTtlRequest>(&header, _body_bytes, handles, &mut req)?;
19655                        let control_handle =
19656                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19657                        Ok(BaseNetworkSocketRequest::SetIpReceiveTtl {
19658                            value: req.value,
19659
19660                            responder: BaseNetworkSocketSetIpReceiveTtlResponder {
19661                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19662                                tx_id: header.tx_id,
19663                            },
19664                        })
19665                    }
19666                    0x678ddd5a5dfa2eb5 => {
19667                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19668                        let mut req = fidl::new_empty!(
19669                            fidl::encoding::EmptyPayload,
19670                            fidl::encoding::DefaultFuchsiaResourceDialect
19671                        );
19672                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19673                        let control_handle =
19674                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19675                        Ok(BaseNetworkSocketRequest::GetIpReceiveTtl {
19676                            responder: BaseNetworkSocketGetIpReceiveTtlResponder {
19677                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19678                                tx_id: header.tx_id,
19679                            },
19680                        })
19681                    }
19682                    0x752fbfa9b12befe => {
19683                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19684                        let mut req = fidl::new_empty!(
19685                            BaseNetworkSocketSetIpMulticastInterfaceRequest,
19686                            fidl::encoding::DefaultFuchsiaResourceDialect
19687                        );
19688                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
19689                        let control_handle =
19690                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19691                        Ok(BaseNetworkSocketRequest::SetIpMulticastInterface {
19692                            iface: req.iface,
19693                            address: req.address,
19694
19695                            responder: BaseNetworkSocketSetIpMulticastInterfaceResponder {
19696                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19697                                tx_id: header.tx_id,
19698                            },
19699                        })
19700                    }
19701                    0x320bd14c4df046c4 => {
19702                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19703                        let mut req = fidl::new_empty!(
19704                            fidl::encoding::EmptyPayload,
19705                            fidl::encoding::DefaultFuchsiaResourceDialect
19706                        );
19707                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19708                        let control_handle =
19709                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19710                        Ok(BaseNetworkSocketRequest::GetIpMulticastInterface {
19711                            responder: BaseNetworkSocketGetIpMulticastInterfaceResponder {
19712                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19713                                tx_id: header.tx_id,
19714                            },
19715                        })
19716                    }
19717                    0x63134d53772916a1 => {
19718                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19719                        let mut req = fidl::new_empty!(
19720                            BaseNetworkSocketSetIpMulticastTtlRequest,
19721                            fidl::encoding::DefaultFuchsiaResourceDialect
19722                        );
19723                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastTtlRequest>(&header, _body_bytes, handles, &mut req)?;
19724                        let control_handle =
19725                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19726                        Ok(BaseNetworkSocketRequest::SetIpMulticastTtl {
19727                            value: req.value,
19728
19729                            responder: BaseNetworkSocketSetIpMulticastTtlResponder {
19730                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19731                                tx_id: header.tx_id,
19732                            },
19733                        })
19734                    }
19735                    0x4665cd378f39e1a => {
19736                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19737                        let mut req = fidl::new_empty!(
19738                            fidl::encoding::EmptyPayload,
19739                            fidl::encoding::DefaultFuchsiaResourceDialect
19740                        );
19741                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19742                        let control_handle =
19743                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19744                        Ok(BaseNetworkSocketRequest::GetIpMulticastTtl {
19745                            responder: BaseNetworkSocketGetIpMulticastTtlResponder {
19746                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19747                                tx_id: header.tx_id,
19748                            },
19749                        })
19750                    }
19751                    0x20c55c11f00943ea => {
19752                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19753                        let mut req = fidl::new_empty!(
19754                            BaseNetworkSocketSetIpMulticastLoopbackRequest,
19755                            fidl::encoding::DefaultFuchsiaResourceDialect
19756                        );
19757                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
19758                        let control_handle =
19759                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19760                        Ok(BaseNetworkSocketRequest::SetIpMulticastLoopback {
19761                            value: req.value,
19762
19763                            responder: BaseNetworkSocketSetIpMulticastLoopbackResponder {
19764                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19765                                tx_id: header.tx_id,
19766                            },
19767                        })
19768                    }
19769                    0x3b6b26ff558298f2 => {
19770                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19771                        let mut req = fidl::new_empty!(
19772                            fidl::encoding::EmptyPayload,
19773                            fidl::encoding::DefaultFuchsiaResourceDialect
19774                        );
19775                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19776                        let control_handle =
19777                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19778                        Ok(BaseNetworkSocketRequest::GetIpMulticastLoopback {
19779                            responder: BaseNetworkSocketGetIpMulticastLoopbackResponder {
19780                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19781                                tx_id: header.tx_id,
19782                            },
19783                        })
19784                    }
19785                    0x76bc7df115a3b4d0 => {
19786                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19787                        let mut req = fidl::new_empty!(
19788                            BaseNetworkSocketAddIpMembershipRequest,
19789                            fidl::encoding::DefaultFuchsiaResourceDialect
19790                        );
19791                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketAddIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
19792                        let control_handle =
19793                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19794                        Ok(BaseNetworkSocketRequest::AddIpMembership {
19795                            membership: req.membership,
19796
19797                            responder: BaseNetworkSocketAddIpMembershipResponder {
19798                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19799                                tx_id: header.tx_id,
19800                            },
19801                        })
19802                    }
19803                    0x2888f3099188d03 => {
19804                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19805                        let mut req = fidl::new_empty!(
19806                            BaseNetworkSocketDropIpMembershipRequest,
19807                            fidl::encoding::DefaultFuchsiaResourceDialect
19808                        );
19809                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketDropIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
19810                        let control_handle =
19811                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19812                        Ok(BaseNetworkSocketRequest::DropIpMembership {
19813                            membership: req.membership,
19814
19815                            responder: BaseNetworkSocketDropIpMembershipResponder {
19816                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19817                                tx_id: header.tx_id,
19818                            },
19819                        })
19820                    }
19821                    0x1ae532b0c066e3a0 => {
19822                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19823                        let mut req = fidl::new_empty!(
19824                            BaseNetworkSocketSetIpTransparentRequest,
19825                            fidl::encoding::DefaultFuchsiaResourceDialect
19826                        );
19827                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTransparentRequest>(&header, _body_bytes, handles, &mut req)?;
19828                        let control_handle =
19829                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19830                        Ok(BaseNetworkSocketRequest::SetIpTransparent {
19831                            value: req.value,
19832
19833                            responder: BaseNetworkSocketSetIpTransparentResponder {
19834                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19835                                tx_id: header.tx_id,
19836                            },
19837                        })
19838                    }
19839                    0x51d43695962ebfb5 => {
19840                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19841                        let mut req = fidl::new_empty!(
19842                            fidl::encoding::EmptyPayload,
19843                            fidl::encoding::DefaultFuchsiaResourceDialect
19844                        );
19845                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19846                        let control_handle =
19847                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19848                        Ok(BaseNetworkSocketRequest::GetIpTransparent {
19849                            responder: BaseNetworkSocketGetIpTransparentResponder {
19850                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19851                                tx_id: header.tx_id,
19852                            },
19853                        })
19854                    }
19855                    0x4722b4ce52f7840 => {
19856                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19857                        let mut req = fidl::new_empty!(
19858                            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
19859                            fidl::encoding::DefaultFuchsiaResourceDialect
19860                        );
19861                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest>(&header, _body_bytes, handles, &mut req)?;
19862                        let control_handle =
19863                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19864                        Ok(BaseNetworkSocketRequest::SetIpReceiveOriginalDestinationAddress {
19865                            value: req.value,
19866
19867                            responder:
19868                                BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResponder {
19869                                    control_handle: std::mem::ManuallyDrop::new(control_handle),
19870                                    tx_id: header.tx_id,
19871                                },
19872                        })
19873                    }
19874                    0x2a0e7dc5d6bfdfe9 => {
19875                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19876                        let mut req = fidl::new_empty!(
19877                            fidl::encoding::EmptyPayload,
19878                            fidl::encoding::DefaultFuchsiaResourceDialect
19879                        );
19880                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19881                        let control_handle =
19882                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19883                        Ok(BaseNetworkSocketRequest::GetIpReceiveOriginalDestinationAddress {
19884                            responder:
19885                                BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponder {
19886                                    control_handle: std::mem::ManuallyDrop::new(control_handle),
19887                                    tx_id: header.tx_id,
19888                                },
19889                        })
19890                    }
19891                    0x7c94727acb4ea4b3 => {
19892                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19893                        let mut req = fidl::new_empty!(
19894                            BaseNetworkSocketAddIpv6MembershipRequest,
19895                            fidl::encoding::DefaultFuchsiaResourceDialect
19896                        );
19897                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketAddIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
19898                        let control_handle =
19899                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19900                        Ok(BaseNetworkSocketRequest::AddIpv6Membership {
19901                            membership: req.membership,
19902
19903                            responder: BaseNetworkSocketAddIpv6MembershipResponder {
19904                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19905                                tx_id: header.tx_id,
19906                            },
19907                        })
19908                    }
19909                    0x42104c70ccaba304 => {
19910                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19911                        let mut req = fidl::new_empty!(
19912                            BaseNetworkSocketDropIpv6MembershipRequest,
19913                            fidl::encoding::DefaultFuchsiaResourceDialect
19914                        );
19915                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketDropIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
19916                        let control_handle =
19917                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19918                        Ok(BaseNetworkSocketRequest::DropIpv6Membership {
19919                            membership: req.membership,
19920
19921                            responder: BaseNetworkSocketDropIpv6MembershipResponder {
19922                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19923                                tx_id: header.tx_id,
19924                            },
19925                        })
19926                    }
19927                    0x135f76db3774ab3b => {
19928                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19929                        let mut req = fidl::new_empty!(
19930                            BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
19931                            fidl::encoding::DefaultFuchsiaResourceDialect
19932                        );
19933                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
19934                        let control_handle =
19935                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19936                        Ok(BaseNetworkSocketRequest::SetIpv6MulticastInterface {
19937                            value: req.value,
19938
19939                            responder: BaseNetworkSocketSetIpv6MulticastInterfaceResponder {
19940                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19941                                tx_id: header.tx_id,
19942                            },
19943                        })
19944                    }
19945                    0x1f26fcdd348f1882 => {
19946                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19947                        let mut req = fidl::new_empty!(
19948                            fidl::encoding::EmptyPayload,
19949                            fidl::encoding::DefaultFuchsiaResourceDialect
19950                        );
19951                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19952                        let control_handle =
19953                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19954                        Ok(BaseNetworkSocketRequest::GetIpv6MulticastInterface {
19955                            responder: BaseNetworkSocketGetIpv6MulticastInterfaceResponder {
19956                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19957                                tx_id: header.tx_id,
19958                            },
19959                        })
19960                    }
19961                    0x157d51e98f462859 => {
19962                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19963                        let mut req = fidl::new_empty!(
19964                            BaseNetworkSocketSetIpv6UnicastHopsRequest,
19965                            fidl::encoding::DefaultFuchsiaResourceDialect
19966                        );
19967                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6UnicastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
19968                        let control_handle =
19969                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19970                        Ok(BaseNetworkSocketRequest::SetIpv6UnicastHops {
19971                            value: req.value,
19972
19973                            responder: BaseNetworkSocketSetIpv6UnicastHopsResponder {
19974                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19975                                tx_id: header.tx_id,
19976                            },
19977                        })
19978                    }
19979                    0x21f4641cad8bd8d2 => {
19980                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19981                        let mut req = fidl::new_empty!(
19982                            fidl::encoding::EmptyPayload,
19983                            fidl::encoding::DefaultFuchsiaResourceDialect
19984                        );
19985                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
19986                        let control_handle =
19987                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
19988                        Ok(BaseNetworkSocketRequest::GetIpv6UnicastHops {
19989                            responder: BaseNetworkSocketGetIpv6UnicastHopsResponder {
19990                                control_handle: std::mem::ManuallyDrop::new(control_handle),
19991                                tx_id: header.tx_id,
19992                            },
19993                        })
19994                    }
19995                    0x5c24808ed2e84a1e => {
19996                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
19997                        let mut req = fidl::new_empty!(
19998                            BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
19999                            fidl::encoding::DefaultFuchsiaResourceDialect
20000                        );
20001                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceiveHopLimitRequest>(&header, _body_bytes, handles, &mut req)?;
20002                        let control_handle =
20003                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
20004                        Ok(BaseNetworkSocketRequest::SetIpv6ReceiveHopLimit {
20005                            value: req.value,
20006
20007                            responder: BaseNetworkSocketSetIpv6ReceiveHopLimitResponder {
20008                                control_handle: std::mem::ManuallyDrop::new(control_handle),
20009                                tx_id: header.tx_id,
20010                            },
20011                        })
20012                    }
20013                    0x341e06689885b4c0 => {
20014                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
20015                        let mut req = fidl::new_empty!(
20016                            fidl::encoding::EmptyPayload,
20017                            fidl::encoding::DefaultFuchsiaResourceDialect
20018                        );
20019                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
20020                        let control_handle =
20021                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
20022                        Ok(BaseNetworkSocketRequest::GetIpv6ReceiveHopLimit {
20023                            responder: BaseNetworkSocketGetIpv6ReceiveHopLimitResponder {
20024                                control_handle: std::mem::ManuallyDrop::new(control_handle),
20025                                tx_id: header.tx_id,
20026                            },
20027                        })
20028                    }
20029                    0x25b9cd4d181f82c1 => {
20030                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
20031                        let mut req = fidl::new_empty!(
20032                            BaseNetworkSocketSetIpv6MulticastHopsRequest,
20033                            fidl::encoding::DefaultFuchsiaResourceDialect
20034                        );
20035                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
20036                        let control_handle =
20037                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
20038                        Ok(BaseNetworkSocketRequest::SetIpv6MulticastHops {
20039                            value: req.value,
20040
20041                            responder: BaseNetworkSocketSetIpv6MulticastHopsResponder {
20042                                control_handle: std::mem::ManuallyDrop::new(control_handle),
20043                                tx_id: header.tx_id,
20044                            },
20045                        })
20046                    }
20047                    0x52916948a365012a => {
20048                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
20049                        let mut req = fidl::new_empty!(
20050                            fidl::encoding::EmptyPayload,
20051                            fidl::encoding::DefaultFuchsiaResourceDialect
20052                        );
20053                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
20054                        let control_handle =
20055                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
20056                        Ok(BaseNetworkSocketRequest::GetIpv6MulticastHops {
20057                            responder: BaseNetworkSocketGetIpv6MulticastHopsResponder {
20058                                control_handle: std::mem::ManuallyDrop::new(control_handle),
20059                                tx_id: header.tx_id,
20060                            },
20061                        })
20062                    }
20063                    0x55701c409ff41b40 => {
20064                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
20065                        let mut req = fidl::new_empty!(
20066                            BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
20067                            fidl::encoding::DefaultFuchsiaResourceDialect
20068                        );
20069                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
20070                        let control_handle =
20071                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
20072                        Ok(BaseNetworkSocketRequest::SetIpv6MulticastLoopback {
20073                            value: req.value,
20074
20075                            responder: BaseNetworkSocketSetIpv6MulticastLoopbackResponder {
20076                                control_handle: std::mem::ManuallyDrop::new(control_handle),
20077                                tx_id: header.tx_id,
20078                            },
20079                        })
20080                    }
20081                    0x4415b701fde319c3 => {
20082                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
20083                        let mut req = fidl::new_empty!(
20084                            fidl::encoding::EmptyPayload,
20085                            fidl::encoding::DefaultFuchsiaResourceDialect
20086                        );
20087                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
20088                        let control_handle =
20089                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
20090                        Ok(BaseNetworkSocketRequest::GetIpv6MulticastLoopback {
20091                            responder: BaseNetworkSocketGetIpv6MulticastLoopbackResponder {
20092                                control_handle: std::mem::ManuallyDrop::new(control_handle),
20093                                tx_id: header.tx_id,
20094                            },
20095                        })
20096                    }
20097                    0x4873f1364758cbba => {
20098                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
20099                        let mut req = fidl::new_empty!(
20100                            BaseNetworkSocketSetIpv6OnlyRequest,
20101                            fidl::encoding::DefaultFuchsiaResourceDialect
20102                        );
20103                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6OnlyRequest>(&header, _body_bytes, handles, &mut req)?;
20104                        let control_handle =
20105                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
20106                        Ok(BaseNetworkSocketRequest::SetIpv6Only {
20107                            value: req.value,
20108
20109                            responder: BaseNetworkSocketSetIpv6OnlyResponder {
20110                                control_handle: std::mem::ManuallyDrop::new(control_handle),
20111                                tx_id: header.tx_id,
20112                            },
20113                        })
20114                    }
20115                    0x4aa3340a1a26b89c => {
20116                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
20117                        let mut req = fidl::new_empty!(
20118                            fidl::encoding::EmptyPayload,
20119                            fidl::encoding::DefaultFuchsiaResourceDialect
20120                        );
20121                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
20122                        let control_handle =
20123                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
20124                        Ok(BaseNetworkSocketRequest::GetIpv6Only {
20125                            responder: BaseNetworkSocketGetIpv6OnlyResponder {
20126                                control_handle: std::mem::ManuallyDrop::new(control_handle),
20127                                tx_id: header.tx_id,
20128                            },
20129                        })
20130                    }
20131                    0x58f07c8788d099a0 => {
20132                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
20133                        let mut req = fidl::new_empty!(
20134                            BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
20135                            fidl::encoding::DefaultFuchsiaResourceDialect
20136                        );
20137                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
20138                        let control_handle =
20139                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
20140                        Ok(BaseNetworkSocketRequest::SetIpv6ReceiveTrafficClass {
20141                            value: req.value,
20142
20143                            responder: BaseNetworkSocketSetIpv6ReceiveTrafficClassResponder {
20144                                control_handle: std::mem::ManuallyDrop::new(control_handle),
20145                                tx_id: header.tx_id,
20146                            },
20147                        })
20148                    }
20149                    0x2e334df1da553ffa => {
20150                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
20151                        let mut req = fidl::new_empty!(
20152                            fidl::encoding::EmptyPayload,
20153                            fidl::encoding::DefaultFuchsiaResourceDialect
20154                        );
20155                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
20156                        let control_handle =
20157                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
20158                        Ok(BaseNetworkSocketRequest::GetIpv6ReceiveTrafficClass {
20159                            responder: BaseNetworkSocketGetIpv6ReceiveTrafficClassResponder {
20160                                control_handle: std::mem::ManuallyDrop::new(control_handle),
20161                                tx_id: header.tx_id,
20162                            },
20163                        })
20164                    }
20165                    0x6af077800c5a0b4f => {
20166                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
20167                        let mut req = fidl::new_empty!(
20168                            BaseNetworkSocketSetIpv6TrafficClassRequest,
20169                            fidl::encoding::DefaultFuchsiaResourceDialect
20170                        );
20171                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6TrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
20172                        let control_handle =
20173                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
20174                        Ok(BaseNetworkSocketRequest::SetIpv6TrafficClass {
20175                            value: req.value,
20176
20177                            responder: BaseNetworkSocketSetIpv6TrafficClassResponder {
20178                                control_handle: std::mem::ManuallyDrop::new(control_handle),
20179                                tx_id: header.tx_id,
20180                            },
20181                        })
20182                    }
20183                    0x6baf6eed8fc2f04 => {
20184                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
20185                        let mut req = fidl::new_empty!(
20186                            fidl::encoding::EmptyPayload,
20187                            fidl::encoding::DefaultFuchsiaResourceDialect
20188                        );
20189                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
20190                        let control_handle =
20191                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
20192                        Ok(BaseNetworkSocketRequest::GetIpv6TrafficClass {
20193                            responder: BaseNetworkSocketGetIpv6TrafficClassResponder {
20194                                control_handle: std::mem::ManuallyDrop::new(control_handle),
20195                                tx_id: header.tx_id,
20196                            },
20197                        })
20198                    }
20199                    0x19259775b1a92768 => {
20200                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
20201                        let mut req = fidl::new_empty!(
20202                            BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
20203                            fidl::encoding::DefaultFuchsiaResourceDialect
20204                        );
20205                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceivePacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
20206                        let control_handle =
20207                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
20208                        Ok(BaseNetworkSocketRequest::SetIpv6ReceivePacketInfo {
20209                            value: req.value,
20210
20211                            responder: BaseNetworkSocketSetIpv6ReceivePacketInfoResponder {
20212                                control_handle: std::mem::ManuallyDrop::new(control_handle),
20213                                tx_id: header.tx_id,
20214                            },
20215                        })
20216                    }
20217                    0x7acd4a2775baec75 => {
20218                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
20219                        let mut req = fidl::new_empty!(
20220                            fidl::encoding::EmptyPayload,
20221                            fidl::encoding::DefaultFuchsiaResourceDialect
20222                        );
20223                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
20224                        let control_handle =
20225                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
20226                        Ok(BaseNetworkSocketRequest::GetIpv6ReceivePacketInfo {
20227                            responder: BaseNetworkSocketGetIpv6ReceivePacketInfoResponder {
20228                                control_handle: std::mem::ManuallyDrop::new(control_handle),
20229                                tx_id: header.tx_id,
20230                            },
20231                        })
20232                    }
20233                    0x38bf28f0dafdbac0 => {
20234                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
20235                        let mut req = fidl::new_empty!(
20236                            fidl::encoding::EmptyPayload,
20237                            fidl::encoding::DefaultFuchsiaResourceDialect
20238                        );
20239                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
20240                        let control_handle =
20241                            BaseNetworkSocketControlHandle { inner: this.inner.clone() };
20242                        Ok(BaseNetworkSocketRequest::GetOriginalDestination {
20243                            responder: BaseNetworkSocketGetOriginalDestinationResponder {
20244                                control_handle: std::mem::ManuallyDrop::new(control_handle),
20245                                tx_id: header.tx_id,
20246                            },
20247                        })
20248                    }
20249                    _ => Err(fidl::Error::UnknownOrdinal {
20250                        ordinal: header.ordinal,
20251                        protocol_name:
20252                            <BaseNetworkSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
20253                    }),
20254                }))
20255            },
20256        )
20257    }
20258}
20259
20260/// A network socket.
20261#[derive(Debug)]
20262pub enum BaseNetworkSocketRequest {
20263    Clone {
20264        request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
20265        control_handle: BaseNetworkSocketControlHandle,
20266    },
20267    /// Terminates the connection.
20268    ///
20269    /// After calling `Close`, the client must not send any other requests.
20270    ///
20271    /// Servers, after sending the status response, should close the connection
20272    /// regardless of status and without sending an epitaph.
20273    ///
20274    /// Closing the client end of the channel should be semantically equivalent
20275    /// to calling `Close` without knowing when the close has completed or its
20276    /// status.
20277    Close {
20278        responder: BaseNetworkSocketCloseResponder,
20279    },
20280    Query {
20281        responder: BaseNetworkSocketQueryResponder,
20282    },
20283    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
20284    SetReuseAddress {
20285        value: bool,
20286        responder: BaseNetworkSocketSetReuseAddressResponder,
20287    },
20288    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
20289    GetReuseAddress {
20290        responder: BaseNetworkSocketGetReuseAddressResponder,
20291    },
20292    /// Get `SOL_SOCKET` -> `SO_ERROR`.
20293    /// Returns the last error if there is an error set on the socket.
20294    GetError {
20295        responder: BaseNetworkSocketGetErrorResponder,
20296    },
20297    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
20298    SetBroadcast {
20299        value: bool,
20300        responder: BaseNetworkSocketSetBroadcastResponder,
20301    },
20302    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
20303    GetBroadcast {
20304        responder: BaseNetworkSocketGetBroadcastResponder,
20305    },
20306    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
20307    SetSendBuffer {
20308        value_bytes: u64,
20309        responder: BaseNetworkSocketSetSendBufferResponder,
20310    },
20311    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
20312    GetSendBuffer {
20313        responder: BaseNetworkSocketGetSendBufferResponder,
20314    },
20315    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
20316    SetReceiveBuffer {
20317        value_bytes: u64,
20318        responder: BaseNetworkSocketSetReceiveBufferResponder,
20319    },
20320    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
20321    GetReceiveBuffer {
20322        responder: BaseNetworkSocketGetReceiveBufferResponder,
20323    },
20324    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
20325    SetKeepAlive {
20326        value: bool,
20327        responder: BaseNetworkSocketSetKeepAliveResponder,
20328    },
20329    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
20330    GetKeepAlive {
20331        responder: BaseNetworkSocketGetKeepAliveResponder,
20332    },
20333    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
20334    SetOutOfBandInline {
20335        value: bool,
20336        responder: BaseNetworkSocketSetOutOfBandInlineResponder,
20337    },
20338    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
20339    GetOutOfBandInline {
20340        responder: BaseNetworkSocketGetOutOfBandInlineResponder,
20341    },
20342    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
20343    SetNoCheck {
20344        value: bool,
20345        responder: BaseNetworkSocketSetNoCheckResponder,
20346    },
20347    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
20348    GetNoCheck {
20349        responder: BaseNetworkSocketGetNoCheckResponder,
20350    },
20351    /// Set `SOL_SOCKET` -> `SO_LINGER`.
20352    SetLinger {
20353        linger: bool,
20354        length_secs: u32,
20355        responder: BaseNetworkSocketSetLingerResponder,
20356    },
20357    /// Get `SOL_SOCKET` -> `SO_LINGER`.
20358    GetLinger {
20359        responder: BaseNetworkSocketGetLingerResponder,
20360    },
20361    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
20362    SetReusePort {
20363        value: bool,
20364        responder: BaseNetworkSocketSetReusePortResponder,
20365    },
20366    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
20367    GetReusePort {
20368        responder: BaseNetworkSocketGetReusePortResponder,
20369    },
20370    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
20371    GetAcceptConn {
20372        responder: BaseNetworkSocketGetAcceptConnResponder,
20373    },
20374    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
20375    SetBindToDevice {
20376        value: String,
20377        responder: BaseNetworkSocketSetBindToDeviceResponder,
20378    },
20379    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
20380    GetBindToDevice {
20381        responder: BaseNetworkSocketGetBindToDeviceResponder,
20382    },
20383    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
20384    /// If `value` is 0, this clears the bound interface.
20385    SetBindToInterfaceIndex {
20386        value: u64,
20387        responder: BaseNetworkSocketSetBindToInterfaceIndexResponder,
20388    },
20389    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
20390    GetBindToInterfaceIndex {
20391        responder: BaseNetworkSocketGetBindToInterfaceIndexResponder,
20392    },
20393    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
20394    SetTimestamp {
20395        value: TimestampOption,
20396        responder: BaseNetworkSocketSetTimestampResponder,
20397    },
20398    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
20399    GetTimestamp {
20400        responder: BaseNetworkSocketGetTimestampResponder,
20401    },
20402    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
20403    /// unlike the standard SO_MARK, this API has multiple mark domains and each
20404    /// mark can be set independently in each domain.
20405    SetMark {
20406        domain: fidl_fuchsia_net::MarkDomain,
20407        mark: OptionalUint32,
20408        responder: BaseNetworkSocketSetMarkResponder,
20409    },
20410    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
20411    /// unlike the standard SO_MARK, this API has multiple mark domains and each
20412    /// mark can be retrieved independently in each domain.
20413    GetMark {
20414        domain: fidl_fuchsia_net::MarkDomain,
20415        responder: BaseNetworkSocketGetMarkResponder,
20416    },
20417    /// Sets the local address used for the socket.
20418    Bind {
20419        addr: fidl_fuchsia_net::SocketAddress,
20420        responder: BaseNetworkSocketBindResponder,
20421    },
20422    /// Initiates a connection to a remote address.
20423    Connect {
20424        addr: fidl_fuchsia_net::SocketAddress,
20425        responder: BaseNetworkSocketConnectResponder,
20426    },
20427    /// Clears connection information from this socket.
20428    Disconnect {
20429        responder: BaseNetworkSocketDisconnectResponder,
20430    },
20431    /// Retrieves the local socket address.
20432    GetSockName {
20433        responder: BaseNetworkSocketGetSockNameResponder,
20434    },
20435    /// Retrieves the remote socket address.
20436    GetPeerName {
20437        responder: BaseNetworkSocketGetPeerNameResponder,
20438    },
20439    /// Shuts down part of the socket.
20440    Shutdown {
20441        mode: ShutdownMode,
20442        responder: BaseNetworkSocketShutdownResponder,
20443    },
20444    /// Set `SOL_IP` -> `IP_TOS`.
20445    SetIpTypeOfService {
20446        value: u8,
20447        responder: BaseNetworkSocketSetIpTypeOfServiceResponder,
20448    },
20449    /// Get `SOL_IP` -> `IP_TOS`.
20450    GetIpTypeOfService {
20451        responder: BaseNetworkSocketGetIpTypeOfServiceResponder,
20452    },
20453    /// Set `SOL_IP` -> `IP_TTL`.
20454    SetIpTtl {
20455        value: OptionalUint8,
20456        responder: BaseNetworkSocketSetIpTtlResponder,
20457    },
20458    /// Get `SOL_IP` -> `IP_TTL`.
20459    GetIpTtl {
20460        responder: BaseNetworkSocketGetIpTtlResponder,
20461    },
20462    /// Set `SOL_IP` -> `IP_PKTINFO`.
20463    SetIpPacketInfo {
20464        value: bool,
20465        responder: BaseNetworkSocketSetIpPacketInfoResponder,
20466    },
20467    /// Get `SOL_IP` -> `IP_PKTINFO`.
20468    GetIpPacketInfo {
20469        responder: BaseNetworkSocketGetIpPacketInfoResponder,
20470    },
20471    /// Set `SOL_IP` -> `IP_RECVTOS`.
20472    SetIpReceiveTypeOfService {
20473        value: bool,
20474        responder: BaseNetworkSocketSetIpReceiveTypeOfServiceResponder,
20475    },
20476    /// Get `SOL_IP` -> `IP_RECVTOS`.
20477    GetIpReceiveTypeOfService {
20478        responder: BaseNetworkSocketGetIpReceiveTypeOfServiceResponder,
20479    },
20480    /// Set `SOL_IP` -> `IP_RECVTTL`.
20481    SetIpReceiveTtl {
20482        value: bool,
20483        responder: BaseNetworkSocketSetIpReceiveTtlResponder,
20484    },
20485    /// Get `SOL_IP` -> `IP_RECVTTL`.
20486    GetIpReceiveTtl {
20487        responder: BaseNetworkSocketGetIpReceiveTtlResponder,
20488    },
20489    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
20490    SetIpMulticastInterface {
20491        iface: u64,
20492        address: fidl_fuchsia_net::Ipv4Address,
20493        responder: BaseNetworkSocketSetIpMulticastInterfaceResponder,
20494    },
20495    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
20496    GetIpMulticastInterface {
20497        responder: BaseNetworkSocketGetIpMulticastInterfaceResponder,
20498    },
20499    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
20500    SetIpMulticastTtl {
20501        value: OptionalUint8,
20502        responder: BaseNetworkSocketSetIpMulticastTtlResponder,
20503    },
20504    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
20505    GetIpMulticastTtl {
20506        responder: BaseNetworkSocketGetIpMulticastTtlResponder,
20507    },
20508    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
20509    SetIpMulticastLoopback {
20510        value: bool,
20511        responder: BaseNetworkSocketSetIpMulticastLoopbackResponder,
20512    },
20513    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
20514    GetIpMulticastLoopback {
20515        responder: BaseNetworkSocketGetIpMulticastLoopbackResponder,
20516    },
20517    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
20518    AddIpMembership {
20519        membership: IpMulticastMembership,
20520        responder: BaseNetworkSocketAddIpMembershipResponder,
20521    },
20522    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
20523    DropIpMembership {
20524        membership: IpMulticastMembership,
20525        responder: BaseNetworkSocketDropIpMembershipResponder,
20526    },
20527    /// Set `SOL_IP` -> `IP_TRANSPARENT`
20528    SetIpTransparent {
20529        value: bool,
20530        responder: BaseNetworkSocketSetIpTransparentResponder,
20531    },
20532    /// Get `SOL_IP` -> `IP_TRANSPARENT`
20533    GetIpTransparent {
20534        responder: BaseNetworkSocketGetIpTransparentResponder,
20535    },
20536    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
20537    SetIpReceiveOriginalDestinationAddress {
20538        value: bool,
20539        responder: BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResponder,
20540    },
20541    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
20542    GetIpReceiveOriginalDestinationAddress {
20543        responder: BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponder,
20544    },
20545    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
20546    AddIpv6Membership {
20547        membership: Ipv6MulticastMembership,
20548        responder: BaseNetworkSocketAddIpv6MembershipResponder,
20549    },
20550    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
20551    DropIpv6Membership {
20552        membership: Ipv6MulticastMembership,
20553        responder: BaseNetworkSocketDropIpv6MembershipResponder,
20554    },
20555    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
20556    SetIpv6MulticastInterface {
20557        value: u64,
20558        responder: BaseNetworkSocketSetIpv6MulticastInterfaceResponder,
20559    },
20560    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
20561    GetIpv6MulticastInterface {
20562        responder: BaseNetworkSocketGetIpv6MulticastInterfaceResponder,
20563    },
20564    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
20565    SetIpv6UnicastHops {
20566        value: OptionalUint8,
20567        responder: BaseNetworkSocketSetIpv6UnicastHopsResponder,
20568    },
20569    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
20570    GetIpv6UnicastHops {
20571        responder: BaseNetworkSocketGetIpv6UnicastHopsResponder,
20572    },
20573    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
20574    SetIpv6ReceiveHopLimit {
20575        value: bool,
20576        responder: BaseNetworkSocketSetIpv6ReceiveHopLimitResponder,
20577    },
20578    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
20579    GetIpv6ReceiveHopLimit {
20580        responder: BaseNetworkSocketGetIpv6ReceiveHopLimitResponder,
20581    },
20582    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
20583    SetIpv6MulticastHops {
20584        value: OptionalUint8,
20585        responder: BaseNetworkSocketSetIpv6MulticastHopsResponder,
20586    },
20587    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
20588    GetIpv6MulticastHops {
20589        responder: BaseNetworkSocketGetIpv6MulticastHopsResponder,
20590    },
20591    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
20592    SetIpv6MulticastLoopback {
20593        value: bool,
20594        responder: BaseNetworkSocketSetIpv6MulticastLoopbackResponder,
20595    },
20596    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
20597    GetIpv6MulticastLoopback {
20598        responder: BaseNetworkSocketGetIpv6MulticastLoopbackResponder,
20599    },
20600    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
20601    SetIpv6Only {
20602        value: bool,
20603        responder: BaseNetworkSocketSetIpv6OnlyResponder,
20604    },
20605    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
20606    GetIpv6Only {
20607        responder: BaseNetworkSocketGetIpv6OnlyResponder,
20608    },
20609    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
20610    SetIpv6ReceiveTrafficClass {
20611        value: bool,
20612        responder: BaseNetworkSocketSetIpv6ReceiveTrafficClassResponder,
20613    },
20614    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
20615    GetIpv6ReceiveTrafficClass {
20616        responder: BaseNetworkSocketGetIpv6ReceiveTrafficClassResponder,
20617    },
20618    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
20619    SetIpv6TrafficClass {
20620        value: OptionalUint8,
20621        responder: BaseNetworkSocketSetIpv6TrafficClassResponder,
20622    },
20623    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
20624    GetIpv6TrafficClass {
20625        responder: BaseNetworkSocketGetIpv6TrafficClassResponder,
20626    },
20627    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
20628    SetIpv6ReceivePacketInfo {
20629        value: bool,
20630        responder: BaseNetworkSocketSetIpv6ReceivePacketInfoResponder,
20631    },
20632    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
20633    GetIpv6ReceivePacketInfo {
20634        responder: BaseNetworkSocketGetIpv6ReceivePacketInfoResponder,
20635    },
20636    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
20637    GetOriginalDestination {
20638        responder: BaseNetworkSocketGetOriginalDestinationResponder,
20639    },
20640}
20641
20642impl BaseNetworkSocketRequest {
20643    #[allow(irrefutable_let_patterns)]
20644    pub fn into_clone(
20645        self,
20646    ) -> Option<(
20647        fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
20648        BaseNetworkSocketControlHandle,
20649    )> {
20650        if let BaseNetworkSocketRequest::Clone { request, control_handle } = self {
20651            Some((request, control_handle))
20652        } else {
20653            None
20654        }
20655    }
20656
20657    #[allow(irrefutable_let_patterns)]
20658    pub fn into_close(self) -> Option<(BaseNetworkSocketCloseResponder)> {
20659        if let BaseNetworkSocketRequest::Close { responder } = self {
20660            Some((responder))
20661        } else {
20662            None
20663        }
20664    }
20665
20666    #[allow(irrefutable_let_patterns)]
20667    pub fn into_query(self) -> Option<(BaseNetworkSocketQueryResponder)> {
20668        if let BaseNetworkSocketRequest::Query { responder } = self {
20669            Some((responder))
20670        } else {
20671            None
20672        }
20673    }
20674
20675    #[allow(irrefutable_let_patterns)]
20676    pub fn into_set_reuse_address(
20677        self,
20678    ) -> Option<(bool, BaseNetworkSocketSetReuseAddressResponder)> {
20679        if let BaseNetworkSocketRequest::SetReuseAddress { value, responder } = self {
20680            Some((value, responder))
20681        } else {
20682            None
20683        }
20684    }
20685
20686    #[allow(irrefutable_let_patterns)]
20687    pub fn into_get_reuse_address(self) -> Option<(BaseNetworkSocketGetReuseAddressResponder)> {
20688        if let BaseNetworkSocketRequest::GetReuseAddress { responder } = self {
20689            Some((responder))
20690        } else {
20691            None
20692        }
20693    }
20694
20695    #[allow(irrefutable_let_patterns)]
20696    pub fn into_get_error(self) -> Option<(BaseNetworkSocketGetErrorResponder)> {
20697        if let BaseNetworkSocketRequest::GetError { responder } = self {
20698            Some((responder))
20699        } else {
20700            None
20701        }
20702    }
20703
20704    #[allow(irrefutable_let_patterns)]
20705    pub fn into_set_broadcast(self) -> Option<(bool, BaseNetworkSocketSetBroadcastResponder)> {
20706        if let BaseNetworkSocketRequest::SetBroadcast { value, responder } = self {
20707            Some((value, responder))
20708        } else {
20709            None
20710        }
20711    }
20712
20713    #[allow(irrefutable_let_patterns)]
20714    pub fn into_get_broadcast(self) -> Option<(BaseNetworkSocketGetBroadcastResponder)> {
20715        if let BaseNetworkSocketRequest::GetBroadcast { responder } = self {
20716            Some((responder))
20717        } else {
20718            None
20719        }
20720    }
20721
20722    #[allow(irrefutable_let_patterns)]
20723    pub fn into_set_send_buffer(self) -> Option<(u64, BaseNetworkSocketSetSendBufferResponder)> {
20724        if let BaseNetworkSocketRequest::SetSendBuffer { value_bytes, responder } = self {
20725            Some((value_bytes, responder))
20726        } else {
20727            None
20728        }
20729    }
20730
20731    #[allow(irrefutable_let_patterns)]
20732    pub fn into_get_send_buffer(self) -> Option<(BaseNetworkSocketGetSendBufferResponder)> {
20733        if let BaseNetworkSocketRequest::GetSendBuffer { responder } = self {
20734            Some((responder))
20735        } else {
20736            None
20737        }
20738    }
20739
20740    #[allow(irrefutable_let_patterns)]
20741    pub fn into_set_receive_buffer(
20742        self,
20743    ) -> Option<(u64, BaseNetworkSocketSetReceiveBufferResponder)> {
20744        if let BaseNetworkSocketRequest::SetReceiveBuffer { value_bytes, responder } = self {
20745            Some((value_bytes, responder))
20746        } else {
20747            None
20748        }
20749    }
20750
20751    #[allow(irrefutable_let_patterns)]
20752    pub fn into_get_receive_buffer(self) -> Option<(BaseNetworkSocketGetReceiveBufferResponder)> {
20753        if let BaseNetworkSocketRequest::GetReceiveBuffer { responder } = self {
20754            Some((responder))
20755        } else {
20756            None
20757        }
20758    }
20759
20760    #[allow(irrefutable_let_patterns)]
20761    pub fn into_set_keep_alive(self) -> Option<(bool, BaseNetworkSocketSetKeepAliveResponder)> {
20762        if let BaseNetworkSocketRequest::SetKeepAlive { value, responder } = self {
20763            Some((value, responder))
20764        } else {
20765            None
20766        }
20767    }
20768
20769    #[allow(irrefutable_let_patterns)]
20770    pub fn into_get_keep_alive(self) -> Option<(BaseNetworkSocketGetKeepAliveResponder)> {
20771        if let BaseNetworkSocketRequest::GetKeepAlive { responder } = self {
20772            Some((responder))
20773        } else {
20774            None
20775        }
20776    }
20777
20778    #[allow(irrefutable_let_patterns)]
20779    pub fn into_set_out_of_band_inline(
20780        self,
20781    ) -> Option<(bool, BaseNetworkSocketSetOutOfBandInlineResponder)> {
20782        if let BaseNetworkSocketRequest::SetOutOfBandInline { value, responder } = self {
20783            Some((value, responder))
20784        } else {
20785            None
20786        }
20787    }
20788
20789    #[allow(irrefutable_let_patterns)]
20790    pub fn into_get_out_of_band_inline(
20791        self,
20792    ) -> Option<(BaseNetworkSocketGetOutOfBandInlineResponder)> {
20793        if let BaseNetworkSocketRequest::GetOutOfBandInline { responder } = self {
20794            Some((responder))
20795        } else {
20796            None
20797        }
20798    }
20799
20800    #[allow(irrefutable_let_patterns)]
20801    pub fn into_set_no_check(self) -> Option<(bool, BaseNetworkSocketSetNoCheckResponder)> {
20802        if let BaseNetworkSocketRequest::SetNoCheck { value, responder } = self {
20803            Some((value, responder))
20804        } else {
20805            None
20806        }
20807    }
20808
20809    #[allow(irrefutable_let_patterns)]
20810    pub fn into_get_no_check(self) -> Option<(BaseNetworkSocketGetNoCheckResponder)> {
20811        if let BaseNetworkSocketRequest::GetNoCheck { responder } = self {
20812            Some((responder))
20813        } else {
20814            None
20815        }
20816    }
20817
20818    #[allow(irrefutable_let_patterns)]
20819    pub fn into_set_linger(self) -> Option<(bool, u32, BaseNetworkSocketSetLingerResponder)> {
20820        if let BaseNetworkSocketRequest::SetLinger { linger, length_secs, responder } = self {
20821            Some((linger, length_secs, responder))
20822        } else {
20823            None
20824        }
20825    }
20826
20827    #[allow(irrefutable_let_patterns)]
20828    pub fn into_get_linger(self) -> Option<(BaseNetworkSocketGetLingerResponder)> {
20829        if let BaseNetworkSocketRequest::GetLinger { responder } = self {
20830            Some((responder))
20831        } else {
20832            None
20833        }
20834    }
20835
20836    #[allow(irrefutable_let_patterns)]
20837    pub fn into_set_reuse_port(self) -> Option<(bool, BaseNetworkSocketSetReusePortResponder)> {
20838        if let BaseNetworkSocketRequest::SetReusePort { value, responder } = self {
20839            Some((value, responder))
20840        } else {
20841            None
20842        }
20843    }
20844
20845    #[allow(irrefutable_let_patterns)]
20846    pub fn into_get_reuse_port(self) -> Option<(BaseNetworkSocketGetReusePortResponder)> {
20847        if let BaseNetworkSocketRequest::GetReusePort { responder } = self {
20848            Some((responder))
20849        } else {
20850            None
20851        }
20852    }
20853
20854    #[allow(irrefutable_let_patterns)]
20855    pub fn into_get_accept_conn(self) -> Option<(BaseNetworkSocketGetAcceptConnResponder)> {
20856        if let BaseNetworkSocketRequest::GetAcceptConn { responder } = self {
20857            Some((responder))
20858        } else {
20859            None
20860        }
20861    }
20862
20863    #[allow(irrefutable_let_patterns)]
20864    pub fn into_set_bind_to_device(
20865        self,
20866    ) -> Option<(String, BaseNetworkSocketSetBindToDeviceResponder)> {
20867        if let BaseNetworkSocketRequest::SetBindToDevice { value, responder } = self {
20868            Some((value, responder))
20869        } else {
20870            None
20871        }
20872    }
20873
20874    #[allow(irrefutable_let_patterns)]
20875    pub fn into_get_bind_to_device(self) -> Option<(BaseNetworkSocketGetBindToDeviceResponder)> {
20876        if let BaseNetworkSocketRequest::GetBindToDevice { responder } = self {
20877            Some((responder))
20878        } else {
20879            None
20880        }
20881    }
20882
20883    #[allow(irrefutable_let_patterns)]
20884    pub fn into_set_bind_to_interface_index(
20885        self,
20886    ) -> Option<(u64, BaseNetworkSocketSetBindToInterfaceIndexResponder)> {
20887        if let BaseNetworkSocketRequest::SetBindToInterfaceIndex { value, responder } = self {
20888            Some((value, responder))
20889        } else {
20890            None
20891        }
20892    }
20893
20894    #[allow(irrefutable_let_patterns)]
20895    pub fn into_get_bind_to_interface_index(
20896        self,
20897    ) -> Option<(BaseNetworkSocketGetBindToInterfaceIndexResponder)> {
20898        if let BaseNetworkSocketRequest::GetBindToInterfaceIndex { responder } = self {
20899            Some((responder))
20900        } else {
20901            None
20902        }
20903    }
20904
20905    #[allow(irrefutable_let_patterns)]
20906    pub fn into_set_timestamp(
20907        self,
20908    ) -> Option<(TimestampOption, BaseNetworkSocketSetTimestampResponder)> {
20909        if let BaseNetworkSocketRequest::SetTimestamp { value, responder } = self {
20910            Some((value, responder))
20911        } else {
20912            None
20913        }
20914    }
20915
20916    #[allow(irrefutable_let_patterns)]
20917    pub fn into_get_timestamp(self) -> Option<(BaseNetworkSocketGetTimestampResponder)> {
20918        if let BaseNetworkSocketRequest::GetTimestamp { responder } = self {
20919            Some((responder))
20920        } else {
20921            None
20922        }
20923    }
20924
20925    #[allow(irrefutable_let_patterns)]
20926    pub fn into_set_mark(
20927        self,
20928    ) -> Option<(fidl_fuchsia_net::MarkDomain, OptionalUint32, BaseNetworkSocketSetMarkResponder)>
20929    {
20930        if let BaseNetworkSocketRequest::SetMark { domain, mark, responder } = self {
20931            Some((domain, mark, responder))
20932        } else {
20933            None
20934        }
20935    }
20936
20937    #[allow(irrefutable_let_patterns)]
20938    pub fn into_get_mark(
20939        self,
20940    ) -> Option<(fidl_fuchsia_net::MarkDomain, BaseNetworkSocketGetMarkResponder)> {
20941        if let BaseNetworkSocketRequest::GetMark { domain, responder } = self {
20942            Some((domain, responder))
20943        } else {
20944            None
20945        }
20946    }
20947
20948    #[allow(irrefutable_let_patterns)]
20949    pub fn into_bind(
20950        self,
20951    ) -> Option<(fidl_fuchsia_net::SocketAddress, BaseNetworkSocketBindResponder)> {
20952        if let BaseNetworkSocketRequest::Bind { addr, responder } = self {
20953            Some((addr, responder))
20954        } else {
20955            None
20956        }
20957    }
20958
20959    #[allow(irrefutable_let_patterns)]
20960    pub fn into_connect(
20961        self,
20962    ) -> Option<(fidl_fuchsia_net::SocketAddress, BaseNetworkSocketConnectResponder)> {
20963        if let BaseNetworkSocketRequest::Connect { addr, responder } = self {
20964            Some((addr, responder))
20965        } else {
20966            None
20967        }
20968    }
20969
20970    #[allow(irrefutable_let_patterns)]
20971    pub fn into_disconnect(self) -> Option<(BaseNetworkSocketDisconnectResponder)> {
20972        if let BaseNetworkSocketRequest::Disconnect { responder } = self {
20973            Some((responder))
20974        } else {
20975            None
20976        }
20977    }
20978
20979    #[allow(irrefutable_let_patterns)]
20980    pub fn into_get_sock_name(self) -> Option<(BaseNetworkSocketGetSockNameResponder)> {
20981        if let BaseNetworkSocketRequest::GetSockName { responder } = self {
20982            Some((responder))
20983        } else {
20984            None
20985        }
20986    }
20987
20988    #[allow(irrefutable_let_patterns)]
20989    pub fn into_get_peer_name(self) -> Option<(BaseNetworkSocketGetPeerNameResponder)> {
20990        if let BaseNetworkSocketRequest::GetPeerName { responder } = self {
20991            Some((responder))
20992        } else {
20993            None
20994        }
20995    }
20996
20997    #[allow(irrefutable_let_patterns)]
20998    pub fn into_shutdown(self) -> Option<(ShutdownMode, BaseNetworkSocketShutdownResponder)> {
20999        if let BaseNetworkSocketRequest::Shutdown { mode, responder } = self {
21000            Some((mode, responder))
21001        } else {
21002            None
21003        }
21004    }
21005
21006    #[allow(irrefutable_let_patterns)]
21007    pub fn into_set_ip_type_of_service(
21008        self,
21009    ) -> Option<(u8, BaseNetworkSocketSetIpTypeOfServiceResponder)> {
21010        if let BaseNetworkSocketRequest::SetIpTypeOfService { value, responder } = self {
21011            Some((value, responder))
21012        } else {
21013            None
21014        }
21015    }
21016
21017    #[allow(irrefutable_let_patterns)]
21018    pub fn into_get_ip_type_of_service(
21019        self,
21020    ) -> Option<(BaseNetworkSocketGetIpTypeOfServiceResponder)> {
21021        if let BaseNetworkSocketRequest::GetIpTypeOfService { responder } = self {
21022            Some((responder))
21023        } else {
21024            None
21025        }
21026    }
21027
21028    #[allow(irrefutable_let_patterns)]
21029    pub fn into_set_ip_ttl(self) -> Option<(OptionalUint8, BaseNetworkSocketSetIpTtlResponder)> {
21030        if let BaseNetworkSocketRequest::SetIpTtl { value, responder } = self {
21031            Some((value, responder))
21032        } else {
21033            None
21034        }
21035    }
21036
21037    #[allow(irrefutable_let_patterns)]
21038    pub fn into_get_ip_ttl(self) -> Option<(BaseNetworkSocketGetIpTtlResponder)> {
21039        if let BaseNetworkSocketRequest::GetIpTtl { responder } = self {
21040            Some((responder))
21041        } else {
21042            None
21043        }
21044    }
21045
21046    #[allow(irrefutable_let_patterns)]
21047    pub fn into_set_ip_packet_info(
21048        self,
21049    ) -> Option<(bool, BaseNetworkSocketSetIpPacketInfoResponder)> {
21050        if let BaseNetworkSocketRequest::SetIpPacketInfo { value, responder } = self {
21051            Some((value, responder))
21052        } else {
21053            None
21054        }
21055    }
21056
21057    #[allow(irrefutable_let_patterns)]
21058    pub fn into_get_ip_packet_info(self) -> Option<(BaseNetworkSocketGetIpPacketInfoResponder)> {
21059        if let BaseNetworkSocketRequest::GetIpPacketInfo { responder } = self {
21060            Some((responder))
21061        } else {
21062            None
21063        }
21064    }
21065
21066    #[allow(irrefutable_let_patterns)]
21067    pub fn into_set_ip_receive_type_of_service(
21068        self,
21069    ) -> Option<(bool, BaseNetworkSocketSetIpReceiveTypeOfServiceResponder)> {
21070        if let BaseNetworkSocketRequest::SetIpReceiveTypeOfService { value, responder } = self {
21071            Some((value, responder))
21072        } else {
21073            None
21074        }
21075    }
21076
21077    #[allow(irrefutable_let_patterns)]
21078    pub fn into_get_ip_receive_type_of_service(
21079        self,
21080    ) -> Option<(BaseNetworkSocketGetIpReceiveTypeOfServiceResponder)> {
21081        if let BaseNetworkSocketRequest::GetIpReceiveTypeOfService { responder } = self {
21082            Some((responder))
21083        } else {
21084            None
21085        }
21086    }
21087
21088    #[allow(irrefutable_let_patterns)]
21089    pub fn into_set_ip_receive_ttl(
21090        self,
21091    ) -> Option<(bool, BaseNetworkSocketSetIpReceiveTtlResponder)> {
21092        if let BaseNetworkSocketRequest::SetIpReceiveTtl { value, responder } = self {
21093            Some((value, responder))
21094        } else {
21095            None
21096        }
21097    }
21098
21099    #[allow(irrefutable_let_patterns)]
21100    pub fn into_get_ip_receive_ttl(self) -> Option<(BaseNetworkSocketGetIpReceiveTtlResponder)> {
21101        if let BaseNetworkSocketRequest::GetIpReceiveTtl { responder } = self {
21102            Some((responder))
21103        } else {
21104            None
21105        }
21106    }
21107
21108    #[allow(irrefutable_let_patterns)]
21109    pub fn into_set_ip_multicast_interface(
21110        self,
21111    ) -> Option<(
21112        u64,
21113        fidl_fuchsia_net::Ipv4Address,
21114        BaseNetworkSocketSetIpMulticastInterfaceResponder,
21115    )> {
21116        if let BaseNetworkSocketRequest::SetIpMulticastInterface { iface, address, responder } =
21117            self
21118        {
21119            Some((iface, address, responder))
21120        } else {
21121            None
21122        }
21123    }
21124
21125    #[allow(irrefutable_let_patterns)]
21126    pub fn into_get_ip_multicast_interface(
21127        self,
21128    ) -> Option<(BaseNetworkSocketGetIpMulticastInterfaceResponder)> {
21129        if let BaseNetworkSocketRequest::GetIpMulticastInterface { responder } = self {
21130            Some((responder))
21131        } else {
21132            None
21133        }
21134    }
21135
21136    #[allow(irrefutable_let_patterns)]
21137    pub fn into_set_ip_multicast_ttl(
21138        self,
21139    ) -> Option<(OptionalUint8, BaseNetworkSocketSetIpMulticastTtlResponder)> {
21140        if let BaseNetworkSocketRequest::SetIpMulticastTtl { value, responder } = self {
21141            Some((value, responder))
21142        } else {
21143            None
21144        }
21145    }
21146
21147    #[allow(irrefutable_let_patterns)]
21148    pub fn into_get_ip_multicast_ttl(
21149        self,
21150    ) -> Option<(BaseNetworkSocketGetIpMulticastTtlResponder)> {
21151        if let BaseNetworkSocketRequest::GetIpMulticastTtl { responder } = self {
21152            Some((responder))
21153        } else {
21154            None
21155        }
21156    }
21157
21158    #[allow(irrefutable_let_patterns)]
21159    pub fn into_set_ip_multicast_loopback(
21160        self,
21161    ) -> Option<(bool, BaseNetworkSocketSetIpMulticastLoopbackResponder)> {
21162        if let BaseNetworkSocketRequest::SetIpMulticastLoopback { value, responder } = self {
21163            Some((value, responder))
21164        } else {
21165            None
21166        }
21167    }
21168
21169    #[allow(irrefutable_let_patterns)]
21170    pub fn into_get_ip_multicast_loopback(
21171        self,
21172    ) -> Option<(BaseNetworkSocketGetIpMulticastLoopbackResponder)> {
21173        if let BaseNetworkSocketRequest::GetIpMulticastLoopback { responder } = self {
21174            Some((responder))
21175        } else {
21176            None
21177        }
21178    }
21179
21180    #[allow(irrefutable_let_patterns)]
21181    pub fn into_add_ip_membership(
21182        self,
21183    ) -> Option<(IpMulticastMembership, BaseNetworkSocketAddIpMembershipResponder)> {
21184        if let BaseNetworkSocketRequest::AddIpMembership { membership, responder } = self {
21185            Some((membership, responder))
21186        } else {
21187            None
21188        }
21189    }
21190
21191    #[allow(irrefutable_let_patterns)]
21192    pub fn into_drop_ip_membership(
21193        self,
21194    ) -> Option<(IpMulticastMembership, BaseNetworkSocketDropIpMembershipResponder)> {
21195        if let BaseNetworkSocketRequest::DropIpMembership { membership, responder } = self {
21196            Some((membership, responder))
21197        } else {
21198            None
21199        }
21200    }
21201
21202    #[allow(irrefutable_let_patterns)]
21203    pub fn into_set_ip_transparent(
21204        self,
21205    ) -> Option<(bool, BaseNetworkSocketSetIpTransparentResponder)> {
21206        if let BaseNetworkSocketRequest::SetIpTransparent { value, responder } = self {
21207            Some((value, responder))
21208        } else {
21209            None
21210        }
21211    }
21212
21213    #[allow(irrefutable_let_patterns)]
21214    pub fn into_get_ip_transparent(self) -> Option<(BaseNetworkSocketGetIpTransparentResponder)> {
21215        if let BaseNetworkSocketRequest::GetIpTransparent { responder } = self {
21216            Some((responder))
21217        } else {
21218            None
21219        }
21220    }
21221
21222    #[allow(irrefutable_let_patterns)]
21223    pub fn into_set_ip_receive_original_destination_address(
21224        self,
21225    ) -> Option<(bool, BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResponder)> {
21226        if let BaseNetworkSocketRequest::SetIpReceiveOriginalDestinationAddress {
21227            value,
21228            responder,
21229        } = self
21230        {
21231            Some((value, responder))
21232        } else {
21233            None
21234        }
21235    }
21236
21237    #[allow(irrefutable_let_patterns)]
21238    pub fn into_get_ip_receive_original_destination_address(
21239        self,
21240    ) -> Option<(BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponder)> {
21241        if let BaseNetworkSocketRequest::GetIpReceiveOriginalDestinationAddress { responder } = self
21242        {
21243            Some((responder))
21244        } else {
21245            None
21246        }
21247    }
21248
21249    #[allow(irrefutable_let_patterns)]
21250    pub fn into_add_ipv6_membership(
21251        self,
21252    ) -> Option<(Ipv6MulticastMembership, BaseNetworkSocketAddIpv6MembershipResponder)> {
21253        if let BaseNetworkSocketRequest::AddIpv6Membership { membership, responder } = self {
21254            Some((membership, responder))
21255        } else {
21256            None
21257        }
21258    }
21259
21260    #[allow(irrefutable_let_patterns)]
21261    pub fn into_drop_ipv6_membership(
21262        self,
21263    ) -> Option<(Ipv6MulticastMembership, BaseNetworkSocketDropIpv6MembershipResponder)> {
21264        if let BaseNetworkSocketRequest::DropIpv6Membership { membership, responder } = self {
21265            Some((membership, responder))
21266        } else {
21267            None
21268        }
21269    }
21270
21271    #[allow(irrefutable_let_patterns)]
21272    pub fn into_set_ipv6_multicast_interface(
21273        self,
21274    ) -> Option<(u64, BaseNetworkSocketSetIpv6MulticastInterfaceResponder)> {
21275        if let BaseNetworkSocketRequest::SetIpv6MulticastInterface { value, responder } = self {
21276            Some((value, responder))
21277        } else {
21278            None
21279        }
21280    }
21281
21282    #[allow(irrefutable_let_patterns)]
21283    pub fn into_get_ipv6_multicast_interface(
21284        self,
21285    ) -> Option<(BaseNetworkSocketGetIpv6MulticastInterfaceResponder)> {
21286        if let BaseNetworkSocketRequest::GetIpv6MulticastInterface { responder } = self {
21287            Some((responder))
21288        } else {
21289            None
21290        }
21291    }
21292
21293    #[allow(irrefutable_let_patterns)]
21294    pub fn into_set_ipv6_unicast_hops(
21295        self,
21296    ) -> Option<(OptionalUint8, BaseNetworkSocketSetIpv6UnicastHopsResponder)> {
21297        if let BaseNetworkSocketRequest::SetIpv6UnicastHops { value, responder } = self {
21298            Some((value, responder))
21299        } else {
21300            None
21301        }
21302    }
21303
21304    #[allow(irrefutable_let_patterns)]
21305    pub fn into_get_ipv6_unicast_hops(
21306        self,
21307    ) -> Option<(BaseNetworkSocketGetIpv6UnicastHopsResponder)> {
21308        if let BaseNetworkSocketRequest::GetIpv6UnicastHops { responder } = self {
21309            Some((responder))
21310        } else {
21311            None
21312        }
21313    }
21314
21315    #[allow(irrefutable_let_patterns)]
21316    pub fn into_set_ipv6_receive_hop_limit(
21317        self,
21318    ) -> Option<(bool, BaseNetworkSocketSetIpv6ReceiveHopLimitResponder)> {
21319        if let BaseNetworkSocketRequest::SetIpv6ReceiveHopLimit { value, responder } = self {
21320            Some((value, responder))
21321        } else {
21322            None
21323        }
21324    }
21325
21326    #[allow(irrefutable_let_patterns)]
21327    pub fn into_get_ipv6_receive_hop_limit(
21328        self,
21329    ) -> Option<(BaseNetworkSocketGetIpv6ReceiveHopLimitResponder)> {
21330        if let BaseNetworkSocketRequest::GetIpv6ReceiveHopLimit { responder } = self {
21331            Some((responder))
21332        } else {
21333            None
21334        }
21335    }
21336
21337    #[allow(irrefutable_let_patterns)]
21338    pub fn into_set_ipv6_multicast_hops(
21339        self,
21340    ) -> Option<(OptionalUint8, BaseNetworkSocketSetIpv6MulticastHopsResponder)> {
21341        if let BaseNetworkSocketRequest::SetIpv6MulticastHops { value, responder } = self {
21342            Some((value, responder))
21343        } else {
21344            None
21345        }
21346    }
21347
21348    #[allow(irrefutable_let_patterns)]
21349    pub fn into_get_ipv6_multicast_hops(
21350        self,
21351    ) -> Option<(BaseNetworkSocketGetIpv6MulticastHopsResponder)> {
21352        if let BaseNetworkSocketRequest::GetIpv6MulticastHops { responder } = self {
21353            Some((responder))
21354        } else {
21355            None
21356        }
21357    }
21358
21359    #[allow(irrefutable_let_patterns)]
21360    pub fn into_set_ipv6_multicast_loopback(
21361        self,
21362    ) -> Option<(bool, BaseNetworkSocketSetIpv6MulticastLoopbackResponder)> {
21363        if let BaseNetworkSocketRequest::SetIpv6MulticastLoopback { value, responder } = self {
21364            Some((value, responder))
21365        } else {
21366            None
21367        }
21368    }
21369
21370    #[allow(irrefutable_let_patterns)]
21371    pub fn into_get_ipv6_multicast_loopback(
21372        self,
21373    ) -> Option<(BaseNetworkSocketGetIpv6MulticastLoopbackResponder)> {
21374        if let BaseNetworkSocketRequest::GetIpv6MulticastLoopback { responder } = self {
21375            Some((responder))
21376        } else {
21377            None
21378        }
21379    }
21380
21381    #[allow(irrefutable_let_patterns)]
21382    pub fn into_set_ipv6_only(self) -> Option<(bool, BaseNetworkSocketSetIpv6OnlyResponder)> {
21383        if let BaseNetworkSocketRequest::SetIpv6Only { value, responder } = self {
21384            Some((value, responder))
21385        } else {
21386            None
21387        }
21388    }
21389
21390    #[allow(irrefutable_let_patterns)]
21391    pub fn into_get_ipv6_only(self) -> Option<(BaseNetworkSocketGetIpv6OnlyResponder)> {
21392        if let BaseNetworkSocketRequest::GetIpv6Only { responder } = self {
21393            Some((responder))
21394        } else {
21395            None
21396        }
21397    }
21398
21399    #[allow(irrefutable_let_patterns)]
21400    pub fn into_set_ipv6_receive_traffic_class(
21401        self,
21402    ) -> Option<(bool, BaseNetworkSocketSetIpv6ReceiveTrafficClassResponder)> {
21403        if let BaseNetworkSocketRequest::SetIpv6ReceiveTrafficClass { value, responder } = self {
21404            Some((value, responder))
21405        } else {
21406            None
21407        }
21408    }
21409
21410    #[allow(irrefutable_let_patterns)]
21411    pub fn into_get_ipv6_receive_traffic_class(
21412        self,
21413    ) -> Option<(BaseNetworkSocketGetIpv6ReceiveTrafficClassResponder)> {
21414        if let BaseNetworkSocketRequest::GetIpv6ReceiveTrafficClass { responder } = self {
21415            Some((responder))
21416        } else {
21417            None
21418        }
21419    }
21420
21421    #[allow(irrefutable_let_patterns)]
21422    pub fn into_set_ipv6_traffic_class(
21423        self,
21424    ) -> Option<(OptionalUint8, BaseNetworkSocketSetIpv6TrafficClassResponder)> {
21425        if let BaseNetworkSocketRequest::SetIpv6TrafficClass { value, responder } = self {
21426            Some((value, responder))
21427        } else {
21428            None
21429        }
21430    }
21431
21432    #[allow(irrefutable_let_patterns)]
21433    pub fn into_get_ipv6_traffic_class(
21434        self,
21435    ) -> Option<(BaseNetworkSocketGetIpv6TrafficClassResponder)> {
21436        if let BaseNetworkSocketRequest::GetIpv6TrafficClass { responder } = self {
21437            Some((responder))
21438        } else {
21439            None
21440        }
21441    }
21442
21443    #[allow(irrefutable_let_patterns)]
21444    pub fn into_set_ipv6_receive_packet_info(
21445        self,
21446    ) -> Option<(bool, BaseNetworkSocketSetIpv6ReceivePacketInfoResponder)> {
21447        if let BaseNetworkSocketRequest::SetIpv6ReceivePacketInfo { value, responder } = self {
21448            Some((value, responder))
21449        } else {
21450            None
21451        }
21452    }
21453
21454    #[allow(irrefutable_let_patterns)]
21455    pub fn into_get_ipv6_receive_packet_info(
21456        self,
21457    ) -> Option<(BaseNetworkSocketGetIpv6ReceivePacketInfoResponder)> {
21458        if let BaseNetworkSocketRequest::GetIpv6ReceivePacketInfo { responder } = self {
21459            Some((responder))
21460        } else {
21461            None
21462        }
21463    }
21464
21465    #[allow(irrefutable_let_patterns)]
21466    pub fn into_get_original_destination(
21467        self,
21468    ) -> Option<(BaseNetworkSocketGetOriginalDestinationResponder)> {
21469        if let BaseNetworkSocketRequest::GetOriginalDestination { responder } = self {
21470            Some((responder))
21471        } else {
21472            None
21473        }
21474    }
21475
21476    /// Name of the method defined in FIDL
21477    pub fn method_name(&self) -> &'static str {
21478        match *self {
21479            BaseNetworkSocketRequest::Clone { .. } => "clone",
21480            BaseNetworkSocketRequest::Close { .. } => "close",
21481            BaseNetworkSocketRequest::Query { .. } => "query",
21482            BaseNetworkSocketRequest::SetReuseAddress { .. } => "set_reuse_address",
21483            BaseNetworkSocketRequest::GetReuseAddress { .. } => "get_reuse_address",
21484            BaseNetworkSocketRequest::GetError { .. } => "get_error",
21485            BaseNetworkSocketRequest::SetBroadcast { .. } => "set_broadcast",
21486            BaseNetworkSocketRequest::GetBroadcast { .. } => "get_broadcast",
21487            BaseNetworkSocketRequest::SetSendBuffer { .. } => "set_send_buffer",
21488            BaseNetworkSocketRequest::GetSendBuffer { .. } => "get_send_buffer",
21489            BaseNetworkSocketRequest::SetReceiveBuffer { .. } => "set_receive_buffer",
21490            BaseNetworkSocketRequest::GetReceiveBuffer { .. } => "get_receive_buffer",
21491            BaseNetworkSocketRequest::SetKeepAlive { .. } => "set_keep_alive",
21492            BaseNetworkSocketRequest::GetKeepAlive { .. } => "get_keep_alive",
21493            BaseNetworkSocketRequest::SetOutOfBandInline { .. } => "set_out_of_band_inline",
21494            BaseNetworkSocketRequest::GetOutOfBandInline { .. } => "get_out_of_band_inline",
21495            BaseNetworkSocketRequest::SetNoCheck { .. } => "set_no_check",
21496            BaseNetworkSocketRequest::GetNoCheck { .. } => "get_no_check",
21497            BaseNetworkSocketRequest::SetLinger { .. } => "set_linger",
21498            BaseNetworkSocketRequest::GetLinger { .. } => "get_linger",
21499            BaseNetworkSocketRequest::SetReusePort { .. } => "set_reuse_port",
21500            BaseNetworkSocketRequest::GetReusePort { .. } => "get_reuse_port",
21501            BaseNetworkSocketRequest::GetAcceptConn { .. } => "get_accept_conn",
21502            BaseNetworkSocketRequest::SetBindToDevice { .. } => "set_bind_to_device",
21503            BaseNetworkSocketRequest::GetBindToDevice { .. } => "get_bind_to_device",
21504            BaseNetworkSocketRequest::SetBindToInterfaceIndex { .. } => {
21505                "set_bind_to_interface_index"
21506            }
21507            BaseNetworkSocketRequest::GetBindToInterfaceIndex { .. } => {
21508                "get_bind_to_interface_index"
21509            }
21510            BaseNetworkSocketRequest::SetTimestamp { .. } => "set_timestamp",
21511            BaseNetworkSocketRequest::GetTimestamp { .. } => "get_timestamp",
21512            BaseNetworkSocketRequest::SetMark { .. } => "set_mark",
21513            BaseNetworkSocketRequest::GetMark { .. } => "get_mark",
21514            BaseNetworkSocketRequest::Bind { .. } => "bind",
21515            BaseNetworkSocketRequest::Connect { .. } => "connect",
21516            BaseNetworkSocketRequest::Disconnect { .. } => "disconnect",
21517            BaseNetworkSocketRequest::GetSockName { .. } => "get_sock_name",
21518            BaseNetworkSocketRequest::GetPeerName { .. } => "get_peer_name",
21519            BaseNetworkSocketRequest::Shutdown { .. } => "shutdown",
21520            BaseNetworkSocketRequest::SetIpTypeOfService { .. } => "set_ip_type_of_service",
21521            BaseNetworkSocketRequest::GetIpTypeOfService { .. } => "get_ip_type_of_service",
21522            BaseNetworkSocketRequest::SetIpTtl { .. } => "set_ip_ttl",
21523            BaseNetworkSocketRequest::GetIpTtl { .. } => "get_ip_ttl",
21524            BaseNetworkSocketRequest::SetIpPacketInfo { .. } => "set_ip_packet_info",
21525            BaseNetworkSocketRequest::GetIpPacketInfo { .. } => "get_ip_packet_info",
21526            BaseNetworkSocketRequest::SetIpReceiveTypeOfService { .. } => {
21527                "set_ip_receive_type_of_service"
21528            }
21529            BaseNetworkSocketRequest::GetIpReceiveTypeOfService { .. } => {
21530                "get_ip_receive_type_of_service"
21531            }
21532            BaseNetworkSocketRequest::SetIpReceiveTtl { .. } => "set_ip_receive_ttl",
21533            BaseNetworkSocketRequest::GetIpReceiveTtl { .. } => "get_ip_receive_ttl",
21534            BaseNetworkSocketRequest::SetIpMulticastInterface { .. } => {
21535                "set_ip_multicast_interface"
21536            }
21537            BaseNetworkSocketRequest::GetIpMulticastInterface { .. } => {
21538                "get_ip_multicast_interface"
21539            }
21540            BaseNetworkSocketRequest::SetIpMulticastTtl { .. } => "set_ip_multicast_ttl",
21541            BaseNetworkSocketRequest::GetIpMulticastTtl { .. } => "get_ip_multicast_ttl",
21542            BaseNetworkSocketRequest::SetIpMulticastLoopback { .. } => "set_ip_multicast_loopback",
21543            BaseNetworkSocketRequest::GetIpMulticastLoopback { .. } => "get_ip_multicast_loopback",
21544            BaseNetworkSocketRequest::AddIpMembership { .. } => "add_ip_membership",
21545            BaseNetworkSocketRequest::DropIpMembership { .. } => "drop_ip_membership",
21546            BaseNetworkSocketRequest::SetIpTransparent { .. } => "set_ip_transparent",
21547            BaseNetworkSocketRequest::GetIpTransparent { .. } => "get_ip_transparent",
21548            BaseNetworkSocketRequest::SetIpReceiveOriginalDestinationAddress { .. } => {
21549                "set_ip_receive_original_destination_address"
21550            }
21551            BaseNetworkSocketRequest::GetIpReceiveOriginalDestinationAddress { .. } => {
21552                "get_ip_receive_original_destination_address"
21553            }
21554            BaseNetworkSocketRequest::AddIpv6Membership { .. } => "add_ipv6_membership",
21555            BaseNetworkSocketRequest::DropIpv6Membership { .. } => "drop_ipv6_membership",
21556            BaseNetworkSocketRequest::SetIpv6MulticastInterface { .. } => {
21557                "set_ipv6_multicast_interface"
21558            }
21559            BaseNetworkSocketRequest::GetIpv6MulticastInterface { .. } => {
21560                "get_ipv6_multicast_interface"
21561            }
21562            BaseNetworkSocketRequest::SetIpv6UnicastHops { .. } => "set_ipv6_unicast_hops",
21563            BaseNetworkSocketRequest::GetIpv6UnicastHops { .. } => "get_ipv6_unicast_hops",
21564            BaseNetworkSocketRequest::SetIpv6ReceiveHopLimit { .. } => "set_ipv6_receive_hop_limit",
21565            BaseNetworkSocketRequest::GetIpv6ReceiveHopLimit { .. } => "get_ipv6_receive_hop_limit",
21566            BaseNetworkSocketRequest::SetIpv6MulticastHops { .. } => "set_ipv6_multicast_hops",
21567            BaseNetworkSocketRequest::GetIpv6MulticastHops { .. } => "get_ipv6_multicast_hops",
21568            BaseNetworkSocketRequest::SetIpv6MulticastLoopback { .. } => {
21569                "set_ipv6_multicast_loopback"
21570            }
21571            BaseNetworkSocketRequest::GetIpv6MulticastLoopback { .. } => {
21572                "get_ipv6_multicast_loopback"
21573            }
21574            BaseNetworkSocketRequest::SetIpv6Only { .. } => "set_ipv6_only",
21575            BaseNetworkSocketRequest::GetIpv6Only { .. } => "get_ipv6_only",
21576            BaseNetworkSocketRequest::SetIpv6ReceiveTrafficClass { .. } => {
21577                "set_ipv6_receive_traffic_class"
21578            }
21579            BaseNetworkSocketRequest::GetIpv6ReceiveTrafficClass { .. } => {
21580                "get_ipv6_receive_traffic_class"
21581            }
21582            BaseNetworkSocketRequest::SetIpv6TrafficClass { .. } => "set_ipv6_traffic_class",
21583            BaseNetworkSocketRequest::GetIpv6TrafficClass { .. } => "get_ipv6_traffic_class",
21584            BaseNetworkSocketRequest::SetIpv6ReceivePacketInfo { .. } => {
21585                "set_ipv6_receive_packet_info"
21586            }
21587            BaseNetworkSocketRequest::GetIpv6ReceivePacketInfo { .. } => {
21588                "get_ipv6_receive_packet_info"
21589            }
21590            BaseNetworkSocketRequest::GetOriginalDestination { .. } => "get_original_destination",
21591        }
21592    }
21593}
21594
21595#[derive(Debug, Clone)]
21596pub struct BaseNetworkSocketControlHandle {
21597    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
21598}
21599
21600impl fidl::endpoints::ControlHandle for BaseNetworkSocketControlHandle {
21601    fn shutdown(&self) {
21602        self.inner.shutdown()
21603    }
21604    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
21605        self.inner.shutdown_with_epitaph(status)
21606    }
21607
21608    fn is_closed(&self) -> bool {
21609        self.inner.channel().is_closed()
21610    }
21611    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
21612        self.inner.channel().on_closed()
21613    }
21614
21615    #[cfg(target_os = "fuchsia")]
21616    fn signal_peer(
21617        &self,
21618        clear_mask: zx::Signals,
21619        set_mask: zx::Signals,
21620    ) -> Result<(), zx_status::Status> {
21621        use fidl::Peered;
21622        self.inner.channel().signal_peer(clear_mask, set_mask)
21623    }
21624}
21625
21626impl BaseNetworkSocketControlHandle {}
21627
21628#[must_use = "FIDL methods require a response to be sent"]
21629#[derive(Debug)]
21630pub struct BaseNetworkSocketCloseResponder {
21631    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
21632    tx_id: u32,
21633}
21634
21635/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
21636/// if the responder is dropped without sending a response, so that the client
21637/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
21638impl std::ops::Drop for BaseNetworkSocketCloseResponder {
21639    fn drop(&mut self) {
21640        self.control_handle.shutdown();
21641        // Safety: drops once, never accessed again
21642        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
21643    }
21644}
21645
21646impl fidl::endpoints::Responder for BaseNetworkSocketCloseResponder {
21647    type ControlHandle = BaseNetworkSocketControlHandle;
21648
21649    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
21650        &self.control_handle
21651    }
21652
21653    fn drop_without_shutdown(mut self) {
21654        // Safety: drops once, never accessed again due to mem::forget
21655        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
21656        // Prevent Drop from running (which would shut down the channel)
21657        std::mem::forget(self);
21658    }
21659}
21660
21661impl BaseNetworkSocketCloseResponder {
21662    /// Sends a response to the FIDL transaction.
21663    ///
21664    /// Sets the channel to shutdown if an error occurs.
21665    pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
21666        let _result = self.send_raw(result);
21667        if _result.is_err() {
21668            self.control_handle.shutdown();
21669        }
21670        self.drop_without_shutdown();
21671        _result
21672    }
21673
21674    /// Similar to "send" but does not shutdown the channel if an error occurs.
21675    pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
21676        let _result = self.send_raw(result);
21677        self.drop_without_shutdown();
21678        _result
21679    }
21680
21681    fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
21682        self.control_handle
21683            .inner
21684            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
21685                result,
21686                self.tx_id,
21687                0x5ac5d459ad7f657e,
21688                fidl::encoding::DynamicFlags::empty(),
21689            )
21690    }
21691}
21692
21693#[must_use = "FIDL methods require a response to be sent"]
21694#[derive(Debug)]
21695pub struct BaseNetworkSocketQueryResponder {
21696    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
21697    tx_id: u32,
21698}
21699
21700/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
21701/// if the responder is dropped without sending a response, so that the client
21702/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
21703impl std::ops::Drop for BaseNetworkSocketQueryResponder {
21704    fn drop(&mut self) {
21705        self.control_handle.shutdown();
21706        // Safety: drops once, never accessed again
21707        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
21708    }
21709}
21710
21711impl fidl::endpoints::Responder for BaseNetworkSocketQueryResponder {
21712    type ControlHandle = BaseNetworkSocketControlHandle;
21713
21714    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
21715        &self.control_handle
21716    }
21717
21718    fn drop_without_shutdown(mut self) {
21719        // Safety: drops once, never accessed again due to mem::forget
21720        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
21721        // Prevent Drop from running (which would shut down the channel)
21722        std::mem::forget(self);
21723    }
21724}
21725
21726impl BaseNetworkSocketQueryResponder {
21727    /// Sends a response to the FIDL transaction.
21728    ///
21729    /// Sets the channel to shutdown if an error occurs.
21730    pub fn send(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
21731        let _result = self.send_raw(protocol);
21732        if _result.is_err() {
21733            self.control_handle.shutdown();
21734        }
21735        self.drop_without_shutdown();
21736        _result
21737    }
21738
21739    /// Similar to "send" but does not shutdown the channel if an error occurs.
21740    pub fn send_no_shutdown_on_err(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
21741        let _result = self.send_raw(protocol);
21742        self.drop_without_shutdown();
21743        _result
21744    }
21745
21746    fn send_raw(&self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
21747        self.control_handle.inner.send::<fidl_fuchsia_unknown::QueryableQueryResponse>(
21748            (protocol,),
21749            self.tx_id,
21750            0x2658edee9decfc06,
21751            fidl::encoding::DynamicFlags::empty(),
21752        )
21753    }
21754}
21755
21756#[must_use = "FIDL methods require a response to be sent"]
21757#[derive(Debug)]
21758pub struct BaseNetworkSocketSetReuseAddressResponder {
21759    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
21760    tx_id: u32,
21761}
21762
21763/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
21764/// if the responder is dropped without sending a response, so that the client
21765/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
21766impl std::ops::Drop for BaseNetworkSocketSetReuseAddressResponder {
21767    fn drop(&mut self) {
21768        self.control_handle.shutdown();
21769        // Safety: drops once, never accessed again
21770        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
21771    }
21772}
21773
21774impl fidl::endpoints::Responder for BaseNetworkSocketSetReuseAddressResponder {
21775    type ControlHandle = BaseNetworkSocketControlHandle;
21776
21777    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
21778        &self.control_handle
21779    }
21780
21781    fn drop_without_shutdown(mut self) {
21782        // Safety: drops once, never accessed again due to mem::forget
21783        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
21784        // Prevent Drop from running (which would shut down the channel)
21785        std::mem::forget(self);
21786    }
21787}
21788
21789impl BaseNetworkSocketSetReuseAddressResponder {
21790    /// Sends a response to the FIDL transaction.
21791    ///
21792    /// Sets the channel to shutdown if an error occurs.
21793    pub fn send(
21794        self,
21795        mut result: Result<(), fidl_fuchsia_posix::Errno>,
21796    ) -> Result<(), fidl::Error> {
21797        let _result = self.send_raw(result);
21798        if _result.is_err() {
21799            self.control_handle.shutdown();
21800        }
21801        self.drop_without_shutdown();
21802        _result
21803    }
21804
21805    /// Similar to "send" but does not shutdown the channel if an error occurs.
21806    pub fn send_no_shutdown_on_err(
21807        self,
21808        mut result: Result<(), fidl_fuchsia_posix::Errno>,
21809    ) -> Result<(), fidl::Error> {
21810        let _result = self.send_raw(result);
21811        self.drop_without_shutdown();
21812        _result
21813    }
21814
21815    fn send_raw(
21816        &self,
21817        mut result: Result<(), fidl_fuchsia_posix::Errno>,
21818    ) -> Result<(), fidl::Error> {
21819        self.control_handle.inner.send::<fidl::encoding::ResultType<
21820            fidl::encoding::EmptyStruct,
21821            fidl_fuchsia_posix::Errno,
21822        >>(
21823            result,
21824            self.tx_id,
21825            0x1fd74ee8b9a4a876,
21826            fidl::encoding::DynamicFlags::empty(),
21827        )
21828    }
21829}
21830
21831#[must_use = "FIDL methods require a response to be sent"]
21832#[derive(Debug)]
21833pub struct BaseNetworkSocketGetReuseAddressResponder {
21834    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
21835    tx_id: u32,
21836}
21837
21838/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
21839/// if the responder is dropped without sending a response, so that the client
21840/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
21841impl std::ops::Drop for BaseNetworkSocketGetReuseAddressResponder {
21842    fn drop(&mut self) {
21843        self.control_handle.shutdown();
21844        // Safety: drops once, never accessed again
21845        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
21846    }
21847}
21848
21849impl fidl::endpoints::Responder for BaseNetworkSocketGetReuseAddressResponder {
21850    type ControlHandle = BaseNetworkSocketControlHandle;
21851
21852    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
21853        &self.control_handle
21854    }
21855
21856    fn drop_without_shutdown(mut self) {
21857        // Safety: drops once, never accessed again due to mem::forget
21858        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
21859        // Prevent Drop from running (which would shut down the channel)
21860        std::mem::forget(self);
21861    }
21862}
21863
21864impl BaseNetworkSocketGetReuseAddressResponder {
21865    /// Sends a response to the FIDL transaction.
21866    ///
21867    /// Sets the channel to shutdown if an error occurs.
21868    pub fn send(
21869        self,
21870        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
21871    ) -> Result<(), fidl::Error> {
21872        let _result = self.send_raw(result);
21873        if _result.is_err() {
21874            self.control_handle.shutdown();
21875        }
21876        self.drop_without_shutdown();
21877        _result
21878    }
21879
21880    /// Similar to "send" but does not shutdown the channel if an error occurs.
21881    pub fn send_no_shutdown_on_err(
21882        self,
21883        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
21884    ) -> Result<(), fidl::Error> {
21885        let _result = self.send_raw(result);
21886        self.drop_without_shutdown();
21887        _result
21888    }
21889
21890    fn send_raw(
21891        &self,
21892        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
21893    ) -> Result<(), fidl::Error> {
21894        self.control_handle.inner.send::<fidl::encoding::ResultType<
21895            BaseSocketGetReuseAddressResponse,
21896            fidl_fuchsia_posix::Errno,
21897        >>(
21898            result.map(|value| (value,)),
21899            self.tx_id,
21900            0x67b7206b8d1bc0a5,
21901            fidl::encoding::DynamicFlags::empty(),
21902        )
21903    }
21904}
21905
21906#[must_use = "FIDL methods require a response to be sent"]
21907#[derive(Debug)]
21908pub struct BaseNetworkSocketGetErrorResponder {
21909    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
21910    tx_id: u32,
21911}
21912
21913/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
21914/// if the responder is dropped without sending a response, so that the client
21915/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
21916impl std::ops::Drop for BaseNetworkSocketGetErrorResponder {
21917    fn drop(&mut self) {
21918        self.control_handle.shutdown();
21919        // Safety: drops once, never accessed again
21920        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
21921    }
21922}
21923
21924impl fidl::endpoints::Responder for BaseNetworkSocketGetErrorResponder {
21925    type ControlHandle = BaseNetworkSocketControlHandle;
21926
21927    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
21928        &self.control_handle
21929    }
21930
21931    fn drop_without_shutdown(mut self) {
21932        // Safety: drops once, never accessed again due to mem::forget
21933        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
21934        // Prevent Drop from running (which would shut down the channel)
21935        std::mem::forget(self);
21936    }
21937}
21938
21939impl BaseNetworkSocketGetErrorResponder {
21940    /// Sends a response to the FIDL transaction.
21941    ///
21942    /// Sets the channel to shutdown if an error occurs.
21943    pub fn send(
21944        self,
21945        mut result: Result<(), fidl_fuchsia_posix::Errno>,
21946    ) -> Result<(), fidl::Error> {
21947        let _result = self.send_raw(result);
21948        if _result.is_err() {
21949            self.control_handle.shutdown();
21950        }
21951        self.drop_without_shutdown();
21952        _result
21953    }
21954
21955    /// Similar to "send" but does not shutdown the channel if an error occurs.
21956    pub fn send_no_shutdown_on_err(
21957        self,
21958        mut result: Result<(), fidl_fuchsia_posix::Errno>,
21959    ) -> Result<(), fidl::Error> {
21960        let _result = self.send_raw(result);
21961        self.drop_without_shutdown();
21962        _result
21963    }
21964
21965    fn send_raw(
21966        &self,
21967        mut result: Result<(), fidl_fuchsia_posix::Errno>,
21968    ) -> Result<(), fidl::Error> {
21969        self.control_handle.inner.send::<fidl::encoding::ResultType<
21970            fidl::encoding::EmptyStruct,
21971            fidl_fuchsia_posix::Errno,
21972        >>(
21973            result,
21974            self.tx_id,
21975            0x5aad39b33e5f6ebb,
21976            fidl::encoding::DynamicFlags::empty(),
21977        )
21978    }
21979}
21980
21981#[must_use = "FIDL methods require a response to be sent"]
21982#[derive(Debug)]
21983pub struct BaseNetworkSocketSetBroadcastResponder {
21984    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
21985    tx_id: u32,
21986}
21987
21988/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
21989/// if the responder is dropped without sending a response, so that the client
21990/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
21991impl std::ops::Drop for BaseNetworkSocketSetBroadcastResponder {
21992    fn drop(&mut self) {
21993        self.control_handle.shutdown();
21994        // Safety: drops once, never accessed again
21995        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
21996    }
21997}
21998
21999impl fidl::endpoints::Responder for BaseNetworkSocketSetBroadcastResponder {
22000    type ControlHandle = BaseNetworkSocketControlHandle;
22001
22002    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
22003        &self.control_handle
22004    }
22005
22006    fn drop_without_shutdown(mut self) {
22007        // Safety: drops once, never accessed again due to mem::forget
22008        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22009        // Prevent Drop from running (which would shut down the channel)
22010        std::mem::forget(self);
22011    }
22012}
22013
22014impl BaseNetworkSocketSetBroadcastResponder {
22015    /// Sends a response to the FIDL transaction.
22016    ///
22017    /// Sets the channel to shutdown if an error occurs.
22018    pub fn send(
22019        self,
22020        mut result: Result<(), fidl_fuchsia_posix::Errno>,
22021    ) -> Result<(), fidl::Error> {
22022        let _result = self.send_raw(result);
22023        if _result.is_err() {
22024            self.control_handle.shutdown();
22025        }
22026        self.drop_without_shutdown();
22027        _result
22028    }
22029
22030    /// Similar to "send" but does not shutdown the channel if an error occurs.
22031    pub fn send_no_shutdown_on_err(
22032        self,
22033        mut result: Result<(), fidl_fuchsia_posix::Errno>,
22034    ) -> Result<(), fidl::Error> {
22035        let _result = self.send_raw(result);
22036        self.drop_without_shutdown();
22037        _result
22038    }
22039
22040    fn send_raw(
22041        &self,
22042        mut result: Result<(), fidl_fuchsia_posix::Errno>,
22043    ) -> Result<(), fidl::Error> {
22044        self.control_handle.inner.send::<fidl::encoding::ResultType<
22045            fidl::encoding::EmptyStruct,
22046            fidl_fuchsia_posix::Errno,
22047        >>(
22048            result,
22049            self.tx_id,
22050            0x6023e081ce3cd947,
22051            fidl::encoding::DynamicFlags::empty(),
22052        )
22053    }
22054}
22055
22056#[must_use = "FIDL methods require a response to be sent"]
22057#[derive(Debug)]
22058pub struct BaseNetworkSocketGetBroadcastResponder {
22059    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
22060    tx_id: u32,
22061}
22062
22063/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
22064/// if the responder is dropped without sending a response, so that the client
22065/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
22066impl std::ops::Drop for BaseNetworkSocketGetBroadcastResponder {
22067    fn drop(&mut self) {
22068        self.control_handle.shutdown();
22069        // Safety: drops once, never accessed again
22070        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22071    }
22072}
22073
22074impl fidl::endpoints::Responder for BaseNetworkSocketGetBroadcastResponder {
22075    type ControlHandle = BaseNetworkSocketControlHandle;
22076
22077    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
22078        &self.control_handle
22079    }
22080
22081    fn drop_without_shutdown(mut self) {
22082        // Safety: drops once, never accessed again due to mem::forget
22083        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22084        // Prevent Drop from running (which would shut down the channel)
22085        std::mem::forget(self);
22086    }
22087}
22088
22089impl BaseNetworkSocketGetBroadcastResponder {
22090    /// Sends a response to the FIDL transaction.
22091    ///
22092    /// Sets the channel to shutdown if an error occurs.
22093    pub fn send(
22094        self,
22095        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
22096    ) -> Result<(), fidl::Error> {
22097        let _result = self.send_raw(result);
22098        if _result.is_err() {
22099            self.control_handle.shutdown();
22100        }
22101        self.drop_without_shutdown();
22102        _result
22103    }
22104
22105    /// Similar to "send" but does not shutdown the channel if an error occurs.
22106    pub fn send_no_shutdown_on_err(
22107        self,
22108        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
22109    ) -> Result<(), fidl::Error> {
22110        let _result = self.send_raw(result);
22111        self.drop_without_shutdown();
22112        _result
22113    }
22114
22115    fn send_raw(
22116        &self,
22117        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
22118    ) -> Result<(), fidl::Error> {
22119        self.control_handle.inner.send::<fidl::encoding::ResultType<
22120            BaseSocketGetBroadcastResponse,
22121            fidl_fuchsia_posix::Errno,
22122        >>(
22123            result.map(|value| (value,)),
22124            self.tx_id,
22125            0x68796fc556f9780d,
22126            fidl::encoding::DynamicFlags::empty(),
22127        )
22128    }
22129}
22130
22131#[must_use = "FIDL methods require a response to be sent"]
22132#[derive(Debug)]
22133pub struct BaseNetworkSocketSetSendBufferResponder {
22134    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
22135    tx_id: u32,
22136}
22137
22138/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
22139/// if the responder is dropped without sending a response, so that the client
22140/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
22141impl std::ops::Drop for BaseNetworkSocketSetSendBufferResponder {
22142    fn drop(&mut self) {
22143        self.control_handle.shutdown();
22144        // Safety: drops once, never accessed again
22145        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22146    }
22147}
22148
22149impl fidl::endpoints::Responder for BaseNetworkSocketSetSendBufferResponder {
22150    type ControlHandle = BaseNetworkSocketControlHandle;
22151
22152    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
22153        &self.control_handle
22154    }
22155
22156    fn drop_without_shutdown(mut self) {
22157        // Safety: drops once, never accessed again due to mem::forget
22158        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22159        // Prevent Drop from running (which would shut down the channel)
22160        std::mem::forget(self);
22161    }
22162}
22163
22164impl BaseNetworkSocketSetSendBufferResponder {
22165    /// Sends a response to the FIDL transaction.
22166    ///
22167    /// Sets the channel to shutdown if an error occurs.
22168    pub fn send(
22169        self,
22170        mut result: Result<(), fidl_fuchsia_posix::Errno>,
22171    ) -> Result<(), fidl::Error> {
22172        let _result = self.send_raw(result);
22173        if _result.is_err() {
22174            self.control_handle.shutdown();
22175        }
22176        self.drop_without_shutdown();
22177        _result
22178    }
22179
22180    /// Similar to "send" but does not shutdown the channel if an error occurs.
22181    pub fn send_no_shutdown_on_err(
22182        self,
22183        mut result: Result<(), fidl_fuchsia_posix::Errno>,
22184    ) -> Result<(), fidl::Error> {
22185        let _result = self.send_raw(result);
22186        self.drop_without_shutdown();
22187        _result
22188    }
22189
22190    fn send_raw(
22191        &self,
22192        mut result: Result<(), fidl_fuchsia_posix::Errno>,
22193    ) -> Result<(), fidl::Error> {
22194        self.control_handle.inner.send::<fidl::encoding::ResultType<
22195            fidl::encoding::EmptyStruct,
22196            fidl_fuchsia_posix::Errno,
22197        >>(
22198            result,
22199            self.tx_id,
22200            0x756eac32d73a7a70,
22201            fidl::encoding::DynamicFlags::empty(),
22202        )
22203    }
22204}
22205
22206#[must_use = "FIDL methods require a response to be sent"]
22207#[derive(Debug)]
22208pub struct BaseNetworkSocketGetSendBufferResponder {
22209    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
22210    tx_id: u32,
22211}
22212
22213/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
22214/// if the responder is dropped without sending a response, so that the client
22215/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
22216impl std::ops::Drop for BaseNetworkSocketGetSendBufferResponder {
22217    fn drop(&mut self) {
22218        self.control_handle.shutdown();
22219        // Safety: drops once, never accessed again
22220        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22221    }
22222}
22223
22224impl fidl::endpoints::Responder for BaseNetworkSocketGetSendBufferResponder {
22225    type ControlHandle = BaseNetworkSocketControlHandle;
22226
22227    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
22228        &self.control_handle
22229    }
22230
22231    fn drop_without_shutdown(mut self) {
22232        // Safety: drops once, never accessed again due to mem::forget
22233        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22234        // Prevent Drop from running (which would shut down the channel)
22235        std::mem::forget(self);
22236    }
22237}
22238
22239impl BaseNetworkSocketGetSendBufferResponder {
22240    /// Sends a response to the FIDL transaction.
22241    ///
22242    /// Sets the channel to shutdown if an error occurs.
22243    pub fn send(
22244        self,
22245        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
22246    ) -> Result<(), fidl::Error> {
22247        let _result = self.send_raw(result);
22248        if _result.is_err() {
22249            self.control_handle.shutdown();
22250        }
22251        self.drop_without_shutdown();
22252        _result
22253    }
22254
22255    /// Similar to "send" but does not shutdown the channel if an error occurs.
22256    pub fn send_no_shutdown_on_err(
22257        self,
22258        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
22259    ) -> Result<(), fidl::Error> {
22260        let _result = self.send_raw(result);
22261        self.drop_without_shutdown();
22262        _result
22263    }
22264
22265    fn send_raw(
22266        &self,
22267        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
22268    ) -> Result<(), fidl::Error> {
22269        self.control_handle.inner.send::<fidl::encoding::ResultType<
22270            BaseSocketGetSendBufferResponse,
22271            fidl_fuchsia_posix::Errno,
22272        >>(
22273            result.map(|value_bytes| (value_bytes,)),
22274            self.tx_id,
22275            0x78a52fd9c7b2410b,
22276            fidl::encoding::DynamicFlags::empty(),
22277        )
22278    }
22279}
22280
22281#[must_use = "FIDL methods require a response to be sent"]
22282#[derive(Debug)]
22283pub struct BaseNetworkSocketSetReceiveBufferResponder {
22284    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
22285    tx_id: u32,
22286}
22287
22288/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
22289/// if the responder is dropped without sending a response, so that the client
22290/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
22291impl std::ops::Drop for BaseNetworkSocketSetReceiveBufferResponder {
22292    fn drop(&mut self) {
22293        self.control_handle.shutdown();
22294        // Safety: drops once, never accessed again
22295        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22296    }
22297}
22298
22299impl fidl::endpoints::Responder for BaseNetworkSocketSetReceiveBufferResponder {
22300    type ControlHandle = BaseNetworkSocketControlHandle;
22301
22302    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
22303        &self.control_handle
22304    }
22305
22306    fn drop_without_shutdown(mut self) {
22307        // Safety: drops once, never accessed again due to mem::forget
22308        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22309        // Prevent Drop from running (which would shut down the channel)
22310        std::mem::forget(self);
22311    }
22312}
22313
22314impl BaseNetworkSocketSetReceiveBufferResponder {
22315    /// Sends a response to the FIDL transaction.
22316    ///
22317    /// Sets the channel to shutdown if an error occurs.
22318    pub fn send(
22319        self,
22320        mut result: Result<(), fidl_fuchsia_posix::Errno>,
22321    ) -> Result<(), fidl::Error> {
22322        let _result = self.send_raw(result);
22323        if _result.is_err() {
22324            self.control_handle.shutdown();
22325        }
22326        self.drop_without_shutdown();
22327        _result
22328    }
22329
22330    /// Similar to "send" but does not shutdown the channel if an error occurs.
22331    pub fn send_no_shutdown_on_err(
22332        self,
22333        mut result: Result<(), fidl_fuchsia_posix::Errno>,
22334    ) -> Result<(), fidl::Error> {
22335        let _result = self.send_raw(result);
22336        self.drop_without_shutdown();
22337        _result
22338    }
22339
22340    fn send_raw(
22341        &self,
22342        mut result: Result<(), fidl_fuchsia_posix::Errno>,
22343    ) -> Result<(), fidl::Error> {
22344        self.control_handle.inner.send::<fidl::encoding::ResultType<
22345            fidl::encoding::EmptyStruct,
22346            fidl_fuchsia_posix::Errno,
22347        >>(
22348            result,
22349            self.tx_id,
22350            0x6b0cf2f1919c7001,
22351            fidl::encoding::DynamicFlags::empty(),
22352        )
22353    }
22354}
22355
22356#[must_use = "FIDL methods require a response to be sent"]
22357#[derive(Debug)]
22358pub struct BaseNetworkSocketGetReceiveBufferResponder {
22359    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
22360    tx_id: u32,
22361}
22362
22363/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
22364/// if the responder is dropped without sending a response, so that the client
22365/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
22366impl std::ops::Drop for BaseNetworkSocketGetReceiveBufferResponder {
22367    fn drop(&mut self) {
22368        self.control_handle.shutdown();
22369        // Safety: drops once, never accessed again
22370        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22371    }
22372}
22373
22374impl fidl::endpoints::Responder for BaseNetworkSocketGetReceiveBufferResponder {
22375    type ControlHandle = BaseNetworkSocketControlHandle;
22376
22377    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
22378        &self.control_handle
22379    }
22380
22381    fn drop_without_shutdown(mut self) {
22382        // Safety: drops once, never accessed again due to mem::forget
22383        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22384        // Prevent Drop from running (which would shut down the channel)
22385        std::mem::forget(self);
22386    }
22387}
22388
22389impl BaseNetworkSocketGetReceiveBufferResponder {
22390    /// Sends a response to the FIDL transaction.
22391    ///
22392    /// Sets the channel to shutdown if an error occurs.
22393    pub fn send(
22394        self,
22395        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
22396    ) -> Result<(), fidl::Error> {
22397        let _result = self.send_raw(result);
22398        if _result.is_err() {
22399            self.control_handle.shutdown();
22400        }
22401        self.drop_without_shutdown();
22402        _result
22403    }
22404
22405    /// Similar to "send" but does not shutdown the channel if an error occurs.
22406    pub fn send_no_shutdown_on_err(
22407        self,
22408        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
22409    ) -> Result<(), fidl::Error> {
22410        let _result = self.send_raw(result);
22411        self.drop_without_shutdown();
22412        _result
22413    }
22414
22415    fn send_raw(
22416        &self,
22417        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
22418    ) -> Result<(), fidl::Error> {
22419        self.control_handle.inner.send::<fidl::encoding::ResultType<
22420            BaseSocketGetReceiveBufferResponse,
22421            fidl_fuchsia_posix::Errno,
22422        >>(
22423            result.map(|value_bytes| (value_bytes,)),
22424            self.tx_id,
22425            0x14c1a4b64f709e5c,
22426            fidl::encoding::DynamicFlags::empty(),
22427        )
22428    }
22429}
22430
22431#[must_use = "FIDL methods require a response to be sent"]
22432#[derive(Debug)]
22433pub struct BaseNetworkSocketSetKeepAliveResponder {
22434    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
22435    tx_id: u32,
22436}
22437
22438/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
22439/// if the responder is dropped without sending a response, so that the client
22440/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
22441impl std::ops::Drop for BaseNetworkSocketSetKeepAliveResponder {
22442    fn drop(&mut self) {
22443        self.control_handle.shutdown();
22444        // Safety: drops once, never accessed again
22445        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22446    }
22447}
22448
22449impl fidl::endpoints::Responder for BaseNetworkSocketSetKeepAliveResponder {
22450    type ControlHandle = BaseNetworkSocketControlHandle;
22451
22452    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
22453        &self.control_handle
22454    }
22455
22456    fn drop_without_shutdown(mut self) {
22457        // Safety: drops once, never accessed again due to mem::forget
22458        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22459        // Prevent Drop from running (which would shut down the channel)
22460        std::mem::forget(self);
22461    }
22462}
22463
22464impl BaseNetworkSocketSetKeepAliveResponder {
22465    /// Sends a response to the FIDL transaction.
22466    ///
22467    /// Sets the channel to shutdown if an error occurs.
22468    pub fn send(
22469        self,
22470        mut result: Result<(), fidl_fuchsia_posix::Errno>,
22471    ) -> Result<(), fidl::Error> {
22472        let _result = self.send_raw(result);
22473        if _result.is_err() {
22474            self.control_handle.shutdown();
22475        }
22476        self.drop_without_shutdown();
22477        _result
22478    }
22479
22480    /// Similar to "send" but does not shutdown the channel if an error occurs.
22481    pub fn send_no_shutdown_on_err(
22482        self,
22483        mut result: Result<(), fidl_fuchsia_posix::Errno>,
22484    ) -> Result<(), fidl::Error> {
22485        let _result = self.send_raw(result);
22486        self.drop_without_shutdown();
22487        _result
22488    }
22489
22490    fn send_raw(
22491        &self,
22492        mut result: Result<(), fidl_fuchsia_posix::Errno>,
22493    ) -> Result<(), fidl::Error> {
22494        self.control_handle.inner.send::<fidl::encoding::ResultType<
22495            fidl::encoding::EmptyStruct,
22496            fidl_fuchsia_posix::Errno,
22497        >>(
22498            result,
22499            self.tx_id,
22500            0x572df8f0b920d2c7,
22501            fidl::encoding::DynamicFlags::empty(),
22502        )
22503    }
22504}
22505
22506#[must_use = "FIDL methods require a response to be sent"]
22507#[derive(Debug)]
22508pub struct BaseNetworkSocketGetKeepAliveResponder {
22509    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
22510    tx_id: u32,
22511}
22512
22513/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
22514/// if the responder is dropped without sending a response, so that the client
22515/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
22516impl std::ops::Drop for BaseNetworkSocketGetKeepAliveResponder {
22517    fn drop(&mut self) {
22518        self.control_handle.shutdown();
22519        // Safety: drops once, never accessed again
22520        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22521    }
22522}
22523
22524impl fidl::endpoints::Responder for BaseNetworkSocketGetKeepAliveResponder {
22525    type ControlHandle = BaseNetworkSocketControlHandle;
22526
22527    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
22528        &self.control_handle
22529    }
22530
22531    fn drop_without_shutdown(mut self) {
22532        // Safety: drops once, never accessed again due to mem::forget
22533        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22534        // Prevent Drop from running (which would shut down the channel)
22535        std::mem::forget(self);
22536    }
22537}
22538
22539impl BaseNetworkSocketGetKeepAliveResponder {
22540    /// Sends a response to the FIDL transaction.
22541    ///
22542    /// Sets the channel to shutdown if an error occurs.
22543    pub fn send(
22544        self,
22545        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
22546    ) -> Result<(), fidl::Error> {
22547        let _result = self.send_raw(result);
22548        if _result.is_err() {
22549            self.control_handle.shutdown();
22550        }
22551        self.drop_without_shutdown();
22552        _result
22553    }
22554
22555    /// Similar to "send" but does not shutdown the channel if an error occurs.
22556    pub fn send_no_shutdown_on_err(
22557        self,
22558        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
22559    ) -> Result<(), fidl::Error> {
22560        let _result = self.send_raw(result);
22561        self.drop_without_shutdown();
22562        _result
22563    }
22564
22565    fn send_raw(
22566        &self,
22567        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
22568    ) -> Result<(), fidl::Error> {
22569        self.control_handle.inner.send::<fidl::encoding::ResultType<
22570            BaseSocketGetKeepAliveResponse,
22571            fidl_fuchsia_posix::Errno,
22572        >>(
22573            result.map(|value| (value,)),
22574            self.tx_id,
22575            0x2dd29d3215f2c9d2,
22576            fidl::encoding::DynamicFlags::empty(),
22577        )
22578    }
22579}
22580
22581#[must_use = "FIDL methods require a response to be sent"]
22582#[derive(Debug)]
22583pub struct BaseNetworkSocketSetOutOfBandInlineResponder {
22584    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
22585    tx_id: u32,
22586}
22587
22588/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
22589/// if the responder is dropped without sending a response, so that the client
22590/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
22591impl std::ops::Drop for BaseNetworkSocketSetOutOfBandInlineResponder {
22592    fn drop(&mut self) {
22593        self.control_handle.shutdown();
22594        // Safety: drops once, never accessed again
22595        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22596    }
22597}
22598
22599impl fidl::endpoints::Responder for BaseNetworkSocketSetOutOfBandInlineResponder {
22600    type ControlHandle = BaseNetworkSocketControlHandle;
22601
22602    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
22603        &self.control_handle
22604    }
22605
22606    fn drop_without_shutdown(mut self) {
22607        // Safety: drops once, never accessed again due to mem::forget
22608        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22609        // Prevent Drop from running (which would shut down the channel)
22610        std::mem::forget(self);
22611    }
22612}
22613
22614impl BaseNetworkSocketSetOutOfBandInlineResponder {
22615    /// Sends a response to the FIDL transaction.
22616    ///
22617    /// Sets the channel to shutdown if an error occurs.
22618    pub fn send(
22619        self,
22620        mut result: Result<(), fidl_fuchsia_posix::Errno>,
22621    ) -> Result<(), fidl::Error> {
22622        let _result = self.send_raw(result);
22623        if _result.is_err() {
22624            self.control_handle.shutdown();
22625        }
22626        self.drop_without_shutdown();
22627        _result
22628    }
22629
22630    /// Similar to "send" but does not shutdown the channel if an error occurs.
22631    pub fn send_no_shutdown_on_err(
22632        self,
22633        mut result: Result<(), fidl_fuchsia_posix::Errno>,
22634    ) -> Result<(), fidl::Error> {
22635        let _result = self.send_raw(result);
22636        self.drop_without_shutdown();
22637        _result
22638    }
22639
22640    fn send_raw(
22641        &self,
22642        mut result: Result<(), fidl_fuchsia_posix::Errno>,
22643    ) -> Result<(), fidl::Error> {
22644        self.control_handle.inner.send::<fidl::encoding::ResultType<
22645            fidl::encoding::EmptyStruct,
22646            fidl_fuchsia_posix::Errno,
22647        >>(
22648            result,
22649            self.tx_id,
22650            0x3ecb49968bee439,
22651            fidl::encoding::DynamicFlags::empty(),
22652        )
22653    }
22654}
22655
22656#[must_use = "FIDL methods require a response to be sent"]
22657#[derive(Debug)]
22658pub struct BaseNetworkSocketGetOutOfBandInlineResponder {
22659    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
22660    tx_id: u32,
22661}
22662
22663/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
22664/// if the responder is dropped without sending a response, so that the client
22665/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
22666impl std::ops::Drop for BaseNetworkSocketGetOutOfBandInlineResponder {
22667    fn drop(&mut self) {
22668        self.control_handle.shutdown();
22669        // Safety: drops once, never accessed again
22670        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22671    }
22672}
22673
22674impl fidl::endpoints::Responder for BaseNetworkSocketGetOutOfBandInlineResponder {
22675    type ControlHandle = BaseNetworkSocketControlHandle;
22676
22677    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
22678        &self.control_handle
22679    }
22680
22681    fn drop_without_shutdown(mut self) {
22682        // Safety: drops once, never accessed again due to mem::forget
22683        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22684        // Prevent Drop from running (which would shut down the channel)
22685        std::mem::forget(self);
22686    }
22687}
22688
22689impl BaseNetworkSocketGetOutOfBandInlineResponder {
22690    /// Sends a response to the FIDL transaction.
22691    ///
22692    /// Sets the channel to shutdown if an error occurs.
22693    pub fn send(
22694        self,
22695        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
22696    ) -> Result<(), fidl::Error> {
22697        let _result = self.send_raw(result);
22698        if _result.is_err() {
22699            self.control_handle.shutdown();
22700        }
22701        self.drop_without_shutdown();
22702        _result
22703    }
22704
22705    /// Similar to "send" but does not shutdown the channel if an error occurs.
22706    pub fn send_no_shutdown_on_err(
22707        self,
22708        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
22709    ) -> Result<(), fidl::Error> {
22710        let _result = self.send_raw(result);
22711        self.drop_without_shutdown();
22712        _result
22713    }
22714
22715    fn send_raw(
22716        &self,
22717        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
22718    ) -> Result<(), fidl::Error> {
22719        self.control_handle.inner.send::<fidl::encoding::ResultType<
22720            BaseSocketGetOutOfBandInlineResponse,
22721            fidl_fuchsia_posix::Errno,
22722        >>(
22723            result.map(|value| (value,)),
22724            self.tx_id,
22725            0x348c1ab3aeca1745,
22726            fidl::encoding::DynamicFlags::empty(),
22727        )
22728    }
22729}
22730
22731#[must_use = "FIDL methods require a response to be sent"]
22732#[derive(Debug)]
22733pub struct BaseNetworkSocketSetNoCheckResponder {
22734    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
22735    tx_id: u32,
22736}
22737
22738/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
22739/// if the responder is dropped without sending a response, so that the client
22740/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
22741impl std::ops::Drop for BaseNetworkSocketSetNoCheckResponder {
22742    fn drop(&mut self) {
22743        self.control_handle.shutdown();
22744        // Safety: drops once, never accessed again
22745        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22746    }
22747}
22748
22749impl fidl::endpoints::Responder for BaseNetworkSocketSetNoCheckResponder {
22750    type ControlHandle = BaseNetworkSocketControlHandle;
22751
22752    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
22753        &self.control_handle
22754    }
22755
22756    fn drop_without_shutdown(mut self) {
22757        // Safety: drops once, never accessed again due to mem::forget
22758        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22759        // Prevent Drop from running (which would shut down the channel)
22760        std::mem::forget(self);
22761    }
22762}
22763
22764impl BaseNetworkSocketSetNoCheckResponder {
22765    /// Sends a response to the FIDL transaction.
22766    ///
22767    /// Sets the channel to shutdown if an error occurs.
22768    pub fn send(
22769        self,
22770        mut result: Result<(), fidl_fuchsia_posix::Errno>,
22771    ) -> Result<(), fidl::Error> {
22772        let _result = self.send_raw(result);
22773        if _result.is_err() {
22774            self.control_handle.shutdown();
22775        }
22776        self.drop_without_shutdown();
22777        _result
22778    }
22779
22780    /// Similar to "send" but does not shutdown the channel if an error occurs.
22781    pub fn send_no_shutdown_on_err(
22782        self,
22783        mut result: Result<(), fidl_fuchsia_posix::Errno>,
22784    ) -> Result<(), fidl::Error> {
22785        let _result = self.send_raw(result);
22786        self.drop_without_shutdown();
22787        _result
22788    }
22789
22790    fn send_raw(
22791        &self,
22792        mut result: Result<(), fidl_fuchsia_posix::Errno>,
22793    ) -> Result<(), fidl::Error> {
22794        self.control_handle.inner.send::<fidl::encoding::ResultType<
22795            fidl::encoding::EmptyStruct,
22796            fidl_fuchsia_posix::Errno,
22797        >>(
22798            result,
22799            self.tx_id,
22800            0x6bbf00c53a4c78c2,
22801            fidl::encoding::DynamicFlags::empty(),
22802        )
22803    }
22804}
22805
22806#[must_use = "FIDL methods require a response to be sent"]
22807#[derive(Debug)]
22808pub struct BaseNetworkSocketGetNoCheckResponder {
22809    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
22810    tx_id: u32,
22811}
22812
22813/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
22814/// if the responder is dropped without sending a response, so that the client
22815/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
22816impl std::ops::Drop for BaseNetworkSocketGetNoCheckResponder {
22817    fn drop(&mut self) {
22818        self.control_handle.shutdown();
22819        // Safety: drops once, never accessed again
22820        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22821    }
22822}
22823
22824impl fidl::endpoints::Responder for BaseNetworkSocketGetNoCheckResponder {
22825    type ControlHandle = BaseNetworkSocketControlHandle;
22826
22827    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
22828        &self.control_handle
22829    }
22830
22831    fn drop_without_shutdown(mut self) {
22832        // Safety: drops once, never accessed again due to mem::forget
22833        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22834        // Prevent Drop from running (which would shut down the channel)
22835        std::mem::forget(self);
22836    }
22837}
22838
22839impl BaseNetworkSocketGetNoCheckResponder {
22840    /// Sends a response to the FIDL transaction.
22841    ///
22842    /// Sets the channel to shutdown if an error occurs.
22843    pub fn send(
22844        self,
22845        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
22846    ) -> Result<(), fidl::Error> {
22847        let _result = self.send_raw(result);
22848        if _result.is_err() {
22849            self.control_handle.shutdown();
22850        }
22851        self.drop_without_shutdown();
22852        _result
22853    }
22854
22855    /// Similar to "send" but does not shutdown the channel if an error occurs.
22856    pub fn send_no_shutdown_on_err(
22857        self,
22858        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
22859    ) -> Result<(), fidl::Error> {
22860        let _result = self.send_raw(result);
22861        self.drop_without_shutdown();
22862        _result
22863    }
22864
22865    fn send_raw(
22866        &self,
22867        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
22868    ) -> Result<(), fidl::Error> {
22869        self.control_handle.inner.send::<fidl::encoding::ResultType<
22870            BaseSocketGetNoCheckResponse,
22871            fidl_fuchsia_posix::Errno,
22872        >>(
22873            result.map(|value| (value,)),
22874            self.tx_id,
22875            0x2cd4249286417694,
22876            fidl::encoding::DynamicFlags::empty(),
22877        )
22878    }
22879}
22880
22881#[must_use = "FIDL methods require a response to be sent"]
22882#[derive(Debug)]
22883pub struct BaseNetworkSocketSetLingerResponder {
22884    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
22885    tx_id: u32,
22886}
22887
22888/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
22889/// if the responder is dropped without sending a response, so that the client
22890/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
22891impl std::ops::Drop for BaseNetworkSocketSetLingerResponder {
22892    fn drop(&mut self) {
22893        self.control_handle.shutdown();
22894        // Safety: drops once, never accessed again
22895        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22896    }
22897}
22898
22899impl fidl::endpoints::Responder for BaseNetworkSocketSetLingerResponder {
22900    type ControlHandle = BaseNetworkSocketControlHandle;
22901
22902    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
22903        &self.control_handle
22904    }
22905
22906    fn drop_without_shutdown(mut self) {
22907        // Safety: drops once, never accessed again due to mem::forget
22908        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22909        // Prevent Drop from running (which would shut down the channel)
22910        std::mem::forget(self);
22911    }
22912}
22913
22914impl BaseNetworkSocketSetLingerResponder {
22915    /// Sends a response to the FIDL transaction.
22916    ///
22917    /// Sets the channel to shutdown if an error occurs.
22918    pub fn send(
22919        self,
22920        mut result: Result<(), fidl_fuchsia_posix::Errno>,
22921    ) -> Result<(), fidl::Error> {
22922        let _result = self.send_raw(result);
22923        if _result.is_err() {
22924            self.control_handle.shutdown();
22925        }
22926        self.drop_without_shutdown();
22927        _result
22928    }
22929
22930    /// Similar to "send" but does not shutdown the channel if an error occurs.
22931    pub fn send_no_shutdown_on_err(
22932        self,
22933        mut result: Result<(), fidl_fuchsia_posix::Errno>,
22934    ) -> Result<(), fidl::Error> {
22935        let _result = self.send_raw(result);
22936        self.drop_without_shutdown();
22937        _result
22938    }
22939
22940    fn send_raw(
22941        &self,
22942        mut result: Result<(), fidl_fuchsia_posix::Errno>,
22943    ) -> Result<(), fidl::Error> {
22944        self.control_handle.inner.send::<fidl::encoding::ResultType<
22945            fidl::encoding::EmptyStruct,
22946            fidl_fuchsia_posix::Errno,
22947        >>(
22948            result,
22949            self.tx_id,
22950            0x45386351246e998e,
22951            fidl::encoding::DynamicFlags::empty(),
22952        )
22953    }
22954}
22955
22956#[must_use = "FIDL methods require a response to be sent"]
22957#[derive(Debug)]
22958pub struct BaseNetworkSocketGetLingerResponder {
22959    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
22960    tx_id: u32,
22961}
22962
22963/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
22964/// if the responder is dropped without sending a response, so that the client
22965/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
22966impl std::ops::Drop for BaseNetworkSocketGetLingerResponder {
22967    fn drop(&mut self) {
22968        self.control_handle.shutdown();
22969        // Safety: drops once, never accessed again
22970        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22971    }
22972}
22973
22974impl fidl::endpoints::Responder for BaseNetworkSocketGetLingerResponder {
22975    type ControlHandle = BaseNetworkSocketControlHandle;
22976
22977    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
22978        &self.control_handle
22979    }
22980
22981    fn drop_without_shutdown(mut self) {
22982        // Safety: drops once, never accessed again due to mem::forget
22983        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
22984        // Prevent Drop from running (which would shut down the channel)
22985        std::mem::forget(self);
22986    }
22987}
22988
22989impl BaseNetworkSocketGetLingerResponder {
22990    /// Sends a response to the FIDL transaction.
22991    ///
22992    /// Sets the channel to shutdown if an error occurs.
22993    pub fn send(
22994        self,
22995        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
22996    ) -> Result<(), fidl::Error> {
22997        let _result = self.send_raw(result);
22998        if _result.is_err() {
22999            self.control_handle.shutdown();
23000        }
23001        self.drop_without_shutdown();
23002        _result
23003    }
23004
23005    /// Similar to "send" but does not shutdown the channel if an error occurs.
23006    pub fn send_no_shutdown_on_err(
23007        self,
23008        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
23009    ) -> Result<(), fidl::Error> {
23010        let _result = self.send_raw(result);
23011        self.drop_without_shutdown();
23012        _result
23013    }
23014
23015    fn send_raw(
23016        &self,
23017        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
23018    ) -> Result<(), fidl::Error> {
23019        self.control_handle.inner.send::<fidl::encoding::ResultType<
23020            BaseSocketGetLingerResponse,
23021            fidl_fuchsia_posix::Errno,
23022        >>(
23023            result,
23024            self.tx_id,
23025            0x48eb20fc5ccb0e45,
23026            fidl::encoding::DynamicFlags::empty(),
23027        )
23028    }
23029}
23030
23031#[must_use = "FIDL methods require a response to be sent"]
23032#[derive(Debug)]
23033pub struct BaseNetworkSocketSetReusePortResponder {
23034    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
23035    tx_id: u32,
23036}
23037
23038/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
23039/// if the responder is dropped without sending a response, so that the client
23040/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
23041impl std::ops::Drop for BaseNetworkSocketSetReusePortResponder {
23042    fn drop(&mut self) {
23043        self.control_handle.shutdown();
23044        // Safety: drops once, never accessed again
23045        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23046    }
23047}
23048
23049impl fidl::endpoints::Responder for BaseNetworkSocketSetReusePortResponder {
23050    type ControlHandle = BaseNetworkSocketControlHandle;
23051
23052    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
23053        &self.control_handle
23054    }
23055
23056    fn drop_without_shutdown(mut self) {
23057        // Safety: drops once, never accessed again due to mem::forget
23058        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23059        // Prevent Drop from running (which would shut down the channel)
23060        std::mem::forget(self);
23061    }
23062}
23063
23064impl BaseNetworkSocketSetReusePortResponder {
23065    /// Sends a response to the FIDL transaction.
23066    ///
23067    /// Sets the channel to shutdown if an error occurs.
23068    pub fn send(
23069        self,
23070        mut result: Result<(), fidl_fuchsia_posix::Errno>,
23071    ) -> Result<(), fidl::Error> {
23072        let _result = self.send_raw(result);
23073        if _result.is_err() {
23074            self.control_handle.shutdown();
23075        }
23076        self.drop_without_shutdown();
23077        _result
23078    }
23079
23080    /// Similar to "send" but does not shutdown the channel if an error occurs.
23081    pub fn send_no_shutdown_on_err(
23082        self,
23083        mut result: Result<(), fidl_fuchsia_posix::Errno>,
23084    ) -> Result<(), fidl::Error> {
23085        let _result = self.send_raw(result);
23086        self.drop_without_shutdown();
23087        _result
23088    }
23089
23090    fn send_raw(
23091        &self,
23092        mut result: Result<(), fidl_fuchsia_posix::Errno>,
23093    ) -> Result<(), fidl::Error> {
23094        self.control_handle.inner.send::<fidl::encoding::ResultType<
23095            fidl::encoding::EmptyStruct,
23096            fidl_fuchsia_posix::Errno,
23097        >>(
23098            result,
23099            self.tx_id,
23100            0x24dd3e5cb36d9ccb,
23101            fidl::encoding::DynamicFlags::empty(),
23102        )
23103    }
23104}
23105
23106#[must_use = "FIDL methods require a response to be sent"]
23107#[derive(Debug)]
23108pub struct BaseNetworkSocketGetReusePortResponder {
23109    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
23110    tx_id: u32,
23111}
23112
23113/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
23114/// if the responder is dropped without sending a response, so that the client
23115/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
23116impl std::ops::Drop for BaseNetworkSocketGetReusePortResponder {
23117    fn drop(&mut self) {
23118        self.control_handle.shutdown();
23119        // Safety: drops once, never accessed again
23120        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23121    }
23122}
23123
23124impl fidl::endpoints::Responder for BaseNetworkSocketGetReusePortResponder {
23125    type ControlHandle = BaseNetworkSocketControlHandle;
23126
23127    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
23128        &self.control_handle
23129    }
23130
23131    fn drop_without_shutdown(mut self) {
23132        // Safety: drops once, never accessed again due to mem::forget
23133        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23134        // Prevent Drop from running (which would shut down the channel)
23135        std::mem::forget(self);
23136    }
23137}
23138
23139impl BaseNetworkSocketGetReusePortResponder {
23140    /// Sends a response to the FIDL transaction.
23141    ///
23142    /// Sets the channel to shutdown if an error occurs.
23143    pub fn send(
23144        self,
23145        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
23146    ) -> Result<(), fidl::Error> {
23147        let _result = self.send_raw(result);
23148        if _result.is_err() {
23149            self.control_handle.shutdown();
23150        }
23151        self.drop_without_shutdown();
23152        _result
23153    }
23154
23155    /// Similar to "send" but does not shutdown the channel if an error occurs.
23156    pub fn send_no_shutdown_on_err(
23157        self,
23158        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
23159    ) -> Result<(), fidl::Error> {
23160        let _result = self.send_raw(result);
23161        self.drop_without_shutdown();
23162        _result
23163    }
23164
23165    fn send_raw(
23166        &self,
23167        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
23168    ) -> Result<(), fidl::Error> {
23169        self.control_handle.inner.send::<fidl::encoding::ResultType<
23170            BaseSocketGetReusePortResponse,
23171            fidl_fuchsia_posix::Errno,
23172        >>(
23173            result.map(|value| (value,)),
23174            self.tx_id,
23175            0x7a112c1ab54ff828,
23176            fidl::encoding::DynamicFlags::empty(),
23177        )
23178    }
23179}
23180
23181#[must_use = "FIDL methods require a response to be sent"]
23182#[derive(Debug)]
23183pub struct BaseNetworkSocketGetAcceptConnResponder {
23184    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
23185    tx_id: u32,
23186}
23187
23188/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
23189/// if the responder is dropped without sending a response, so that the client
23190/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
23191impl std::ops::Drop for BaseNetworkSocketGetAcceptConnResponder {
23192    fn drop(&mut self) {
23193        self.control_handle.shutdown();
23194        // Safety: drops once, never accessed again
23195        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23196    }
23197}
23198
23199impl fidl::endpoints::Responder for BaseNetworkSocketGetAcceptConnResponder {
23200    type ControlHandle = BaseNetworkSocketControlHandle;
23201
23202    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
23203        &self.control_handle
23204    }
23205
23206    fn drop_without_shutdown(mut self) {
23207        // Safety: drops once, never accessed again due to mem::forget
23208        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23209        // Prevent Drop from running (which would shut down the channel)
23210        std::mem::forget(self);
23211    }
23212}
23213
23214impl BaseNetworkSocketGetAcceptConnResponder {
23215    /// Sends a response to the FIDL transaction.
23216    ///
23217    /// Sets the channel to shutdown if an error occurs.
23218    pub fn send(
23219        self,
23220        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
23221    ) -> Result<(), fidl::Error> {
23222        let _result = self.send_raw(result);
23223        if _result.is_err() {
23224            self.control_handle.shutdown();
23225        }
23226        self.drop_without_shutdown();
23227        _result
23228    }
23229
23230    /// Similar to "send" but does not shutdown the channel if an error occurs.
23231    pub fn send_no_shutdown_on_err(
23232        self,
23233        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
23234    ) -> Result<(), fidl::Error> {
23235        let _result = self.send_raw(result);
23236        self.drop_without_shutdown();
23237        _result
23238    }
23239
23240    fn send_raw(
23241        &self,
23242        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
23243    ) -> Result<(), fidl::Error> {
23244        self.control_handle.inner.send::<fidl::encoding::ResultType<
23245            BaseSocketGetAcceptConnResponse,
23246            fidl_fuchsia_posix::Errno,
23247        >>(
23248            result.map(|value| (value,)),
23249            self.tx_id,
23250            0x67ce6db6c2ec8966,
23251            fidl::encoding::DynamicFlags::empty(),
23252        )
23253    }
23254}
23255
23256#[must_use = "FIDL methods require a response to be sent"]
23257#[derive(Debug)]
23258pub struct BaseNetworkSocketSetBindToDeviceResponder {
23259    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
23260    tx_id: u32,
23261}
23262
23263/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
23264/// if the responder is dropped without sending a response, so that the client
23265/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
23266impl std::ops::Drop for BaseNetworkSocketSetBindToDeviceResponder {
23267    fn drop(&mut self) {
23268        self.control_handle.shutdown();
23269        // Safety: drops once, never accessed again
23270        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23271    }
23272}
23273
23274impl fidl::endpoints::Responder for BaseNetworkSocketSetBindToDeviceResponder {
23275    type ControlHandle = BaseNetworkSocketControlHandle;
23276
23277    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
23278        &self.control_handle
23279    }
23280
23281    fn drop_without_shutdown(mut self) {
23282        // Safety: drops once, never accessed again due to mem::forget
23283        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23284        // Prevent Drop from running (which would shut down the channel)
23285        std::mem::forget(self);
23286    }
23287}
23288
23289impl BaseNetworkSocketSetBindToDeviceResponder {
23290    /// Sends a response to the FIDL transaction.
23291    ///
23292    /// Sets the channel to shutdown if an error occurs.
23293    pub fn send(
23294        self,
23295        mut result: Result<(), fidl_fuchsia_posix::Errno>,
23296    ) -> Result<(), fidl::Error> {
23297        let _result = self.send_raw(result);
23298        if _result.is_err() {
23299            self.control_handle.shutdown();
23300        }
23301        self.drop_without_shutdown();
23302        _result
23303    }
23304
23305    /// Similar to "send" but does not shutdown the channel if an error occurs.
23306    pub fn send_no_shutdown_on_err(
23307        self,
23308        mut result: Result<(), fidl_fuchsia_posix::Errno>,
23309    ) -> Result<(), fidl::Error> {
23310        let _result = self.send_raw(result);
23311        self.drop_without_shutdown();
23312        _result
23313    }
23314
23315    fn send_raw(
23316        &self,
23317        mut result: Result<(), fidl_fuchsia_posix::Errno>,
23318    ) -> Result<(), fidl::Error> {
23319        self.control_handle.inner.send::<fidl::encoding::ResultType<
23320            fidl::encoding::EmptyStruct,
23321            fidl_fuchsia_posix::Errno,
23322        >>(
23323            result,
23324            self.tx_id,
23325            0x2118b483f28aafc4,
23326            fidl::encoding::DynamicFlags::empty(),
23327        )
23328    }
23329}
23330
23331#[must_use = "FIDL methods require a response to be sent"]
23332#[derive(Debug)]
23333pub struct BaseNetworkSocketGetBindToDeviceResponder {
23334    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
23335    tx_id: u32,
23336}
23337
23338/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
23339/// if the responder is dropped without sending a response, so that the client
23340/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
23341impl std::ops::Drop for BaseNetworkSocketGetBindToDeviceResponder {
23342    fn drop(&mut self) {
23343        self.control_handle.shutdown();
23344        // Safety: drops once, never accessed again
23345        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23346    }
23347}
23348
23349impl fidl::endpoints::Responder for BaseNetworkSocketGetBindToDeviceResponder {
23350    type ControlHandle = BaseNetworkSocketControlHandle;
23351
23352    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
23353        &self.control_handle
23354    }
23355
23356    fn drop_without_shutdown(mut self) {
23357        // Safety: drops once, never accessed again due to mem::forget
23358        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23359        // Prevent Drop from running (which would shut down the channel)
23360        std::mem::forget(self);
23361    }
23362}
23363
23364impl BaseNetworkSocketGetBindToDeviceResponder {
23365    /// Sends a response to the FIDL transaction.
23366    ///
23367    /// Sets the channel to shutdown if an error occurs.
23368    pub fn send(
23369        self,
23370        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
23371    ) -> Result<(), fidl::Error> {
23372        let _result = self.send_raw(result);
23373        if _result.is_err() {
23374            self.control_handle.shutdown();
23375        }
23376        self.drop_without_shutdown();
23377        _result
23378    }
23379
23380    /// Similar to "send" but does not shutdown the channel if an error occurs.
23381    pub fn send_no_shutdown_on_err(
23382        self,
23383        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
23384    ) -> Result<(), fidl::Error> {
23385        let _result = self.send_raw(result);
23386        self.drop_without_shutdown();
23387        _result
23388    }
23389
23390    fn send_raw(
23391        &self,
23392        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
23393    ) -> Result<(), fidl::Error> {
23394        self.control_handle.inner.send::<fidl::encoding::ResultType<
23395            BaseSocketGetBindToDeviceResponse,
23396            fidl_fuchsia_posix::Errno,
23397        >>(
23398            result.map(|value| (value,)),
23399            self.tx_id,
23400            0x1ab1fbf0ef7906c8,
23401            fidl::encoding::DynamicFlags::empty(),
23402        )
23403    }
23404}
23405
23406#[must_use = "FIDL methods require a response to be sent"]
23407#[derive(Debug)]
23408pub struct BaseNetworkSocketSetBindToInterfaceIndexResponder {
23409    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
23410    tx_id: u32,
23411}
23412
23413/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
23414/// if the responder is dropped without sending a response, so that the client
23415/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
23416impl std::ops::Drop for BaseNetworkSocketSetBindToInterfaceIndexResponder {
23417    fn drop(&mut self) {
23418        self.control_handle.shutdown();
23419        // Safety: drops once, never accessed again
23420        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23421    }
23422}
23423
23424impl fidl::endpoints::Responder for BaseNetworkSocketSetBindToInterfaceIndexResponder {
23425    type ControlHandle = BaseNetworkSocketControlHandle;
23426
23427    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
23428        &self.control_handle
23429    }
23430
23431    fn drop_without_shutdown(mut self) {
23432        // Safety: drops once, never accessed again due to mem::forget
23433        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23434        // Prevent Drop from running (which would shut down the channel)
23435        std::mem::forget(self);
23436    }
23437}
23438
23439impl BaseNetworkSocketSetBindToInterfaceIndexResponder {
23440    /// Sends a response to the FIDL transaction.
23441    ///
23442    /// Sets the channel to shutdown if an error occurs.
23443    pub fn send(
23444        self,
23445        mut result: Result<(), fidl_fuchsia_posix::Errno>,
23446    ) -> Result<(), fidl::Error> {
23447        let _result = self.send_raw(result);
23448        if _result.is_err() {
23449            self.control_handle.shutdown();
23450        }
23451        self.drop_without_shutdown();
23452        _result
23453    }
23454
23455    /// Similar to "send" but does not shutdown the channel if an error occurs.
23456    pub fn send_no_shutdown_on_err(
23457        self,
23458        mut result: Result<(), fidl_fuchsia_posix::Errno>,
23459    ) -> Result<(), fidl::Error> {
23460        let _result = self.send_raw(result);
23461        self.drop_without_shutdown();
23462        _result
23463    }
23464
23465    fn send_raw(
23466        &self,
23467        mut result: Result<(), fidl_fuchsia_posix::Errno>,
23468    ) -> Result<(), fidl::Error> {
23469        self.control_handle.inner.send::<fidl::encoding::ResultType<
23470            fidl::encoding::EmptyStruct,
23471            fidl_fuchsia_posix::Errno,
23472        >>(
23473            result,
23474            self.tx_id,
23475            0x6e387a0def00821,
23476            fidl::encoding::DynamicFlags::empty(),
23477        )
23478    }
23479}
23480
23481#[must_use = "FIDL methods require a response to be sent"]
23482#[derive(Debug)]
23483pub struct BaseNetworkSocketGetBindToInterfaceIndexResponder {
23484    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
23485    tx_id: u32,
23486}
23487
23488/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
23489/// if the responder is dropped without sending a response, so that the client
23490/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
23491impl std::ops::Drop for BaseNetworkSocketGetBindToInterfaceIndexResponder {
23492    fn drop(&mut self) {
23493        self.control_handle.shutdown();
23494        // Safety: drops once, never accessed again
23495        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23496    }
23497}
23498
23499impl fidl::endpoints::Responder for BaseNetworkSocketGetBindToInterfaceIndexResponder {
23500    type ControlHandle = BaseNetworkSocketControlHandle;
23501
23502    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
23503        &self.control_handle
23504    }
23505
23506    fn drop_without_shutdown(mut self) {
23507        // Safety: drops once, never accessed again due to mem::forget
23508        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23509        // Prevent Drop from running (which would shut down the channel)
23510        std::mem::forget(self);
23511    }
23512}
23513
23514impl BaseNetworkSocketGetBindToInterfaceIndexResponder {
23515    /// Sends a response to the FIDL transaction.
23516    ///
23517    /// Sets the channel to shutdown if an error occurs.
23518    pub fn send(
23519        self,
23520        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
23521    ) -> Result<(), fidl::Error> {
23522        let _result = self.send_raw(result);
23523        if _result.is_err() {
23524            self.control_handle.shutdown();
23525        }
23526        self.drop_without_shutdown();
23527        _result
23528    }
23529
23530    /// Similar to "send" but does not shutdown the channel if an error occurs.
23531    pub fn send_no_shutdown_on_err(
23532        self,
23533        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
23534    ) -> Result<(), fidl::Error> {
23535        let _result = self.send_raw(result);
23536        self.drop_without_shutdown();
23537        _result
23538    }
23539
23540    fn send_raw(
23541        &self,
23542        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
23543    ) -> Result<(), fidl::Error> {
23544        self.control_handle.inner.send::<fidl::encoding::ResultType<
23545            BaseSocketGetBindToInterfaceIndexResponse,
23546            fidl_fuchsia_posix::Errno,
23547        >>(
23548            result.map(|value| (value,)),
23549            self.tx_id,
23550            0x59c31dd3e3078295,
23551            fidl::encoding::DynamicFlags::empty(),
23552        )
23553    }
23554}
23555
23556#[must_use = "FIDL methods require a response to be sent"]
23557#[derive(Debug)]
23558pub struct BaseNetworkSocketSetTimestampResponder {
23559    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
23560    tx_id: u32,
23561}
23562
23563/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
23564/// if the responder is dropped without sending a response, so that the client
23565/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
23566impl std::ops::Drop for BaseNetworkSocketSetTimestampResponder {
23567    fn drop(&mut self) {
23568        self.control_handle.shutdown();
23569        // Safety: drops once, never accessed again
23570        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23571    }
23572}
23573
23574impl fidl::endpoints::Responder for BaseNetworkSocketSetTimestampResponder {
23575    type ControlHandle = BaseNetworkSocketControlHandle;
23576
23577    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
23578        &self.control_handle
23579    }
23580
23581    fn drop_without_shutdown(mut self) {
23582        // Safety: drops once, never accessed again due to mem::forget
23583        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23584        // Prevent Drop from running (which would shut down the channel)
23585        std::mem::forget(self);
23586    }
23587}
23588
23589impl BaseNetworkSocketSetTimestampResponder {
23590    /// Sends a response to the FIDL transaction.
23591    ///
23592    /// Sets the channel to shutdown if an error occurs.
23593    pub fn send(
23594        self,
23595        mut result: Result<(), fidl_fuchsia_posix::Errno>,
23596    ) -> Result<(), fidl::Error> {
23597        let _result = self.send_raw(result);
23598        if _result.is_err() {
23599            self.control_handle.shutdown();
23600        }
23601        self.drop_without_shutdown();
23602        _result
23603    }
23604
23605    /// Similar to "send" but does not shutdown the channel if an error occurs.
23606    pub fn send_no_shutdown_on_err(
23607        self,
23608        mut result: Result<(), fidl_fuchsia_posix::Errno>,
23609    ) -> Result<(), fidl::Error> {
23610        let _result = self.send_raw(result);
23611        self.drop_without_shutdown();
23612        _result
23613    }
23614
23615    fn send_raw(
23616        &self,
23617        mut result: Result<(), fidl_fuchsia_posix::Errno>,
23618    ) -> Result<(), fidl::Error> {
23619        self.control_handle.inner.send::<fidl::encoding::ResultType<
23620            fidl::encoding::EmptyStruct,
23621            fidl_fuchsia_posix::Errno,
23622        >>(
23623            result,
23624            self.tx_id,
23625            0x285d6516c263d839,
23626            fidl::encoding::DynamicFlags::empty(),
23627        )
23628    }
23629}
23630
23631#[must_use = "FIDL methods require a response to be sent"]
23632#[derive(Debug)]
23633pub struct BaseNetworkSocketGetTimestampResponder {
23634    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
23635    tx_id: u32,
23636}
23637
23638/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
23639/// if the responder is dropped without sending a response, so that the client
23640/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
23641impl std::ops::Drop for BaseNetworkSocketGetTimestampResponder {
23642    fn drop(&mut self) {
23643        self.control_handle.shutdown();
23644        // Safety: drops once, never accessed again
23645        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23646    }
23647}
23648
23649impl fidl::endpoints::Responder for BaseNetworkSocketGetTimestampResponder {
23650    type ControlHandle = BaseNetworkSocketControlHandle;
23651
23652    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
23653        &self.control_handle
23654    }
23655
23656    fn drop_without_shutdown(mut self) {
23657        // Safety: drops once, never accessed again due to mem::forget
23658        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23659        // Prevent Drop from running (which would shut down the channel)
23660        std::mem::forget(self);
23661    }
23662}
23663
23664impl BaseNetworkSocketGetTimestampResponder {
23665    /// Sends a response to the FIDL transaction.
23666    ///
23667    /// Sets the channel to shutdown if an error occurs.
23668    pub fn send(
23669        self,
23670        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
23671    ) -> Result<(), fidl::Error> {
23672        let _result = self.send_raw(result);
23673        if _result.is_err() {
23674            self.control_handle.shutdown();
23675        }
23676        self.drop_without_shutdown();
23677        _result
23678    }
23679
23680    /// Similar to "send" but does not shutdown the channel if an error occurs.
23681    pub fn send_no_shutdown_on_err(
23682        self,
23683        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
23684    ) -> Result<(), fidl::Error> {
23685        let _result = self.send_raw(result);
23686        self.drop_without_shutdown();
23687        _result
23688    }
23689
23690    fn send_raw(
23691        &self,
23692        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
23693    ) -> Result<(), fidl::Error> {
23694        self.control_handle.inner.send::<fidl::encoding::ResultType<
23695            BaseSocketGetTimestampResponse,
23696            fidl_fuchsia_posix::Errno,
23697        >>(
23698            result.map(|value| (value,)),
23699            self.tx_id,
23700            0x49f2fffbbcc2bd27,
23701            fidl::encoding::DynamicFlags::empty(),
23702        )
23703    }
23704}
23705
23706#[must_use = "FIDL methods require a response to be sent"]
23707#[derive(Debug)]
23708pub struct BaseNetworkSocketSetMarkResponder {
23709    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
23710    tx_id: u32,
23711}
23712
23713/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
23714/// if the responder is dropped without sending a response, so that the client
23715/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
23716impl std::ops::Drop for BaseNetworkSocketSetMarkResponder {
23717    fn drop(&mut self) {
23718        self.control_handle.shutdown();
23719        // Safety: drops once, never accessed again
23720        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23721    }
23722}
23723
23724impl fidl::endpoints::Responder for BaseNetworkSocketSetMarkResponder {
23725    type ControlHandle = BaseNetworkSocketControlHandle;
23726
23727    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
23728        &self.control_handle
23729    }
23730
23731    fn drop_without_shutdown(mut self) {
23732        // Safety: drops once, never accessed again due to mem::forget
23733        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23734        // Prevent Drop from running (which would shut down the channel)
23735        std::mem::forget(self);
23736    }
23737}
23738
23739impl BaseNetworkSocketSetMarkResponder {
23740    /// Sends a response to the FIDL transaction.
23741    ///
23742    /// Sets the channel to shutdown if an error occurs.
23743    pub fn send(
23744        self,
23745        mut result: Result<(), fidl_fuchsia_posix::Errno>,
23746    ) -> Result<(), fidl::Error> {
23747        let _result = self.send_raw(result);
23748        if _result.is_err() {
23749            self.control_handle.shutdown();
23750        }
23751        self.drop_without_shutdown();
23752        _result
23753    }
23754
23755    /// Similar to "send" but does not shutdown the channel if an error occurs.
23756    pub fn send_no_shutdown_on_err(
23757        self,
23758        mut result: Result<(), fidl_fuchsia_posix::Errno>,
23759    ) -> Result<(), fidl::Error> {
23760        let _result = self.send_raw(result);
23761        self.drop_without_shutdown();
23762        _result
23763    }
23764
23765    fn send_raw(
23766        &self,
23767        mut result: Result<(), fidl_fuchsia_posix::Errno>,
23768    ) -> Result<(), fidl::Error> {
23769        self.control_handle.inner.send::<fidl::encoding::ResultType<
23770            fidl::encoding::EmptyStruct,
23771            fidl_fuchsia_posix::Errno,
23772        >>(
23773            result,
23774            self.tx_id,
23775            0x6ead6de09f653236,
23776            fidl::encoding::DynamicFlags::empty(),
23777        )
23778    }
23779}
23780
23781#[must_use = "FIDL methods require a response to be sent"]
23782#[derive(Debug)]
23783pub struct BaseNetworkSocketGetMarkResponder {
23784    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
23785    tx_id: u32,
23786}
23787
23788/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
23789/// if the responder is dropped without sending a response, so that the client
23790/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
23791impl std::ops::Drop for BaseNetworkSocketGetMarkResponder {
23792    fn drop(&mut self) {
23793        self.control_handle.shutdown();
23794        // Safety: drops once, never accessed again
23795        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23796    }
23797}
23798
23799impl fidl::endpoints::Responder for BaseNetworkSocketGetMarkResponder {
23800    type ControlHandle = BaseNetworkSocketControlHandle;
23801
23802    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
23803        &self.control_handle
23804    }
23805
23806    fn drop_without_shutdown(mut self) {
23807        // Safety: drops once, never accessed again due to mem::forget
23808        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23809        // Prevent Drop from running (which would shut down the channel)
23810        std::mem::forget(self);
23811    }
23812}
23813
23814impl BaseNetworkSocketGetMarkResponder {
23815    /// Sends a response to the FIDL transaction.
23816    ///
23817    /// Sets the channel to shutdown if an error occurs.
23818    pub fn send(
23819        self,
23820        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
23821    ) -> Result<(), fidl::Error> {
23822        let _result = self.send_raw(result);
23823        if _result.is_err() {
23824            self.control_handle.shutdown();
23825        }
23826        self.drop_without_shutdown();
23827        _result
23828    }
23829
23830    /// Similar to "send" but does not shutdown the channel if an error occurs.
23831    pub fn send_no_shutdown_on_err(
23832        self,
23833        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
23834    ) -> Result<(), fidl::Error> {
23835        let _result = self.send_raw(result);
23836        self.drop_without_shutdown();
23837        _result
23838    }
23839
23840    fn send_raw(
23841        &self,
23842        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
23843    ) -> Result<(), fidl::Error> {
23844        self.control_handle.inner.send::<fidl::encoding::ResultType<
23845            BaseSocketGetMarkResponse,
23846            fidl_fuchsia_posix::Errno,
23847        >>(
23848            result.map(|mark| (mark,)),
23849            self.tx_id,
23850            0x57a2752c61d93d47,
23851            fidl::encoding::DynamicFlags::empty(),
23852        )
23853    }
23854}
23855
23856#[must_use = "FIDL methods require a response to be sent"]
23857#[derive(Debug)]
23858pub struct BaseNetworkSocketBindResponder {
23859    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
23860    tx_id: u32,
23861}
23862
23863/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
23864/// if the responder is dropped without sending a response, so that the client
23865/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
23866impl std::ops::Drop for BaseNetworkSocketBindResponder {
23867    fn drop(&mut self) {
23868        self.control_handle.shutdown();
23869        // Safety: drops once, never accessed again
23870        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23871    }
23872}
23873
23874impl fidl::endpoints::Responder for BaseNetworkSocketBindResponder {
23875    type ControlHandle = BaseNetworkSocketControlHandle;
23876
23877    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
23878        &self.control_handle
23879    }
23880
23881    fn drop_without_shutdown(mut self) {
23882        // Safety: drops once, never accessed again due to mem::forget
23883        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23884        // Prevent Drop from running (which would shut down the channel)
23885        std::mem::forget(self);
23886    }
23887}
23888
23889impl BaseNetworkSocketBindResponder {
23890    /// Sends a response to the FIDL transaction.
23891    ///
23892    /// Sets the channel to shutdown if an error occurs.
23893    pub fn send(
23894        self,
23895        mut result: Result<(), fidl_fuchsia_posix::Errno>,
23896    ) -> Result<(), fidl::Error> {
23897        let _result = self.send_raw(result);
23898        if _result.is_err() {
23899            self.control_handle.shutdown();
23900        }
23901        self.drop_without_shutdown();
23902        _result
23903    }
23904
23905    /// Similar to "send" but does not shutdown the channel if an error occurs.
23906    pub fn send_no_shutdown_on_err(
23907        self,
23908        mut result: Result<(), fidl_fuchsia_posix::Errno>,
23909    ) -> Result<(), fidl::Error> {
23910        let _result = self.send_raw(result);
23911        self.drop_without_shutdown();
23912        _result
23913    }
23914
23915    fn send_raw(
23916        &self,
23917        mut result: Result<(), fidl_fuchsia_posix::Errno>,
23918    ) -> Result<(), fidl::Error> {
23919        self.control_handle.inner.send::<fidl::encoding::ResultType<
23920            fidl::encoding::EmptyStruct,
23921            fidl_fuchsia_posix::Errno,
23922        >>(
23923            result,
23924            self.tx_id,
23925            0x4bc6400ae92125d,
23926            fidl::encoding::DynamicFlags::empty(),
23927        )
23928    }
23929}
23930
23931#[must_use = "FIDL methods require a response to be sent"]
23932#[derive(Debug)]
23933pub struct BaseNetworkSocketConnectResponder {
23934    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
23935    tx_id: u32,
23936}
23937
23938/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
23939/// if the responder is dropped without sending a response, so that the client
23940/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
23941impl std::ops::Drop for BaseNetworkSocketConnectResponder {
23942    fn drop(&mut self) {
23943        self.control_handle.shutdown();
23944        // Safety: drops once, never accessed again
23945        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23946    }
23947}
23948
23949impl fidl::endpoints::Responder for BaseNetworkSocketConnectResponder {
23950    type ControlHandle = BaseNetworkSocketControlHandle;
23951
23952    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
23953        &self.control_handle
23954    }
23955
23956    fn drop_without_shutdown(mut self) {
23957        // Safety: drops once, never accessed again due to mem::forget
23958        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
23959        // Prevent Drop from running (which would shut down the channel)
23960        std::mem::forget(self);
23961    }
23962}
23963
23964impl BaseNetworkSocketConnectResponder {
23965    /// Sends a response to the FIDL transaction.
23966    ///
23967    /// Sets the channel to shutdown if an error occurs.
23968    pub fn send(
23969        self,
23970        mut result: Result<(), fidl_fuchsia_posix::Errno>,
23971    ) -> Result<(), fidl::Error> {
23972        let _result = self.send_raw(result);
23973        if _result.is_err() {
23974            self.control_handle.shutdown();
23975        }
23976        self.drop_without_shutdown();
23977        _result
23978    }
23979
23980    /// Similar to "send" but does not shutdown the channel if an error occurs.
23981    pub fn send_no_shutdown_on_err(
23982        self,
23983        mut result: Result<(), fidl_fuchsia_posix::Errno>,
23984    ) -> Result<(), fidl::Error> {
23985        let _result = self.send_raw(result);
23986        self.drop_without_shutdown();
23987        _result
23988    }
23989
23990    fn send_raw(
23991        &self,
23992        mut result: Result<(), fidl_fuchsia_posix::Errno>,
23993    ) -> Result<(), fidl::Error> {
23994        self.control_handle.inner.send::<fidl::encoding::ResultType<
23995            fidl::encoding::EmptyStruct,
23996            fidl_fuchsia_posix::Errno,
23997        >>(
23998            result,
23999            self.tx_id,
24000            0x5f05f19bfdd38871,
24001            fidl::encoding::DynamicFlags::empty(),
24002        )
24003    }
24004}
24005
24006#[must_use = "FIDL methods require a response to be sent"]
24007#[derive(Debug)]
24008pub struct BaseNetworkSocketDisconnectResponder {
24009    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
24010    tx_id: u32,
24011}
24012
24013/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
24014/// if the responder is dropped without sending a response, so that the client
24015/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
24016impl std::ops::Drop for BaseNetworkSocketDisconnectResponder {
24017    fn drop(&mut self) {
24018        self.control_handle.shutdown();
24019        // Safety: drops once, never accessed again
24020        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24021    }
24022}
24023
24024impl fidl::endpoints::Responder for BaseNetworkSocketDisconnectResponder {
24025    type ControlHandle = BaseNetworkSocketControlHandle;
24026
24027    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
24028        &self.control_handle
24029    }
24030
24031    fn drop_without_shutdown(mut self) {
24032        // Safety: drops once, never accessed again due to mem::forget
24033        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24034        // Prevent Drop from running (which would shut down the channel)
24035        std::mem::forget(self);
24036    }
24037}
24038
24039impl BaseNetworkSocketDisconnectResponder {
24040    /// Sends a response to the FIDL transaction.
24041    ///
24042    /// Sets the channel to shutdown if an error occurs.
24043    pub fn send(
24044        self,
24045        mut result: Result<(), fidl_fuchsia_posix::Errno>,
24046    ) -> Result<(), fidl::Error> {
24047        let _result = self.send_raw(result);
24048        if _result.is_err() {
24049            self.control_handle.shutdown();
24050        }
24051        self.drop_without_shutdown();
24052        _result
24053    }
24054
24055    /// Similar to "send" but does not shutdown the channel if an error occurs.
24056    pub fn send_no_shutdown_on_err(
24057        self,
24058        mut result: Result<(), fidl_fuchsia_posix::Errno>,
24059    ) -> Result<(), fidl::Error> {
24060        let _result = self.send_raw(result);
24061        self.drop_without_shutdown();
24062        _result
24063    }
24064
24065    fn send_raw(
24066        &self,
24067        mut result: Result<(), fidl_fuchsia_posix::Errno>,
24068    ) -> Result<(), fidl::Error> {
24069        self.control_handle.inner.send::<fidl::encoding::ResultType<
24070            fidl::encoding::EmptyStruct,
24071            fidl_fuchsia_posix::Errno,
24072        >>(
24073            result,
24074            self.tx_id,
24075            0x74e63b91f7b29b2,
24076            fidl::encoding::DynamicFlags::empty(),
24077        )
24078    }
24079}
24080
24081#[must_use = "FIDL methods require a response to be sent"]
24082#[derive(Debug)]
24083pub struct BaseNetworkSocketGetSockNameResponder {
24084    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
24085    tx_id: u32,
24086}
24087
24088/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
24089/// if the responder is dropped without sending a response, so that the client
24090/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
24091impl std::ops::Drop for BaseNetworkSocketGetSockNameResponder {
24092    fn drop(&mut self) {
24093        self.control_handle.shutdown();
24094        // Safety: drops once, never accessed again
24095        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24096    }
24097}
24098
24099impl fidl::endpoints::Responder for BaseNetworkSocketGetSockNameResponder {
24100    type ControlHandle = BaseNetworkSocketControlHandle;
24101
24102    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
24103        &self.control_handle
24104    }
24105
24106    fn drop_without_shutdown(mut self) {
24107        // Safety: drops once, never accessed again due to mem::forget
24108        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24109        // Prevent Drop from running (which would shut down the channel)
24110        std::mem::forget(self);
24111    }
24112}
24113
24114impl BaseNetworkSocketGetSockNameResponder {
24115    /// Sends a response to the FIDL transaction.
24116    ///
24117    /// Sets the channel to shutdown if an error occurs.
24118    pub fn send(
24119        self,
24120        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
24121    ) -> Result<(), fidl::Error> {
24122        let _result = self.send_raw(result);
24123        if _result.is_err() {
24124            self.control_handle.shutdown();
24125        }
24126        self.drop_without_shutdown();
24127        _result
24128    }
24129
24130    /// Similar to "send" but does not shutdown the channel if an error occurs.
24131    pub fn send_no_shutdown_on_err(
24132        self,
24133        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
24134    ) -> Result<(), fidl::Error> {
24135        let _result = self.send_raw(result);
24136        self.drop_without_shutdown();
24137        _result
24138    }
24139
24140    fn send_raw(
24141        &self,
24142        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
24143    ) -> Result<(), fidl::Error> {
24144        self.control_handle.inner.send::<fidl::encoding::ResultType<
24145            BaseNetworkSocketGetSockNameResponse,
24146            fidl_fuchsia_posix::Errno,
24147        >>(
24148            result.map(|addr| (addr,)),
24149            self.tx_id,
24150            0x475f23f84a1a4f85,
24151            fidl::encoding::DynamicFlags::empty(),
24152        )
24153    }
24154}
24155
24156#[must_use = "FIDL methods require a response to be sent"]
24157#[derive(Debug)]
24158pub struct BaseNetworkSocketGetPeerNameResponder {
24159    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
24160    tx_id: u32,
24161}
24162
24163/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
24164/// if the responder is dropped without sending a response, so that the client
24165/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
24166impl std::ops::Drop for BaseNetworkSocketGetPeerNameResponder {
24167    fn drop(&mut self) {
24168        self.control_handle.shutdown();
24169        // Safety: drops once, never accessed again
24170        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24171    }
24172}
24173
24174impl fidl::endpoints::Responder for BaseNetworkSocketGetPeerNameResponder {
24175    type ControlHandle = BaseNetworkSocketControlHandle;
24176
24177    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
24178        &self.control_handle
24179    }
24180
24181    fn drop_without_shutdown(mut self) {
24182        // Safety: drops once, never accessed again due to mem::forget
24183        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24184        // Prevent Drop from running (which would shut down the channel)
24185        std::mem::forget(self);
24186    }
24187}
24188
24189impl BaseNetworkSocketGetPeerNameResponder {
24190    /// Sends a response to the FIDL transaction.
24191    ///
24192    /// Sets the channel to shutdown if an error occurs.
24193    pub fn send(
24194        self,
24195        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
24196    ) -> Result<(), fidl::Error> {
24197        let _result = self.send_raw(result);
24198        if _result.is_err() {
24199            self.control_handle.shutdown();
24200        }
24201        self.drop_without_shutdown();
24202        _result
24203    }
24204
24205    /// Similar to "send" but does not shutdown the channel if an error occurs.
24206    pub fn send_no_shutdown_on_err(
24207        self,
24208        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
24209    ) -> Result<(), fidl::Error> {
24210        let _result = self.send_raw(result);
24211        self.drop_without_shutdown();
24212        _result
24213    }
24214
24215    fn send_raw(
24216        &self,
24217        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
24218    ) -> Result<(), fidl::Error> {
24219        self.control_handle.inner.send::<fidl::encoding::ResultType<
24220            BaseNetworkSocketGetPeerNameResponse,
24221            fidl_fuchsia_posix::Errno,
24222        >>(
24223            result.map(|addr| (addr,)),
24224            self.tx_id,
24225            0x1ffecf4bd5b6432e,
24226            fidl::encoding::DynamicFlags::empty(),
24227        )
24228    }
24229}
24230
24231#[must_use = "FIDL methods require a response to be sent"]
24232#[derive(Debug)]
24233pub struct BaseNetworkSocketShutdownResponder {
24234    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
24235    tx_id: u32,
24236}
24237
24238/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
24239/// if the responder is dropped without sending a response, so that the client
24240/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
24241impl std::ops::Drop for BaseNetworkSocketShutdownResponder {
24242    fn drop(&mut self) {
24243        self.control_handle.shutdown();
24244        // Safety: drops once, never accessed again
24245        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24246    }
24247}
24248
24249impl fidl::endpoints::Responder for BaseNetworkSocketShutdownResponder {
24250    type ControlHandle = BaseNetworkSocketControlHandle;
24251
24252    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
24253        &self.control_handle
24254    }
24255
24256    fn drop_without_shutdown(mut self) {
24257        // Safety: drops once, never accessed again due to mem::forget
24258        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24259        // Prevent Drop from running (which would shut down the channel)
24260        std::mem::forget(self);
24261    }
24262}
24263
24264impl BaseNetworkSocketShutdownResponder {
24265    /// Sends a response to the FIDL transaction.
24266    ///
24267    /// Sets the channel to shutdown if an error occurs.
24268    pub fn send(
24269        self,
24270        mut result: Result<(), fidl_fuchsia_posix::Errno>,
24271    ) -> Result<(), fidl::Error> {
24272        let _result = self.send_raw(result);
24273        if _result.is_err() {
24274            self.control_handle.shutdown();
24275        }
24276        self.drop_without_shutdown();
24277        _result
24278    }
24279
24280    /// Similar to "send" but does not shutdown the channel if an error occurs.
24281    pub fn send_no_shutdown_on_err(
24282        self,
24283        mut result: Result<(), fidl_fuchsia_posix::Errno>,
24284    ) -> Result<(), fidl::Error> {
24285        let _result = self.send_raw(result);
24286        self.drop_without_shutdown();
24287        _result
24288    }
24289
24290    fn send_raw(
24291        &self,
24292        mut result: Result<(), fidl_fuchsia_posix::Errno>,
24293    ) -> Result<(), fidl::Error> {
24294        self.control_handle.inner.send::<fidl::encoding::ResultType<
24295            fidl::encoding::EmptyStruct,
24296            fidl_fuchsia_posix::Errno,
24297        >>(
24298            result,
24299            self.tx_id,
24300            0x247f38b6db68c336,
24301            fidl::encoding::DynamicFlags::empty(),
24302        )
24303    }
24304}
24305
24306#[must_use = "FIDL methods require a response to be sent"]
24307#[derive(Debug)]
24308pub struct BaseNetworkSocketSetIpTypeOfServiceResponder {
24309    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
24310    tx_id: u32,
24311}
24312
24313/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
24314/// if the responder is dropped without sending a response, so that the client
24315/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
24316impl std::ops::Drop for BaseNetworkSocketSetIpTypeOfServiceResponder {
24317    fn drop(&mut self) {
24318        self.control_handle.shutdown();
24319        // Safety: drops once, never accessed again
24320        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24321    }
24322}
24323
24324impl fidl::endpoints::Responder for BaseNetworkSocketSetIpTypeOfServiceResponder {
24325    type ControlHandle = BaseNetworkSocketControlHandle;
24326
24327    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
24328        &self.control_handle
24329    }
24330
24331    fn drop_without_shutdown(mut self) {
24332        // Safety: drops once, never accessed again due to mem::forget
24333        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24334        // Prevent Drop from running (which would shut down the channel)
24335        std::mem::forget(self);
24336    }
24337}
24338
24339impl BaseNetworkSocketSetIpTypeOfServiceResponder {
24340    /// Sends a response to the FIDL transaction.
24341    ///
24342    /// Sets the channel to shutdown if an error occurs.
24343    pub fn send(
24344        self,
24345        mut result: Result<(), fidl_fuchsia_posix::Errno>,
24346    ) -> Result<(), fidl::Error> {
24347        let _result = self.send_raw(result);
24348        if _result.is_err() {
24349            self.control_handle.shutdown();
24350        }
24351        self.drop_without_shutdown();
24352        _result
24353    }
24354
24355    /// Similar to "send" but does not shutdown the channel if an error occurs.
24356    pub fn send_no_shutdown_on_err(
24357        self,
24358        mut result: Result<(), fidl_fuchsia_posix::Errno>,
24359    ) -> Result<(), fidl::Error> {
24360        let _result = self.send_raw(result);
24361        self.drop_without_shutdown();
24362        _result
24363    }
24364
24365    fn send_raw(
24366        &self,
24367        mut result: Result<(), fidl_fuchsia_posix::Errno>,
24368    ) -> Result<(), fidl::Error> {
24369        self.control_handle.inner.send::<fidl::encoding::ResultType<
24370            fidl::encoding::EmptyStruct,
24371            fidl_fuchsia_posix::Errno,
24372        >>(
24373            result,
24374            self.tx_id,
24375            0x995c600475b6d46,
24376            fidl::encoding::DynamicFlags::empty(),
24377        )
24378    }
24379}
24380
24381#[must_use = "FIDL methods require a response to be sent"]
24382#[derive(Debug)]
24383pub struct BaseNetworkSocketGetIpTypeOfServiceResponder {
24384    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
24385    tx_id: u32,
24386}
24387
24388/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
24389/// if the responder is dropped without sending a response, so that the client
24390/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
24391impl std::ops::Drop for BaseNetworkSocketGetIpTypeOfServiceResponder {
24392    fn drop(&mut self) {
24393        self.control_handle.shutdown();
24394        // Safety: drops once, never accessed again
24395        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24396    }
24397}
24398
24399impl fidl::endpoints::Responder for BaseNetworkSocketGetIpTypeOfServiceResponder {
24400    type ControlHandle = BaseNetworkSocketControlHandle;
24401
24402    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
24403        &self.control_handle
24404    }
24405
24406    fn drop_without_shutdown(mut self) {
24407        // Safety: drops once, never accessed again due to mem::forget
24408        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24409        // Prevent Drop from running (which would shut down the channel)
24410        std::mem::forget(self);
24411    }
24412}
24413
24414impl BaseNetworkSocketGetIpTypeOfServiceResponder {
24415    /// Sends a response to the FIDL transaction.
24416    ///
24417    /// Sets the channel to shutdown if an error occurs.
24418    pub fn send(
24419        self,
24420        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
24421    ) -> Result<(), fidl::Error> {
24422        let _result = self.send_raw(result);
24423        if _result.is_err() {
24424            self.control_handle.shutdown();
24425        }
24426        self.drop_without_shutdown();
24427        _result
24428    }
24429
24430    /// Similar to "send" but does not shutdown the channel if an error occurs.
24431    pub fn send_no_shutdown_on_err(
24432        self,
24433        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
24434    ) -> Result<(), fidl::Error> {
24435        let _result = self.send_raw(result);
24436        self.drop_without_shutdown();
24437        _result
24438    }
24439
24440    fn send_raw(
24441        &self,
24442        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
24443    ) -> Result<(), fidl::Error> {
24444        self.control_handle.inner.send::<fidl::encoding::ResultType<
24445            BaseNetworkSocketGetIpTypeOfServiceResponse,
24446            fidl_fuchsia_posix::Errno,
24447        >>(
24448            result.map(|value| (value,)),
24449            self.tx_id,
24450            0x3814a04259f75fcb,
24451            fidl::encoding::DynamicFlags::empty(),
24452        )
24453    }
24454}
24455
24456#[must_use = "FIDL methods require a response to be sent"]
24457#[derive(Debug)]
24458pub struct BaseNetworkSocketSetIpTtlResponder {
24459    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
24460    tx_id: u32,
24461}
24462
24463/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
24464/// if the responder is dropped without sending a response, so that the client
24465/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
24466impl std::ops::Drop for BaseNetworkSocketSetIpTtlResponder {
24467    fn drop(&mut self) {
24468        self.control_handle.shutdown();
24469        // Safety: drops once, never accessed again
24470        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24471    }
24472}
24473
24474impl fidl::endpoints::Responder for BaseNetworkSocketSetIpTtlResponder {
24475    type ControlHandle = BaseNetworkSocketControlHandle;
24476
24477    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
24478        &self.control_handle
24479    }
24480
24481    fn drop_without_shutdown(mut self) {
24482        // Safety: drops once, never accessed again due to mem::forget
24483        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24484        // Prevent Drop from running (which would shut down the channel)
24485        std::mem::forget(self);
24486    }
24487}
24488
24489impl BaseNetworkSocketSetIpTtlResponder {
24490    /// Sends a response to the FIDL transaction.
24491    ///
24492    /// Sets the channel to shutdown if an error occurs.
24493    pub fn send(
24494        self,
24495        mut result: Result<(), fidl_fuchsia_posix::Errno>,
24496    ) -> Result<(), fidl::Error> {
24497        let _result = self.send_raw(result);
24498        if _result.is_err() {
24499            self.control_handle.shutdown();
24500        }
24501        self.drop_without_shutdown();
24502        _result
24503    }
24504
24505    /// Similar to "send" but does not shutdown the channel if an error occurs.
24506    pub fn send_no_shutdown_on_err(
24507        self,
24508        mut result: Result<(), fidl_fuchsia_posix::Errno>,
24509    ) -> Result<(), fidl::Error> {
24510        let _result = self.send_raw(result);
24511        self.drop_without_shutdown();
24512        _result
24513    }
24514
24515    fn send_raw(
24516        &self,
24517        mut result: Result<(), fidl_fuchsia_posix::Errno>,
24518    ) -> Result<(), fidl::Error> {
24519        self.control_handle.inner.send::<fidl::encoding::ResultType<
24520            fidl::encoding::EmptyStruct,
24521            fidl_fuchsia_posix::Errno,
24522        >>(
24523            result,
24524            self.tx_id,
24525            0x29e2424b433ae1ef,
24526            fidl::encoding::DynamicFlags::empty(),
24527        )
24528    }
24529}
24530
24531#[must_use = "FIDL methods require a response to be sent"]
24532#[derive(Debug)]
24533pub struct BaseNetworkSocketGetIpTtlResponder {
24534    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
24535    tx_id: u32,
24536}
24537
24538/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
24539/// if the responder is dropped without sending a response, so that the client
24540/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
24541impl std::ops::Drop for BaseNetworkSocketGetIpTtlResponder {
24542    fn drop(&mut self) {
24543        self.control_handle.shutdown();
24544        // Safety: drops once, never accessed again
24545        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24546    }
24547}
24548
24549impl fidl::endpoints::Responder for BaseNetworkSocketGetIpTtlResponder {
24550    type ControlHandle = BaseNetworkSocketControlHandle;
24551
24552    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
24553        &self.control_handle
24554    }
24555
24556    fn drop_without_shutdown(mut self) {
24557        // Safety: drops once, never accessed again due to mem::forget
24558        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24559        // Prevent Drop from running (which would shut down the channel)
24560        std::mem::forget(self);
24561    }
24562}
24563
24564impl BaseNetworkSocketGetIpTtlResponder {
24565    /// Sends a response to the FIDL transaction.
24566    ///
24567    /// Sets the channel to shutdown if an error occurs.
24568    pub fn send(
24569        self,
24570        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
24571    ) -> Result<(), fidl::Error> {
24572        let _result = self.send_raw(result);
24573        if _result.is_err() {
24574            self.control_handle.shutdown();
24575        }
24576        self.drop_without_shutdown();
24577        _result
24578    }
24579
24580    /// Similar to "send" but does not shutdown the channel if an error occurs.
24581    pub fn send_no_shutdown_on_err(
24582        self,
24583        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
24584    ) -> Result<(), fidl::Error> {
24585        let _result = self.send_raw(result);
24586        self.drop_without_shutdown();
24587        _result
24588    }
24589
24590    fn send_raw(
24591        &self,
24592        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
24593    ) -> Result<(), fidl::Error> {
24594        self.control_handle.inner.send::<fidl::encoding::ResultType<
24595            BaseNetworkSocketGetIpTtlResponse,
24596            fidl_fuchsia_posix::Errno,
24597        >>(
24598            result.map(|value| (value,)),
24599            self.tx_id,
24600            0x47e47fa1f24da471,
24601            fidl::encoding::DynamicFlags::empty(),
24602        )
24603    }
24604}
24605
24606#[must_use = "FIDL methods require a response to be sent"]
24607#[derive(Debug)]
24608pub struct BaseNetworkSocketSetIpPacketInfoResponder {
24609    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
24610    tx_id: u32,
24611}
24612
24613/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
24614/// if the responder is dropped without sending a response, so that the client
24615/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
24616impl std::ops::Drop for BaseNetworkSocketSetIpPacketInfoResponder {
24617    fn drop(&mut self) {
24618        self.control_handle.shutdown();
24619        // Safety: drops once, never accessed again
24620        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24621    }
24622}
24623
24624impl fidl::endpoints::Responder for BaseNetworkSocketSetIpPacketInfoResponder {
24625    type ControlHandle = BaseNetworkSocketControlHandle;
24626
24627    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
24628        &self.control_handle
24629    }
24630
24631    fn drop_without_shutdown(mut self) {
24632        // Safety: drops once, never accessed again due to mem::forget
24633        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24634        // Prevent Drop from running (which would shut down the channel)
24635        std::mem::forget(self);
24636    }
24637}
24638
24639impl BaseNetworkSocketSetIpPacketInfoResponder {
24640    /// Sends a response to the FIDL transaction.
24641    ///
24642    /// Sets the channel to shutdown if an error occurs.
24643    pub fn send(
24644        self,
24645        mut result: Result<(), fidl_fuchsia_posix::Errno>,
24646    ) -> Result<(), fidl::Error> {
24647        let _result = self.send_raw(result);
24648        if _result.is_err() {
24649            self.control_handle.shutdown();
24650        }
24651        self.drop_without_shutdown();
24652        _result
24653    }
24654
24655    /// Similar to "send" but does not shutdown the channel if an error occurs.
24656    pub fn send_no_shutdown_on_err(
24657        self,
24658        mut result: Result<(), fidl_fuchsia_posix::Errno>,
24659    ) -> Result<(), fidl::Error> {
24660        let _result = self.send_raw(result);
24661        self.drop_without_shutdown();
24662        _result
24663    }
24664
24665    fn send_raw(
24666        &self,
24667        mut result: Result<(), fidl_fuchsia_posix::Errno>,
24668    ) -> Result<(), fidl::Error> {
24669        self.control_handle.inner.send::<fidl::encoding::ResultType<
24670            fidl::encoding::EmptyStruct,
24671            fidl_fuchsia_posix::Errno,
24672        >>(
24673            result,
24674            self.tx_id,
24675            0x392d16bee20c0e16,
24676            fidl::encoding::DynamicFlags::empty(),
24677        )
24678    }
24679}
24680
24681#[must_use = "FIDL methods require a response to be sent"]
24682#[derive(Debug)]
24683pub struct BaseNetworkSocketGetIpPacketInfoResponder {
24684    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
24685    tx_id: u32,
24686}
24687
24688/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
24689/// if the responder is dropped without sending a response, so that the client
24690/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
24691impl std::ops::Drop for BaseNetworkSocketGetIpPacketInfoResponder {
24692    fn drop(&mut self) {
24693        self.control_handle.shutdown();
24694        // Safety: drops once, never accessed again
24695        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24696    }
24697}
24698
24699impl fidl::endpoints::Responder for BaseNetworkSocketGetIpPacketInfoResponder {
24700    type ControlHandle = BaseNetworkSocketControlHandle;
24701
24702    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
24703        &self.control_handle
24704    }
24705
24706    fn drop_without_shutdown(mut self) {
24707        // Safety: drops once, never accessed again due to mem::forget
24708        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24709        // Prevent Drop from running (which would shut down the channel)
24710        std::mem::forget(self);
24711    }
24712}
24713
24714impl BaseNetworkSocketGetIpPacketInfoResponder {
24715    /// Sends a response to the FIDL transaction.
24716    ///
24717    /// Sets the channel to shutdown if an error occurs.
24718    pub fn send(
24719        self,
24720        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
24721    ) -> Result<(), fidl::Error> {
24722        let _result = self.send_raw(result);
24723        if _result.is_err() {
24724            self.control_handle.shutdown();
24725        }
24726        self.drop_without_shutdown();
24727        _result
24728    }
24729
24730    /// Similar to "send" but does not shutdown the channel if an error occurs.
24731    pub fn send_no_shutdown_on_err(
24732        self,
24733        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
24734    ) -> Result<(), fidl::Error> {
24735        let _result = self.send_raw(result);
24736        self.drop_without_shutdown();
24737        _result
24738    }
24739
24740    fn send_raw(
24741        &self,
24742        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
24743    ) -> Result<(), fidl::Error> {
24744        self.control_handle.inner.send::<fidl::encoding::ResultType<
24745            BaseNetworkSocketGetIpPacketInfoResponse,
24746            fidl_fuchsia_posix::Errno,
24747        >>(
24748            result.map(|value| (value,)),
24749            self.tx_id,
24750            0x54b505f242280740,
24751            fidl::encoding::DynamicFlags::empty(),
24752        )
24753    }
24754}
24755
24756#[must_use = "FIDL methods require a response to be sent"]
24757#[derive(Debug)]
24758pub struct BaseNetworkSocketSetIpReceiveTypeOfServiceResponder {
24759    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
24760    tx_id: u32,
24761}
24762
24763/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
24764/// if the responder is dropped without sending a response, so that the client
24765/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
24766impl std::ops::Drop for BaseNetworkSocketSetIpReceiveTypeOfServiceResponder {
24767    fn drop(&mut self) {
24768        self.control_handle.shutdown();
24769        // Safety: drops once, never accessed again
24770        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24771    }
24772}
24773
24774impl fidl::endpoints::Responder for BaseNetworkSocketSetIpReceiveTypeOfServiceResponder {
24775    type ControlHandle = BaseNetworkSocketControlHandle;
24776
24777    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
24778        &self.control_handle
24779    }
24780
24781    fn drop_without_shutdown(mut self) {
24782        // Safety: drops once, never accessed again due to mem::forget
24783        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24784        // Prevent Drop from running (which would shut down the channel)
24785        std::mem::forget(self);
24786    }
24787}
24788
24789impl BaseNetworkSocketSetIpReceiveTypeOfServiceResponder {
24790    /// Sends a response to the FIDL transaction.
24791    ///
24792    /// Sets the channel to shutdown if an error occurs.
24793    pub fn send(
24794        self,
24795        mut result: Result<(), fidl_fuchsia_posix::Errno>,
24796    ) -> Result<(), fidl::Error> {
24797        let _result = self.send_raw(result);
24798        if _result.is_err() {
24799            self.control_handle.shutdown();
24800        }
24801        self.drop_without_shutdown();
24802        _result
24803    }
24804
24805    /// Similar to "send" but does not shutdown the channel if an error occurs.
24806    pub fn send_no_shutdown_on_err(
24807        self,
24808        mut result: Result<(), fidl_fuchsia_posix::Errno>,
24809    ) -> Result<(), fidl::Error> {
24810        let _result = self.send_raw(result);
24811        self.drop_without_shutdown();
24812        _result
24813    }
24814
24815    fn send_raw(
24816        &self,
24817        mut result: Result<(), fidl_fuchsia_posix::Errno>,
24818    ) -> Result<(), fidl::Error> {
24819        self.control_handle.inner.send::<fidl::encoding::ResultType<
24820            fidl::encoding::EmptyStruct,
24821            fidl_fuchsia_posix::Errno,
24822        >>(
24823            result,
24824            self.tx_id,
24825            0x6c4f6714995f84ef,
24826            fidl::encoding::DynamicFlags::empty(),
24827        )
24828    }
24829}
24830
24831#[must_use = "FIDL methods require a response to be sent"]
24832#[derive(Debug)]
24833pub struct BaseNetworkSocketGetIpReceiveTypeOfServiceResponder {
24834    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
24835    tx_id: u32,
24836}
24837
24838/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
24839/// if the responder is dropped without sending a response, so that the client
24840/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
24841impl std::ops::Drop for BaseNetworkSocketGetIpReceiveTypeOfServiceResponder {
24842    fn drop(&mut self) {
24843        self.control_handle.shutdown();
24844        // Safety: drops once, never accessed again
24845        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24846    }
24847}
24848
24849impl fidl::endpoints::Responder for BaseNetworkSocketGetIpReceiveTypeOfServiceResponder {
24850    type ControlHandle = BaseNetworkSocketControlHandle;
24851
24852    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
24853        &self.control_handle
24854    }
24855
24856    fn drop_without_shutdown(mut self) {
24857        // Safety: drops once, never accessed again due to mem::forget
24858        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24859        // Prevent Drop from running (which would shut down the channel)
24860        std::mem::forget(self);
24861    }
24862}
24863
24864impl BaseNetworkSocketGetIpReceiveTypeOfServiceResponder {
24865    /// Sends a response to the FIDL transaction.
24866    ///
24867    /// Sets the channel to shutdown if an error occurs.
24868    pub fn send(
24869        self,
24870        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
24871    ) -> Result<(), fidl::Error> {
24872        let _result = self.send_raw(result);
24873        if _result.is_err() {
24874            self.control_handle.shutdown();
24875        }
24876        self.drop_without_shutdown();
24877        _result
24878    }
24879
24880    /// Similar to "send" but does not shutdown the channel if an error occurs.
24881    pub fn send_no_shutdown_on_err(
24882        self,
24883        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
24884    ) -> Result<(), fidl::Error> {
24885        let _result = self.send_raw(result);
24886        self.drop_without_shutdown();
24887        _result
24888    }
24889
24890    fn send_raw(
24891        &self,
24892        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
24893    ) -> Result<(), fidl::Error> {
24894        self.control_handle.inner.send::<fidl::encoding::ResultType<
24895            BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
24896            fidl_fuchsia_posix::Errno,
24897        >>(
24898            result.map(|value| (value,)),
24899            self.tx_id,
24900            0x4158ba7dc2795960,
24901            fidl::encoding::DynamicFlags::empty(),
24902        )
24903    }
24904}
24905
24906#[must_use = "FIDL methods require a response to be sent"]
24907#[derive(Debug)]
24908pub struct BaseNetworkSocketSetIpReceiveTtlResponder {
24909    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
24910    tx_id: u32,
24911}
24912
24913/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
24914/// if the responder is dropped without sending a response, so that the client
24915/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
24916impl std::ops::Drop for BaseNetworkSocketSetIpReceiveTtlResponder {
24917    fn drop(&mut self) {
24918        self.control_handle.shutdown();
24919        // Safety: drops once, never accessed again
24920        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24921    }
24922}
24923
24924impl fidl::endpoints::Responder for BaseNetworkSocketSetIpReceiveTtlResponder {
24925    type ControlHandle = BaseNetworkSocketControlHandle;
24926
24927    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
24928        &self.control_handle
24929    }
24930
24931    fn drop_without_shutdown(mut self) {
24932        // Safety: drops once, never accessed again due to mem::forget
24933        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24934        // Prevent Drop from running (which would shut down the channel)
24935        std::mem::forget(self);
24936    }
24937}
24938
24939impl BaseNetworkSocketSetIpReceiveTtlResponder {
24940    /// Sends a response to the FIDL transaction.
24941    ///
24942    /// Sets the channel to shutdown if an error occurs.
24943    pub fn send(
24944        self,
24945        mut result: Result<(), fidl_fuchsia_posix::Errno>,
24946    ) -> Result<(), fidl::Error> {
24947        let _result = self.send_raw(result);
24948        if _result.is_err() {
24949            self.control_handle.shutdown();
24950        }
24951        self.drop_without_shutdown();
24952        _result
24953    }
24954
24955    /// Similar to "send" but does not shutdown the channel if an error occurs.
24956    pub fn send_no_shutdown_on_err(
24957        self,
24958        mut result: Result<(), fidl_fuchsia_posix::Errno>,
24959    ) -> Result<(), fidl::Error> {
24960        let _result = self.send_raw(result);
24961        self.drop_without_shutdown();
24962        _result
24963    }
24964
24965    fn send_raw(
24966        &self,
24967        mut result: Result<(), fidl_fuchsia_posix::Errno>,
24968    ) -> Result<(), fidl::Error> {
24969        self.control_handle.inner.send::<fidl::encoding::ResultType<
24970            fidl::encoding::EmptyStruct,
24971            fidl_fuchsia_posix::Errno,
24972        >>(
24973            result,
24974            self.tx_id,
24975            0x46f15be0ce0ab82b,
24976            fidl::encoding::DynamicFlags::empty(),
24977        )
24978    }
24979}
24980
24981#[must_use = "FIDL methods require a response to be sent"]
24982#[derive(Debug)]
24983pub struct BaseNetworkSocketGetIpReceiveTtlResponder {
24984    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
24985    tx_id: u32,
24986}
24987
24988/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
24989/// if the responder is dropped without sending a response, so that the client
24990/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
24991impl std::ops::Drop for BaseNetworkSocketGetIpReceiveTtlResponder {
24992    fn drop(&mut self) {
24993        self.control_handle.shutdown();
24994        // Safety: drops once, never accessed again
24995        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
24996    }
24997}
24998
24999impl fidl::endpoints::Responder for BaseNetworkSocketGetIpReceiveTtlResponder {
25000    type ControlHandle = BaseNetworkSocketControlHandle;
25001
25002    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
25003        &self.control_handle
25004    }
25005
25006    fn drop_without_shutdown(mut self) {
25007        // Safety: drops once, never accessed again due to mem::forget
25008        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25009        // Prevent Drop from running (which would shut down the channel)
25010        std::mem::forget(self);
25011    }
25012}
25013
25014impl BaseNetworkSocketGetIpReceiveTtlResponder {
25015    /// Sends a response to the FIDL transaction.
25016    ///
25017    /// Sets the channel to shutdown if an error occurs.
25018    pub fn send(
25019        self,
25020        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
25021    ) -> Result<(), fidl::Error> {
25022        let _result = self.send_raw(result);
25023        if _result.is_err() {
25024            self.control_handle.shutdown();
25025        }
25026        self.drop_without_shutdown();
25027        _result
25028    }
25029
25030    /// Similar to "send" but does not shutdown the channel if an error occurs.
25031    pub fn send_no_shutdown_on_err(
25032        self,
25033        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
25034    ) -> Result<(), fidl::Error> {
25035        let _result = self.send_raw(result);
25036        self.drop_without_shutdown();
25037        _result
25038    }
25039
25040    fn send_raw(
25041        &self,
25042        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
25043    ) -> Result<(), fidl::Error> {
25044        self.control_handle.inner.send::<fidl::encoding::ResultType<
25045            BaseNetworkSocketGetIpReceiveTtlResponse,
25046            fidl_fuchsia_posix::Errno,
25047        >>(
25048            result.map(|value| (value,)),
25049            self.tx_id,
25050            0x678ddd5a5dfa2eb5,
25051            fidl::encoding::DynamicFlags::empty(),
25052        )
25053    }
25054}
25055
25056#[must_use = "FIDL methods require a response to be sent"]
25057#[derive(Debug)]
25058pub struct BaseNetworkSocketSetIpMulticastInterfaceResponder {
25059    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
25060    tx_id: u32,
25061}
25062
25063/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
25064/// if the responder is dropped without sending a response, so that the client
25065/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
25066impl std::ops::Drop for BaseNetworkSocketSetIpMulticastInterfaceResponder {
25067    fn drop(&mut self) {
25068        self.control_handle.shutdown();
25069        // Safety: drops once, never accessed again
25070        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25071    }
25072}
25073
25074impl fidl::endpoints::Responder for BaseNetworkSocketSetIpMulticastInterfaceResponder {
25075    type ControlHandle = BaseNetworkSocketControlHandle;
25076
25077    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
25078        &self.control_handle
25079    }
25080
25081    fn drop_without_shutdown(mut self) {
25082        // Safety: drops once, never accessed again due to mem::forget
25083        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25084        // Prevent Drop from running (which would shut down the channel)
25085        std::mem::forget(self);
25086    }
25087}
25088
25089impl BaseNetworkSocketSetIpMulticastInterfaceResponder {
25090    /// Sends a response to the FIDL transaction.
25091    ///
25092    /// Sets the channel to shutdown if an error occurs.
25093    pub fn send(
25094        self,
25095        mut result: Result<(), fidl_fuchsia_posix::Errno>,
25096    ) -> Result<(), fidl::Error> {
25097        let _result = self.send_raw(result);
25098        if _result.is_err() {
25099            self.control_handle.shutdown();
25100        }
25101        self.drop_without_shutdown();
25102        _result
25103    }
25104
25105    /// Similar to "send" but does not shutdown the channel if an error occurs.
25106    pub fn send_no_shutdown_on_err(
25107        self,
25108        mut result: Result<(), fidl_fuchsia_posix::Errno>,
25109    ) -> Result<(), fidl::Error> {
25110        let _result = self.send_raw(result);
25111        self.drop_without_shutdown();
25112        _result
25113    }
25114
25115    fn send_raw(
25116        &self,
25117        mut result: Result<(), fidl_fuchsia_posix::Errno>,
25118    ) -> Result<(), fidl::Error> {
25119        self.control_handle.inner.send::<fidl::encoding::ResultType<
25120            fidl::encoding::EmptyStruct,
25121            fidl_fuchsia_posix::Errno,
25122        >>(
25123            result,
25124            self.tx_id,
25125            0x752fbfa9b12befe,
25126            fidl::encoding::DynamicFlags::empty(),
25127        )
25128    }
25129}
25130
25131#[must_use = "FIDL methods require a response to be sent"]
25132#[derive(Debug)]
25133pub struct BaseNetworkSocketGetIpMulticastInterfaceResponder {
25134    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
25135    tx_id: u32,
25136}
25137
25138/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
25139/// if the responder is dropped without sending a response, so that the client
25140/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
25141impl std::ops::Drop for BaseNetworkSocketGetIpMulticastInterfaceResponder {
25142    fn drop(&mut self) {
25143        self.control_handle.shutdown();
25144        // Safety: drops once, never accessed again
25145        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25146    }
25147}
25148
25149impl fidl::endpoints::Responder for BaseNetworkSocketGetIpMulticastInterfaceResponder {
25150    type ControlHandle = BaseNetworkSocketControlHandle;
25151
25152    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
25153        &self.control_handle
25154    }
25155
25156    fn drop_without_shutdown(mut self) {
25157        // Safety: drops once, never accessed again due to mem::forget
25158        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25159        // Prevent Drop from running (which would shut down the channel)
25160        std::mem::forget(self);
25161    }
25162}
25163
25164impl BaseNetworkSocketGetIpMulticastInterfaceResponder {
25165    /// Sends a response to the FIDL transaction.
25166    ///
25167    /// Sets the channel to shutdown if an error occurs.
25168    pub fn send(
25169        self,
25170        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
25171    ) -> Result<(), fidl::Error> {
25172        let _result = self.send_raw(result);
25173        if _result.is_err() {
25174            self.control_handle.shutdown();
25175        }
25176        self.drop_without_shutdown();
25177        _result
25178    }
25179
25180    /// Similar to "send" but does not shutdown the channel if an error occurs.
25181    pub fn send_no_shutdown_on_err(
25182        self,
25183        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
25184    ) -> Result<(), fidl::Error> {
25185        let _result = self.send_raw(result);
25186        self.drop_without_shutdown();
25187        _result
25188    }
25189
25190    fn send_raw(
25191        &self,
25192        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
25193    ) -> Result<(), fidl::Error> {
25194        self.control_handle.inner.send::<fidl::encoding::ResultType<
25195            BaseNetworkSocketGetIpMulticastInterfaceResponse,
25196            fidl_fuchsia_posix::Errno,
25197        >>(
25198            result.map(|value| (value,)),
25199            self.tx_id,
25200            0x320bd14c4df046c4,
25201            fidl::encoding::DynamicFlags::empty(),
25202        )
25203    }
25204}
25205
25206#[must_use = "FIDL methods require a response to be sent"]
25207#[derive(Debug)]
25208pub struct BaseNetworkSocketSetIpMulticastTtlResponder {
25209    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
25210    tx_id: u32,
25211}
25212
25213/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
25214/// if the responder is dropped without sending a response, so that the client
25215/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
25216impl std::ops::Drop for BaseNetworkSocketSetIpMulticastTtlResponder {
25217    fn drop(&mut self) {
25218        self.control_handle.shutdown();
25219        // Safety: drops once, never accessed again
25220        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25221    }
25222}
25223
25224impl fidl::endpoints::Responder for BaseNetworkSocketSetIpMulticastTtlResponder {
25225    type ControlHandle = BaseNetworkSocketControlHandle;
25226
25227    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
25228        &self.control_handle
25229    }
25230
25231    fn drop_without_shutdown(mut self) {
25232        // Safety: drops once, never accessed again due to mem::forget
25233        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25234        // Prevent Drop from running (which would shut down the channel)
25235        std::mem::forget(self);
25236    }
25237}
25238
25239impl BaseNetworkSocketSetIpMulticastTtlResponder {
25240    /// Sends a response to the FIDL transaction.
25241    ///
25242    /// Sets the channel to shutdown if an error occurs.
25243    pub fn send(
25244        self,
25245        mut result: Result<(), fidl_fuchsia_posix::Errno>,
25246    ) -> Result<(), fidl::Error> {
25247        let _result = self.send_raw(result);
25248        if _result.is_err() {
25249            self.control_handle.shutdown();
25250        }
25251        self.drop_without_shutdown();
25252        _result
25253    }
25254
25255    /// Similar to "send" but does not shutdown the channel if an error occurs.
25256    pub fn send_no_shutdown_on_err(
25257        self,
25258        mut result: Result<(), fidl_fuchsia_posix::Errno>,
25259    ) -> Result<(), fidl::Error> {
25260        let _result = self.send_raw(result);
25261        self.drop_without_shutdown();
25262        _result
25263    }
25264
25265    fn send_raw(
25266        &self,
25267        mut result: Result<(), fidl_fuchsia_posix::Errno>,
25268    ) -> Result<(), fidl::Error> {
25269        self.control_handle.inner.send::<fidl::encoding::ResultType<
25270            fidl::encoding::EmptyStruct,
25271            fidl_fuchsia_posix::Errno,
25272        >>(
25273            result,
25274            self.tx_id,
25275            0x63134d53772916a1,
25276            fidl::encoding::DynamicFlags::empty(),
25277        )
25278    }
25279}
25280
25281#[must_use = "FIDL methods require a response to be sent"]
25282#[derive(Debug)]
25283pub struct BaseNetworkSocketGetIpMulticastTtlResponder {
25284    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
25285    tx_id: u32,
25286}
25287
25288/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
25289/// if the responder is dropped without sending a response, so that the client
25290/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
25291impl std::ops::Drop for BaseNetworkSocketGetIpMulticastTtlResponder {
25292    fn drop(&mut self) {
25293        self.control_handle.shutdown();
25294        // Safety: drops once, never accessed again
25295        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25296    }
25297}
25298
25299impl fidl::endpoints::Responder for BaseNetworkSocketGetIpMulticastTtlResponder {
25300    type ControlHandle = BaseNetworkSocketControlHandle;
25301
25302    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
25303        &self.control_handle
25304    }
25305
25306    fn drop_without_shutdown(mut self) {
25307        // Safety: drops once, never accessed again due to mem::forget
25308        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25309        // Prevent Drop from running (which would shut down the channel)
25310        std::mem::forget(self);
25311    }
25312}
25313
25314impl BaseNetworkSocketGetIpMulticastTtlResponder {
25315    /// Sends a response to the FIDL transaction.
25316    ///
25317    /// Sets the channel to shutdown if an error occurs.
25318    pub fn send(
25319        self,
25320        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
25321    ) -> Result<(), fidl::Error> {
25322        let _result = self.send_raw(result);
25323        if _result.is_err() {
25324            self.control_handle.shutdown();
25325        }
25326        self.drop_without_shutdown();
25327        _result
25328    }
25329
25330    /// Similar to "send" but does not shutdown the channel if an error occurs.
25331    pub fn send_no_shutdown_on_err(
25332        self,
25333        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
25334    ) -> Result<(), fidl::Error> {
25335        let _result = self.send_raw(result);
25336        self.drop_without_shutdown();
25337        _result
25338    }
25339
25340    fn send_raw(
25341        &self,
25342        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
25343    ) -> Result<(), fidl::Error> {
25344        self.control_handle.inner.send::<fidl::encoding::ResultType<
25345            BaseNetworkSocketGetIpMulticastTtlResponse,
25346            fidl_fuchsia_posix::Errno,
25347        >>(
25348            result.map(|value| (value,)),
25349            self.tx_id,
25350            0x4665cd378f39e1a,
25351            fidl::encoding::DynamicFlags::empty(),
25352        )
25353    }
25354}
25355
25356#[must_use = "FIDL methods require a response to be sent"]
25357#[derive(Debug)]
25358pub struct BaseNetworkSocketSetIpMulticastLoopbackResponder {
25359    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
25360    tx_id: u32,
25361}
25362
25363/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
25364/// if the responder is dropped without sending a response, so that the client
25365/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
25366impl std::ops::Drop for BaseNetworkSocketSetIpMulticastLoopbackResponder {
25367    fn drop(&mut self) {
25368        self.control_handle.shutdown();
25369        // Safety: drops once, never accessed again
25370        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25371    }
25372}
25373
25374impl fidl::endpoints::Responder for BaseNetworkSocketSetIpMulticastLoopbackResponder {
25375    type ControlHandle = BaseNetworkSocketControlHandle;
25376
25377    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
25378        &self.control_handle
25379    }
25380
25381    fn drop_without_shutdown(mut self) {
25382        // Safety: drops once, never accessed again due to mem::forget
25383        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25384        // Prevent Drop from running (which would shut down the channel)
25385        std::mem::forget(self);
25386    }
25387}
25388
25389impl BaseNetworkSocketSetIpMulticastLoopbackResponder {
25390    /// Sends a response to the FIDL transaction.
25391    ///
25392    /// Sets the channel to shutdown if an error occurs.
25393    pub fn send(
25394        self,
25395        mut result: Result<(), fidl_fuchsia_posix::Errno>,
25396    ) -> Result<(), fidl::Error> {
25397        let _result = self.send_raw(result);
25398        if _result.is_err() {
25399            self.control_handle.shutdown();
25400        }
25401        self.drop_without_shutdown();
25402        _result
25403    }
25404
25405    /// Similar to "send" but does not shutdown the channel if an error occurs.
25406    pub fn send_no_shutdown_on_err(
25407        self,
25408        mut result: Result<(), fidl_fuchsia_posix::Errno>,
25409    ) -> Result<(), fidl::Error> {
25410        let _result = self.send_raw(result);
25411        self.drop_without_shutdown();
25412        _result
25413    }
25414
25415    fn send_raw(
25416        &self,
25417        mut result: Result<(), fidl_fuchsia_posix::Errno>,
25418    ) -> Result<(), fidl::Error> {
25419        self.control_handle.inner.send::<fidl::encoding::ResultType<
25420            fidl::encoding::EmptyStruct,
25421            fidl_fuchsia_posix::Errno,
25422        >>(
25423            result,
25424            self.tx_id,
25425            0x20c55c11f00943ea,
25426            fidl::encoding::DynamicFlags::empty(),
25427        )
25428    }
25429}
25430
25431#[must_use = "FIDL methods require a response to be sent"]
25432#[derive(Debug)]
25433pub struct BaseNetworkSocketGetIpMulticastLoopbackResponder {
25434    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
25435    tx_id: u32,
25436}
25437
25438/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
25439/// if the responder is dropped without sending a response, so that the client
25440/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
25441impl std::ops::Drop for BaseNetworkSocketGetIpMulticastLoopbackResponder {
25442    fn drop(&mut self) {
25443        self.control_handle.shutdown();
25444        // Safety: drops once, never accessed again
25445        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25446    }
25447}
25448
25449impl fidl::endpoints::Responder for BaseNetworkSocketGetIpMulticastLoopbackResponder {
25450    type ControlHandle = BaseNetworkSocketControlHandle;
25451
25452    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
25453        &self.control_handle
25454    }
25455
25456    fn drop_without_shutdown(mut self) {
25457        // Safety: drops once, never accessed again due to mem::forget
25458        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25459        // Prevent Drop from running (which would shut down the channel)
25460        std::mem::forget(self);
25461    }
25462}
25463
25464impl BaseNetworkSocketGetIpMulticastLoopbackResponder {
25465    /// Sends a response to the FIDL transaction.
25466    ///
25467    /// Sets the channel to shutdown if an error occurs.
25468    pub fn send(
25469        self,
25470        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
25471    ) -> Result<(), fidl::Error> {
25472        let _result = self.send_raw(result);
25473        if _result.is_err() {
25474            self.control_handle.shutdown();
25475        }
25476        self.drop_without_shutdown();
25477        _result
25478    }
25479
25480    /// Similar to "send" but does not shutdown the channel if an error occurs.
25481    pub fn send_no_shutdown_on_err(
25482        self,
25483        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
25484    ) -> Result<(), fidl::Error> {
25485        let _result = self.send_raw(result);
25486        self.drop_without_shutdown();
25487        _result
25488    }
25489
25490    fn send_raw(
25491        &self,
25492        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
25493    ) -> Result<(), fidl::Error> {
25494        self.control_handle.inner.send::<fidl::encoding::ResultType<
25495            BaseNetworkSocketGetIpMulticastLoopbackResponse,
25496            fidl_fuchsia_posix::Errno,
25497        >>(
25498            result.map(|value| (value,)),
25499            self.tx_id,
25500            0x3b6b26ff558298f2,
25501            fidl::encoding::DynamicFlags::empty(),
25502        )
25503    }
25504}
25505
25506#[must_use = "FIDL methods require a response to be sent"]
25507#[derive(Debug)]
25508pub struct BaseNetworkSocketAddIpMembershipResponder {
25509    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
25510    tx_id: u32,
25511}
25512
25513/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
25514/// if the responder is dropped without sending a response, so that the client
25515/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
25516impl std::ops::Drop for BaseNetworkSocketAddIpMembershipResponder {
25517    fn drop(&mut self) {
25518        self.control_handle.shutdown();
25519        // Safety: drops once, never accessed again
25520        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25521    }
25522}
25523
25524impl fidl::endpoints::Responder for BaseNetworkSocketAddIpMembershipResponder {
25525    type ControlHandle = BaseNetworkSocketControlHandle;
25526
25527    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
25528        &self.control_handle
25529    }
25530
25531    fn drop_without_shutdown(mut self) {
25532        // Safety: drops once, never accessed again due to mem::forget
25533        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25534        // Prevent Drop from running (which would shut down the channel)
25535        std::mem::forget(self);
25536    }
25537}
25538
25539impl BaseNetworkSocketAddIpMembershipResponder {
25540    /// Sends a response to the FIDL transaction.
25541    ///
25542    /// Sets the channel to shutdown if an error occurs.
25543    pub fn send(
25544        self,
25545        mut result: Result<(), fidl_fuchsia_posix::Errno>,
25546    ) -> Result<(), fidl::Error> {
25547        let _result = self.send_raw(result);
25548        if _result.is_err() {
25549            self.control_handle.shutdown();
25550        }
25551        self.drop_without_shutdown();
25552        _result
25553    }
25554
25555    /// Similar to "send" but does not shutdown the channel if an error occurs.
25556    pub fn send_no_shutdown_on_err(
25557        self,
25558        mut result: Result<(), fidl_fuchsia_posix::Errno>,
25559    ) -> Result<(), fidl::Error> {
25560        let _result = self.send_raw(result);
25561        self.drop_without_shutdown();
25562        _result
25563    }
25564
25565    fn send_raw(
25566        &self,
25567        mut result: Result<(), fidl_fuchsia_posix::Errno>,
25568    ) -> Result<(), fidl::Error> {
25569        self.control_handle.inner.send::<fidl::encoding::ResultType<
25570            fidl::encoding::EmptyStruct,
25571            fidl_fuchsia_posix::Errno,
25572        >>(
25573            result,
25574            self.tx_id,
25575            0x76bc7df115a3b4d0,
25576            fidl::encoding::DynamicFlags::empty(),
25577        )
25578    }
25579}
25580
25581#[must_use = "FIDL methods require a response to be sent"]
25582#[derive(Debug)]
25583pub struct BaseNetworkSocketDropIpMembershipResponder {
25584    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
25585    tx_id: u32,
25586}
25587
25588/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
25589/// if the responder is dropped without sending a response, so that the client
25590/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
25591impl std::ops::Drop for BaseNetworkSocketDropIpMembershipResponder {
25592    fn drop(&mut self) {
25593        self.control_handle.shutdown();
25594        // Safety: drops once, never accessed again
25595        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25596    }
25597}
25598
25599impl fidl::endpoints::Responder for BaseNetworkSocketDropIpMembershipResponder {
25600    type ControlHandle = BaseNetworkSocketControlHandle;
25601
25602    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
25603        &self.control_handle
25604    }
25605
25606    fn drop_without_shutdown(mut self) {
25607        // Safety: drops once, never accessed again due to mem::forget
25608        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25609        // Prevent Drop from running (which would shut down the channel)
25610        std::mem::forget(self);
25611    }
25612}
25613
25614impl BaseNetworkSocketDropIpMembershipResponder {
25615    /// Sends a response to the FIDL transaction.
25616    ///
25617    /// Sets the channel to shutdown if an error occurs.
25618    pub fn send(
25619        self,
25620        mut result: Result<(), fidl_fuchsia_posix::Errno>,
25621    ) -> Result<(), fidl::Error> {
25622        let _result = self.send_raw(result);
25623        if _result.is_err() {
25624            self.control_handle.shutdown();
25625        }
25626        self.drop_without_shutdown();
25627        _result
25628    }
25629
25630    /// Similar to "send" but does not shutdown the channel if an error occurs.
25631    pub fn send_no_shutdown_on_err(
25632        self,
25633        mut result: Result<(), fidl_fuchsia_posix::Errno>,
25634    ) -> Result<(), fidl::Error> {
25635        let _result = self.send_raw(result);
25636        self.drop_without_shutdown();
25637        _result
25638    }
25639
25640    fn send_raw(
25641        &self,
25642        mut result: Result<(), fidl_fuchsia_posix::Errno>,
25643    ) -> Result<(), fidl::Error> {
25644        self.control_handle.inner.send::<fidl::encoding::ResultType<
25645            fidl::encoding::EmptyStruct,
25646            fidl_fuchsia_posix::Errno,
25647        >>(
25648            result,
25649            self.tx_id,
25650            0x2888f3099188d03,
25651            fidl::encoding::DynamicFlags::empty(),
25652        )
25653    }
25654}
25655
25656#[must_use = "FIDL methods require a response to be sent"]
25657#[derive(Debug)]
25658pub struct BaseNetworkSocketSetIpTransparentResponder {
25659    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
25660    tx_id: u32,
25661}
25662
25663/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
25664/// if the responder is dropped without sending a response, so that the client
25665/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
25666impl std::ops::Drop for BaseNetworkSocketSetIpTransparentResponder {
25667    fn drop(&mut self) {
25668        self.control_handle.shutdown();
25669        // Safety: drops once, never accessed again
25670        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25671    }
25672}
25673
25674impl fidl::endpoints::Responder for BaseNetworkSocketSetIpTransparentResponder {
25675    type ControlHandle = BaseNetworkSocketControlHandle;
25676
25677    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
25678        &self.control_handle
25679    }
25680
25681    fn drop_without_shutdown(mut self) {
25682        // Safety: drops once, never accessed again due to mem::forget
25683        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25684        // Prevent Drop from running (which would shut down the channel)
25685        std::mem::forget(self);
25686    }
25687}
25688
25689impl BaseNetworkSocketSetIpTransparentResponder {
25690    /// Sends a response to the FIDL transaction.
25691    ///
25692    /// Sets the channel to shutdown if an error occurs.
25693    pub fn send(
25694        self,
25695        mut result: Result<(), fidl_fuchsia_posix::Errno>,
25696    ) -> Result<(), fidl::Error> {
25697        let _result = self.send_raw(result);
25698        if _result.is_err() {
25699            self.control_handle.shutdown();
25700        }
25701        self.drop_without_shutdown();
25702        _result
25703    }
25704
25705    /// Similar to "send" but does not shutdown the channel if an error occurs.
25706    pub fn send_no_shutdown_on_err(
25707        self,
25708        mut result: Result<(), fidl_fuchsia_posix::Errno>,
25709    ) -> Result<(), fidl::Error> {
25710        let _result = self.send_raw(result);
25711        self.drop_without_shutdown();
25712        _result
25713    }
25714
25715    fn send_raw(
25716        &self,
25717        mut result: Result<(), fidl_fuchsia_posix::Errno>,
25718    ) -> Result<(), fidl::Error> {
25719        self.control_handle.inner.send::<fidl::encoding::ResultType<
25720            fidl::encoding::EmptyStruct,
25721            fidl_fuchsia_posix::Errno,
25722        >>(
25723            result,
25724            self.tx_id,
25725            0x1ae532b0c066e3a0,
25726            fidl::encoding::DynamicFlags::empty(),
25727        )
25728    }
25729}
25730
25731#[must_use = "FIDL methods require a response to be sent"]
25732#[derive(Debug)]
25733pub struct BaseNetworkSocketGetIpTransparentResponder {
25734    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
25735    tx_id: u32,
25736}
25737
25738/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
25739/// if the responder is dropped without sending a response, so that the client
25740/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
25741impl std::ops::Drop for BaseNetworkSocketGetIpTransparentResponder {
25742    fn drop(&mut self) {
25743        self.control_handle.shutdown();
25744        // Safety: drops once, never accessed again
25745        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25746    }
25747}
25748
25749impl fidl::endpoints::Responder for BaseNetworkSocketGetIpTransparentResponder {
25750    type ControlHandle = BaseNetworkSocketControlHandle;
25751
25752    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
25753        &self.control_handle
25754    }
25755
25756    fn drop_without_shutdown(mut self) {
25757        // Safety: drops once, never accessed again due to mem::forget
25758        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25759        // Prevent Drop from running (which would shut down the channel)
25760        std::mem::forget(self);
25761    }
25762}
25763
25764impl BaseNetworkSocketGetIpTransparentResponder {
25765    /// Sends a response to the FIDL transaction.
25766    ///
25767    /// Sets the channel to shutdown if an error occurs.
25768    pub fn send(
25769        self,
25770        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
25771    ) -> Result<(), fidl::Error> {
25772        let _result = self.send_raw(result);
25773        if _result.is_err() {
25774            self.control_handle.shutdown();
25775        }
25776        self.drop_without_shutdown();
25777        _result
25778    }
25779
25780    /// Similar to "send" but does not shutdown the channel if an error occurs.
25781    pub fn send_no_shutdown_on_err(
25782        self,
25783        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
25784    ) -> Result<(), fidl::Error> {
25785        let _result = self.send_raw(result);
25786        self.drop_without_shutdown();
25787        _result
25788    }
25789
25790    fn send_raw(
25791        &self,
25792        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
25793    ) -> Result<(), fidl::Error> {
25794        self.control_handle.inner.send::<fidl::encoding::ResultType<
25795            BaseNetworkSocketGetIpTransparentResponse,
25796            fidl_fuchsia_posix::Errno,
25797        >>(
25798            result.map(|value| (value,)),
25799            self.tx_id,
25800            0x51d43695962ebfb5,
25801            fidl::encoding::DynamicFlags::empty(),
25802        )
25803    }
25804}
25805
25806#[must_use = "FIDL methods require a response to be sent"]
25807#[derive(Debug)]
25808pub struct BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResponder {
25809    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
25810    tx_id: u32,
25811}
25812
25813/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
25814/// if the responder is dropped without sending a response, so that the client
25815/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
25816impl std::ops::Drop for BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResponder {
25817    fn drop(&mut self) {
25818        self.control_handle.shutdown();
25819        // Safety: drops once, never accessed again
25820        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25821    }
25822}
25823
25824impl fidl::endpoints::Responder
25825    for BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResponder
25826{
25827    type ControlHandle = BaseNetworkSocketControlHandle;
25828
25829    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
25830        &self.control_handle
25831    }
25832
25833    fn drop_without_shutdown(mut self) {
25834        // Safety: drops once, never accessed again due to mem::forget
25835        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25836        // Prevent Drop from running (which would shut down the channel)
25837        std::mem::forget(self);
25838    }
25839}
25840
25841impl BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResponder {
25842    /// Sends a response to the FIDL transaction.
25843    ///
25844    /// Sets the channel to shutdown if an error occurs.
25845    pub fn send(
25846        self,
25847        mut result: Result<(), fidl_fuchsia_posix::Errno>,
25848    ) -> Result<(), fidl::Error> {
25849        let _result = self.send_raw(result);
25850        if _result.is_err() {
25851            self.control_handle.shutdown();
25852        }
25853        self.drop_without_shutdown();
25854        _result
25855    }
25856
25857    /// Similar to "send" but does not shutdown the channel if an error occurs.
25858    pub fn send_no_shutdown_on_err(
25859        self,
25860        mut result: Result<(), fidl_fuchsia_posix::Errno>,
25861    ) -> Result<(), fidl::Error> {
25862        let _result = self.send_raw(result);
25863        self.drop_without_shutdown();
25864        _result
25865    }
25866
25867    fn send_raw(
25868        &self,
25869        mut result: Result<(), fidl_fuchsia_posix::Errno>,
25870    ) -> Result<(), fidl::Error> {
25871        self.control_handle.inner.send::<fidl::encoding::ResultType<
25872            fidl::encoding::EmptyStruct,
25873            fidl_fuchsia_posix::Errno,
25874        >>(
25875            result,
25876            self.tx_id,
25877            0x4722b4ce52f7840,
25878            fidl::encoding::DynamicFlags::empty(),
25879        )
25880    }
25881}
25882
25883#[must_use = "FIDL methods require a response to be sent"]
25884#[derive(Debug)]
25885pub struct BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponder {
25886    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
25887    tx_id: u32,
25888}
25889
25890/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
25891/// if the responder is dropped without sending a response, so that the client
25892/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
25893impl std::ops::Drop for BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponder {
25894    fn drop(&mut self) {
25895        self.control_handle.shutdown();
25896        // Safety: drops once, never accessed again
25897        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25898    }
25899}
25900
25901impl fidl::endpoints::Responder
25902    for BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponder
25903{
25904    type ControlHandle = BaseNetworkSocketControlHandle;
25905
25906    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
25907        &self.control_handle
25908    }
25909
25910    fn drop_without_shutdown(mut self) {
25911        // Safety: drops once, never accessed again due to mem::forget
25912        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25913        // Prevent Drop from running (which would shut down the channel)
25914        std::mem::forget(self);
25915    }
25916}
25917
25918impl BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponder {
25919    /// Sends a response to the FIDL transaction.
25920    ///
25921    /// Sets the channel to shutdown if an error occurs.
25922    pub fn send(
25923        self,
25924        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
25925    ) -> Result<(), fidl::Error> {
25926        let _result = self.send_raw(result);
25927        if _result.is_err() {
25928            self.control_handle.shutdown();
25929        }
25930        self.drop_without_shutdown();
25931        _result
25932    }
25933
25934    /// Similar to "send" but does not shutdown the channel if an error occurs.
25935    pub fn send_no_shutdown_on_err(
25936        self,
25937        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
25938    ) -> Result<(), fidl::Error> {
25939        let _result = self.send_raw(result);
25940        self.drop_without_shutdown();
25941        _result
25942    }
25943
25944    fn send_raw(
25945        &self,
25946        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
25947    ) -> Result<(), fidl::Error> {
25948        self.control_handle.inner.send::<fidl::encoding::ResultType<
25949            BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
25950            fidl_fuchsia_posix::Errno,
25951        >>(
25952            result.map(|value| (value,)),
25953            self.tx_id,
25954            0x2a0e7dc5d6bfdfe9,
25955            fidl::encoding::DynamicFlags::empty(),
25956        )
25957    }
25958}
25959
25960#[must_use = "FIDL methods require a response to be sent"]
25961#[derive(Debug)]
25962pub struct BaseNetworkSocketAddIpv6MembershipResponder {
25963    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
25964    tx_id: u32,
25965}
25966
25967/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
25968/// if the responder is dropped without sending a response, so that the client
25969/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
25970impl std::ops::Drop for BaseNetworkSocketAddIpv6MembershipResponder {
25971    fn drop(&mut self) {
25972        self.control_handle.shutdown();
25973        // Safety: drops once, never accessed again
25974        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25975    }
25976}
25977
25978impl fidl::endpoints::Responder for BaseNetworkSocketAddIpv6MembershipResponder {
25979    type ControlHandle = BaseNetworkSocketControlHandle;
25980
25981    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
25982        &self.control_handle
25983    }
25984
25985    fn drop_without_shutdown(mut self) {
25986        // Safety: drops once, never accessed again due to mem::forget
25987        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
25988        // Prevent Drop from running (which would shut down the channel)
25989        std::mem::forget(self);
25990    }
25991}
25992
25993impl BaseNetworkSocketAddIpv6MembershipResponder {
25994    /// Sends a response to the FIDL transaction.
25995    ///
25996    /// Sets the channel to shutdown if an error occurs.
25997    pub fn send(
25998        self,
25999        mut result: Result<(), fidl_fuchsia_posix::Errno>,
26000    ) -> Result<(), fidl::Error> {
26001        let _result = self.send_raw(result);
26002        if _result.is_err() {
26003            self.control_handle.shutdown();
26004        }
26005        self.drop_without_shutdown();
26006        _result
26007    }
26008
26009    /// Similar to "send" but does not shutdown the channel if an error occurs.
26010    pub fn send_no_shutdown_on_err(
26011        self,
26012        mut result: Result<(), fidl_fuchsia_posix::Errno>,
26013    ) -> Result<(), fidl::Error> {
26014        let _result = self.send_raw(result);
26015        self.drop_without_shutdown();
26016        _result
26017    }
26018
26019    fn send_raw(
26020        &self,
26021        mut result: Result<(), fidl_fuchsia_posix::Errno>,
26022    ) -> Result<(), fidl::Error> {
26023        self.control_handle.inner.send::<fidl::encoding::ResultType<
26024            fidl::encoding::EmptyStruct,
26025            fidl_fuchsia_posix::Errno,
26026        >>(
26027            result,
26028            self.tx_id,
26029            0x7c94727acb4ea4b3,
26030            fidl::encoding::DynamicFlags::empty(),
26031        )
26032    }
26033}
26034
26035#[must_use = "FIDL methods require a response to be sent"]
26036#[derive(Debug)]
26037pub struct BaseNetworkSocketDropIpv6MembershipResponder {
26038    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
26039    tx_id: u32,
26040}
26041
26042/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
26043/// if the responder is dropped without sending a response, so that the client
26044/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
26045impl std::ops::Drop for BaseNetworkSocketDropIpv6MembershipResponder {
26046    fn drop(&mut self) {
26047        self.control_handle.shutdown();
26048        // Safety: drops once, never accessed again
26049        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26050    }
26051}
26052
26053impl fidl::endpoints::Responder for BaseNetworkSocketDropIpv6MembershipResponder {
26054    type ControlHandle = BaseNetworkSocketControlHandle;
26055
26056    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
26057        &self.control_handle
26058    }
26059
26060    fn drop_without_shutdown(mut self) {
26061        // Safety: drops once, never accessed again due to mem::forget
26062        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26063        // Prevent Drop from running (which would shut down the channel)
26064        std::mem::forget(self);
26065    }
26066}
26067
26068impl BaseNetworkSocketDropIpv6MembershipResponder {
26069    /// Sends a response to the FIDL transaction.
26070    ///
26071    /// Sets the channel to shutdown if an error occurs.
26072    pub fn send(
26073        self,
26074        mut result: Result<(), fidl_fuchsia_posix::Errno>,
26075    ) -> Result<(), fidl::Error> {
26076        let _result = self.send_raw(result);
26077        if _result.is_err() {
26078            self.control_handle.shutdown();
26079        }
26080        self.drop_without_shutdown();
26081        _result
26082    }
26083
26084    /// Similar to "send" but does not shutdown the channel if an error occurs.
26085    pub fn send_no_shutdown_on_err(
26086        self,
26087        mut result: Result<(), fidl_fuchsia_posix::Errno>,
26088    ) -> Result<(), fidl::Error> {
26089        let _result = self.send_raw(result);
26090        self.drop_without_shutdown();
26091        _result
26092    }
26093
26094    fn send_raw(
26095        &self,
26096        mut result: Result<(), fidl_fuchsia_posix::Errno>,
26097    ) -> Result<(), fidl::Error> {
26098        self.control_handle.inner.send::<fidl::encoding::ResultType<
26099            fidl::encoding::EmptyStruct,
26100            fidl_fuchsia_posix::Errno,
26101        >>(
26102            result,
26103            self.tx_id,
26104            0x42104c70ccaba304,
26105            fidl::encoding::DynamicFlags::empty(),
26106        )
26107    }
26108}
26109
26110#[must_use = "FIDL methods require a response to be sent"]
26111#[derive(Debug)]
26112pub struct BaseNetworkSocketSetIpv6MulticastInterfaceResponder {
26113    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
26114    tx_id: u32,
26115}
26116
26117/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
26118/// if the responder is dropped without sending a response, so that the client
26119/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
26120impl std::ops::Drop for BaseNetworkSocketSetIpv6MulticastInterfaceResponder {
26121    fn drop(&mut self) {
26122        self.control_handle.shutdown();
26123        // Safety: drops once, never accessed again
26124        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26125    }
26126}
26127
26128impl fidl::endpoints::Responder for BaseNetworkSocketSetIpv6MulticastInterfaceResponder {
26129    type ControlHandle = BaseNetworkSocketControlHandle;
26130
26131    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
26132        &self.control_handle
26133    }
26134
26135    fn drop_without_shutdown(mut self) {
26136        // Safety: drops once, never accessed again due to mem::forget
26137        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26138        // Prevent Drop from running (which would shut down the channel)
26139        std::mem::forget(self);
26140    }
26141}
26142
26143impl BaseNetworkSocketSetIpv6MulticastInterfaceResponder {
26144    /// Sends a response to the FIDL transaction.
26145    ///
26146    /// Sets the channel to shutdown if an error occurs.
26147    pub fn send(
26148        self,
26149        mut result: Result<(), fidl_fuchsia_posix::Errno>,
26150    ) -> Result<(), fidl::Error> {
26151        let _result = self.send_raw(result);
26152        if _result.is_err() {
26153            self.control_handle.shutdown();
26154        }
26155        self.drop_without_shutdown();
26156        _result
26157    }
26158
26159    /// Similar to "send" but does not shutdown the channel if an error occurs.
26160    pub fn send_no_shutdown_on_err(
26161        self,
26162        mut result: Result<(), fidl_fuchsia_posix::Errno>,
26163    ) -> Result<(), fidl::Error> {
26164        let _result = self.send_raw(result);
26165        self.drop_without_shutdown();
26166        _result
26167    }
26168
26169    fn send_raw(
26170        &self,
26171        mut result: Result<(), fidl_fuchsia_posix::Errno>,
26172    ) -> Result<(), fidl::Error> {
26173        self.control_handle.inner.send::<fidl::encoding::ResultType<
26174            fidl::encoding::EmptyStruct,
26175            fidl_fuchsia_posix::Errno,
26176        >>(
26177            result,
26178            self.tx_id,
26179            0x135f76db3774ab3b,
26180            fidl::encoding::DynamicFlags::empty(),
26181        )
26182    }
26183}
26184
26185#[must_use = "FIDL methods require a response to be sent"]
26186#[derive(Debug)]
26187pub struct BaseNetworkSocketGetIpv6MulticastInterfaceResponder {
26188    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
26189    tx_id: u32,
26190}
26191
26192/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
26193/// if the responder is dropped without sending a response, so that the client
26194/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
26195impl std::ops::Drop for BaseNetworkSocketGetIpv6MulticastInterfaceResponder {
26196    fn drop(&mut self) {
26197        self.control_handle.shutdown();
26198        // Safety: drops once, never accessed again
26199        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26200    }
26201}
26202
26203impl fidl::endpoints::Responder for BaseNetworkSocketGetIpv6MulticastInterfaceResponder {
26204    type ControlHandle = BaseNetworkSocketControlHandle;
26205
26206    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
26207        &self.control_handle
26208    }
26209
26210    fn drop_without_shutdown(mut self) {
26211        // Safety: drops once, never accessed again due to mem::forget
26212        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26213        // Prevent Drop from running (which would shut down the channel)
26214        std::mem::forget(self);
26215    }
26216}
26217
26218impl BaseNetworkSocketGetIpv6MulticastInterfaceResponder {
26219    /// Sends a response to the FIDL transaction.
26220    ///
26221    /// Sets the channel to shutdown if an error occurs.
26222    pub fn send(
26223        self,
26224        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
26225    ) -> Result<(), fidl::Error> {
26226        let _result = self.send_raw(result);
26227        if _result.is_err() {
26228            self.control_handle.shutdown();
26229        }
26230        self.drop_without_shutdown();
26231        _result
26232    }
26233
26234    /// Similar to "send" but does not shutdown the channel if an error occurs.
26235    pub fn send_no_shutdown_on_err(
26236        self,
26237        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
26238    ) -> Result<(), fidl::Error> {
26239        let _result = self.send_raw(result);
26240        self.drop_without_shutdown();
26241        _result
26242    }
26243
26244    fn send_raw(
26245        &self,
26246        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
26247    ) -> Result<(), fidl::Error> {
26248        self.control_handle.inner.send::<fidl::encoding::ResultType<
26249            BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
26250            fidl_fuchsia_posix::Errno,
26251        >>(
26252            result.map(|value| (value,)),
26253            self.tx_id,
26254            0x1f26fcdd348f1882,
26255            fidl::encoding::DynamicFlags::empty(),
26256        )
26257    }
26258}
26259
26260#[must_use = "FIDL methods require a response to be sent"]
26261#[derive(Debug)]
26262pub struct BaseNetworkSocketSetIpv6UnicastHopsResponder {
26263    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
26264    tx_id: u32,
26265}
26266
26267/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
26268/// if the responder is dropped without sending a response, so that the client
26269/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
26270impl std::ops::Drop for BaseNetworkSocketSetIpv6UnicastHopsResponder {
26271    fn drop(&mut self) {
26272        self.control_handle.shutdown();
26273        // Safety: drops once, never accessed again
26274        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26275    }
26276}
26277
26278impl fidl::endpoints::Responder for BaseNetworkSocketSetIpv6UnicastHopsResponder {
26279    type ControlHandle = BaseNetworkSocketControlHandle;
26280
26281    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
26282        &self.control_handle
26283    }
26284
26285    fn drop_without_shutdown(mut self) {
26286        // Safety: drops once, never accessed again due to mem::forget
26287        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26288        // Prevent Drop from running (which would shut down the channel)
26289        std::mem::forget(self);
26290    }
26291}
26292
26293impl BaseNetworkSocketSetIpv6UnicastHopsResponder {
26294    /// Sends a response to the FIDL transaction.
26295    ///
26296    /// Sets the channel to shutdown if an error occurs.
26297    pub fn send(
26298        self,
26299        mut result: Result<(), fidl_fuchsia_posix::Errno>,
26300    ) -> Result<(), fidl::Error> {
26301        let _result = self.send_raw(result);
26302        if _result.is_err() {
26303            self.control_handle.shutdown();
26304        }
26305        self.drop_without_shutdown();
26306        _result
26307    }
26308
26309    /// Similar to "send" but does not shutdown the channel if an error occurs.
26310    pub fn send_no_shutdown_on_err(
26311        self,
26312        mut result: Result<(), fidl_fuchsia_posix::Errno>,
26313    ) -> Result<(), fidl::Error> {
26314        let _result = self.send_raw(result);
26315        self.drop_without_shutdown();
26316        _result
26317    }
26318
26319    fn send_raw(
26320        &self,
26321        mut result: Result<(), fidl_fuchsia_posix::Errno>,
26322    ) -> Result<(), fidl::Error> {
26323        self.control_handle.inner.send::<fidl::encoding::ResultType<
26324            fidl::encoding::EmptyStruct,
26325            fidl_fuchsia_posix::Errno,
26326        >>(
26327            result,
26328            self.tx_id,
26329            0x157d51e98f462859,
26330            fidl::encoding::DynamicFlags::empty(),
26331        )
26332    }
26333}
26334
26335#[must_use = "FIDL methods require a response to be sent"]
26336#[derive(Debug)]
26337pub struct BaseNetworkSocketGetIpv6UnicastHopsResponder {
26338    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
26339    tx_id: u32,
26340}
26341
26342/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
26343/// if the responder is dropped without sending a response, so that the client
26344/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
26345impl std::ops::Drop for BaseNetworkSocketGetIpv6UnicastHopsResponder {
26346    fn drop(&mut self) {
26347        self.control_handle.shutdown();
26348        // Safety: drops once, never accessed again
26349        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26350    }
26351}
26352
26353impl fidl::endpoints::Responder for BaseNetworkSocketGetIpv6UnicastHopsResponder {
26354    type ControlHandle = BaseNetworkSocketControlHandle;
26355
26356    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
26357        &self.control_handle
26358    }
26359
26360    fn drop_without_shutdown(mut self) {
26361        // Safety: drops once, never accessed again due to mem::forget
26362        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26363        // Prevent Drop from running (which would shut down the channel)
26364        std::mem::forget(self);
26365    }
26366}
26367
26368impl BaseNetworkSocketGetIpv6UnicastHopsResponder {
26369    /// Sends a response to the FIDL transaction.
26370    ///
26371    /// Sets the channel to shutdown if an error occurs.
26372    pub fn send(
26373        self,
26374        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
26375    ) -> Result<(), fidl::Error> {
26376        let _result = self.send_raw(result);
26377        if _result.is_err() {
26378            self.control_handle.shutdown();
26379        }
26380        self.drop_without_shutdown();
26381        _result
26382    }
26383
26384    /// Similar to "send" but does not shutdown the channel if an error occurs.
26385    pub fn send_no_shutdown_on_err(
26386        self,
26387        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
26388    ) -> Result<(), fidl::Error> {
26389        let _result = self.send_raw(result);
26390        self.drop_without_shutdown();
26391        _result
26392    }
26393
26394    fn send_raw(
26395        &self,
26396        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
26397    ) -> Result<(), fidl::Error> {
26398        self.control_handle.inner.send::<fidl::encoding::ResultType<
26399            BaseNetworkSocketGetIpv6UnicastHopsResponse,
26400            fidl_fuchsia_posix::Errno,
26401        >>(
26402            result.map(|value| (value,)),
26403            self.tx_id,
26404            0x21f4641cad8bd8d2,
26405            fidl::encoding::DynamicFlags::empty(),
26406        )
26407    }
26408}
26409
26410#[must_use = "FIDL methods require a response to be sent"]
26411#[derive(Debug)]
26412pub struct BaseNetworkSocketSetIpv6ReceiveHopLimitResponder {
26413    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
26414    tx_id: u32,
26415}
26416
26417/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
26418/// if the responder is dropped without sending a response, so that the client
26419/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
26420impl std::ops::Drop for BaseNetworkSocketSetIpv6ReceiveHopLimitResponder {
26421    fn drop(&mut self) {
26422        self.control_handle.shutdown();
26423        // Safety: drops once, never accessed again
26424        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26425    }
26426}
26427
26428impl fidl::endpoints::Responder for BaseNetworkSocketSetIpv6ReceiveHopLimitResponder {
26429    type ControlHandle = BaseNetworkSocketControlHandle;
26430
26431    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
26432        &self.control_handle
26433    }
26434
26435    fn drop_without_shutdown(mut self) {
26436        // Safety: drops once, never accessed again due to mem::forget
26437        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26438        // Prevent Drop from running (which would shut down the channel)
26439        std::mem::forget(self);
26440    }
26441}
26442
26443impl BaseNetworkSocketSetIpv6ReceiveHopLimitResponder {
26444    /// Sends a response to the FIDL transaction.
26445    ///
26446    /// Sets the channel to shutdown if an error occurs.
26447    pub fn send(
26448        self,
26449        mut result: Result<(), fidl_fuchsia_posix::Errno>,
26450    ) -> Result<(), fidl::Error> {
26451        let _result = self.send_raw(result);
26452        if _result.is_err() {
26453            self.control_handle.shutdown();
26454        }
26455        self.drop_without_shutdown();
26456        _result
26457    }
26458
26459    /// Similar to "send" but does not shutdown the channel if an error occurs.
26460    pub fn send_no_shutdown_on_err(
26461        self,
26462        mut result: Result<(), fidl_fuchsia_posix::Errno>,
26463    ) -> Result<(), fidl::Error> {
26464        let _result = self.send_raw(result);
26465        self.drop_without_shutdown();
26466        _result
26467    }
26468
26469    fn send_raw(
26470        &self,
26471        mut result: Result<(), fidl_fuchsia_posix::Errno>,
26472    ) -> Result<(), fidl::Error> {
26473        self.control_handle.inner.send::<fidl::encoding::ResultType<
26474            fidl::encoding::EmptyStruct,
26475            fidl_fuchsia_posix::Errno,
26476        >>(
26477            result,
26478            self.tx_id,
26479            0x5c24808ed2e84a1e,
26480            fidl::encoding::DynamicFlags::empty(),
26481        )
26482    }
26483}
26484
26485#[must_use = "FIDL methods require a response to be sent"]
26486#[derive(Debug)]
26487pub struct BaseNetworkSocketGetIpv6ReceiveHopLimitResponder {
26488    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
26489    tx_id: u32,
26490}
26491
26492/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
26493/// if the responder is dropped without sending a response, so that the client
26494/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
26495impl std::ops::Drop for BaseNetworkSocketGetIpv6ReceiveHopLimitResponder {
26496    fn drop(&mut self) {
26497        self.control_handle.shutdown();
26498        // Safety: drops once, never accessed again
26499        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26500    }
26501}
26502
26503impl fidl::endpoints::Responder for BaseNetworkSocketGetIpv6ReceiveHopLimitResponder {
26504    type ControlHandle = BaseNetworkSocketControlHandle;
26505
26506    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
26507        &self.control_handle
26508    }
26509
26510    fn drop_without_shutdown(mut self) {
26511        // Safety: drops once, never accessed again due to mem::forget
26512        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26513        // Prevent Drop from running (which would shut down the channel)
26514        std::mem::forget(self);
26515    }
26516}
26517
26518impl BaseNetworkSocketGetIpv6ReceiveHopLimitResponder {
26519    /// Sends a response to the FIDL transaction.
26520    ///
26521    /// Sets the channel to shutdown if an error occurs.
26522    pub fn send(
26523        self,
26524        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
26525    ) -> Result<(), fidl::Error> {
26526        let _result = self.send_raw(result);
26527        if _result.is_err() {
26528            self.control_handle.shutdown();
26529        }
26530        self.drop_without_shutdown();
26531        _result
26532    }
26533
26534    /// Similar to "send" but does not shutdown the channel if an error occurs.
26535    pub fn send_no_shutdown_on_err(
26536        self,
26537        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
26538    ) -> Result<(), fidl::Error> {
26539        let _result = self.send_raw(result);
26540        self.drop_without_shutdown();
26541        _result
26542    }
26543
26544    fn send_raw(
26545        &self,
26546        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
26547    ) -> Result<(), fidl::Error> {
26548        self.control_handle.inner.send::<fidl::encoding::ResultType<
26549            BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
26550            fidl_fuchsia_posix::Errno,
26551        >>(
26552            result.map(|value| (value,)),
26553            self.tx_id,
26554            0x341e06689885b4c0,
26555            fidl::encoding::DynamicFlags::empty(),
26556        )
26557    }
26558}
26559
26560#[must_use = "FIDL methods require a response to be sent"]
26561#[derive(Debug)]
26562pub struct BaseNetworkSocketSetIpv6MulticastHopsResponder {
26563    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
26564    tx_id: u32,
26565}
26566
26567/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
26568/// if the responder is dropped without sending a response, so that the client
26569/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
26570impl std::ops::Drop for BaseNetworkSocketSetIpv6MulticastHopsResponder {
26571    fn drop(&mut self) {
26572        self.control_handle.shutdown();
26573        // Safety: drops once, never accessed again
26574        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26575    }
26576}
26577
26578impl fidl::endpoints::Responder for BaseNetworkSocketSetIpv6MulticastHopsResponder {
26579    type ControlHandle = BaseNetworkSocketControlHandle;
26580
26581    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
26582        &self.control_handle
26583    }
26584
26585    fn drop_without_shutdown(mut self) {
26586        // Safety: drops once, never accessed again due to mem::forget
26587        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26588        // Prevent Drop from running (which would shut down the channel)
26589        std::mem::forget(self);
26590    }
26591}
26592
26593impl BaseNetworkSocketSetIpv6MulticastHopsResponder {
26594    /// Sends a response to the FIDL transaction.
26595    ///
26596    /// Sets the channel to shutdown if an error occurs.
26597    pub fn send(
26598        self,
26599        mut result: Result<(), fidl_fuchsia_posix::Errno>,
26600    ) -> Result<(), fidl::Error> {
26601        let _result = self.send_raw(result);
26602        if _result.is_err() {
26603            self.control_handle.shutdown();
26604        }
26605        self.drop_without_shutdown();
26606        _result
26607    }
26608
26609    /// Similar to "send" but does not shutdown the channel if an error occurs.
26610    pub fn send_no_shutdown_on_err(
26611        self,
26612        mut result: Result<(), fidl_fuchsia_posix::Errno>,
26613    ) -> Result<(), fidl::Error> {
26614        let _result = self.send_raw(result);
26615        self.drop_without_shutdown();
26616        _result
26617    }
26618
26619    fn send_raw(
26620        &self,
26621        mut result: Result<(), fidl_fuchsia_posix::Errno>,
26622    ) -> Result<(), fidl::Error> {
26623        self.control_handle.inner.send::<fidl::encoding::ResultType<
26624            fidl::encoding::EmptyStruct,
26625            fidl_fuchsia_posix::Errno,
26626        >>(
26627            result,
26628            self.tx_id,
26629            0x25b9cd4d181f82c1,
26630            fidl::encoding::DynamicFlags::empty(),
26631        )
26632    }
26633}
26634
26635#[must_use = "FIDL methods require a response to be sent"]
26636#[derive(Debug)]
26637pub struct BaseNetworkSocketGetIpv6MulticastHopsResponder {
26638    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
26639    tx_id: u32,
26640}
26641
26642/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
26643/// if the responder is dropped without sending a response, so that the client
26644/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
26645impl std::ops::Drop for BaseNetworkSocketGetIpv6MulticastHopsResponder {
26646    fn drop(&mut self) {
26647        self.control_handle.shutdown();
26648        // Safety: drops once, never accessed again
26649        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26650    }
26651}
26652
26653impl fidl::endpoints::Responder for BaseNetworkSocketGetIpv6MulticastHopsResponder {
26654    type ControlHandle = BaseNetworkSocketControlHandle;
26655
26656    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
26657        &self.control_handle
26658    }
26659
26660    fn drop_without_shutdown(mut self) {
26661        // Safety: drops once, never accessed again due to mem::forget
26662        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26663        // Prevent Drop from running (which would shut down the channel)
26664        std::mem::forget(self);
26665    }
26666}
26667
26668impl BaseNetworkSocketGetIpv6MulticastHopsResponder {
26669    /// Sends a response to the FIDL transaction.
26670    ///
26671    /// Sets the channel to shutdown if an error occurs.
26672    pub fn send(
26673        self,
26674        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
26675    ) -> Result<(), fidl::Error> {
26676        let _result = self.send_raw(result);
26677        if _result.is_err() {
26678            self.control_handle.shutdown();
26679        }
26680        self.drop_without_shutdown();
26681        _result
26682    }
26683
26684    /// Similar to "send" but does not shutdown the channel if an error occurs.
26685    pub fn send_no_shutdown_on_err(
26686        self,
26687        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
26688    ) -> Result<(), fidl::Error> {
26689        let _result = self.send_raw(result);
26690        self.drop_without_shutdown();
26691        _result
26692    }
26693
26694    fn send_raw(
26695        &self,
26696        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
26697    ) -> Result<(), fidl::Error> {
26698        self.control_handle.inner.send::<fidl::encoding::ResultType<
26699            BaseNetworkSocketGetIpv6MulticastHopsResponse,
26700            fidl_fuchsia_posix::Errno,
26701        >>(
26702            result.map(|value| (value,)),
26703            self.tx_id,
26704            0x52916948a365012a,
26705            fidl::encoding::DynamicFlags::empty(),
26706        )
26707    }
26708}
26709
26710#[must_use = "FIDL methods require a response to be sent"]
26711#[derive(Debug)]
26712pub struct BaseNetworkSocketSetIpv6MulticastLoopbackResponder {
26713    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
26714    tx_id: u32,
26715}
26716
26717/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
26718/// if the responder is dropped without sending a response, so that the client
26719/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
26720impl std::ops::Drop for BaseNetworkSocketSetIpv6MulticastLoopbackResponder {
26721    fn drop(&mut self) {
26722        self.control_handle.shutdown();
26723        // Safety: drops once, never accessed again
26724        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26725    }
26726}
26727
26728impl fidl::endpoints::Responder for BaseNetworkSocketSetIpv6MulticastLoopbackResponder {
26729    type ControlHandle = BaseNetworkSocketControlHandle;
26730
26731    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
26732        &self.control_handle
26733    }
26734
26735    fn drop_without_shutdown(mut self) {
26736        // Safety: drops once, never accessed again due to mem::forget
26737        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26738        // Prevent Drop from running (which would shut down the channel)
26739        std::mem::forget(self);
26740    }
26741}
26742
26743impl BaseNetworkSocketSetIpv6MulticastLoopbackResponder {
26744    /// Sends a response to the FIDL transaction.
26745    ///
26746    /// Sets the channel to shutdown if an error occurs.
26747    pub fn send(
26748        self,
26749        mut result: Result<(), fidl_fuchsia_posix::Errno>,
26750    ) -> Result<(), fidl::Error> {
26751        let _result = self.send_raw(result);
26752        if _result.is_err() {
26753            self.control_handle.shutdown();
26754        }
26755        self.drop_without_shutdown();
26756        _result
26757    }
26758
26759    /// Similar to "send" but does not shutdown the channel if an error occurs.
26760    pub fn send_no_shutdown_on_err(
26761        self,
26762        mut result: Result<(), fidl_fuchsia_posix::Errno>,
26763    ) -> Result<(), fidl::Error> {
26764        let _result = self.send_raw(result);
26765        self.drop_without_shutdown();
26766        _result
26767    }
26768
26769    fn send_raw(
26770        &self,
26771        mut result: Result<(), fidl_fuchsia_posix::Errno>,
26772    ) -> Result<(), fidl::Error> {
26773        self.control_handle.inner.send::<fidl::encoding::ResultType<
26774            fidl::encoding::EmptyStruct,
26775            fidl_fuchsia_posix::Errno,
26776        >>(
26777            result,
26778            self.tx_id,
26779            0x55701c409ff41b40,
26780            fidl::encoding::DynamicFlags::empty(),
26781        )
26782    }
26783}
26784
26785#[must_use = "FIDL methods require a response to be sent"]
26786#[derive(Debug)]
26787pub struct BaseNetworkSocketGetIpv6MulticastLoopbackResponder {
26788    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
26789    tx_id: u32,
26790}
26791
26792/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
26793/// if the responder is dropped without sending a response, so that the client
26794/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
26795impl std::ops::Drop for BaseNetworkSocketGetIpv6MulticastLoopbackResponder {
26796    fn drop(&mut self) {
26797        self.control_handle.shutdown();
26798        // Safety: drops once, never accessed again
26799        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26800    }
26801}
26802
26803impl fidl::endpoints::Responder for BaseNetworkSocketGetIpv6MulticastLoopbackResponder {
26804    type ControlHandle = BaseNetworkSocketControlHandle;
26805
26806    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
26807        &self.control_handle
26808    }
26809
26810    fn drop_without_shutdown(mut self) {
26811        // Safety: drops once, never accessed again due to mem::forget
26812        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26813        // Prevent Drop from running (which would shut down the channel)
26814        std::mem::forget(self);
26815    }
26816}
26817
26818impl BaseNetworkSocketGetIpv6MulticastLoopbackResponder {
26819    /// Sends a response to the FIDL transaction.
26820    ///
26821    /// Sets the channel to shutdown if an error occurs.
26822    pub fn send(
26823        self,
26824        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
26825    ) -> Result<(), fidl::Error> {
26826        let _result = self.send_raw(result);
26827        if _result.is_err() {
26828            self.control_handle.shutdown();
26829        }
26830        self.drop_without_shutdown();
26831        _result
26832    }
26833
26834    /// Similar to "send" but does not shutdown the channel if an error occurs.
26835    pub fn send_no_shutdown_on_err(
26836        self,
26837        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
26838    ) -> Result<(), fidl::Error> {
26839        let _result = self.send_raw(result);
26840        self.drop_without_shutdown();
26841        _result
26842    }
26843
26844    fn send_raw(
26845        &self,
26846        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
26847    ) -> Result<(), fidl::Error> {
26848        self.control_handle.inner.send::<fidl::encoding::ResultType<
26849            BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
26850            fidl_fuchsia_posix::Errno,
26851        >>(
26852            result.map(|value| (value,)),
26853            self.tx_id,
26854            0x4415b701fde319c3,
26855            fidl::encoding::DynamicFlags::empty(),
26856        )
26857    }
26858}
26859
26860#[must_use = "FIDL methods require a response to be sent"]
26861#[derive(Debug)]
26862pub struct BaseNetworkSocketSetIpv6OnlyResponder {
26863    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
26864    tx_id: u32,
26865}
26866
26867/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
26868/// if the responder is dropped without sending a response, so that the client
26869/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
26870impl std::ops::Drop for BaseNetworkSocketSetIpv6OnlyResponder {
26871    fn drop(&mut self) {
26872        self.control_handle.shutdown();
26873        // Safety: drops once, never accessed again
26874        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26875    }
26876}
26877
26878impl fidl::endpoints::Responder for BaseNetworkSocketSetIpv6OnlyResponder {
26879    type ControlHandle = BaseNetworkSocketControlHandle;
26880
26881    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
26882        &self.control_handle
26883    }
26884
26885    fn drop_without_shutdown(mut self) {
26886        // Safety: drops once, never accessed again due to mem::forget
26887        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26888        // Prevent Drop from running (which would shut down the channel)
26889        std::mem::forget(self);
26890    }
26891}
26892
26893impl BaseNetworkSocketSetIpv6OnlyResponder {
26894    /// Sends a response to the FIDL transaction.
26895    ///
26896    /// Sets the channel to shutdown if an error occurs.
26897    pub fn send(
26898        self,
26899        mut result: Result<(), fidl_fuchsia_posix::Errno>,
26900    ) -> Result<(), fidl::Error> {
26901        let _result = self.send_raw(result);
26902        if _result.is_err() {
26903            self.control_handle.shutdown();
26904        }
26905        self.drop_without_shutdown();
26906        _result
26907    }
26908
26909    /// Similar to "send" but does not shutdown the channel if an error occurs.
26910    pub fn send_no_shutdown_on_err(
26911        self,
26912        mut result: Result<(), fidl_fuchsia_posix::Errno>,
26913    ) -> Result<(), fidl::Error> {
26914        let _result = self.send_raw(result);
26915        self.drop_without_shutdown();
26916        _result
26917    }
26918
26919    fn send_raw(
26920        &self,
26921        mut result: Result<(), fidl_fuchsia_posix::Errno>,
26922    ) -> Result<(), fidl::Error> {
26923        self.control_handle.inner.send::<fidl::encoding::ResultType<
26924            fidl::encoding::EmptyStruct,
26925            fidl_fuchsia_posix::Errno,
26926        >>(
26927            result,
26928            self.tx_id,
26929            0x4873f1364758cbba,
26930            fidl::encoding::DynamicFlags::empty(),
26931        )
26932    }
26933}
26934
26935#[must_use = "FIDL methods require a response to be sent"]
26936#[derive(Debug)]
26937pub struct BaseNetworkSocketGetIpv6OnlyResponder {
26938    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
26939    tx_id: u32,
26940}
26941
26942/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
26943/// if the responder is dropped without sending a response, so that the client
26944/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
26945impl std::ops::Drop for BaseNetworkSocketGetIpv6OnlyResponder {
26946    fn drop(&mut self) {
26947        self.control_handle.shutdown();
26948        // Safety: drops once, never accessed again
26949        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26950    }
26951}
26952
26953impl fidl::endpoints::Responder for BaseNetworkSocketGetIpv6OnlyResponder {
26954    type ControlHandle = BaseNetworkSocketControlHandle;
26955
26956    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
26957        &self.control_handle
26958    }
26959
26960    fn drop_without_shutdown(mut self) {
26961        // Safety: drops once, never accessed again due to mem::forget
26962        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
26963        // Prevent Drop from running (which would shut down the channel)
26964        std::mem::forget(self);
26965    }
26966}
26967
26968impl BaseNetworkSocketGetIpv6OnlyResponder {
26969    /// Sends a response to the FIDL transaction.
26970    ///
26971    /// Sets the channel to shutdown if an error occurs.
26972    pub fn send(
26973        self,
26974        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
26975    ) -> Result<(), fidl::Error> {
26976        let _result = self.send_raw(result);
26977        if _result.is_err() {
26978            self.control_handle.shutdown();
26979        }
26980        self.drop_without_shutdown();
26981        _result
26982    }
26983
26984    /// Similar to "send" but does not shutdown the channel if an error occurs.
26985    pub fn send_no_shutdown_on_err(
26986        self,
26987        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
26988    ) -> Result<(), fidl::Error> {
26989        let _result = self.send_raw(result);
26990        self.drop_without_shutdown();
26991        _result
26992    }
26993
26994    fn send_raw(
26995        &self,
26996        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
26997    ) -> Result<(), fidl::Error> {
26998        self.control_handle.inner.send::<fidl::encoding::ResultType<
26999            BaseNetworkSocketGetIpv6OnlyResponse,
27000            fidl_fuchsia_posix::Errno,
27001        >>(
27002            result.map(|value| (value,)),
27003            self.tx_id,
27004            0x4aa3340a1a26b89c,
27005            fidl::encoding::DynamicFlags::empty(),
27006        )
27007    }
27008}
27009
27010#[must_use = "FIDL methods require a response to be sent"]
27011#[derive(Debug)]
27012pub struct BaseNetworkSocketSetIpv6ReceiveTrafficClassResponder {
27013    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
27014    tx_id: u32,
27015}
27016
27017/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
27018/// if the responder is dropped without sending a response, so that the client
27019/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
27020impl std::ops::Drop for BaseNetworkSocketSetIpv6ReceiveTrafficClassResponder {
27021    fn drop(&mut self) {
27022        self.control_handle.shutdown();
27023        // Safety: drops once, never accessed again
27024        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
27025    }
27026}
27027
27028impl fidl::endpoints::Responder for BaseNetworkSocketSetIpv6ReceiveTrafficClassResponder {
27029    type ControlHandle = BaseNetworkSocketControlHandle;
27030
27031    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
27032        &self.control_handle
27033    }
27034
27035    fn drop_without_shutdown(mut self) {
27036        // Safety: drops once, never accessed again due to mem::forget
27037        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
27038        // Prevent Drop from running (which would shut down the channel)
27039        std::mem::forget(self);
27040    }
27041}
27042
27043impl BaseNetworkSocketSetIpv6ReceiveTrafficClassResponder {
27044    /// Sends a response to the FIDL transaction.
27045    ///
27046    /// Sets the channel to shutdown if an error occurs.
27047    pub fn send(
27048        self,
27049        mut result: Result<(), fidl_fuchsia_posix::Errno>,
27050    ) -> Result<(), fidl::Error> {
27051        let _result = self.send_raw(result);
27052        if _result.is_err() {
27053            self.control_handle.shutdown();
27054        }
27055        self.drop_without_shutdown();
27056        _result
27057    }
27058
27059    /// Similar to "send" but does not shutdown the channel if an error occurs.
27060    pub fn send_no_shutdown_on_err(
27061        self,
27062        mut result: Result<(), fidl_fuchsia_posix::Errno>,
27063    ) -> Result<(), fidl::Error> {
27064        let _result = self.send_raw(result);
27065        self.drop_without_shutdown();
27066        _result
27067    }
27068
27069    fn send_raw(
27070        &self,
27071        mut result: Result<(), fidl_fuchsia_posix::Errno>,
27072    ) -> Result<(), fidl::Error> {
27073        self.control_handle.inner.send::<fidl::encoding::ResultType<
27074            fidl::encoding::EmptyStruct,
27075            fidl_fuchsia_posix::Errno,
27076        >>(
27077            result,
27078            self.tx_id,
27079            0x58f07c8788d099a0,
27080            fidl::encoding::DynamicFlags::empty(),
27081        )
27082    }
27083}
27084
27085#[must_use = "FIDL methods require a response to be sent"]
27086#[derive(Debug)]
27087pub struct BaseNetworkSocketGetIpv6ReceiveTrafficClassResponder {
27088    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
27089    tx_id: u32,
27090}
27091
27092/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
27093/// if the responder is dropped without sending a response, so that the client
27094/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
27095impl std::ops::Drop for BaseNetworkSocketGetIpv6ReceiveTrafficClassResponder {
27096    fn drop(&mut self) {
27097        self.control_handle.shutdown();
27098        // Safety: drops once, never accessed again
27099        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
27100    }
27101}
27102
27103impl fidl::endpoints::Responder for BaseNetworkSocketGetIpv6ReceiveTrafficClassResponder {
27104    type ControlHandle = BaseNetworkSocketControlHandle;
27105
27106    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
27107        &self.control_handle
27108    }
27109
27110    fn drop_without_shutdown(mut self) {
27111        // Safety: drops once, never accessed again due to mem::forget
27112        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
27113        // Prevent Drop from running (which would shut down the channel)
27114        std::mem::forget(self);
27115    }
27116}
27117
27118impl BaseNetworkSocketGetIpv6ReceiveTrafficClassResponder {
27119    /// Sends a response to the FIDL transaction.
27120    ///
27121    /// Sets the channel to shutdown if an error occurs.
27122    pub fn send(
27123        self,
27124        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
27125    ) -> Result<(), fidl::Error> {
27126        let _result = self.send_raw(result);
27127        if _result.is_err() {
27128            self.control_handle.shutdown();
27129        }
27130        self.drop_without_shutdown();
27131        _result
27132    }
27133
27134    /// Similar to "send" but does not shutdown the channel if an error occurs.
27135    pub fn send_no_shutdown_on_err(
27136        self,
27137        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
27138    ) -> Result<(), fidl::Error> {
27139        let _result = self.send_raw(result);
27140        self.drop_without_shutdown();
27141        _result
27142    }
27143
27144    fn send_raw(
27145        &self,
27146        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
27147    ) -> Result<(), fidl::Error> {
27148        self.control_handle.inner.send::<fidl::encoding::ResultType<
27149            BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
27150            fidl_fuchsia_posix::Errno,
27151        >>(
27152            result.map(|value| (value,)),
27153            self.tx_id,
27154            0x2e334df1da553ffa,
27155            fidl::encoding::DynamicFlags::empty(),
27156        )
27157    }
27158}
27159
27160#[must_use = "FIDL methods require a response to be sent"]
27161#[derive(Debug)]
27162pub struct BaseNetworkSocketSetIpv6TrafficClassResponder {
27163    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
27164    tx_id: u32,
27165}
27166
27167/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
27168/// if the responder is dropped without sending a response, so that the client
27169/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
27170impl std::ops::Drop for BaseNetworkSocketSetIpv6TrafficClassResponder {
27171    fn drop(&mut self) {
27172        self.control_handle.shutdown();
27173        // Safety: drops once, never accessed again
27174        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
27175    }
27176}
27177
27178impl fidl::endpoints::Responder for BaseNetworkSocketSetIpv6TrafficClassResponder {
27179    type ControlHandle = BaseNetworkSocketControlHandle;
27180
27181    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
27182        &self.control_handle
27183    }
27184
27185    fn drop_without_shutdown(mut self) {
27186        // Safety: drops once, never accessed again due to mem::forget
27187        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
27188        // Prevent Drop from running (which would shut down the channel)
27189        std::mem::forget(self);
27190    }
27191}
27192
27193impl BaseNetworkSocketSetIpv6TrafficClassResponder {
27194    /// Sends a response to the FIDL transaction.
27195    ///
27196    /// Sets the channel to shutdown if an error occurs.
27197    pub fn send(
27198        self,
27199        mut result: Result<(), fidl_fuchsia_posix::Errno>,
27200    ) -> Result<(), fidl::Error> {
27201        let _result = self.send_raw(result);
27202        if _result.is_err() {
27203            self.control_handle.shutdown();
27204        }
27205        self.drop_without_shutdown();
27206        _result
27207    }
27208
27209    /// Similar to "send" but does not shutdown the channel if an error occurs.
27210    pub fn send_no_shutdown_on_err(
27211        self,
27212        mut result: Result<(), fidl_fuchsia_posix::Errno>,
27213    ) -> Result<(), fidl::Error> {
27214        let _result = self.send_raw(result);
27215        self.drop_without_shutdown();
27216        _result
27217    }
27218
27219    fn send_raw(
27220        &self,
27221        mut result: Result<(), fidl_fuchsia_posix::Errno>,
27222    ) -> Result<(), fidl::Error> {
27223        self.control_handle.inner.send::<fidl::encoding::ResultType<
27224            fidl::encoding::EmptyStruct,
27225            fidl_fuchsia_posix::Errno,
27226        >>(
27227            result,
27228            self.tx_id,
27229            0x6af077800c5a0b4f,
27230            fidl::encoding::DynamicFlags::empty(),
27231        )
27232    }
27233}
27234
27235#[must_use = "FIDL methods require a response to be sent"]
27236#[derive(Debug)]
27237pub struct BaseNetworkSocketGetIpv6TrafficClassResponder {
27238    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
27239    tx_id: u32,
27240}
27241
27242/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
27243/// if the responder is dropped without sending a response, so that the client
27244/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
27245impl std::ops::Drop for BaseNetworkSocketGetIpv6TrafficClassResponder {
27246    fn drop(&mut self) {
27247        self.control_handle.shutdown();
27248        // Safety: drops once, never accessed again
27249        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
27250    }
27251}
27252
27253impl fidl::endpoints::Responder for BaseNetworkSocketGetIpv6TrafficClassResponder {
27254    type ControlHandle = BaseNetworkSocketControlHandle;
27255
27256    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
27257        &self.control_handle
27258    }
27259
27260    fn drop_without_shutdown(mut self) {
27261        // Safety: drops once, never accessed again due to mem::forget
27262        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
27263        // Prevent Drop from running (which would shut down the channel)
27264        std::mem::forget(self);
27265    }
27266}
27267
27268impl BaseNetworkSocketGetIpv6TrafficClassResponder {
27269    /// Sends a response to the FIDL transaction.
27270    ///
27271    /// Sets the channel to shutdown if an error occurs.
27272    pub fn send(
27273        self,
27274        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
27275    ) -> Result<(), fidl::Error> {
27276        let _result = self.send_raw(result);
27277        if _result.is_err() {
27278            self.control_handle.shutdown();
27279        }
27280        self.drop_without_shutdown();
27281        _result
27282    }
27283
27284    /// Similar to "send" but does not shutdown the channel if an error occurs.
27285    pub fn send_no_shutdown_on_err(
27286        self,
27287        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
27288    ) -> Result<(), fidl::Error> {
27289        let _result = self.send_raw(result);
27290        self.drop_without_shutdown();
27291        _result
27292    }
27293
27294    fn send_raw(
27295        &self,
27296        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
27297    ) -> Result<(), fidl::Error> {
27298        self.control_handle.inner.send::<fidl::encoding::ResultType<
27299            BaseNetworkSocketGetIpv6TrafficClassResponse,
27300            fidl_fuchsia_posix::Errno,
27301        >>(
27302            result.map(|value| (value,)),
27303            self.tx_id,
27304            0x6baf6eed8fc2f04,
27305            fidl::encoding::DynamicFlags::empty(),
27306        )
27307    }
27308}
27309
27310#[must_use = "FIDL methods require a response to be sent"]
27311#[derive(Debug)]
27312pub struct BaseNetworkSocketSetIpv6ReceivePacketInfoResponder {
27313    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
27314    tx_id: u32,
27315}
27316
27317/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
27318/// if the responder is dropped without sending a response, so that the client
27319/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
27320impl std::ops::Drop for BaseNetworkSocketSetIpv6ReceivePacketInfoResponder {
27321    fn drop(&mut self) {
27322        self.control_handle.shutdown();
27323        // Safety: drops once, never accessed again
27324        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
27325    }
27326}
27327
27328impl fidl::endpoints::Responder for BaseNetworkSocketSetIpv6ReceivePacketInfoResponder {
27329    type ControlHandle = BaseNetworkSocketControlHandle;
27330
27331    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
27332        &self.control_handle
27333    }
27334
27335    fn drop_without_shutdown(mut self) {
27336        // Safety: drops once, never accessed again due to mem::forget
27337        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
27338        // Prevent Drop from running (which would shut down the channel)
27339        std::mem::forget(self);
27340    }
27341}
27342
27343impl BaseNetworkSocketSetIpv6ReceivePacketInfoResponder {
27344    /// Sends a response to the FIDL transaction.
27345    ///
27346    /// Sets the channel to shutdown if an error occurs.
27347    pub fn send(
27348        self,
27349        mut result: Result<(), fidl_fuchsia_posix::Errno>,
27350    ) -> Result<(), fidl::Error> {
27351        let _result = self.send_raw(result);
27352        if _result.is_err() {
27353            self.control_handle.shutdown();
27354        }
27355        self.drop_without_shutdown();
27356        _result
27357    }
27358
27359    /// Similar to "send" but does not shutdown the channel if an error occurs.
27360    pub fn send_no_shutdown_on_err(
27361        self,
27362        mut result: Result<(), fidl_fuchsia_posix::Errno>,
27363    ) -> Result<(), fidl::Error> {
27364        let _result = self.send_raw(result);
27365        self.drop_without_shutdown();
27366        _result
27367    }
27368
27369    fn send_raw(
27370        &self,
27371        mut result: Result<(), fidl_fuchsia_posix::Errno>,
27372    ) -> Result<(), fidl::Error> {
27373        self.control_handle.inner.send::<fidl::encoding::ResultType<
27374            fidl::encoding::EmptyStruct,
27375            fidl_fuchsia_posix::Errno,
27376        >>(
27377            result,
27378            self.tx_id,
27379            0x19259775b1a92768,
27380            fidl::encoding::DynamicFlags::empty(),
27381        )
27382    }
27383}
27384
27385#[must_use = "FIDL methods require a response to be sent"]
27386#[derive(Debug)]
27387pub struct BaseNetworkSocketGetIpv6ReceivePacketInfoResponder {
27388    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
27389    tx_id: u32,
27390}
27391
27392/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
27393/// if the responder is dropped without sending a response, so that the client
27394/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
27395impl std::ops::Drop for BaseNetworkSocketGetIpv6ReceivePacketInfoResponder {
27396    fn drop(&mut self) {
27397        self.control_handle.shutdown();
27398        // Safety: drops once, never accessed again
27399        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
27400    }
27401}
27402
27403impl fidl::endpoints::Responder for BaseNetworkSocketGetIpv6ReceivePacketInfoResponder {
27404    type ControlHandle = BaseNetworkSocketControlHandle;
27405
27406    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
27407        &self.control_handle
27408    }
27409
27410    fn drop_without_shutdown(mut self) {
27411        // Safety: drops once, never accessed again due to mem::forget
27412        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
27413        // Prevent Drop from running (which would shut down the channel)
27414        std::mem::forget(self);
27415    }
27416}
27417
27418impl BaseNetworkSocketGetIpv6ReceivePacketInfoResponder {
27419    /// Sends a response to the FIDL transaction.
27420    ///
27421    /// Sets the channel to shutdown if an error occurs.
27422    pub fn send(
27423        self,
27424        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
27425    ) -> Result<(), fidl::Error> {
27426        let _result = self.send_raw(result);
27427        if _result.is_err() {
27428            self.control_handle.shutdown();
27429        }
27430        self.drop_without_shutdown();
27431        _result
27432    }
27433
27434    /// Similar to "send" but does not shutdown the channel if an error occurs.
27435    pub fn send_no_shutdown_on_err(
27436        self,
27437        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
27438    ) -> Result<(), fidl::Error> {
27439        let _result = self.send_raw(result);
27440        self.drop_without_shutdown();
27441        _result
27442    }
27443
27444    fn send_raw(
27445        &self,
27446        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
27447    ) -> Result<(), fidl::Error> {
27448        self.control_handle.inner.send::<fidl::encoding::ResultType<
27449            BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
27450            fidl_fuchsia_posix::Errno,
27451        >>(
27452            result.map(|value| (value,)),
27453            self.tx_id,
27454            0x7acd4a2775baec75,
27455            fidl::encoding::DynamicFlags::empty(),
27456        )
27457    }
27458}
27459
27460#[must_use = "FIDL methods require a response to be sent"]
27461#[derive(Debug)]
27462pub struct BaseNetworkSocketGetOriginalDestinationResponder {
27463    control_handle: std::mem::ManuallyDrop<BaseNetworkSocketControlHandle>,
27464    tx_id: u32,
27465}
27466
27467/// Set the the channel to be shutdown (see [`BaseNetworkSocketControlHandle::shutdown`])
27468/// if the responder is dropped without sending a response, so that the client
27469/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
27470impl std::ops::Drop for BaseNetworkSocketGetOriginalDestinationResponder {
27471    fn drop(&mut self) {
27472        self.control_handle.shutdown();
27473        // Safety: drops once, never accessed again
27474        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
27475    }
27476}
27477
27478impl fidl::endpoints::Responder for BaseNetworkSocketGetOriginalDestinationResponder {
27479    type ControlHandle = BaseNetworkSocketControlHandle;
27480
27481    fn control_handle(&self) -> &BaseNetworkSocketControlHandle {
27482        &self.control_handle
27483    }
27484
27485    fn drop_without_shutdown(mut self) {
27486        // Safety: drops once, never accessed again due to mem::forget
27487        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
27488        // Prevent Drop from running (which would shut down the channel)
27489        std::mem::forget(self);
27490    }
27491}
27492
27493impl BaseNetworkSocketGetOriginalDestinationResponder {
27494    /// Sends a response to the FIDL transaction.
27495    ///
27496    /// Sets the channel to shutdown if an error occurs.
27497    pub fn send(
27498        self,
27499        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
27500    ) -> Result<(), fidl::Error> {
27501        let _result = self.send_raw(result);
27502        if _result.is_err() {
27503            self.control_handle.shutdown();
27504        }
27505        self.drop_without_shutdown();
27506        _result
27507    }
27508
27509    /// Similar to "send" but does not shutdown the channel if an error occurs.
27510    pub fn send_no_shutdown_on_err(
27511        self,
27512        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
27513    ) -> Result<(), fidl::Error> {
27514        let _result = self.send_raw(result);
27515        self.drop_without_shutdown();
27516        _result
27517    }
27518
27519    fn send_raw(
27520        &self,
27521        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
27522    ) -> Result<(), fidl::Error> {
27523        self.control_handle.inner.send::<fidl::encoding::ResultType<
27524            BaseNetworkSocketGetOriginalDestinationResponse,
27525            fidl_fuchsia_posix::Errno,
27526        >>(
27527            result.map(|value| (value,)),
27528            self.tx_id,
27529            0x38bf28f0dafdbac0,
27530            fidl::encoding::DynamicFlags::empty(),
27531        )
27532    }
27533}
27534
27535#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
27536pub struct BaseSocketMarker;
27537
27538impl fidl::endpoints::ProtocolMarker for BaseSocketMarker {
27539    type Proxy = BaseSocketProxy;
27540    type RequestStream = BaseSocketRequestStream;
27541    #[cfg(target_os = "fuchsia")]
27542    type SynchronousProxy = BaseSocketSynchronousProxy;
27543
27544    const DEBUG_NAME: &'static str = "(anonymous) BaseSocket";
27545}
27546pub type BaseSocketSetReuseAddressResult = Result<(), fidl_fuchsia_posix::Errno>;
27547pub type BaseSocketGetReuseAddressResult = Result<bool, fidl_fuchsia_posix::Errno>;
27548pub type BaseSocketGetErrorResult = Result<(), fidl_fuchsia_posix::Errno>;
27549pub type BaseSocketSetBroadcastResult = Result<(), fidl_fuchsia_posix::Errno>;
27550pub type BaseSocketGetBroadcastResult = Result<bool, fidl_fuchsia_posix::Errno>;
27551pub type BaseSocketSetSendBufferResult = Result<(), fidl_fuchsia_posix::Errno>;
27552pub type BaseSocketGetSendBufferResult = Result<u64, fidl_fuchsia_posix::Errno>;
27553pub type BaseSocketSetReceiveBufferResult = Result<(), fidl_fuchsia_posix::Errno>;
27554pub type BaseSocketGetReceiveBufferResult = Result<u64, fidl_fuchsia_posix::Errno>;
27555pub type BaseSocketSetKeepAliveResult = Result<(), fidl_fuchsia_posix::Errno>;
27556pub type BaseSocketGetKeepAliveResult = Result<bool, fidl_fuchsia_posix::Errno>;
27557pub type BaseSocketSetOutOfBandInlineResult = Result<(), fidl_fuchsia_posix::Errno>;
27558pub type BaseSocketGetOutOfBandInlineResult = Result<bool, fidl_fuchsia_posix::Errno>;
27559pub type BaseSocketSetNoCheckResult = Result<(), fidl_fuchsia_posix::Errno>;
27560pub type BaseSocketGetNoCheckResult = Result<bool, fidl_fuchsia_posix::Errno>;
27561pub type BaseSocketSetLingerResult = Result<(), fidl_fuchsia_posix::Errno>;
27562pub type BaseSocketGetLingerResult = Result<(bool, u32), fidl_fuchsia_posix::Errno>;
27563pub type BaseSocketSetReusePortResult = Result<(), fidl_fuchsia_posix::Errno>;
27564pub type BaseSocketGetReusePortResult = Result<bool, fidl_fuchsia_posix::Errno>;
27565pub type BaseSocketGetAcceptConnResult = Result<bool, fidl_fuchsia_posix::Errno>;
27566pub type BaseSocketSetBindToDeviceResult = Result<(), fidl_fuchsia_posix::Errno>;
27567pub type BaseSocketGetBindToDeviceResult = Result<String, fidl_fuchsia_posix::Errno>;
27568pub type BaseSocketSetBindToInterfaceIndexResult = Result<(), fidl_fuchsia_posix::Errno>;
27569pub type BaseSocketGetBindToInterfaceIndexResult = Result<u64, fidl_fuchsia_posix::Errno>;
27570pub type BaseSocketSetTimestampResult = Result<(), fidl_fuchsia_posix::Errno>;
27571pub type BaseSocketGetTimestampResult = Result<TimestampOption, fidl_fuchsia_posix::Errno>;
27572pub type BaseSocketSetMarkResult = Result<(), fidl_fuchsia_posix::Errno>;
27573pub type BaseSocketGetMarkResult = Result<OptionalUint32, fidl_fuchsia_posix::Errno>;
27574
27575pub trait BaseSocketProxyInterface: Send + Sync {
27576    fn r#clone(
27577        &self,
27578        request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
27579    ) -> Result<(), fidl::Error>;
27580    type CloseResponseFut: std::future::Future<
27581            Output = Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error>,
27582        > + Send;
27583    fn r#close(&self) -> Self::CloseResponseFut;
27584    type QueryResponseFut: std::future::Future<Output = Result<Vec<u8>, fidl::Error>> + Send;
27585    fn r#query(&self) -> Self::QueryResponseFut;
27586    type SetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketSetReuseAddressResult, fidl::Error>>
27587        + Send;
27588    fn r#set_reuse_address(&self, value: bool) -> Self::SetReuseAddressResponseFut;
27589    type GetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketGetReuseAddressResult, fidl::Error>>
27590        + Send;
27591    fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut;
27592    type GetErrorResponseFut: std::future::Future<Output = Result<BaseSocketGetErrorResult, fidl::Error>>
27593        + Send;
27594    fn r#get_error(&self) -> Self::GetErrorResponseFut;
27595    type SetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketSetBroadcastResult, fidl::Error>>
27596        + Send;
27597    fn r#set_broadcast(&self, value: bool) -> Self::SetBroadcastResponseFut;
27598    type GetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketGetBroadcastResult, fidl::Error>>
27599        + Send;
27600    fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut;
27601    type SetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetSendBufferResult, fidl::Error>>
27602        + Send;
27603    fn r#set_send_buffer(&self, value_bytes: u64) -> Self::SetSendBufferResponseFut;
27604    type GetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetSendBufferResult, fidl::Error>>
27605        + Send;
27606    fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut;
27607    type SetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetReceiveBufferResult, fidl::Error>>
27608        + Send;
27609    fn r#set_receive_buffer(&self, value_bytes: u64) -> Self::SetReceiveBufferResponseFut;
27610    type GetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetReceiveBufferResult, fidl::Error>>
27611        + Send;
27612    fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut;
27613    type SetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketSetKeepAliveResult, fidl::Error>>
27614        + Send;
27615    fn r#set_keep_alive(&self, value: bool) -> Self::SetKeepAliveResponseFut;
27616    type GetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketGetKeepAliveResult, fidl::Error>>
27617        + Send;
27618    fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut;
27619    type SetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketSetOutOfBandInlineResult, fidl::Error>>
27620        + Send;
27621    fn r#set_out_of_band_inline(&self, value: bool) -> Self::SetOutOfBandInlineResponseFut;
27622    type GetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketGetOutOfBandInlineResult, fidl::Error>>
27623        + Send;
27624    fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut;
27625    type SetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketSetNoCheckResult, fidl::Error>>
27626        + Send;
27627    fn r#set_no_check(&self, value: bool) -> Self::SetNoCheckResponseFut;
27628    type GetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketGetNoCheckResult, fidl::Error>>
27629        + Send;
27630    fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut;
27631    type SetLingerResponseFut: std::future::Future<Output = Result<BaseSocketSetLingerResult, fidl::Error>>
27632        + Send;
27633    fn r#set_linger(&self, linger: bool, length_secs: u32) -> Self::SetLingerResponseFut;
27634    type GetLingerResponseFut: std::future::Future<Output = Result<BaseSocketGetLingerResult, fidl::Error>>
27635        + Send;
27636    fn r#get_linger(&self) -> Self::GetLingerResponseFut;
27637    type SetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketSetReusePortResult, fidl::Error>>
27638        + Send;
27639    fn r#set_reuse_port(&self, value: bool) -> Self::SetReusePortResponseFut;
27640    type GetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketGetReusePortResult, fidl::Error>>
27641        + Send;
27642    fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut;
27643    type GetAcceptConnResponseFut: std::future::Future<Output = Result<BaseSocketGetAcceptConnResult, fidl::Error>>
27644        + Send;
27645    fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut;
27646    type SetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToDeviceResult, fidl::Error>>
27647        + Send;
27648    fn r#set_bind_to_device(&self, value: &str) -> Self::SetBindToDeviceResponseFut;
27649    type GetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToDeviceResult, fidl::Error>>
27650        + Send;
27651    fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut;
27652    type SetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error>>
27653        + Send;
27654    fn r#set_bind_to_interface_index(&self, value: u64)
27655        -> Self::SetBindToInterfaceIndexResponseFut;
27656    type GetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error>>
27657        + Send;
27658    fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut;
27659    type SetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketSetTimestampResult, fidl::Error>>
27660        + Send;
27661    fn r#set_timestamp(&self, value: TimestampOption) -> Self::SetTimestampResponseFut;
27662    type GetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketGetTimestampResult, fidl::Error>>
27663        + Send;
27664    fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut;
27665    type SetMarkResponseFut: std::future::Future<Output = Result<BaseSocketSetMarkResult, fidl::Error>>
27666        + Send;
27667    fn r#set_mark(
27668        &self,
27669        domain: fidl_fuchsia_net::MarkDomain,
27670        mark: &OptionalUint32,
27671    ) -> Self::SetMarkResponseFut;
27672    type GetMarkResponseFut: std::future::Future<Output = Result<BaseSocketGetMarkResult, fidl::Error>>
27673        + Send;
27674    fn r#get_mark(&self, domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut;
27675}
27676#[derive(Debug)]
27677#[cfg(target_os = "fuchsia")]
27678pub struct BaseSocketSynchronousProxy {
27679    client: fidl::client::sync::Client,
27680}
27681
27682#[cfg(target_os = "fuchsia")]
27683impl fidl::endpoints::SynchronousProxy for BaseSocketSynchronousProxy {
27684    type Proxy = BaseSocketProxy;
27685    type Protocol = BaseSocketMarker;
27686
27687    fn from_channel(inner: fidl::Channel) -> Self {
27688        Self::new(inner)
27689    }
27690
27691    fn into_channel(self) -> fidl::Channel {
27692        self.client.into_channel()
27693    }
27694
27695    fn as_channel(&self) -> &fidl::Channel {
27696        self.client.as_channel()
27697    }
27698}
27699
27700#[cfg(target_os = "fuchsia")]
27701impl BaseSocketSynchronousProxy {
27702    pub fn new(channel: fidl::Channel) -> Self {
27703        let protocol_name = <BaseSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
27704        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
27705    }
27706
27707    pub fn into_channel(self) -> fidl::Channel {
27708        self.client.into_channel()
27709    }
27710
27711    /// Waits until an event arrives and returns it. It is safe for other
27712    /// threads to make concurrent requests while waiting for an event.
27713    pub fn wait_for_event(
27714        &self,
27715        deadline: zx::MonotonicInstant,
27716    ) -> Result<BaseSocketEvent, fidl::Error> {
27717        BaseSocketEvent::decode(self.client.wait_for_event(deadline)?)
27718    }
27719
27720    pub fn r#clone(
27721        &self,
27722        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
27723    ) -> Result<(), fidl::Error> {
27724        self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
27725            (request,),
27726            0x20d8a7aba2168a79,
27727            fidl::encoding::DynamicFlags::empty(),
27728        )
27729    }
27730
27731    /// Terminates the connection.
27732    ///
27733    /// After calling `Close`, the client must not send any other requests.
27734    ///
27735    /// Servers, after sending the status response, should close the connection
27736    /// regardless of status and without sending an epitaph.
27737    ///
27738    /// Closing the client end of the channel should be semantically equivalent
27739    /// to calling `Close` without knowing when the close has completed or its
27740    /// status.
27741    pub fn r#close(
27742        &self,
27743        ___deadline: zx::MonotonicInstant,
27744    ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
27745        let _response = self.client.send_query::<
27746            fidl::encoding::EmptyPayload,
27747            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
27748        >(
27749            (),
27750            0x5ac5d459ad7f657e,
27751            fidl::encoding::DynamicFlags::empty(),
27752            ___deadline,
27753        )?;
27754        Ok(_response.map(|x| x))
27755    }
27756
27757    pub fn r#query(&self, ___deadline: zx::MonotonicInstant) -> Result<Vec<u8>, fidl::Error> {
27758        let _response = self.client.send_query::<
27759            fidl::encoding::EmptyPayload,
27760            fidl_fuchsia_unknown::QueryableQueryResponse,
27761        >(
27762            (),
27763            0x2658edee9decfc06,
27764            fidl::encoding::DynamicFlags::empty(),
27765            ___deadline,
27766        )?;
27767        Ok(_response.protocol)
27768    }
27769
27770    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
27771    pub fn r#set_reuse_address(
27772        &self,
27773        mut value: bool,
27774        ___deadline: zx::MonotonicInstant,
27775    ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
27776        let _response =
27777            self.client.send_query::<BaseSocketSetReuseAddressRequest, fidl::encoding::ResultType<
27778                fidl::encoding::EmptyStruct,
27779                fidl_fuchsia_posix::Errno,
27780            >>(
27781                (value,),
27782                0x1fd74ee8b9a4a876,
27783                fidl::encoding::DynamicFlags::empty(),
27784                ___deadline,
27785            )?;
27786        Ok(_response.map(|x| x))
27787    }
27788
27789    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
27790    pub fn r#get_reuse_address(
27791        &self,
27792        ___deadline: zx::MonotonicInstant,
27793    ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
27794        let _response = self
27795            .client
27796            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
27797                BaseSocketGetReuseAddressResponse,
27798                fidl_fuchsia_posix::Errno,
27799            >>(
27800                (), 0x67b7206b8d1bc0a5, fidl::encoding::DynamicFlags::empty(), ___deadline
27801            )?;
27802        Ok(_response.map(|x| x.value))
27803    }
27804
27805    /// Get `SOL_SOCKET` -> `SO_ERROR`.
27806    /// Returns the last error if there is an error set on the socket.
27807    pub fn r#get_error(
27808        &self,
27809        ___deadline: zx::MonotonicInstant,
27810    ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
27811        let _response =
27812            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
27813                fidl::encoding::EmptyStruct,
27814                fidl_fuchsia_posix::Errno,
27815            >>(
27816                (),
27817                0x5aad39b33e5f6ebb,
27818                fidl::encoding::DynamicFlags::empty(),
27819                ___deadline,
27820            )?;
27821        Ok(_response.map(|x| x))
27822    }
27823
27824    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
27825    pub fn r#set_broadcast(
27826        &self,
27827        mut value: bool,
27828        ___deadline: zx::MonotonicInstant,
27829    ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
27830        let _response =
27831            self.client.send_query::<BaseSocketSetBroadcastRequest, fidl::encoding::ResultType<
27832                fidl::encoding::EmptyStruct,
27833                fidl_fuchsia_posix::Errno,
27834            >>(
27835                (value,),
27836                0x6023e081ce3cd947,
27837                fidl::encoding::DynamicFlags::empty(),
27838                ___deadline,
27839            )?;
27840        Ok(_response.map(|x| x))
27841    }
27842
27843    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
27844    pub fn r#get_broadcast(
27845        &self,
27846        ___deadline: zx::MonotonicInstant,
27847    ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
27848        let _response =
27849            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
27850                BaseSocketGetBroadcastResponse,
27851                fidl_fuchsia_posix::Errno,
27852            >>(
27853                (),
27854                0x68796fc556f9780d,
27855                fidl::encoding::DynamicFlags::empty(),
27856                ___deadline,
27857            )?;
27858        Ok(_response.map(|x| x.value))
27859    }
27860
27861    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
27862    pub fn r#set_send_buffer(
27863        &self,
27864        mut value_bytes: u64,
27865        ___deadline: zx::MonotonicInstant,
27866    ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
27867        let _response =
27868            self.client.send_query::<BaseSocketSetSendBufferRequest, fidl::encoding::ResultType<
27869                fidl::encoding::EmptyStruct,
27870                fidl_fuchsia_posix::Errno,
27871            >>(
27872                (value_bytes,),
27873                0x756eac32d73a7a70,
27874                fidl::encoding::DynamicFlags::empty(),
27875                ___deadline,
27876            )?;
27877        Ok(_response.map(|x| x))
27878    }
27879
27880    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
27881    pub fn r#get_send_buffer(
27882        &self,
27883        ___deadline: zx::MonotonicInstant,
27884    ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
27885        let _response = self
27886            .client
27887            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
27888                BaseSocketGetSendBufferResponse,
27889                fidl_fuchsia_posix::Errno,
27890            >>(
27891                (), 0x78a52fd9c7b2410b, fidl::encoding::DynamicFlags::empty(), ___deadline
27892            )?;
27893        Ok(_response.map(|x| x.value_bytes))
27894    }
27895
27896    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
27897    pub fn r#set_receive_buffer(
27898        &self,
27899        mut value_bytes: u64,
27900        ___deadline: zx::MonotonicInstant,
27901    ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
27902        let _response =
27903            self.client
27904                .send_query::<BaseSocketSetReceiveBufferRequest, fidl::encoding::ResultType<
27905                    fidl::encoding::EmptyStruct,
27906                    fidl_fuchsia_posix::Errno,
27907                >>(
27908                    (value_bytes,),
27909                    0x6b0cf2f1919c7001,
27910                    fidl::encoding::DynamicFlags::empty(),
27911                    ___deadline,
27912                )?;
27913        Ok(_response.map(|x| x))
27914    }
27915
27916    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
27917    pub fn r#get_receive_buffer(
27918        &self,
27919        ___deadline: zx::MonotonicInstant,
27920    ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
27921        let _response = self
27922            .client
27923            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
27924                BaseSocketGetReceiveBufferResponse,
27925                fidl_fuchsia_posix::Errno,
27926            >>(
27927                (), 0x14c1a4b64f709e5c, fidl::encoding::DynamicFlags::empty(), ___deadline
27928            )?;
27929        Ok(_response.map(|x| x.value_bytes))
27930    }
27931
27932    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
27933    pub fn r#set_keep_alive(
27934        &self,
27935        mut value: bool,
27936        ___deadline: zx::MonotonicInstant,
27937    ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
27938        let _response =
27939            self.client.send_query::<BaseSocketSetKeepAliveRequest, fidl::encoding::ResultType<
27940                fidl::encoding::EmptyStruct,
27941                fidl_fuchsia_posix::Errno,
27942            >>(
27943                (value,),
27944                0x572df8f0b920d2c7,
27945                fidl::encoding::DynamicFlags::empty(),
27946                ___deadline,
27947            )?;
27948        Ok(_response.map(|x| x))
27949    }
27950
27951    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
27952    pub fn r#get_keep_alive(
27953        &self,
27954        ___deadline: zx::MonotonicInstant,
27955    ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
27956        let _response =
27957            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
27958                BaseSocketGetKeepAliveResponse,
27959                fidl_fuchsia_posix::Errno,
27960            >>(
27961                (),
27962                0x2dd29d3215f2c9d2,
27963                fidl::encoding::DynamicFlags::empty(),
27964                ___deadline,
27965            )?;
27966        Ok(_response.map(|x| x.value))
27967    }
27968
27969    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
27970    pub fn r#set_out_of_band_inline(
27971        &self,
27972        mut value: bool,
27973        ___deadline: zx::MonotonicInstant,
27974    ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
27975        let _response =
27976            self.client
27977                .send_query::<BaseSocketSetOutOfBandInlineRequest, fidl::encoding::ResultType<
27978                    fidl::encoding::EmptyStruct,
27979                    fidl_fuchsia_posix::Errno,
27980                >>(
27981                    (value,),
27982                    0x3ecb49968bee439,
27983                    fidl::encoding::DynamicFlags::empty(),
27984                    ___deadline,
27985                )?;
27986        Ok(_response.map(|x| x))
27987    }
27988
27989    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
27990    pub fn r#get_out_of_band_inline(
27991        &self,
27992        ___deadline: zx::MonotonicInstant,
27993    ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
27994        let _response = self
27995            .client
27996            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
27997                BaseSocketGetOutOfBandInlineResponse,
27998                fidl_fuchsia_posix::Errno,
27999            >>(
28000                (), 0x348c1ab3aeca1745, fidl::encoding::DynamicFlags::empty(), ___deadline
28001            )?;
28002        Ok(_response.map(|x| x.value))
28003    }
28004
28005    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
28006    pub fn r#set_no_check(
28007        &self,
28008        mut value: bool,
28009        ___deadline: zx::MonotonicInstant,
28010    ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
28011        let _response =
28012            self.client.send_query::<BaseSocketSetNoCheckRequest, fidl::encoding::ResultType<
28013                fidl::encoding::EmptyStruct,
28014                fidl_fuchsia_posix::Errno,
28015            >>(
28016                (value,),
28017                0x6bbf00c53a4c78c2,
28018                fidl::encoding::DynamicFlags::empty(),
28019                ___deadline,
28020            )?;
28021        Ok(_response.map(|x| x))
28022    }
28023
28024    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
28025    pub fn r#get_no_check(
28026        &self,
28027        ___deadline: zx::MonotonicInstant,
28028    ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
28029        let _response =
28030            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
28031                BaseSocketGetNoCheckResponse,
28032                fidl_fuchsia_posix::Errno,
28033            >>(
28034                (),
28035                0x2cd4249286417694,
28036                fidl::encoding::DynamicFlags::empty(),
28037                ___deadline,
28038            )?;
28039        Ok(_response.map(|x| x.value))
28040    }
28041
28042    /// Set `SOL_SOCKET` -> `SO_LINGER`.
28043    pub fn r#set_linger(
28044        &self,
28045        mut linger: bool,
28046        mut length_secs: u32,
28047        ___deadline: zx::MonotonicInstant,
28048    ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
28049        let _response =
28050            self.client.send_query::<BaseSocketSetLingerRequest, fidl::encoding::ResultType<
28051                fidl::encoding::EmptyStruct,
28052                fidl_fuchsia_posix::Errno,
28053            >>(
28054                (linger, length_secs),
28055                0x45386351246e998e,
28056                fidl::encoding::DynamicFlags::empty(),
28057                ___deadline,
28058            )?;
28059        Ok(_response.map(|x| x))
28060    }
28061
28062    /// Get `SOL_SOCKET` -> `SO_LINGER`.
28063    pub fn r#get_linger(
28064        &self,
28065        ___deadline: zx::MonotonicInstant,
28066    ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
28067        let _response =
28068            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
28069                BaseSocketGetLingerResponse,
28070                fidl_fuchsia_posix::Errno,
28071            >>(
28072                (),
28073                0x48eb20fc5ccb0e45,
28074                fidl::encoding::DynamicFlags::empty(),
28075                ___deadline,
28076            )?;
28077        Ok(_response.map(|x| (x.linger, x.length_secs)))
28078    }
28079
28080    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
28081    pub fn r#set_reuse_port(
28082        &self,
28083        mut value: bool,
28084        ___deadline: zx::MonotonicInstant,
28085    ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
28086        let _response =
28087            self.client.send_query::<BaseSocketSetReusePortRequest, fidl::encoding::ResultType<
28088                fidl::encoding::EmptyStruct,
28089                fidl_fuchsia_posix::Errno,
28090            >>(
28091                (value,),
28092                0x24dd3e5cb36d9ccb,
28093                fidl::encoding::DynamicFlags::empty(),
28094                ___deadline,
28095            )?;
28096        Ok(_response.map(|x| x))
28097    }
28098
28099    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
28100    pub fn r#get_reuse_port(
28101        &self,
28102        ___deadline: zx::MonotonicInstant,
28103    ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
28104        let _response =
28105            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
28106                BaseSocketGetReusePortResponse,
28107                fidl_fuchsia_posix::Errno,
28108            >>(
28109                (),
28110                0x7a112c1ab54ff828,
28111                fidl::encoding::DynamicFlags::empty(),
28112                ___deadline,
28113            )?;
28114        Ok(_response.map(|x| x.value))
28115    }
28116
28117    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
28118    pub fn r#get_accept_conn(
28119        &self,
28120        ___deadline: zx::MonotonicInstant,
28121    ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
28122        let _response = self
28123            .client
28124            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
28125                BaseSocketGetAcceptConnResponse,
28126                fidl_fuchsia_posix::Errno,
28127            >>(
28128                (), 0x67ce6db6c2ec8966, fidl::encoding::DynamicFlags::empty(), ___deadline
28129            )?;
28130        Ok(_response.map(|x| x.value))
28131    }
28132
28133    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
28134    pub fn r#set_bind_to_device(
28135        &self,
28136        mut value: &str,
28137        ___deadline: zx::MonotonicInstant,
28138    ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
28139        let _response =
28140            self.client.send_query::<BaseSocketSetBindToDeviceRequest, fidl::encoding::ResultType<
28141                fidl::encoding::EmptyStruct,
28142                fidl_fuchsia_posix::Errno,
28143            >>(
28144                (value,),
28145                0x2118b483f28aafc4,
28146                fidl::encoding::DynamicFlags::empty(),
28147                ___deadline,
28148            )?;
28149        Ok(_response.map(|x| x))
28150    }
28151
28152    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
28153    pub fn r#get_bind_to_device(
28154        &self,
28155        ___deadline: zx::MonotonicInstant,
28156    ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
28157        let _response = self
28158            .client
28159            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
28160                BaseSocketGetBindToDeviceResponse,
28161                fidl_fuchsia_posix::Errno,
28162            >>(
28163                (), 0x1ab1fbf0ef7906c8, fidl::encoding::DynamicFlags::empty(), ___deadline
28164            )?;
28165        Ok(_response.map(|x| x.value))
28166    }
28167
28168    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
28169    /// If `value` is 0, this clears the bound interface.
28170    pub fn r#set_bind_to_interface_index(
28171        &self,
28172        mut value: u64,
28173        ___deadline: zx::MonotonicInstant,
28174    ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
28175        let _response =
28176            self.client
28177                .send_query::<BaseSocketSetBindToInterfaceIndexRequest, fidl::encoding::ResultType<
28178                    fidl::encoding::EmptyStruct,
28179                    fidl_fuchsia_posix::Errno,
28180                >>(
28181                    (value,),
28182                    0x6e387a0def00821,
28183                    fidl::encoding::DynamicFlags::empty(),
28184                    ___deadline,
28185                )?;
28186        Ok(_response.map(|x| x))
28187    }
28188
28189    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
28190    pub fn r#get_bind_to_interface_index(
28191        &self,
28192        ___deadline: zx::MonotonicInstant,
28193    ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
28194        let _response = self
28195            .client
28196            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
28197                BaseSocketGetBindToInterfaceIndexResponse,
28198                fidl_fuchsia_posix::Errno,
28199            >>(
28200                (), 0x59c31dd3e3078295, fidl::encoding::DynamicFlags::empty(), ___deadline
28201            )?;
28202        Ok(_response.map(|x| x.value))
28203    }
28204
28205    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
28206    pub fn r#set_timestamp(
28207        &self,
28208        mut value: TimestampOption,
28209        ___deadline: zx::MonotonicInstant,
28210    ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
28211        let _response =
28212            self.client.send_query::<BaseSocketSetTimestampRequest, fidl::encoding::ResultType<
28213                fidl::encoding::EmptyStruct,
28214                fidl_fuchsia_posix::Errno,
28215            >>(
28216                (value,),
28217                0x285d6516c263d839,
28218                fidl::encoding::DynamicFlags::empty(),
28219                ___deadline,
28220            )?;
28221        Ok(_response.map(|x| x))
28222    }
28223
28224    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
28225    pub fn r#get_timestamp(
28226        &self,
28227        ___deadline: zx::MonotonicInstant,
28228    ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
28229        let _response =
28230            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
28231                BaseSocketGetTimestampResponse,
28232                fidl_fuchsia_posix::Errno,
28233            >>(
28234                (),
28235                0x49f2fffbbcc2bd27,
28236                fidl::encoding::DynamicFlags::empty(),
28237                ___deadline,
28238            )?;
28239        Ok(_response.map(|x| x.value))
28240    }
28241
28242    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
28243    /// unlike the standard SO_MARK, this API has multiple mark domains and each
28244    /// mark can be set independently in each domain.
28245    pub fn r#set_mark(
28246        &self,
28247        mut domain: fidl_fuchsia_net::MarkDomain,
28248        mut mark: &OptionalUint32,
28249        ___deadline: zx::MonotonicInstant,
28250    ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
28251        let _response =
28252            self.client.send_query::<BaseSocketSetMarkRequest, fidl::encoding::ResultType<
28253                fidl::encoding::EmptyStruct,
28254                fidl_fuchsia_posix::Errno,
28255            >>(
28256                (domain, mark),
28257                0x6ead6de09f653236,
28258                fidl::encoding::DynamicFlags::empty(),
28259                ___deadline,
28260            )?;
28261        Ok(_response.map(|x| x))
28262    }
28263
28264    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
28265    /// unlike the standard SO_MARK, this API has multiple mark domains and each
28266    /// mark can be retrieved independently in each domain.
28267    pub fn r#get_mark(
28268        &self,
28269        mut domain: fidl_fuchsia_net::MarkDomain,
28270        ___deadline: zx::MonotonicInstant,
28271    ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
28272        let _response =
28273            self.client.send_query::<BaseSocketGetMarkRequest, fidl::encoding::ResultType<
28274                BaseSocketGetMarkResponse,
28275                fidl_fuchsia_posix::Errno,
28276            >>(
28277                (domain,),
28278                0x57a2752c61d93d47,
28279                fidl::encoding::DynamicFlags::empty(),
28280                ___deadline,
28281            )?;
28282        Ok(_response.map(|x| x.mark))
28283    }
28284}
28285
28286#[cfg(target_os = "fuchsia")]
28287impl From<BaseSocketSynchronousProxy> for zx::Handle {
28288    fn from(value: BaseSocketSynchronousProxy) -> Self {
28289        value.into_channel().into()
28290    }
28291}
28292
28293#[cfg(target_os = "fuchsia")]
28294impl From<fidl::Channel> for BaseSocketSynchronousProxy {
28295    fn from(value: fidl::Channel) -> Self {
28296        Self::new(value)
28297    }
28298}
28299
28300#[derive(Debug, Clone)]
28301pub struct BaseSocketProxy {
28302    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
28303}
28304
28305impl fidl::endpoints::Proxy for BaseSocketProxy {
28306    type Protocol = BaseSocketMarker;
28307
28308    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
28309        Self::new(inner)
28310    }
28311
28312    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
28313        self.client.into_channel().map_err(|client| Self { client })
28314    }
28315
28316    fn as_channel(&self) -> &::fidl::AsyncChannel {
28317        self.client.as_channel()
28318    }
28319}
28320
28321impl BaseSocketProxy {
28322    /// Create a new Proxy for fuchsia.posix.socket/BaseSocket.
28323    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
28324        let protocol_name = <BaseSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
28325        Self { client: fidl::client::Client::new(channel, protocol_name) }
28326    }
28327
28328    /// Get a Stream of events from the remote end of the protocol.
28329    ///
28330    /// # Panics
28331    ///
28332    /// Panics if the event stream was already taken.
28333    pub fn take_event_stream(&self) -> BaseSocketEventStream {
28334        BaseSocketEventStream { event_receiver: self.client.take_event_receiver() }
28335    }
28336
28337    pub fn r#clone(
28338        &self,
28339        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
28340    ) -> Result<(), fidl::Error> {
28341        BaseSocketProxyInterface::r#clone(self, request)
28342    }
28343
28344    /// Terminates the connection.
28345    ///
28346    /// After calling `Close`, the client must not send any other requests.
28347    ///
28348    /// Servers, after sending the status response, should close the connection
28349    /// regardless of status and without sending an epitaph.
28350    ///
28351    /// Closing the client end of the channel should be semantically equivalent
28352    /// to calling `Close` without knowing when the close has completed or its
28353    /// status.
28354    pub fn r#close(
28355        &self,
28356    ) -> fidl::client::QueryResponseFut<
28357        fidl_fuchsia_unknown::CloseableCloseResult,
28358        fidl::encoding::DefaultFuchsiaResourceDialect,
28359    > {
28360        BaseSocketProxyInterface::r#close(self)
28361    }
28362
28363    pub fn r#query(
28364        &self,
28365    ) -> fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>
28366    {
28367        BaseSocketProxyInterface::r#query(self)
28368    }
28369
28370    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
28371    pub fn r#set_reuse_address(
28372        &self,
28373        mut value: bool,
28374    ) -> fidl::client::QueryResponseFut<
28375        BaseSocketSetReuseAddressResult,
28376        fidl::encoding::DefaultFuchsiaResourceDialect,
28377    > {
28378        BaseSocketProxyInterface::r#set_reuse_address(self, value)
28379    }
28380
28381    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
28382    pub fn r#get_reuse_address(
28383        &self,
28384    ) -> fidl::client::QueryResponseFut<
28385        BaseSocketGetReuseAddressResult,
28386        fidl::encoding::DefaultFuchsiaResourceDialect,
28387    > {
28388        BaseSocketProxyInterface::r#get_reuse_address(self)
28389    }
28390
28391    /// Get `SOL_SOCKET` -> `SO_ERROR`.
28392    /// Returns the last error if there is an error set on the socket.
28393    pub fn r#get_error(
28394        &self,
28395    ) -> fidl::client::QueryResponseFut<
28396        BaseSocketGetErrorResult,
28397        fidl::encoding::DefaultFuchsiaResourceDialect,
28398    > {
28399        BaseSocketProxyInterface::r#get_error(self)
28400    }
28401
28402    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
28403    pub fn r#set_broadcast(
28404        &self,
28405        mut value: bool,
28406    ) -> fidl::client::QueryResponseFut<
28407        BaseSocketSetBroadcastResult,
28408        fidl::encoding::DefaultFuchsiaResourceDialect,
28409    > {
28410        BaseSocketProxyInterface::r#set_broadcast(self, value)
28411    }
28412
28413    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
28414    pub fn r#get_broadcast(
28415        &self,
28416    ) -> fidl::client::QueryResponseFut<
28417        BaseSocketGetBroadcastResult,
28418        fidl::encoding::DefaultFuchsiaResourceDialect,
28419    > {
28420        BaseSocketProxyInterface::r#get_broadcast(self)
28421    }
28422
28423    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
28424    pub fn r#set_send_buffer(
28425        &self,
28426        mut value_bytes: u64,
28427    ) -> fidl::client::QueryResponseFut<
28428        BaseSocketSetSendBufferResult,
28429        fidl::encoding::DefaultFuchsiaResourceDialect,
28430    > {
28431        BaseSocketProxyInterface::r#set_send_buffer(self, value_bytes)
28432    }
28433
28434    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
28435    pub fn r#get_send_buffer(
28436        &self,
28437    ) -> fidl::client::QueryResponseFut<
28438        BaseSocketGetSendBufferResult,
28439        fidl::encoding::DefaultFuchsiaResourceDialect,
28440    > {
28441        BaseSocketProxyInterface::r#get_send_buffer(self)
28442    }
28443
28444    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
28445    pub fn r#set_receive_buffer(
28446        &self,
28447        mut value_bytes: u64,
28448    ) -> fidl::client::QueryResponseFut<
28449        BaseSocketSetReceiveBufferResult,
28450        fidl::encoding::DefaultFuchsiaResourceDialect,
28451    > {
28452        BaseSocketProxyInterface::r#set_receive_buffer(self, value_bytes)
28453    }
28454
28455    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
28456    pub fn r#get_receive_buffer(
28457        &self,
28458    ) -> fidl::client::QueryResponseFut<
28459        BaseSocketGetReceiveBufferResult,
28460        fidl::encoding::DefaultFuchsiaResourceDialect,
28461    > {
28462        BaseSocketProxyInterface::r#get_receive_buffer(self)
28463    }
28464
28465    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
28466    pub fn r#set_keep_alive(
28467        &self,
28468        mut value: bool,
28469    ) -> fidl::client::QueryResponseFut<
28470        BaseSocketSetKeepAliveResult,
28471        fidl::encoding::DefaultFuchsiaResourceDialect,
28472    > {
28473        BaseSocketProxyInterface::r#set_keep_alive(self, value)
28474    }
28475
28476    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
28477    pub fn r#get_keep_alive(
28478        &self,
28479    ) -> fidl::client::QueryResponseFut<
28480        BaseSocketGetKeepAliveResult,
28481        fidl::encoding::DefaultFuchsiaResourceDialect,
28482    > {
28483        BaseSocketProxyInterface::r#get_keep_alive(self)
28484    }
28485
28486    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
28487    pub fn r#set_out_of_band_inline(
28488        &self,
28489        mut value: bool,
28490    ) -> fidl::client::QueryResponseFut<
28491        BaseSocketSetOutOfBandInlineResult,
28492        fidl::encoding::DefaultFuchsiaResourceDialect,
28493    > {
28494        BaseSocketProxyInterface::r#set_out_of_band_inline(self, value)
28495    }
28496
28497    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
28498    pub fn r#get_out_of_band_inline(
28499        &self,
28500    ) -> fidl::client::QueryResponseFut<
28501        BaseSocketGetOutOfBandInlineResult,
28502        fidl::encoding::DefaultFuchsiaResourceDialect,
28503    > {
28504        BaseSocketProxyInterface::r#get_out_of_band_inline(self)
28505    }
28506
28507    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
28508    pub fn r#set_no_check(
28509        &self,
28510        mut value: bool,
28511    ) -> fidl::client::QueryResponseFut<
28512        BaseSocketSetNoCheckResult,
28513        fidl::encoding::DefaultFuchsiaResourceDialect,
28514    > {
28515        BaseSocketProxyInterface::r#set_no_check(self, value)
28516    }
28517
28518    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
28519    pub fn r#get_no_check(
28520        &self,
28521    ) -> fidl::client::QueryResponseFut<
28522        BaseSocketGetNoCheckResult,
28523        fidl::encoding::DefaultFuchsiaResourceDialect,
28524    > {
28525        BaseSocketProxyInterface::r#get_no_check(self)
28526    }
28527
28528    /// Set `SOL_SOCKET` -> `SO_LINGER`.
28529    pub fn r#set_linger(
28530        &self,
28531        mut linger: bool,
28532        mut length_secs: u32,
28533    ) -> fidl::client::QueryResponseFut<
28534        BaseSocketSetLingerResult,
28535        fidl::encoding::DefaultFuchsiaResourceDialect,
28536    > {
28537        BaseSocketProxyInterface::r#set_linger(self, linger, length_secs)
28538    }
28539
28540    /// Get `SOL_SOCKET` -> `SO_LINGER`.
28541    pub fn r#get_linger(
28542        &self,
28543    ) -> fidl::client::QueryResponseFut<
28544        BaseSocketGetLingerResult,
28545        fidl::encoding::DefaultFuchsiaResourceDialect,
28546    > {
28547        BaseSocketProxyInterface::r#get_linger(self)
28548    }
28549
28550    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
28551    pub fn r#set_reuse_port(
28552        &self,
28553        mut value: bool,
28554    ) -> fidl::client::QueryResponseFut<
28555        BaseSocketSetReusePortResult,
28556        fidl::encoding::DefaultFuchsiaResourceDialect,
28557    > {
28558        BaseSocketProxyInterface::r#set_reuse_port(self, value)
28559    }
28560
28561    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
28562    pub fn r#get_reuse_port(
28563        &self,
28564    ) -> fidl::client::QueryResponseFut<
28565        BaseSocketGetReusePortResult,
28566        fidl::encoding::DefaultFuchsiaResourceDialect,
28567    > {
28568        BaseSocketProxyInterface::r#get_reuse_port(self)
28569    }
28570
28571    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
28572    pub fn r#get_accept_conn(
28573        &self,
28574    ) -> fidl::client::QueryResponseFut<
28575        BaseSocketGetAcceptConnResult,
28576        fidl::encoding::DefaultFuchsiaResourceDialect,
28577    > {
28578        BaseSocketProxyInterface::r#get_accept_conn(self)
28579    }
28580
28581    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
28582    pub fn r#set_bind_to_device(
28583        &self,
28584        mut value: &str,
28585    ) -> fidl::client::QueryResponseFut<
28586        BaseSocketSetBindToDeviceResult,
28587        fidl::encoding::DefaultFuchsiaResourceDialect,
28588    > {
28589        BaseSocketProxyInterface::r#set_bind_to_device(self, value)
28590    }
28591
28592    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
28593    pub fn r#get_bind_to_device(
28594        &self,
28595    ) -> fidl::client::QueryResponseFut<
28596        BaseSocketGetBindToDeviceResult,
28597        fidl::encoding::DefaultFuchsiaResourceDialect,
28598    > {
28599        BaseSocketProxyInterface::r#get_bind_to_device(self)
28600    }
28601
28602    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
28603    /// If `value` is 0, this clears the bound interface.
28604    pub fn r#set_bind_to_interface_index(
28605        &self,
28606        mut value: u64,
28607    ) -> fidl::client::QueryResponseFut<
28608        BaseSocketSetBindToInterfaceIndexResult,
28609        fidl::encoding::DefaultFuchsiaResourceDialect,
28610    > {
28611        BaseSocketProxyInterface::r#set_bind_to_interface_index(self, value)
28612    }
28613
28614    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
28615    pub fn r#get_bind_to_interface_index(
28616        &self,
28617    ) -> fidl::client::QueryResponseFut<
28618        BaseSocketGetBindToInterfaceIndexResult,
28619        fidl::encoding::DefaultFuchsiaResourceDialect,
28620    > {
28621        BaseSocketProxyInterface::r#get_bind_to_interface_index(self)
28622    }
28623
28624    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
28625    pub fn r#set_timestamp(
28626        &self,
28627        mut value: TimestampOption,
28628    ) -> fidl::client::QueryResponseFut<
28629        BaseSocketSetTimestampResult,
28630        fidl::encoding::DefaultFuchsiaResourceDialect,
28631    > {
28632        BaseSocketProxyInterface::r#set_timestamp(self, value)
28633    }
28634
28635    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
28636    pub fn r#get_timestamp(
28637        &self,
28638    ) -> fidl::client::QueryResponseFut<
28639        BaseSocketGetTimestampResult,
28640        fidl::encoding::DefaultFuchsiaResourceDialect,
28641    > {
28642        BaseSocketProxyInterface::r#get_timestamp(self)
28643    }
28644
28645    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
28646    /// unlike the standard SO_MARK, this API has multiple mark domains and each
28647    /// mark can be set independently in each domain.
28648    pub fn r#set_mark(
28649        &self,
28650        mut domain: fidl_fuchsia_net::MarkDomain,
28651        mut mark: &OptionalUint32,
28652    ) -> fidl::client::QueryResponseFut<
28653        BaseSocketSetMarkResult,
28654        fidl::encoding::DefaultFuchsiaResourceDialect,
28655    > {
28656        BaseSocketProxyInterface::r#set_mark(self, domain, mark)
28657    }
28658
28659    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
28660    /// unlike the standard SO_MARK, this API has multiple mark domains and each
28661    /// mark can be retrieved independently in each domain.
28662    pub fn r#get_mark(
28663        &self,
28664        mut domain: fidl_fuchsia_net::MarkDomain,
28665    ) -> fidl::client::QueryResponseFut<
28666        BaseSocketGetMarkResult,
28667        fidl::encoding::DefaultFuchsiaResourceDialect,
28668    > {
28669        BaseSocketProxyInterface::r#get_mark(self, domain)
28670    }
28671}
28672
28673impl BaseSocketProxyInterface for BaseSocketProxy {
28674    fn r#clone(
28675        &self,
28676        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
28677    ) -> Result<(), fidl::Error> {
28678        self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
28679            (request,),
28680            0x20d8a7aba2168a79,
28681            fidl::encoding::DynamicFlags::empty(),
28682        )
28683    }
28684
28685    type CloseResponseFut = fidl::client::QueryResponseFut<
28686        fidl_fuchsia_unknown::CloseableCloseResult,
28687        fidl::encoding::DefaultFuchsiaResourceDialect,
28688    >;
28689    fn r#close(&self) -> Self::CloseResponseFut {
28690        fn _decode(
28691            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
28692        ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
28693            let _response = fidl::client::decode_transaction_body::<
28694                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
28695                fidl::encoding::DefaultFuchsiaResourceDialect,
28696                0x5ac5d459ad7f657e,
28697            >(_buf?)?;
28698            Ok(_response.map(|x| x))
28699        }
28700        self.client.send_query_and_decode::<
28701            fidl::encoding::EmptyPayload,
28702            fidl_fuchsia_unknown::CloseableCloseResult,
28703        >(
28704            (),
28705            0x5ac5d459ad7f657e,
28706            fidl::encoding::DynamicFlags::empty(),
28707            _decode,
28708        )
28709    }
28710
28711    type QueryResponseFut =
28712        fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>;
28713    fn r#query(&self) -> Self::QueryResponseFut {
28714        fn _decode(
28715            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
28716        ) -> Result<Vec<u8>, fidl::Error> {
28717            let _response = fidl::client::decode_transaction_body::<
28718                fidl_fuchsia_unknown::QueryableQueryResponse,
28719                fidl::encoding::DefaultFuchsiaResourceDialect,
28720                0x2658edee9decfc06,
28721            >(_buf?)?;
28722            Ok(_response.protocol)
28723        }
28724        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<u8>>(
28725            (),
28726            0x2658edee9decfc06,
28727            fidl::encoding::DynamicFlags::empty(),
28728            _decode,
28729        )
28730    }
28731
28732    type SetReuseAddressResponseFut = fidl::client::QueryResponseFut<
28733        BaseSocketSetReuseAddressResult,
28734        fidl::encoding::DefaultFuchsiaResourceDialect,
28735    >;
28736    fn r#set_reuse_address(&self, mut value: bool) -> Self::SetReuseAddressResponseFut {
28737        fn _decode(
28738            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
28739        ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
28740            let _response = fidl::client::decode_transaction_body::<
28741                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
28742                fidl::encoding::DefaultFuchsiaResourceDialect,
28743                0x1fd74ee8b9a4a876,
28744            >(_buf?)?;
28745            Ok(_response.map(|x| x))
28746        }
28747        self.client.send_query_and_decode::<
28748            BaseSocketSetReuseAddressRequest,
28749            BaseSocketSetReuseAddressResult,
28750        >(
28751            (value,),
28752            0x1fd74ee8b9a4a876,
28753            fidl::encoding::DynamicFlags::empty(),
28754            _decode,
28755        )
28756    }
28757
28758    type GetReuseAddressResponseFut = fidl::client::QueryResponseFut<
28759        BaseSocketGetReuseAddressResult,
28760        fidl::encoding::DefaultFuchsiaResourceDialect,
28761    >;
28762    fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut {
28763        fn _decode(
28764            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
28765        ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
28766            let _response = fidl::client::decode_transaction_body::<
28767                fidl::encoding::ResultType<
28768                    BaseSocketGetReuseAddressResponse,
28769                    fidl_fuchsia_posix::Errno,
28770                >,
28771                fidl::encoding::DefaultFuchsiaResourceDialect,
28772                0x67b7206b8d1bc0a5,
28773            >(_buf?)?;
28774            Ok(_response.map(|x| x.value))
28775        }
28776        self.client
28777            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReuseAddressResult>(
28778                (),
28779                0x67b7206b8d1bc0a5,
28780                fidl::encoding::DynamicFlags::empty(),
28781                _decode,
28782            )
28783    }
28784
28785    type GetErrorResponseFut = fidl::client::QueryResponseFut<
28786        BaseSocketGetErrorResult,
28787        fidl::encoding::DefaultFuchsiaResourceDialect,
28788    >;
28789    fn r#get_error(&self) -> Self::GetErrorResponseFut {
28790        fn _decode(
28791            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
28792        ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
28793            let _response = fidl::client::decode_transaction_body::<
28794                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
28795                fidl::encoding::DefaultFuchsiaResourceDialect,
28796                0x5aad39b33e5f6ebb,
28797            >(_buf?)?;
28798            Ok(_response.map(|x| x))
28799        }
28800        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetErrorResult>(
28801            (),
28802            0x5aad39b33e5f6ebb,
28803            fidl::encoding::DynamicFlags::empty(),
28804            _decode,
28805        )
28806    }
28807
28808    type SetBroadcastResponseFut = fidl::client::QueryResponseFut<
28809        BaseSocketSetBroadcastResult,
28810        fidl::encoding::DefaultFuchsiaResourceDialect,
28811    >;
28812    fn r#set_broadcast(&self, mut value: bool) -> Self::SetBroadcastResponseFut {
28813        fn _decode(
28814            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
28815        ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
28816            let _response = fidl::client::decode_transaction_body::<
28817                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
28818                fidl::encoding::DefaultFuchsiaResourceDialect,
28819                0x6023e081ce3cd947,
28820            >(_buf?)?;
28821            Ok(_response.map(|x| x))
28822        }
28823        self.client
28824            .send_query_and_decode::<BaseSocketSetBroadcastRequest, BaseSocketSetBroadcastResult>(
28825                (value,),
28826                0x6023e081ce3cd947,
28827                fidl::encoding::DynamicFlags::empty(),
28828                _decode,
28829            )
28830    }
28831
28832    type GetBroadcastResponseFut = fidl::client::QueryResponseFut<
28833        BaseSocketGetBroadcastResult,
28834        fidl::encoding::DefaultFuchsiaResourceDialect,
28835    >;
28836    fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut {
28837        fn _decode(
28838            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
28839        ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
28840            let _response = fidl::client::decode_transaction_body::<
28841                fidl::encoding::ResultType<
28842                    BaseSocketGetBroadcastResponse,
28843                    fidl_fuchsia_posix::Errno,
28844                >,
28845                fidl::encoding::DefaultFuchsiaResourceDialect,
28846                0x68796fc556f9780d,
28847            >(_buf?)?;
28848            Ok(_response.map(|x| x.value))
28849        }
28850        self.client
28851            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBroadcastResult>(
28852                (),
28853                0x68796fc556f9780d,
28854                fidl::encoding::DynamicFlags::empty(),
28855                _decode,
28856            )
28857    }
28858
28859    type SetSendBufferResponseFut = fidl::client::QueryResponseFut<
28860        BaseSocketSetSendBufferResult,
28861        fidl::encoding::DefaultFuchsiaResourceDialect,
28862    >;
28863    fn r#set_send_buffer(&self, mut value_bytes: u64) -> Self::SetSendBufferResponseFut {
28864        fn _decode(
28865            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
28866        ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
28867            let _response = fidl::client::decode_transaction_body::<
28868                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
28869                fidl::encoding::DefaultFuchsiaResourceDialect,
28870                0x756eac32d73a7a70,
28871            >(_buf?)?;
28872            Ok(_response.map(|x| x))
28873        }
28874        self.client
28875            .send_query_and_decode::<BaseSocketSetSendBufferRequest, BaseSocketSetSendBufferResult>(
28876                (value_bytes,),
28877                0x756eac32d73a7a70,
28878                fidl::encoding::DynamicFlags::empty(),
28879                _decode,
28880            )
28881    }
28882
28883    type GetSendBufferResponseFut = fidl::client::QueryResponseFut<
28884        BaseSocketGetSendBufferResult,
28885        fidl::encoding::DefaultFuchsiaResourceDialect,
28886    >;
28887    fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut {
28888        fn _decode(
28889            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
28890        ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
28891            let _response = fidl::client::decode_transaction_body::<
28892                fidl::encoding::ResultType<
28893                    BaseSocketGetSendBufferResponse,
28894                    fidl_fuchsia_posix::Errno,
28895                >,
28896                fidl::encoding::DefaultFuchsiaResourceDialect,
28897                0x78a52fd9c7b2410b,
28898            >(_buf?)?;
28899            Ok(_response.map(|x| x.value_bytes))
28900        }
28901        self.client
28902            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetSendBufferResult>(
28903                (),
28904                0x78a52fd9c7b2410b,
28905                fidl::encoding::DynamicFlags::empty(),
28906                _decode,
28907            )
28908    }
28909
28910    type SetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
28911        BaseSocketSetReceiveBufferResult,
28912        fidl::encoding::DefaultFuchsiaResourceDialect,
28913    >;
28914    fn r#set_receive_buffer(&self, mut value_bytes: u64) -> Self::SetReceiveBufferResponseFut {
28915        fn _decode(
28916            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
28917        ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
28918            let _response = fidl::client::decode_transaction_body::<
28919                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
28920                fidl::encoding::DefaultFuchsiaResourceDialect,
28921                0x6b0cf2f1919c7001,
28922            >(_buf?)?;
28923            Ok(_response.map(|x| x))
28924        }
28925        self.client.send_query_and_decode::<
28926            BaseSocketSetReceiveBufferRequest,
28927            BaseSocketSetReceiveBufferResult,
28928        >(
28929            (value_bytes,),
28930            0x6b0cf2f1919c7001,
28931            fidl::encoding::DynamicFlags::empty(),
28932            _decode,
28933        )
28934    }
28935
28936    type GetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
28937        BaseSocketGetReceiveBufferResult,
28938        fidl::encoding::DefaultFuchsiaResourceDialect,
28939    >;
28940    fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut {
28941        fn _decode(
28942            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
28943        ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
28944            let _response = fidl::client::decode_transaction_body::<
28945                fidl::encoding::ResultType<
28946                    BaseSocketGetReceiveBufferResponse,
28947                    fidl_fuchsia_posix::Errno,
28948                >,
28949                fidl::encoding::DefaultFuchsiaResourceDialect,
28950                0x14c1a4b64f709e5c,
28951            >(_buf?)?;
28952            Ok(_response.map(|x| x.value_bytes))
28953        }
28954        self.client.send_query_and_decode::<
28955            fidl::encoding::EmptyPayload,
28956            BaseSocketGetReceiveBufferResult,
28957        >(
28958            (),
28959            0x14c1a4b64f709e5c,
28960            fidl::encoding::DynamicFlags::empty(),
28961            _decode,
28962        )
28963    }
28964
28965    type SetKeepAliveResponseFut = fidl::client::QueryResponseFut<
28966        BaseSocketSetKeepAliveResult,
28967        fidl::encoding::DefaultFuchsiaResourceDialect,
28968    >;
28969    fn r#set_keep_alive(&self, mut value: bool) -> Self::SetKeepAliveResponseFut {
28970        fn _decode(
28971            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
28972        ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
28973            let _response = fidl::client::decode_transaction_body::<
28974                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
28975                fidl::encoding::DefaultFuchsiaResourceDialect,
28976                0x572df8f0b920d2c7,
28977            >(_buf?)?;
28978            Ok(_response.map(|x| x))
28979        }
28980        self.client
28981            .send_query_and_decode::<BaseSocketSetKeepAliveRequest, BaseSocketSetKeepAliveResult>(
28982                (value,),
28983                0x572df8f0b920d2c7,
28984                fidl::encoding::DynamicFlags::empty(),
28985                _decode,
28986            )
28987    }
28988
28989    type GetKeepAliveResponseFut = fidl::client::QueryResponseFut<
28990        BaseSocketGetKeepAliveResult,
28991        fidl::encoding::DefaultFuchsiaResourceDialect,
28992    >;
28993    fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut {
28994        fn _decode(
28995            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
28996        ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
28997            let _response = fidl::client::decode_transaction_body::<
28998                fidl::encoding::ResultType<
28999                    BaseSocketGetKeepAliveResponse,
29000                    fidl_fuchsia_posix::Errno,
29001                >,
29002                fidl::encoding::DefaultFuchsiaResourceDialect,
29003                0x2dd29d3215f2c9d2,
29004            >(_buf?)?;
29005            Ok(_response.map(|x| x.value))
29006        }
29007        self.client
29008            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetKeepAliveResult>(
29009                (),
29010                0x2dd29d3215f2c9d2,
29011                fidl::encoding::DynamicFlags::empty(),
29012                _decode,
29013            )
29014    }
29015
29016    type SetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
29017        BaseSocketSetOutOfBandInlineResult,
29018        fidl::encoding::DefaultFuchsiaResourceDialect,
29019    >;
29020    fn r#set_out_of_band_inline(&self, mut value: bool) -> Self::SetOutOfBandInlineResponseFut {
29021        fn _decode(
29022            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29023        ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
29024            let _response = fidl::client::decode_transaction_body::<
29025                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
29026                fidl::encoding::DefaultFuchsiaResourceDialect,
29027                0x3ecb49968bee439,
29028            >(_buf?)?;
29029            Ok(_response.map(|x| x))
29030        }
29031        self.client.send_query_and_decode::<
29032            BaseSocketSetOutOfBandInlineRequest,
29033            BaseSocketSetOutOfBandInlineResult,
29034        >(
29035            (value,),
29036            0x3ecb49968bee439,
29037            fidl::encoding::DynamicFlags::empty(),
29038            _decode,
29039        )
29040    }
29041
29042    type GetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
29043        BaseSocketGetOutOfBandInlineResult,
29044        fidl::encoding::DefaultFuchsiaResourceDialect,
29045    >;
29046    fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut {
29047        fn _decode(
29048            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29049        ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
29050            let _response = fidl::client::decode_transaction_body::<
29051                fidl::encoding::ResultType<
29052                    BaseSocketGetOutOfBandInlineResponse,
29053                    fidl_fuchsia_posix::Errno,
29054                >,
29055                fidl::encoding::DefaultFuchsiaResourceDialect,
29056                0x348c1ab3aeca1745,
29057            >(_buf?)?;
29058            Ok(_response.map(|x| x.value))
29059        }
29060        self.client.send_query_and_decode::<
29061            fidl::encoding::EmptyPayload,
29062            BaseSocketGetOutOfBandInlineResult,
29063        >(
29064            (),
29065            0x348c1ab3aeca1745,
29066            fidl::encoding::DynamicFlags::empty(),
29067            _decode,
29068        )
29069    }
29070
29071    type SetNoCheckResponseFut = fidl::client::QueryResponseFut<
29072        BaseSocketSetNoCheckResult,
29073        fidl::encoding::DefaultFuchsiaResourceDialect,
29074    >;
29075    fn r#set_no_check(&self, mut value: bool) -> Self::SetNoCheckResponseFut {
29076        fn _decode(
29077            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29078        ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
29079            let _response = fidl::client::decode_transaction_body::<
29080                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
29081                fidl::encoding::DefaultFuchsiaResourceDialect,
29082                0x6bbf00c53a4c78c2,
29083            >(_buf?)?;
29084            Ok(_response.map(|x| x))
29085        }
29086        self.client
29087            .send_query_and_decode::<BaseSocketSetNoCheckRequest, BaseSocketSetNoCheckResult>(
29088                (value,),
29089                0x6bbf00c53a4c78c2,
29090                fidl::encoding::DynamicFlags::empty(),
29091                _decode,
29092            )
29093    }
29094
29095    type GetNoCheckResponseFut = fidl::client::QueryResponseFut<
29096        BaseSocketGetNoCheckResult,
29097        fidl::encoding::DefaultFuchsiaResourceDialect,
29098    >;
29099    fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut {
29100        fn _decode(
29101            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29102        ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
29103            let _response = fidl::client::decode_transaction_body::<
29104                fidl::encoding::ResultType<BaseSocketGetNoCheckResponse, fidl_fuchsia_posix::Errno>,
29105                fidl::encoding::DefaultFuchsiaResourceDialect,
29106                0x2cd4249286417694,
29107            >(_buf?)?;
29108            Ok(_response.map(|x| x.value))
29109        }
29110        self.client
29111            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetNoCheckResult>(
29112                (),
29113                0x2cd4249286417694,
29114                fidl::encoding::DynamicFlags::empty(),
29115                _decode,
29116            )
29117    }
29118
29119    type SetLingerResponseFut = fidl::client::QueryResponseFut<
29120        BaseSocketSetLingerResult,
29121        fidl::encoding::DefaultFuchsiaResourceDialect,
29122    >;
29123    fn r#set_linger(&self, mut linger: bool, mut length_secs: u32) -> Self::SetLingerResponseFut {
29124        fn _decode(
29125            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29126        ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
29127            let _response = fidl::client::decode_transaction_body::<
29128                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
29129                fidl::encoding::DefaultFuchsiaResourceDialect,
29130                0x45386351246e998e,
29131            >(_buf?)?;
29132            Ok(_response.map(|x| x))
29133        }
29134        self.client.send_query_and_decode::<BaseSocketSetLingerRequest, BaseSocketSetLingerResult>(
29135            (linger, length_secs),
29136            0x45386351246e998e,
29137            fidl::encoding::DynamicFlags::empty(),
29138            _decode,
29139        )
29140    }
29141
29142    type GetLingerResponseFut = fidl::client::QueryResponseFut<
29143        BaseSocketGetLingerResult,
29144        fidl::encoding::DefaultFuchsiaResourceDialect,
29145    >;
29146    fn r#get_linger(&self) -> Self::GetLingerResponseFut {
29147        fn _decode(
29148            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29149        ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
29150            let _response = fidl::client::decode_transaction_body::<
29151                fidl::encoding::ResultType<BaseSocketGetLingerResponse, fidl_fuchsia_posix::Errno>,
29152                fidl::encoding::DefaultFuchsiaResourceDialect,
29153                0x48eb20fc5ccb0e45,
29154            >(_buf?)?;
29155            Ok(_response.map(|x| (x.linger, x.length_secs)))
29156        }
29157        self.client
29158            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetLingerResult>(
29159                (),
29160                0x48eb20fc5ccb0e45,
29161                fidl::encoding::DynamicFlags::empty(),
29162                _decode,
29163            )
29164    }
29165
29166    type SetReusePortResponseFut = fidl::client::QueryResponseFut<
29167        BaseSocketSetReusePortResult,
29168        fidl::encoding::DefaultFuchsiaResourceDialect,
29169    >;
29170    fn r#set_reuse_port(&self, mut value: bool) -> Self::SetReusePortResponseFut {
29171        fn _decode(
29172            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29173        ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
29174            let _response = fidl::client::decode_transaction_body::<
29175                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
29176                fidl::encoding::DefaultFuchsiaResourceDialect,
29177                0x24dd3e5cb36d9ccb,
29178            >(_buf?)?;
29179            Ok(_response.map(|x| x))
29180        }
29181        self.client
29182            .send_query_and_decode::<BaseSocketSetReusePortRequest, BaseSocketSetReusePortResult>(
29183                (value,),
29184                0x24dd3e5cb36d9ccb,
29185                fidl::encoding::DynamicFlags::empty(),
29186                _decode,
29187            )
29188    }
29189
29190    type GetReusePortResponseFut = fidl::client::QueryResponseFut<
29191        BaseSocketGetReusePortResult,
29192        fidl::encoding::DefaultFuchsiaResourceDialect,
29193    >;
29194    fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut {
29195        fn _decode(
29196            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29197        ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
29198            let _response = fidl::client::decode_transaction_body::<
29199                fidl::encoding::ResultType<
29200                    BaseSocketGetReusePortResponse,
29201                    fidl_fuchsia_posix::Errno,
29202                >,
29203                fidl::encoding::DefaultFuchsiaResourceDialect,
29204                0x7a112c1ab54ff828,
29205            >(_buf?)?;
29206            Ok(_response.map(|x| x.value))
29207        }
29208        self.client
29209            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReusePortResult>(
29210                (),
29211                0x7a112c1ab54ff828,
29212                fidl::encoding::DynamicFlags::empty(),
29213                _decode,
29214            )
29215    }
29216
29217    type GetAcceptConnResponseFut = fidl::client::QueryResponseFut<
29218        BaseSocketGetAcceptConnResult,
29219        fidl::encoding::DefaultFuchsiaResourceDialect,
29220    >;
29221    fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut {
29222        fn _decode(
29223            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29224        ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
29225            let _response = fidl::client::decode_transaction_body::<
29226                fidl::encoding::ResultType<
29227                    BaseSocketGetAcceptConnResponse,
29228                    fidl_fuchsia_posix::Errno,
29229                >,
29230                fidl::encoding::DefaultFuchsiaResourceDialect,
29231                0x67ce6db6c2ec8966,
29232            >(_buf?)?;
29233            Ok(_response.map(|x| x.value))
29234        }
29235        self.client
29236            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetAcceptConnResult>(
29237                (),
29238                0x67ce6db6c2ec8966,
29239                fidl::encoding::DynamicFlags::empty(),
29240                _decode,
29241            )
29242    }
29243
29244    type SetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
29245        BaseSocketSetBindToDeviceResult,
29246        fidl::encoding::DefaultFuchsiaResourceDialect,
29247    >;
29248    fn r#set_bind_to_device(&self, mut value: &str) -> Self::SetBindToDeviceResponseFut {
29249        fn _decode(
29250            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29251        ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
29252            let _response = fidl::client::decode_transaction_body::<
29253                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
29254                fidl::encoding::DefaultFuchsiaResourceDialect,
29255                0x2118b483f28aafc4,
29256            >(_buf?)?;
29257            Ok(_response.map(|x| x))
29258        }
29259        self.client.send_query_and_decode::<
29260            BaseSocketSetBindToDeviceRequest,
29261            BaseSocketSetBindToDeviceResult,
29262        >(
29263            (value,),
29264            0x2118b483f28aafc4,
29265            fidl::encoding::DynamicFlags::empty(),
29266            _decode,
29267        )
29268    }
29269
29270    type GetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
29271        BaseSocketGetBindToDeviceResult,
29272        fidl::encoding::DefaultFuchsiaResourceDialect,
29273    >;
29274    fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut {
29275        fn _decode(
29276            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29277        ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
29278            let _response = fidl::client::decode_transaction_body::<
29279                fidl::encoding::ResultType<
29280                    BaseSocketGetBindToDeviceResponse,
29281                    fidl_fuchsia_posix::Errno,
29282                >,
29283                fidl::encoding::DefaultFuchsiaResourceDialect,
29284                0x1ab1fbf0ef7906c8,
29285            >(_buf?)?;
29286            Ok(_response.map(|x| x.value))
29287        }
29288        self.client
29289            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBindToDeviceResult>(
29290                (),
29291                0x1ab1fbf0ef7906c8,
29292                fidl::encoding::DynamicFlags::empty(),
29293                _decode,
29294            )
29295    }
29296
29297    type SetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
29298        BaseSocketSetBindToInterfaceIndexResult,
29299        fidl::encoding::DefaultFuchsiaResourceDialect,
29300    >;
29301    fn r#set_bind_to_interface_index(
29302        &self,
29303        mut value: u64,
29304    ) -> Self::SetBindToInterfaceIndexResponseFut {
29305        fn _decode(
29306            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29307        ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
29308            let _response = fidl::client::decode_transaction_body::<
29309                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
29310                fidl::encoding::DefaultFuchsiaResourceDialect,
29311                0x6e387a0def00821,
29312            >(_buf?)?;
29313            Ok(_response.map(|x| x))
29314        }
29315        self.client.send_query_and_decode::<
29316            BaseSocketSetBindToInterfaceIndexRequest,
29317            BaseSocketSetBindToInterfaceIndexResult,
29318        >(
29319            (value,),
29320            0x6e387a0def00821,
29321            fidl::encoding::DynamicFlags::empty(),
29322            _decode,
29323        )
29324    }
29325
29326    type GetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
29327        BaseSocketGetBindToInterfaceIndexResult,
29328        fidl::encoding::DefaultFuchsiaResourceDialect,
29329    >;
29330    fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut {
29331        fn _decode(
29332            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29333        ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
29334            let _response = fidl::client::decode_transaction_body::<
29335                fidl::encoding::ResultType<
29336                    BaseSocketGetBindToInterfaceIndexResponse,
29337                    fidl_fuchsia_posix::Errno,
29338                >,
29339                fidl::encoding::DefaultFuchsiaResourceDialect,
29340                0x59c31dd3e3078295,
29341            >(_buf?)?;
29342            Ok(_response.map(|x| x.value))
29343        }
29344        self.client.send_query_and_decode::<
29345            fidl::encoding::EmptyPayload,
29346            BaseSocketGetBindToInterfaceIndexResult,
29347        >(
29348            (),
29349            0x59c31dd3e3078295,
29350            fidl::encoding::DynamicFlags::empty(),
29351            _decode,
29352        )
29353    }
29354
29355    type SetTimestampResponseFut = fidl::client::QueryResponseFut<
29356        BaseSocketSetTimestampResult,
29357        fidl::encoding::DefaultFuchsiaResourceDialect,
29358    >;
29359    fn r#set_timestamp(&self, mut value: TimestampOption) -> Self::SetTimestampResponseFut {
29360        fn _decode(
29361            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29362        ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
29363            let _response = fidl::client::decode_transaction_body::<
29364                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
29365                fidl::encoding::DefaultFuchsiaResourceDialect,
29366                0x285d6516c263d839,
29367            >(_buf?)?;
29368            Ok(_response.map(|x| x))
29369        }
29370        self.client
29371            .send_query_and_decode::<BaseSocketSetTimestampRequest, BaseSocketSetTimestampResult>(
29372                (value,),
29373                0x285d6516c263d839,
29374                fidl::encoding::DynamicFlags::empty(),
29375                _decode,
29376            )
29377    }
29378
29379    type GetTimestampResponseFut = fidl::client::QueryResponseFut<
29380        BaseSocketGetTimestampResult,
29381        fidl::encoding::DefaultFuchsiaResourceDialect,
29382    >;
29383    fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut {
29384        fn _decode(
29385            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29386        ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
29387            let _response = fidl::client::decode_transaction_body::<
29388                fidl::encoding::ResultType<
29389                    BaseSocketGetTimestampResponse,
29390                    fidl_fuchsia_posix::Errno,
29391                >,
29392                fidl::encoding::DefaultFuchsiaResourceDialect,
29393                0x49f2fffbbcc2bd27,
29394            >(_buf?)?;
29395            Ok(_response.map(|x| x.value))
29396        }
29397        self.client
29398            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetTimestampResult>(
29399                (),
29400                0x49f2fffbbcc2bd27,
29401                fidl::encoding::DynamicFlags::empty(),
29402                _decode,
29403            )
29404    }
29405
29406    type SetMarkResponseFut = fidl::client::QueryResponseFut<
29407        BaseSocketSetMarkResult,
29408        fidl::encoding::DefaultFuchsiaResourceDialect,
29409    >;
29410    fn r#set_mark(
29411        &self,
29412        mut domain: fidl_fuchsia_net::MarkDomain,
29413        mut mark: &OptionalUint32,
29414    ) -> Self::SetMarkResponseFut {
29415        fn _decode(
29416            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29417        ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
29418            let _response = fidl::client::decode_transaction_body::<
29419                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
29420                fidl::encoding::DefaultFuchsiaResourceDialect,
29421                0x6ead6de09f653236,
29422            >(_buf?)?;
29423            Ok(_response.map(|x| x))
29424        }
29425        self.client.send_query_and_decode::<BaseSocketSetMarkRequest, BaseSocketSetMarkResult>(
29426            (domain, mark),
29427            0x6ead6de09f653236,
29428            fidl::encoding::DynamicFlags::empty(),
29429            _decode,
29430        )
29431    }
29432
29433    type GetMarkResponseFut = fidl::client::QueryResponseFut<
29434        BaseSocketGetMarkResult,
29435        fidl::encoding::DefaultFuchsiaResourceDialect,
29436    >;
29437    fn r#get_mark(&self, mut domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut {
29438        fn _decode(
29439            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
29440        ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
29441            let _response = fidl::client::decode_transaction_body::<
29442                fidl::encoding::ResultType<BaseSocketGetMarkResponse, fidl_fuchsia_posix::Errno>,
29443                fidl::encoding::DefaultFuchsiaResourceDialect,
29444                0x57a2752c61d93d47,
29445            >(_buf?)?;
29446            Ok(_response.map(|x| x.mark))
29447        }
29448        self.client.send_query_and_decode::<BaseSocketGetMarkRequest, BaseSocketGetMarkResult>(
29449            (domain,),
29450            0x57a2752c61d93d47,
29451            fidl::encoding::DynamicFlags::empty(),
29452            _decode,
29453        )
29454    }
29455}
29456
29457pub struct BaseSocketEventStream {
29458    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
29459}
29460
29461impl std::marker::Unpin for BaseSocketEventStream {}
29462
29463impl futures::stream::FusedStream for BaseSocketEventStream {
29464    fn is_terminated(&self) -> bool {
29465        self.event_receiver.is_terminated()
29466    }
29467}
29468
29469impl futures::Stream for BaseSocketEventStream {
29470    type Item = Result<BaseSocketEvent, fidl::Error>;
29471
29472    fn poll_next(
29473        mut self: std::pin::Pin<&mut Self>,
29474        cx: &mut std::task::Context<'_>,
29475    ) -> std::task::Poll<Option<Self::Item>> {
29476        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
29477            &mut self.event_receiver,
29478            cx
29479        )?) {
29480            Some(buf) => std::task::Poll::Ready(Some(BaseSocketEvent::decode(buf))),
29481            None => std::task::Poll::Ready(None),
29482        }
29483    }
29484}
29485
29486#[derive(Debug)]
29487pub enum BaseSocketEvent {}
29488
29489impl BaseSocketEvent {
29490    /// Decodes a message buffer as a [`BaseSocketEvent`].
29491    fn decode(
29492        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
29493    ) -> Result<BaseSocketEvent, fidl::Error> {
29494        let (bytes, _handles) = buf.split_mut();
29495        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
29496        debug_assert_eq!(tx_header.tx_id, 0);
29497        match tx_header.ordinal {
29498            _ => Err(fidl::Error::UnknownOrdinal {
29499                ordinal: tx_header.ordinal,
29500                protocol_name: <BaseSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
29501            }),
29502        }
29503    }
29504}
29505
29506/// A Stream of incoming requests for fuchsia.posix.socket/BaseSocket.
29507pub struct BaseSocketRequestStream {
29508    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
29509    is_terminated: bool,
29510}
29511
29512impl std::marker::Unpin for BaseSocketRequestStream {}
29513
29514impl futures::stream::FusedStream for BaseSocketRequestStream {
29515    fn is_terminated(&self) -> bool {
29516        self.is_terminated
29517    }
29518}
29519
29520impl fidl::endpoints::RequestStream for BaseSocketRequestStream {
29521    type Protocol = BaseSocketMarker;
29522    type ControlHandle = BaseSocketControlHandle;
29523
29524    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
29525        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
29526    }
29527
29528    fn control_handle(&self) -> Self::ControlHandle {
29529        BaseSocketControlHandle { inner: self.inner.clone() }
29530    }
29531
29532    fn into_inner(
29533        self,
29534    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
29535    {
29536        (self.inner, self.is_terminated)
29537    }
29538
29539    fn from_inner(
29540        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
29541        is_terminated: bool,
29542    ) -> Self {
29543        Self { inner, is_terminated }
29544    }
29545}
29546
29547impl futures::Stream for BaseSocketRequestStream {
29548    type Item = Result<BaseSocketRequest, fidl::Error>;
29549
29550    fn poll_next(
29551        mut self: std::pin::Pin<&mut Self>,
29552        cx: &mut std::task::Context<'_>,
29553    ) -> std::task::Poll<Option<Self::Item>> {
29554        let this = &mut *self;
29555        if this.inner.check_shutdown(cx) {
29556            this.is_terminated = true;
29557            return std::task::Poll::Ready(None);
29558        }
29559        if this.is_terminated {
29560            panic!("polled BaseSocketRequestStream after completion");
29561        }
29562        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
29563            |bytes, handles| {
29564                match this.inner.channel().read_etc(cx, bytes, handles) {
29565                    std::task::Poll::Ready(Ok(())) => {}
29566                    std::task::Poll::Pending => return std::task::Poll::Pending,
29567                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
29568                        this.is_terminated = true;
29569                        return std::task::Poll::Ready(None);
29570                    }
29571                    std::task::Poll::Ready(Err(e)) => {
29572                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
29573                            e.into(),
29574                        ))))
29575                    }
29576                }
29577
29578                // A message has been received from the channel
29579                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
29580
29581                std::task::Poll::Ready(Some(match header.ordinal {
29582                    0x20d8a7aba2168a79 => {
29583                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
29584                        let mut req = fidl::new_empty!(
29585                            fidl_fuchsia_unknown::CloneableCloneRequest,
29586                            fidl::encoding::DefaultFuchsiaResourceDialect
29587                        );
29588                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_unknown::CloneableCloneRequest>(&header, _body_bytes, handles, &mut req)?;
29589                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29590                        Ok(BaseSocketRequest::Clone { request: req.request, control_handle })
29591                    }
29592                    0x5ac5d459ad7f657e => {
29593                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29594                        let mut req = fidl::new_empty!(
29595                            fidl::encoding::EmptyPayload,
29596                            fidl::encoding::DefaultFuchsiaResourceDialect
29597                        );
29598                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
29599                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29600                        Ok(BaseSocketRequest::Close {
29601                            responder: BaseSocketCloseResponder {
29602                                control_handle: std::mem::ManuallyDrop::new(control_handle),
29603                                tx_id: header.tx_id,
29604                            },
29605                        })
29606                    }
29607                    0x2658edee9decfc06 => {
29608                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29609                        let mut req = fidl::new_empty!(
29610                            fidl::encoding::EmptyPayload,
29611                            fidl::encoding::DefaultFuchsiaResourceDialect
29612                        );
29613                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
29614                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29615                        Ok(BaseSocketRequest::Query {
29616                            responder: BaseSocketQueryResponder {
29617                                control_handle: std::mem::ManuallyDrop::new(control_handle),
29618                                tx_id: header.tx_id,
29619                            },
29620                        })
29621                    }
29622                    0x1fd74ee8b9a4a876 => {
29623                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29624                        let mut req = fidl::new_empty!(
29625                            BaseSocketSetReuseAddressRequest,
29626                            fidl::encoding::DefaultFuchsiaResourceDialect
29627                        );
29628                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReuseAddressRequest>(&header, _body_bytes, handles, &mut req)?;
29629                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29630                        Ok(BaseSocketRequest::SetReuseAddress {
29631                            value: req.value,
29632
29633                            responder: BaseSocketSetReuseAddressResponder {
29634                                control_handle: std::mem::ManuallyDrop::new(control_handle),
29635                                tx_id: header.tx_id,
29636                            },
29637                        })
29638                    }
29639                    0x67b7206b8d1bc0a5 => {
29640                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29641                        let mut req = fidl::new_empty!(
29642                            fidl::encoding::EmptyPayload,
29643                            fidl::encoding::DefaultFuchsiaResourceDialect
29644                        );
29645                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
29646                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29647                        Ok(BaseSocketRequest::GetReuseAddress {
29648                            responder: BaseSocketGetReuseAddressResponder {
29649                                control_handle: std::mem::ManuallyDrop::new(control_handle),
29650                                tx_id: header.tx_id,
29651                            },
29652                        })
29653                    }
29654                    0x5aad39b33e5f6ebb => {
29655                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29656                        let mut req = fidl::new_empty!(
29657                            fidl::encoding::EmptyPayload,
29658                            fidl::encoding::DefaultFuchsiaResourceDialect
29659                        );
29660                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
29661                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29662                        Ok(BaseSocketRequest::GetError {
29663                            responder: BaseSocketGetErrorResponder {
29664                                control_handle: std::mem::ManuallyDrop::new(control_handle),
29665                                tx_id: header.tx_id,
29666                            },
29667                        })
29668                    }
29669                    0x6023e081ce3cd947 => {
29670                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29671                        let mut req = fidl::new_empty!(
29672                            BaseSocketSetBroadcastRequest,
29673                            fidl::encoding::DefaultFuchsiaResourceDialect
29674                        );
29675                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBroadcastRequest>(&header, _body_bytes, handles, &mut req)?;
29676                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29677                        Ok(BaseSocketRequest::SetBroadcast {
29678                            value: req.value,
29679
29680                            responder: BaseSocketSetBroadcastResponder {
29681                                control_handle: std::mem::ManuallyDrop::new(control_handle),
29682                                tx_id: header.tx_id,
29683                            },
29684                        })
29685                    }
29686                    0x68796fc556f9780d => {
29687                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29688                        let mut req = fidl::new_empty!(
29689                            fidl::encoding::EmptyPayload,
29690                            fidl::encoding::DefaultFuchsiaResourceDialect
29691                        );
29692                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
29693                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29694                        Ok(BaseSocketRequest::GetBroadcast {
29695                            responder: BaseSocketGetBroadcastResponder {
29696                                control_handle: std::mem::ManuallyDrop::new(control_handle),
29697                                tx_id: header.tx_id,
29698                            },
29699                        })
29700                    }
29701                    0x756eac32d73a7a70 => {
29702                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29703                        let mut req = fidl::new_empty!(
29704                            BaseSocketSetSendBufferRequest,
29705                            fidl::encoding::DefaultFuchsiaResourceDialect
29706                        );
29707                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetSendBufferRequest>(&header, _body_bytes, handles, &mut req)?;
29708                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29709                        Ok(BaseSocketRequest::SetSendBuffer {
29710                            value_bytes: req.value_bytes,
29711
29712                            responder: BaseSocketSetSendBufferResponder {
29713                                control_handle: std::mem::ManuallyDrop::new(control_handle),
29714                                tx_id: header.tx_id,
29715                            },
29716                        })
29717                    }
29718                    0x78a52fd9c7b2410b => {
29719                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29720                        let mut req = fidl::new_empty!(
29721                            fidl::encoding::EmptyPayload,
29722                            fidl::encoding::DefaultFuchsiaResourceDialect
29723                        );
29724                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
29725                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29726                        Ok(BaseSocketRequest::GetSendBuffer {
29727                            responder: BaseSocketGetSendBufferResponder {
29728                                control_handle: std::mem::ManuallyDrop::new(control_handle),
29729                                tx_id: header.tx_id,
29730                            },
29731                        })
29732                    }
29733                    0x6b0cf2f1919c7001 => {
29734                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29735                        let mut req = fidl::new_empty!(
29736                            BaseSocketSetReceiveBufferRequest,
29737                            fidl::encoding::DefaultFuchsiaResourceDialect
29738                        );
29739                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReceiveBufferRequest>(&header, _body_bytes, handles, &mut req)?;
29740                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29741                        Ok(BaseSocketRequest::SetReceiveBuffer {
29742                            value_bytes: req.value_bytes,
29743
29744                            responder: BaseSocketSetReceiveBufferResponder {
29745                                control_handle: std::mem::ManuallyDrop::new(control_handle),
29746                                tx_id: header.tx_id,
29747                            },
29748                        })
29749                    }
29750                    0x14c1a4b64f709e5c => {
29751                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29752                        let mut req = fidl::new_empty!(
29753                            fidl::encoding::EmptyPayload,
29754                            fidl::encoding::DefaultFuchsiaResourceDialect
29755                        );
29756                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
29757                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29758                        Ok(BaseSocketRequest::GetReceiveBuffer {
29759                            responder: BaseSocketGetReceiveBufferResponder {
29760                                control_handle: std::mem::ManuallyDrop::new(control_handle),
29761                                tx_id: header.tx_id,
29762                            },
29763                        })
29764                    }
29765                    0x572df8f0b920d2c7 => {
29766                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29767                        let mut req = fidl::new_empty!(
29768                            BaseSocketSetKeepAliveRequest,
29769                            fidl::encoding::DefaultFuchsiaResourceDialect
29770                        );
29771                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetKeepAliveRequest>(&header, _body_bytes, handles, &mut req)?;
29772                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29773                        Ok(BaseSocketRequest::SetKeepAlive {
29774                            value: req.value,
29775
29776                            responder: BaseSocketSetKeepAliveResponder {
29777                                control_handle: std::mem::ManuallyDrop::new(control_handle),
29778                                tx_id: header.tx_id,
29779                            },
29780                        })
29781                    }
29782                    0x2dd29d3215f2c9d2 => {
29783                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29784                        let mut req = fidl::new_empty!(
29785                            fidl::encoding::EmptyPayload,
29786                            fidl::encoding::DefaultFuchsiaResourceDialect
29787                        );
29788                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
29789                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29790                        Ok(BaseSocketRequest::GetKeepAlive {
29791                            responder: BaseSocketGetKeepAliveResponder {
29792                                control_handle: std::mem::ManuallyDrop::new(control_handle),
29793                                tx_id: header.tx_id,
29794                            },
29795                        })
29796                    }
29797                    0x3ecb49968bee439 => {
29798                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29799                        let mut req = fidl::new_empty!(
29800                            BaseSocketSetOutOfBandInlineRequest,
29801                            fidl::encoding::DefaultFuchsiaResourceDialect
29802                        );
29803                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetOutOfBandInlineRequest>(&header, _body_bytes, handles, &mut req)?;
29804                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29805                        Ok(BaseSocketRequest::SetOutOfBandInline {
29806                            value: req.value,
29807
29808                            responder: BaseSocketSetOutOfBandInlineResponder {
29809                                control_handle: std::mem::ManuallyDrop::new(control_handle),
29810                                tx_id: header.tx_id,
29811                            },
29812                        })
29813                    }
29814                    0x348c1ab3aeca1745 => {
29815                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29816                        let mut req = fidl::new_empty!(
29817                            fidl::encoding::EmptyPayload,
29818                            fidl::encoding::DefaultFuchsiaResourceDialect
29819                        );
29820                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
29821                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29822                        Ok(BaseSocketRequest::GetOutOfBandInline {
29823                            responder: BaseSocketGetOutOfBandInlineResponder {
29824                                control_handle: std::mem::ManuallyDrop::new(control_handle),
29825                                tx_id: header.tx_id,
29826                            },
29827                        })
29828                    }
29829                    0x6bbf00c53a4c78c2 => {
29830                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29831                        let mut req = fidl::new_empty!(
29832                            BaseSocketSetNoCheckRequest,
29833                            fidl::encoding::DefaultFuchsiaResourceDialect
29834                        );
29835                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetNoCheckRequest>(&header, _body_bytes, handles, &mut req)?;
29836                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29837                        Ok(BaseSocketRequest::SetNoCheck {
29838                            value: req.value,
29839
29840                            responder: BaseSocketSetNoCheckResponder {
29841                                control_handle: std::mem::ManuallyDrop::new(control_handle),
29842                                tx_id: header.tx_id,
29843                            },
29844                        })
29845                    }
29846                    0x2cd4249286417694 => {
29847                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29848                        let mut req = fidl::new_empty!(
29849                            fidl::encoding::EmptyPayload,
29850                            fidl::encoding::DefaultFuchsiaResourceDialect
29851                        );
29852                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
29853                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29854                        Ok(BaseSocketRequest::GetNoCheck {
29855                            responder: BaseSocketGetNoCheckResponder {
29856                                control_handle: std::mem::ManuallyDrop::new(control_handle),
29857                                tx_id: header.tx_id,
29858                            },
29859                        })
29860                    }
29861                    0x45386351246e998e => {
29862                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29863                        let mut req = fidl::new_empty!(
29864                            BaseSocketSetLingerRequest,
29865                            fidl::encoding::DefaultFuchsiaResourceDialect
29866                        );
29867                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetLingerRequest>(&header, _body_bytes, handles, &mut req)?;
29868                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29869                        Ok(BaseSocketRequest::SetLinger {
29870                            linger: req.linger,
29871                            length_secs: req.length_secs,
29872
29873                            responder: BaseSocketSetLingerResponder {
29874                                control_handle: std::mem::ManuallyDrop::new(control_handle),
29875                                tx_id: header.tx_id,
29876                            },
29877                        })
29878                    }
29879                    0x48eb20fc5ccb0e45 => {
29880                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29881                        let mut req = fidl::new_empty!(
29882                            fidl::encoding::EmptyPayload,
29883                            fidl::encoding::DefaultFuchsiaResourceDialect
29884                        );
29885                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
29886                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29887                        Ok(BaseSocketRequest::GetLinger {
29888                            responder: BaseSocketGetLingerResponder {
29889                                control_handle: std::mem::ManuallyDrop::new(control_handle),
29890                                tx_id: header.tx_id,
29891                            },
29892                        })
29893                    }
29894                    0x24dd3e5cb36d9ccb => {
29895                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29896                        let mut req = fidl::new_empty!(
29897                            BaseSocketSetReusePortRequest,
29898                            fidl::encoding::DefaultFuchsiaResourceDialect
29899                        );
29900                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReusePortRequest>(&header, _body_bytes, handles, &mut req)?;
29901                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29902                        Ok(BaseSocketRequest::SetReusePort {
29903                            value: req.value,
29904
29905                            responder: BaseSocketSetReusePortResponder {
29906                                control_handle: std::mem::ManuallyDrop::new(control_handle),
29907                                tx_id: header.tx_id,
29908                            },
29909                        })
29910                    }
29911                    0x7a112c1ab54ff828 => {
29912                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29913                        let mut req = fidl::new_empty!(
29914                            fidl::encoding::EmptyPayload,
29915                            fidl::encoding::DefaultFuchsiaResourceDialect
29916                        );
29917                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
29918                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29919                        Ok(BaseSocketRequest::GetReusePort {
29920                            responder: BaseSocketGetReusePortResponder {
29921                                control_handle: std::mem::ManuallyDrop::new(control_handle),
29922                                tx_id: header.tx_id,
29923                            },
29924                        })
29925                    }
29926                    0x67ce6db6c2ec8966 => {
29927                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29928                        let mut req = fidl::new_empty!(
29929                            fidl::encoding::EmptyPayload,
29930                            fidl::encoding::DefaultFuchsiaResourceDialect
29931                        );
29932                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
29933                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29934                        Ok(BaseSocketRequest::GetAcceptConn {
29935                            responder: BaseSocketGetAcceptConnResponder {
29936                                control_handle: std::mem::ManuallyDrop::new(control_handle),
29937                                tx_id: header.tx_id,
29938                            },
29939                        })
29940                    }
29941                    0x2118b483f28aafc4 => {
29942                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29943                        let mut req = fidl::new_empty!(
29944                            BaseSocketSetBindToDeviceRequest,
29945                            fidl::encoding::DefaultFuchsiaResourceDialect
29946                        );
29947                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToDeviceRequest>(&header, _body_bytes, handles, &mut req)?;
29948                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29949                        Ok(BaseSocketRequest::SetBindToDevice {
29950                            value: req.value,
29951
29952                            responder: BaseSocketSetBindToDeviceResponder {
29953                                control_handle: std::mem::ManuallyDrop::new(control_handle),
29954                                tx_id: header.tx_id,
29955                            },
29956                        })
29957                    }
29958                    0x1ab1fbf0ef7906c8 => {
29959                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29960                        let mut req = fidl::new_empty!(
29961                            fidl::encoding::EmptyPayload,
29962                            fidl::encoding::DefaultFuchsiaResourceDialect
29963                        );
29964                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
29965                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29966                        Ok(BaseSocketRequest::GetBindToDevice {
29967                            responder: BaseSocketGetBindToDeviceResponder {
29968                                control_handle: std::mem::ManuallyDrop::new(control_handle),
29969                                tx_id: header.tx_id,
29970                            },
29971                        })
29972                    }
29973                    0x6e387a0def00821 => {
29974                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29975                        let mut req = fidl::new_empty!(
29976                            BaseSocketSetBindToInterfaceIndexRequest,
29977                            fidl::encoding::DefaultFuchsiaResourceDialect
29978                        );
29979                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToInterfaceIndexRequest>(&header, _body_bytes, handles, &mut req)?;
29980                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29981                        Ok(BaseSocketRequest::SetBindToInterfaceIndex {
29982                            value: req.value,
29983
29984                            responder: BaseSocketSetBindToInterfaceIndexResponder {
29985                                control_handle: std::mem::ManuallyDrop::new(control_handle),
29986                                tx_id: header.tx_id,
29987                            },
29988                        })
29989                    }
29990                    0x59c31dd3e3078295 => {
29991                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
29992                        let mut req = fidl::new_empty!(
29993                            fidl::encoding::EmptyPayload,
29994                            fidl::encoding::DefaultFuchsiaResourceDialect
29995                        );
29996                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
29997                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
29998                        Ok(BaseSocketRequest::GetBindToInterfaceIndex {
29999                            responder: BaseSocketGetBindToInterfaceIndexResponder {
30000                                control_handle: std::mem::ManuallyDrop::new(control_handle),
30001                                tx_id: header.tx_id,
30002                            },
30003                        })
30004                    }
30005                    0x285d6516c263d839 => {
30006                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
30007                        let mut req = fidl::new_empty!(
30008                            BaseSocketSetTimestampRequest,
30009                            fidl::encoding::DefaultFuchsiaResourceDialect
30010                        );
30011                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetTimestampRequest>(&header, _body_bytes, handles, &mut req)?;
30012                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
30013                        Ok(BaseSocketRequest::SetTimestamp {
30014                            value: req.value,
30015
30016                            responder: BaseSocketSetTimestampResponder {
30017                                control_handle: std::mem::ManuallyDrop::new(control_handle),
30018                                tx_id: header.tx_id,
30019                            },
30020                        })
30021                    }
30022                    0x49f2fffbbcc2bd27 => {
30023                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
30024                        let mut req = fidl::new_empty!(
30025                            fidl::encoding::EmptyPayload,
30026                            fidl::encoding::DefaultFuchsiaResourceDialect
30027                        );
30028                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
30029                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
30030                        Ok(BaseSocketRequest::GetTimestamp {
30031                            responder: BaseSocketGetTimestampResponder {
30032                                control_handle: std::mem::ManuallyDrop::new(control_handle),
30033                                tx_id: header.tx_id,
30034                            },
30035                        })
30036                    }
30037                    0x6ead6de09f653236 => {
30038                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
30039                        let mut req = fidl::new_empty!(
30040                            BaseSocketSetMarkRequest,
30041                            fidl::encoding::DefaultFuchsiaResourceDialect
30042                        );
30043                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
30044                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
30045                        Ok(BaseSocketRequest::SetMark {
30046                            domain: req.domain,
30047                            mark: req.mark,
30048
30049                            responder: BaseSocketSetMarkResponder {
30050                                control_handle: std::mem::ManuallyDrop::new(control_handle),
30051                                tx_id: header.tx_id,
30052                            },
30053                        })
30054                    }
30055                    0x57a2752c61d93d47 => {
30056                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
30057                        let mut req = fidl::new_empty!(
30058                            BaseSocketGetMarkRequest,
30059                            fidl::encoding::DefaultFuchsiaResourceDialect
30060                        );
30061                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketGetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
30062                        let control_handle = BaseSocketControlHandle { inner: this.inner.clone() };
30063                        Ok(BaseSocketRequest::GetMark {
30064                            domain: req.domain,
30065
30066                            responder: BaseSocketGetMarkResponder {
30067                                control_handle: std::mem::ManuallyDrop::new(control_handle),
30068                                tx_id: header.tx_id,
30069                            },
30070                        })
30071                    }
30072                    _ => Err(fidl::Error::UnknownOrdinal {
30073                        ordinal: header.ordinal,
30074                        protocol_name:
30075                            <BaseSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
30076                    }),
30077                }))
30078            },
30079        )
30080    }
30081}
30082
30083/// A socket.
30084#[derive(Debug)]
30085pub enum BaseSocketRequest {
30086    Clone {
30087        request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
30088        control_handle: BaseSocketControlHandle,
30089    },
30090    /// Terminates the connection.
30091    ///
30092    /// After calling `Close`, the client must not send any other requests.
30093    ///
30094    /// Servers, after sending the status response, should close the connection
30095    /// regardless of status and without sending an epitaph.
30096    ///
30097    /// Closing the client end of the channel should be semantically equivalent
30098    /// to calling `Close` without knowing when the close has completed or its
30099    /// status.
30100    Close {
30101        responder: BaseSocketCloseResponder,
30102    },
30103    Query {
30104        responder: BaseSocketQueryResponder,
30105    },
30106    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
30107    SetReuseAddress {
30108        value: bool,
30109        responder: BaseSocketSetReuseAddressResponder,
30110    },
30111    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
30112    GetReuseAddress {
30113        responder: BaseSocketGetReuseAddressResponder,
30114    },
30115    /// Get `SOL_SOCKET` -> `SO_ERROR`.
30116    /// Returns the last error if there is an error set on the socket.
30117    GetError {
30118        responder: BaseSocketGetErrorResponder,
30119    },
30120    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
30121    SetBroadcast {
30122        value: bool,
30123        responder: BaseSocketSetBroadcastResponder,
30124    },
30125    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
30126    GetBroadcast {
30127        responder: BaseSocketGetBroadcastResponder,
30128    },
30129    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
30130    SetSendBuffer {
30131        value_bytes: u64,
30132        responder: BaseSocketSetSendBufferResponder,
30133    },
30134    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
30135    GetSendBuffer {
30136        responder: BaseSocketGetSendBufferResponder,
30137    },
30138    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
30139    SetReceiveBuffer {
30140        value_bytes: u64,
30141        responder: BaseSocketSetReceiveBufferResponder,
30142    },
30143    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
30144    GetReceiveBuffer {
30145        responder: BaseSocketGetReceiveBufferResponder,
30146    },
30147    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
30148    SetKeepAlive {
30149        value: bool,
30150        responder: BaseSocketSetKeepAliveResponder,
30151    },
30152    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
30153    GetKeepAlive {
30154        responder: BaseSocketGetKeepAliveResponder,
30155    },
30156    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
30157    SetOutOfBandInline {
30158        value: bool,
30159        responder: BaseSocketSetOutOfBandInlineResponder,
30160    },
30161    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
30162    GetOutOfBandInline {
30163        responder: BaseSocketGetOutOfBandInlineResponder,
30164    },
30165    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
30166    SetNoCheck {
30167        value: bool,
30168        responder: BaseSocketSetNoCheckResponder,
30169    },
30170    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
30171    GetNoCheck {
30172        responder: BaseSocketGetNoCheckResponder,
30173    },
30174    /// Set `SOL_SOCKET` -> `SO_LINGER`.
30175    SetLinger {
30176        linger: bool,
30177        length_secs: u32,
30178        responder: BaseSocketSetLingerResponder,
30179    },
30180    /// Get `SOL_SOCKET` -> `SO_LINGER`.
30181    GetLinger {
30182        responder: BaseSocketGetLingerResponder,
30183    },
30184    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
30185    SetReusePort {
30186        value: bool,
30187        responder: BaseSocketSetReusePortResponder,
30188    },
30189    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
30190    GetReusePort {
30191        responder: BaseSocketGetReusePortResponder,
30192    },
30193    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
30194    GetAcceptConn {
30195        responder: BaseSocketGetAcceptConnResponder,
30196    },
30197    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
30198    SetBindToDevice {
30199        value: String,
30200        responder: BaseSocketSetBindToDeviceResponder,
30201    },
30202    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
30203    GetBindToDevice {
30204        responder: BaseSocketGetBindToDeviceResponder,
30205    },
30206    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
30207    /// If `value` is 0, this clears the bound interface.
30208    SetBindToInterfaceIndex {
30209        value: u64,
30210        responder: BaseSocketSetBindToInterfaceIndexResponder,
30211    },
30212    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
30213    GetBindToInterfaceIndex {
30214        responder: BaseSocketGetBindToInterfaceIndexResponder,
30215    },
30216    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
30217    SetTimestamp {
30218        value: TimestampOption,
30219        responder: BaseSocketSetTimestampResponder,
30220    },
30221    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
30222    GetTimestamp {
30223        responder: BaseSocketGetTimestampResponder,
30224    },
30225    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
30226    /// unlike the standard SO_MARK, this API has multiple mark domains and each
30227    /// mark can be set independently in each domain.
30228    SetMark {
30229        domain: fidl_fuchsia_net::MarkDomain,
30230        mark: OptionalUint32,
30231        responder: BaseSocketSetMarkResponder,
30232    },
30233    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
30234    /// unlike the standard SO_MARK, this API has multiple mark domains and each
30235    /// mark can be retrieved independently in each domain.
30236    GetMark {
30237        domain: fidl_fuchsia_net::MarkDomain,
30238        responder: BaseSocketGetMarkResponder,
30239    },
30240}
30241
30242impl BaseSocketRequest {
30243    #[allow(irrefutable_let_patterns)]
30244    pub fn into_clone(
30245        self,
30246    ) -> Option<(
30247        fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
30248        BaseSocketControlHandle,
30249    )> {
30250        if let BaseSocketRequest::Clone { request, control_handle } = self {
30251            Some((request, control_handle))
30252        } else {
30253            None
30254        }
30255    }
30256
30257    #[allow(irrefutable_let_patterns)]
30258    pub fn into_close(self) -> Option<(BaseSocketCloseResponder)> {
30259        if let BaseSocketRequest::Close { responder } = self {
30260            Some((responder))
30261        } else {
30262            None
30263        }
30264    }
30265
30266    #[allow(irrefutable_let_patterns)]
30267    pub fn into_query(self) -> Option<(BaseSocketQueryResponder)> {
30268        if let BaseSocketRequest::Query { responder } = self {
30269            Some((responder))
30270        } else {
30271            None
30272        }
30273    }
30274
30275    #[allow(irrefutable_let_patterns)]
30276    pub fn into_set_reuse_address(self) -> Option<(bool, BaseSocketSetReuseAddressResponder)> {
30277        if let BaseSocketRequest::SetReuseAddress { value, responder } = self {
30278            Some((value, responder))
30279        } else {
30280            None
30281        }
30282    }
30283
30284    #[allow(irrefutable_let_patterns)]
30285    pub fn into_get_reuse_address(self) -> Option<(BaseSocketGetReuseAddressResponder)> {
30286        if let BaseSocketRequest::GetReuseAddress { responder } = self {
30287            Some((responder))
30288        } else {
30289            None
30290        }
30291    }
30292
30293    #[allow(irrefutable_let_patterns)]
30294    pub fn into_get_error(self) -> Option<(BaseSocketGetErrorResponder)> {
30295        if let BaseSocketRequest::GetError { responder } = self {
30296            Some((responder))
30297        } else {
30298            None
30299        }
30300    }
30301
30302    #[allow(irrefutable_let_patterns)]
30303    pub fn into_set_broadcast(self) -> Option<(bool, BaseSocketSetBroadcastResponder)> {
30304        if let BaseSocketRequest::SetBroadcast { value, responder } = self {
30305            Some((value, responder))
30306        } else {
30307            None
30308        }
30309    }
30310
30311    #[allow(irrefutable_let_patterns)]
30312    pub fn into_get_broadcast(self) -> Option<(BaseSocketGetBroadcastResponder)> {
30313        if let BaseSocketRequest::GetBroadcast { responder } = self {
30314            Some((responder))
30315        } else {
30316            None
30317        }
30318    }
30319
30320    #[allow(irrefutable_let_patterns)]
30321    pub fn into_set_send_buffer(self) -> Option<(u64, BaseSocketSetSendBufferResponder)> {
30322        if let BaseSocketRequest::SetSendBuffer { value_bytes, responder } = self {
30323            Some((value_bytes, responder))
30324        } else {
30325            None
30326        }
30327    }
30328
30329    #[allow(irrefutable_let_patterns)]
30330    pub fn into_get_send_buffer(self) -> Option<(BaseSocketGetSendBufferResponder)> {
30331        if let BaseSocketRequest::GetSendBuffer { responder } = self {
30332            Some((responder))
30333        } else {
30334            None
30335        }
30336    }
30337
30338    #[allow(irrefutable_let_patterns)]
30339    pub fn into_set_receive_buffer(self) -> Option<(u64, BaseSocketSetReceiveBufferResponder)> {
30340        if let BaseSocketRequest::SetReceiveBuffer { value_bytes, responder } = self {
30341            Some((value_bytes, responder))
30342        } else {
30343            None
30344        }
30345    }
30346
30347    #[allow(irrefutable_let_patterns)]
30348    pub fn into_get_receive_buffer(self) -> Option<(BaseSocketGetReceiveBufferResponder)> {
30349        if let BaseSocketRequest::GetReceiveBuffer { responder } = self {
30350            Some((responder))
30351        } else {
30352            None
30353        }
30354    }
30355
30356    #[allow(irrefutable_let_patterns)]
30357    pub fn into_set_keep_alive(self) -> Option<(bool, BaseSocketSetKeepAliveResponder)> {
30358        if let BaseSocketRequest::SetKeepAlive { value, responder } = self {
30359            Some((value, responder))
30360        } else {
30361            None
30362        }
30363    }
30364
30365    #[allow(irrefutable_let_patterns)]
30366    pub fn into_get_keep_alive(self) -> Option<(BaseSocketGetKeepAliveResponder)> {
30367        if let BaseSocketRequest::GetKeepAlive { responder } = self {
30368            Some((responder))
30369        } else {
30370            None
30371        }
30372    }
30373
30374    #[allow(irrefutable_let_patterns)]
30375    pub fn into_set_out_of_band_inline(
30376        self,
30377    ) -> Option<(bool, BaseSocketSetOutOfBandInlineResponder)> {
30378        if let BaseSocketRequest::SetOutOfBandInline { value, responder } = self {
30379            Some((value, responder))
30380        } else {
30381            None
30382        }
30383    }
30384
30385    #[allow(irrefutable_let_patterns)]
30386    pub fn into_get_out_of_band_inline(self) -> Option<(BaseSocketGetOutOfBandInlineResponder)> {
30387        if let BaseSocketRequest::GetOutOfBandInline { responder } = self {
30388            Some((responder))
30389        } else {
30390            None
30391        }
30392    }
30393
30394    #[allow(irrefutable_let_patterns)]
30395    pub fn into_set_no_check(self) -> Option<(bool, BaseSocketSetNoCheckResponder)> {
30396        if let BaseSocketRequest::SetNoCheck { value, responder } = self {
30397            Some((value, responder))
30398        } else {
30399            None
30400        }
30401    }
30402
30403    #[allow(irrefutable_let_patterns)]
30404    pub fn into_get_no_check(self) -> Option<(BaseSocketGetNoCheckResponder)> {
30405        if let BaseSocketRequest::GetNoCheck { responder } = self {
30406            Some((responder))
30407        } else {
30408            None
30409        }
30410    }
30411
30412    #[allow(irrefutable_let_patterns)]
30413    pub fn into_set_linger(self) -> Option<(bool, u32, BaseSocketSetLingerResponder)> {
30414        if let BaseSocketRequest::SetLinger { linger, length_secs, responder } = self {
30415            Some((linger, length_secs, responder))
30416        } else {
30417            None
30418        }
30419    }
30420
30421    #[allow(irrefutable_let_patterns)]
30422    pub fn into_get_linger(self) -> Option<(BaseSocketGetLingerResponder)> {
30423        if let BaseSocketRequest::GetLinger { responder } = self {
30424            Some((responder))
30425        } else {
30426            None
30427        }
30428    }
30429
30430    #[allow(irrefutable_let_patterns)]
30431    pub fn into_set_reuse_port(self) -> Option<(bool, BaseSocketSetReusePortResponder)> {
30432        if let BaseSocketRequest::SetReusePort { value, responder } = self {
30433            Some((value, responder))
30434        } else {
30435            None
30436        }
30437    }
30438
30439    #[allow(irrefutable_let_patterns)]
30440    pub fn into_get_reuse_port(self) -> Option<(BaseSocketGetReusePortResponder)> {
30441        if let BaseSocketRequest::GetReusePort { responder } = self {
30442            Some((responder))
30443        } else {
30444            None
30445        }
30446    }
30447
30448    #[allow(irrefutable_let_patterns)]
30449    pub fn into_get_accept_conn(self) -> Option<(BaseSocketGetAcceptConnResponder)> {
30450        if let BaseSocketRequest::GetAcceptConn { responder } = self {
30451            Some((responder))
30452        } else {
30453            None
30454        }
30455    }
30456
30457    #[allow(irrefutable_let_patterns)]
30458    pub fn into_set_bind_to_device(self) -> Option<(String, BaseSocketSetBindToDeviceResponder)> {
30459        if let BaseSocketRequest::SetBindToDevice { value, responder } = self {
30460            Some((value, responder))
30461        } else {
30462            None
30463        }
30464    }
30465
30466    #[allow(irrefutable_let_patterns)]
30467    pub fn into_get_bind_to_device(self) -> Option<(BaseSocketGetBindToDeviceResponder)> {
30468        if let BaseSocketRequest::GetBindToDevice { responder } = self {
30469            Some((responder))
30470        } else {
30471            None
30472        }
30473    }
30474
30475    #[allow(irrefutable_let_patterns)]
30476    pub fn into_set_bind_to_interface_index(
30477        self,
30478    ) -> Option<(u64, BaseSocketSetBindToInterfaceIndexResponder)> {
30479        if let BaseSocketRequest::SetBindToInterfaceIndex { value, responder } = self {
30480            Some((value, responder))
30481        } else {
30482            None
30483        }
30484    }
30485
30486    #[allow(irrefutable_let_patterns)]
30487    pub fn into_get_bind_to_interface_index(
30488        self,
30489    ) -> Option<(BaseSocketGetBindToInterfaceIndexResponder)> {
30490        if let BaseSocketRequest::GetBindToInterfaceIndex { responder } = self {
30491            Some((responder))
30492        } else {
30493            None
30494        }
30495    }
30496
30497    #[allow(irrefutable_let_patterns)]
30498    pub fn into_set_timestamp(self) -> Option<(TimestampOption, BaseSocketSetTimestampResponder)> {
30499        if let BaseSocketRequest::SetTimestamp { value, responder } = self {
30500            Some((value, responder))
30501        } else {
30502            None
30503        }
30504    }
30505
30506    #[allow(irrefutable_let_patterns)]
30507    pub fn into_get_timestamp(self) -> Option<(BaseSocketGetTimestampResponder)> {
30508        if let BaseSocketRequest::GetTimestamp { responder } = self {
30509            Some((responder))
30510        } else {
30511            None
30512        }
30513    }
30514
30515    #[allow(irrefutable_let_patterns)]
30516    pub fn into_set_mark(
30517        self,
30518    ) -> Option<(fidl_fuchsia_net::MarkDomain, OptionalUint32, BaseSocketSetMarkResponder)> {
30519        if let BaseSocketRequest::SetMark { domain, mark, responder } = self {
30520            Some((domain, mark, responder))
30521        } else {
30522            None
30523        }
30524    }
30525
30526    #[allow(irrefutable_let_patterns)]
30527    pub fn into_get_mark(
30528        self,
30529    ) -> Option<(fidl_fuchsia_net::MarkDomain, BaseSocketGetMarkResponder)> {
30530        if let BaseSocketRequest::GetMark { domain, responder } = self {
30531            Some((domain, responder))
30532        } else {
30533            None
30534        }
30535    }
30536
30537    /// Name of the method defined in FIDL
30538    pub fn method_name(&self) -> &'static str {
30539        match *self {
30540            BaseSocketRequest::Clone { .. } => "clone",
30541            BaseSocketRequest::Close { .. } => "close",
30542            BaseSocketRequest::Query { .. } => "query",
30543            BaseSocketRequest::SetReuseAddress { .. } => "set_reuse_address",
30544            BaseSocketRequest::GetReuseAddress { .. } => "get_reuse_address",
30545            BaseSocketRequest::GetError { .. } => "get_error",
30546            BaseSocketRequest::SetBroadcast { .. } => "set_broadcast",
30547            BaseSocketRequest::GetBroadcast { .. } => "get_broadcast",
30548            BaseSocketRequest::SetSendBuffer { .. } => "set_send_buffer",
30549            BaseSocketRequest::GetSendBuffer { .. } => "get_send_buffer",
30550            BaseSocketRequest::SetReceiveBuffer { .. } => "set_receive_buffer",
30551            BaseSocketRequest::GetReceiveBuffer { .. } => "get_receive_buffer",
30552            BaseSocketRequest::SetKeepAlive { .. } => "set_keep_alive",
30553            BaseSocketRequest::GetKeepAlive { .. } => "get_keep_alive",
30554            BaseSocketRequest::SetOutOfBandInline { .. } => "set_out_of_band_inline",
30555            BaseSocketRequest::GetOutOfBandInline { .. } => "get_out_of_band_inline",
30556            BaseSocketRequest::SetNoCheck { .. } => "set_no_check",
30557            BaseSocketRequest::GetNoCheck { .. } => "get_no_check",
30558            BaseSocketRequest::SetLinger { .. } => "set_linger",
30559            BaseSocketRequest::GetLinger { .. } => "get_linger",
30560            BaseSocketRequest::SetReusePort { .. } => "set_reuse_port",
30561            BaseSocketRequest::GetReusePort { .. } => "get_reuse_port",
30562            BaseSocketRequest::GetAcceptConn { .. } => "get_accept_conn",
30563            BaseSocketRequest::SetBindToDevice { .. } => "set_bind_to_device",
30564            BaseSocketRequest::GetBindToDevice { .. } => "get_bind_to_device",
30565            BaseSocketRequest::SetBindToInterfaceIndex { .. } => "set_bind_to_interface_index",
30566            BaseSocketRequest::GetBindToInterfaceIndex { .. } => "get_bind_to_interface_index",
30567            BaseSocketRequest::SetTimestamp { .. } => "set_timestamp",
30568            BaseSocketRequest::GetTimestamp { .. } => "get_timestamp",
30569            BaseSocketRequest::SetMark { .. } => "set_mark",
30570            BaseSocketRequest::GetMark { .. } => "get_mark",
30571        }
30572    }
30573}
30574
30575#[derive(Debug, Clone)]
30576pub struct BaseSocketControlHandle {
30577    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
30578}
30579
30580impl fidl::endpoints::ControlHandle for BaseSocketControlHandle {
30581    fn shutdown(&self) {
30582        self.inner.shutdown()
30583    }
30584    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
30585        self.inner.shutdown_with_epitaph(status)
30586    }
30587
30588    fn is_closed(&self) -> bool {
30589        self.inner.channel().is_closed()
30590    }
30591    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
30592        self.inner.channel().on_closed()
30593    }
30594
30595    #[cfg(target_os = "fuchsia")]
30596    fn signal_peer(
30597        &self,
30598        clear_mask: zx::Signals,
30599        set_mask: zx::Signals,
30600    ) -> Result<(), zx_status::Status> {
30601        use fidl::Peered;
30602        self.inner.channel().signal_peer(clear_mask, set_mask)
30603    }
30604}
30605
30606impl BaseSocketControlHandle {}
30607
30608#[must_use = "FIDL methods require a response to be sent"]
30609#[derive(Debug)]
30610pub struct BaseSocketCloseResponder {
30611    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
30612    tx_id: u32,
30613}
30614
30615/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
30616/// if the responder is dropped without sending a response, so that the client
30617/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
30618impl std::ops::Drop for BaseSocketCloseResponder {
30619    fn drop(&mut self) {
30620        self.control_handle.shutdown();
30621        // Safety: drops once, never accessed again
30622        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
30623    }
30624}
30625
30626impl fidl::endpoints::Responder for BaseSocketCloseResponder {
30627    type ControlHandle = BaseSocketControlHandle;
30628
30629    fn control_handle(&self) -> &BaseSocketControlHandle {
30630        &self.control_handle
30631    }
30632
30633    fn drop_without_shutdown(mut self) {
30634        // Safety: drops once, never accessed again due to mem::forget
30635        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
30636        // Prevent Drop from running (which would shut down the channel)
30637        std::mem::forget(self);
30638    }
30639}
30640
30641impl BaseSocketCloseResponder {
30642    /// Sends a response to the FIDL transaction.
30643    ///
30644    /// Sets the channel to shutdown if an error occurs.
30645    pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
30646        let _result = self.send_raw(result);
30647        if _result.is_err() {
30648            self.control_handle.shutdown();
30649        }
30650        self.drop_without_shutdown();
30651        _result
30652    }
30653
30654    /// Similar to "send" but does not shutdown the channel if an error occurs.
30655    pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
30656        let _result = self.send_raw(result);
30657        self.drop_without_shutdown();
30658        _result
30659    }
30660
30661    fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
30662        self.control_handle
30663            .inner
30664            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
30665                result,
30666                self.tx_id,
30667                0x5ac5d459ad7f657e,
30668                fidl::encoding::DynamicFlags::empty(),
30669            )
30670    }
30671}
30672
30673#[must_use = "FIDL methods require a response to be sent"]
30674#[derive(Debug)]
30675pub struct BaseSocketQueryResponder {
30676    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
30677    tx_id: u32,
30678}
30679
30680/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
30681/// if the responder is dropped without sending a response, so that the client
30682/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
30683impl std::ops::Drop for BaseSocketQueryResponder {
30684    fn drop(&mut self) {
30685        self.control_handle.shutdown();
30686        // Safety: drops once, never accessed again
30687        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
30688    }
30689}
30690
30691impl fidl::endpoints::Responder for BaseSocketQueryResponder {
30692    type ControlHandle = BaseSocketControlHandle;
30693
30694    fn control_handle(&self) -> &BaseSocketControlHandle {
30695        &self.control_handle
30696    }
30697
30698    fn drop_without_shutdown(mut self) {
30699        // Safety: drops once, never accessed again due to mem::forget
30700        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
30701        // Prevent Drop from running (which would shut down the channel)
30702        std::mem::forget(self);
30703    }
30704}
30705
30706impl BaseSocketQueryResponder {
30707    /// Sends a response to the FIDL transaction.
30708    ///
30709    /// Sets the channel to shutdown if an error occurs.
30710    pub fn send(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
30711        let _result = self.send_raw(protocol);
30712        if _result.is_err() {
30713            self.control_handle.shutdown();
30714        }
30715        self.drop_without_shutdown();
30716        _result
30717    }
30718
30719    /// Similar to "send" but does not shutdown the channel if an error occurs.
30720    pub fn send_no_shutdown_on_err(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
30721        let _result = self.send_raw(protocol);
30722        self.drop_without_shutdown();
30723        _result
30724    }
30725
30726    fn send_raw(&self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
30727        self.control_handle.inner.send::<fidl_fuchsia_unknown::QueryableQueryResponse>(
30728            (protocol,),
30729            self.tx_id,
30730            0x2658edee9decfc06,
30731            fidl::encoding::DynamicFlags::empty(),
30732        )
30733    }
30734}
30735
30736#[must_use = "FIDL methods require a response to be sent"]
30737#[derive(Debug)]
30738pub struct BaseSocketSetReuseAddressResponder {
30739    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
30740    tx_id: u32,
30741}
30742
30743/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
30744/// if the responder is dropped without sending a response, so that the client
30745/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
30746impl std::ops::Drop for BaseSocketSetReuseAddressResponder {
30747    fn drop(&mut self) {
30748        self.control_handle.shutdown();
30749        // Safety: drops once, never accessed again
30750        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
30751    }
30752}
30753
30754impl fidl::endpoints::Responder for BaseSocketSetReuseAddressResponder {
30755    type ControlHandle = BaseSocketControlHandle;
30756
30757    fn control_handle(&self) -> &BaseSocketControlHandle {
30758        &self.control_handle
30759    }
30760
30761    fn drop_without_shutdown(mut self) {
30762        // Safety: drops once, never accessed again due to mem::forget
30763        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
30764        // Prevent Drop from running (which would shut down the channel)
30765        std::mem::forget(self);
30766    }
30767}
30768
30769impl BaseSocketSetReuseAddressResponder {
30770    /// Sends a response to the FIDL transaction.
30771    ///
30772    /// Sets the channel to shutdown if an error occurs.
30773    pub fn send(
30774        self,
30775        mut result: Result<(), fidl_fuchsia_posix::Errno>,
30776    ) -> Result<(), fidl::Error> {
30777        let _result = self.send_raw(result);
30778        if _result.is_err() {
30779            self.control_handle.shutdown();
30780        }
30781        self.drop_without_shutdown();
30782        _result
30783    }
30784
30785    /// Similar to "send" but does not shutdown the channel if an error occurs.
30786    pub fn send_no_shutdown_on_err(
30787        self,
30788        mut result: Result<(), fidl_fuchsia_posix::Errno>,
30789    ) -> Result<(), fidl::Error> {
30790        let _result = self.send_raw(result);
30791        self.drop_without_shutdown();
30792        _result
30793    }
30794
30795    fn send_raw(
30796        &self,
30797        mut result: Result<(), fidl_fuchsia_posix::Errno>,
30798    ) -> Result<(), fidl::Error> {
30799        self.control_handle.inner.send::<fidl::encoding::ResultType<
30800            fidl::encoding::EmptyStruct,
30801            fidl_fuchsia_posix::Errno,
30802        >>(
30803            result,
30804            self.tx_id,
30805            0x1fd74ee8b9a4a876,
30806            fidl::encoding::DynamicFlags::empty(),
30807        )
30808    }
30809}
30810
30811#[must_use = "FIDL methods require a response to be sent"]
30812#[derive(Debug)]
30813pub struct BaseSocketGetReuseAddressResponder {
30814    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
30815    tx_id: u32,
30816}
30817
30818/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
30819/// if the responder is dropped without sending a response, so that the client
30820/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
30821impl std::ops::Drop for BaseSocketGetReuseAddressResponder {
30822    fn drop(&mut self) {
30823        self.control_handle.shutdown();
30824        // Safety: drops once, never accessed again
30825        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
30826    }
30827}
30828
30829impl fidl::endpoints::Responder for BaseSocketGetReuseAddressResponder {
30830    type ControlHandle = BaseSocketControlHandle;
30831
30832    fn control_handle(&self) -> &BaseSocketControlHandle {
30833        &self.control_handle
30834    }
30835
30836    fn drop_without_shutdown(mut self) {
30837        // Safety: drops once, never accessed again due to mem::forget
30838        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
30839        // Prevent Drop from running (which would shut down the channel)
30840        std::mem::forget(self);
30841    }
30842}
30843
30844impl BaseSocketGetReuseAddressResponder {
30845    /// Sends a response to the FIDL transaction.
30846    ///
30847    /// Sets the channel to shutdown if an error occurs.
30848    pub fn send(
30849        self,
30850        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
30851    ) -> Result<(), fidl::Error> {
30852        let _result = self.send_raw(result);
30853        if _result.is_err() {
30854            self.control_handle.shutdown();
30855        }
30856        self.drop_without_shutdown();
30857        _result
30858    }
30859
30860    /// Similar to "send" but does not shutdown the channel if an error occurs.
30861    pub fn send_no_shutdown_on_err(
30862        self,
30863        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
30864    ) -> Result<(), fidl::Error> {
30865        let _result = self.send_raw(result);
30866        self.drop_without_shutdown();
30867        _result
30868    }
30869
30870    fn send_raw(
30871        &self,
30872        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
30873    ) -> Result<(), fidl::Error> {
30874        self.control_handle.inner.send::<fidl::encoding::ResultType<
30875            BaseSocketGetReuseAddressResponse,
30876            fidl_fuchsia_posix::Errno,
30877        >>(
30878            result.map(|value| (value,)),
30879            self.tx_id,
30880            0x67b7206b8d1bc0a5,
30881            fidl::encoding::DynamicFlags::empty(),
30882        )
30883    }
30884}
30885
30886#[must_use = "FIDL methods require a response to be sent"]
30887#[derive(Debug)]
30888pub struct BaseSocketGetErrorResponder {
30889    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
30890    tx_id: u32,
30891}
30892
30893/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
30894/// if the responder is dropped without sending a response, so that the client
30895/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
30896impl std::ops::Drop for BaseSocketGetErrorResponder {
30897    fn drop(&mut self) {
30898        self.control_handle.shutdown();
30899        // Safety: drops once, never accessed again
30900        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
30901    }
30902}
30903
30904impl fidl::endpoints::Responder for BaseSocketGetErrorResponder {
30905    type ControlHandle = BaseSocketControlHandle;
30906
30907    fn control_handle(&self) -> &BaseSocketControlHandle {
30908        &self.control_handle
30909    }
30910
30911    fn drop_without_shutdown(mut self) {
30912        // Safety: drops once, never accessed again due to mem::forget
30913        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
30914        // Prevent Drop from running (which would shut down the channel)
30915        std::mem::forget(self);
30916    }
30917}
30918
30919impl BaseSocketGetErrorResponder {
30920    /// Sends a response to the FIDL transaction.
30921    ///
30922    /// Sets the channel to shutdown if an error occurs.
30923    pub fn send(
30924        self,
30925        mut result: Result<(), fidl_fuchsia_posix::Errno>,
30926    ) -> Result<(), fidl::Error> {
30927        let _result = self.send_raw(result);
30928        if _result.is_err() {
30929            self.control_handle.shutdown();
30930        }
30931        self.drop_without_shutdown();
30932        _result
30933    }
30934
30935    /// Similar to "send" but does not shutdown the channel if an error occurs.
30936    pub fn send_no_shutdown_on_err(
30937        self,
30938        mut result: Result<(), fidl_fuchsia_posix::Errno>,
30939    ) -> Result<(), fidl::Error> {
30940        let _result = self.send_raw(result);
30941        self.drop_without_shutdown();
30942        _result
30943    }
30944
30945    fn send_raw(
30946        &self,
30947        mut result: Result<(), fidl_fuchsia_posix::Errno>,
30948    ) -> Result<(), fidl::Error> {
30949        self.control_handle.inner.send::<fidl::encoding::ResultType<
30950            fidl::encoding::EmptyStruct,
30951            fidl_fuchsia_posix::Errno,
30952        >>(
30953            result,
30954            self.tx_id,
30955            0x5aad39b33e5f6ebb,
30956            fidl::encoding::DynamicFlags::empty(),
30957        )
30958    }
30959}
30960
30961#[must_use = "FIDL methods require a response to be sent"]
30962#[derive(Debug)]
30963pub struct BaseSocketSetBroadcastResponder {
30964    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
30965    tx_id: u32,
30966}
30967
30968/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
30969/// if the responder is dropped without sending a response, so that the client
30970/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
30971impl std::ops::Drop for BaseSocketSetBroadcastResponder {
30972    fn drop(&mut self) {
30973        self.control_handle.shutdown();
30974        // Safety: drops once, never accessed again
30975        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
30976    }
30977}
30978
30979impl fidl::endpoints::Responder for BaseSocketSetBroadcastResponder {
30980    type ControlHandle = BaseSocketControlHandle;
30981
30982    fn control_handle(&self) -> &BaseSocketControlHandle {
30983        &self.control_handle
30984    }
30985
30986    fn drop_without_shutdown(mut self) {
30987        // Safety: drops once, never accessed again due to mem::forget
30988        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
30989        // Prevent Drop from running (which would shut down the channel)
30990        std::mem::forget(self);
30991    }
30992}
30993
30994impl BaseSocketSetBroadcastResponder {
30995    /// Sends a response to the FIDL transaction.
30996    ///
30997    /// Sets the channel to shutdown if an error occurs.
30998    pub fn send(
30999        self,
31000        mut result: Result<(), fidl_fuchsia_posix::Errno>,
31001    ) -> Result<(), fidl::Error> {
31002        let _result = self.send_raw(result);
31003        if _result.is_err() {
31004            self.control_handle.shutdown();
31005        }
31006        self.drop_without_shutdown();
31007        _result
31008    }
31009
31010    /// Similar to "send" but does not shutdown the channel if an error occurs.
31011    pub fn send_no_shutdown_on_err(
31012        self,
31013        mut result: Result<(), fidl_fuchsia_posix::Errno>,
31014    ) -> Result<(), fidl::Error> {
31015        let _result = self.send_raw(result);
31016        self.drop_without_shutdown();
31017        _result
31018    }
31019
31020    fn send_raw(
31021        &self,
31022        mut result: Result<(), fidl_fuchsia_posix::Errno>,
31023    ) -> Result<(), fidl::Error> {
31024        self.control_handle.inner.send::<fidl::encoding::ResultType<
31025            fidl::encoding::EmptyStruct,
31026            fidl_fuchsia_posix::Errno,
31027        >>(
31028            result,
31029            self.tx_id,
31030            0x6023e081ce3cd947,
31031            fidl::encoding::DynamicFlags::empty(),
31032        )
31033    }
31034}
31035
31036#[must_use = "FIDL methods require a response to be sent"]
31037#[derive(Debug)]
31038pub struct BaseSocketGetBroadcastResponder {
31039    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
31040    tx_id: u32,
31041}
31042
31043/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
31044/// if the responder is dropped without sending a response, so that the client
31045/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
31046impl std::ops::Drop for BaseSocketGetBroadcastResponder {
31047    fn drop(&mut self) {
31048        self.control_handle.shutdown();
31049        // Safety: drops once, never accessed again
31050        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31051    }
31052}
31053
31054impl fidl::endpoints::Responder for BaseSocketGetBroadcastResponder {
31055    type ControlHandle = BaseSocketControlHandle;
31056
31057    fn control_handle(&self) -> &BaseSocketControlHandle {
31058        &self.control_handle
31059    }
31060
31061    fn drop_without_shutdown(mut self) {
31062        // Safety: drops once, never accessed again due to mem::forget
31063        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31064        // Prevent Drop from running (which would shut down the channel)
31065        std::mem::forget(self);
31066    }
31067}
31068
31069impl BaseSocketGetBroadcastResponder {
31070    /// Sends a response to the FIDL transaction.
31071    ///
31072    /// Sets the channel to shutdown if an error occurs.
31073    pub fn send(
31074        self,
31075        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
31076    ) -> Result<(), fidl::Error> {
31077        let _result = self.send_raw(result);
31078        if _result.is_err() {
31079            self.control_handle.shutdown();
31080        }
31081        self.drop_without_shutdown();
31082        _result
31083    }
31084
31085    /// Similar to "send" but does not shutdown the channel if an error occurs.
31086    pub fn send_no_shutdown_on_err(
31087        self,
31088        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
31089    ) -> Result<(), fidl::Error> {
31090        let _result = self.send_raw(result);
31091        self.drop_without_shutdown();
31092        _result
31093    }
31094
31095    fn send_raw(
31096        &self,
31097        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
31098    ) -> Result<(), fidl::Error> {
31099        self.control_handle.inner.send::<fidl::encoding::ResultType<
31100            BaseSocketGetBroadcastResponse,
31101            fidl_fuchsia_posix::Errno,
31102        >>(
31103            result.map(|value| (value,)),
31104            self.tx_id,
31105            0x68796fc556f9780d,
31106            fidl::encoding::DynamicFlags::empty(),
31107        )
31108    }
31109}
31110
31111#[must_use = "FIDL methods require a response to be sent"]
31112#[derive(Debug)]
31113pub struct BaseSocketSetSendBufferResponder {
31114    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
31115    tx_id: u32,
31116}
31117
31118/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
31119/// if the responder is dropped without sending a response, so that the client
31120/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
31121impl std::ops::Drop for BaseSocketSetSendBufferResponder {
31122    fn drop(&mut self) {
31123        self.control_handle.shutdown();
31124        // Safety: drops once, never accessed again
31125        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31126    }
31127}
31128
31129impl fidl::endpoints::Responder for BaseSocketSetSendBufferResponder {
31130    type ControlHandle = BaseSocketControlHandle;
31131
31132    fn control_handle(&self) -> &BaseSocketControlHandle {
31133        &self.control_handle
31134    }
31135
31136    fn drop_without_shutdown(mut self) {
31137        // Safety: drops once, never accessed again due to mem::forget
31138        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31139        // Prevent Drop from running (which would shut down the channel)
31140        std::mem::forget(self);
31141    }
31142}
31143
31144impl BaseSocketSetSendBufferResponder {
31145    /// Sends a response to the FIDL transaction.
31146    ///
31147    /// Sets the channel to shutdown if an error occurs.
31148    pub fn send(
31149        self,
31150        mut result: Result<(), fidl_fuchsia_posix::Errno>,
31151    ) -> Result<(), fidl::Error> {
31152        let _result = self.send_raw(result);
31153        if _result.is_err() {
31154            self.control_handle.shutdown();
31155        }
31156        self.drop_without_shutdown();
31157        _result
31158    }
31159
31160    /// Similar to "send" but does not shutdown the channel if an error occurs.
31161    pub fn send_no_shutdown_on_err(
31162        self,
31163        mut result: Result<(), fidl_fuchsia_posix::Errno>,
31164    ) -> Result<(), fidl::Error> {
31165        let _result = self.send_raw(result);
31166        self.drop_without_shutdown();
31167        _result
31168    }
31169
31170    fn send_raw(
31171        &self,
31172        mut result: Result<(), fidl_fuchsia_posix::Errno>,
31173    ) -> Result<(), fidl::Error> {
31174        self.control_handle.inner.send::<fidl::encoding::ResultType<
31175            fidl::encoding::EmptyStruct,
31176            fidl_fuchsia_posix::Errno,
31177        >>(
31178            result,
31179            self.tx_id,
31180            0x756eac32d73a7a70,
31181            fidl::encoding::DynamicFlags::empty(),
31182        )
31183    }
31184}
31185
31186#[must_use = "FIDL methods require a response to be sent"]
31187#[derive(Debug)]
31188pub struct BaseSocketGetSendBufferResponder {
31189    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
31190    tx_id: u32,
31191}
31192
31193/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
31194/// if the responder is dropped without sending a response, so that the client
31195/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
31196impl std::ops::Drop for BaseSocketGetSendBufferResponder {
31197    fn drop(&mut self) {
31198        self.control_handle.shutdown();
31199        // Safety: drops once, never accessed again
31200        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31201    }
31202}
31203
31204impl fidl::endpoints::Responder for BaseSocketGetSendBufferResponder {
31205    type ControlHandle = BaseSocketControlHandle;
31206
31207    fn control_handle(&self) -> &BaseSocketControlHandle {
31208        &self.control_handle
31209    }
31210
31211    fn drop_without_shutdown(mut self) {
31212        // Safety: drops once, never accessed again due to mem::forget
31213        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31214        // Prevent Drop from running (which would shut down the channel)
31215        std::mem::forget(self);
31216    }
31217}
31218
31219impl BaseSocketGetSendBufferResponder {
31220    /// Sends a response to the FIDL transaction.
31221    ///
31222    /// Sets the channel to shutdown if an error occurs.
31223    pub fn send(
31224        self,
31225        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
31226    ) -> Result<(), fidl::Error> {
31227        let _result = self.send_raw(result);
31228        if _result.is_err() {
31229            self.control_handle.shutdown();
31230        }
31231        self.drop_without_shutdown();
31232        _result
31233    }
31234
31235    /// Similar to "send" but does not shutdown the channel if an error occurs.
31236    pub fn send_no_shutdown_on_err(
31237        self,
31238        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
31239    ) -> Result<(), fidl::Error> {
31240        let _result = self.send_raw(result);
31241        self.drop_without_shutdown();
31242        _result
31243    }
31244
31245    fn send_raw(
31246        &self,
31247        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
31248    ) -> Result<(), fidl::Error> {
31249        self.control_handle.inner.send::<fidl::encoding::ResultType<
31250            BaseSocketGetSendBufferResponse,
31251            fidl_fuchsia_posix::Errno,
31252        >>(
31253            result.map(|value_bytes| (value_bytes,)),
31254            self.tx_id,
31255            0x78a52fd9c7b2410b,
31256            fidl::encoding::DynamicFlags::empty(),
31257        )
31258    }
31259}
31260
31261#[must_use = "FIDL methods require a response to be sent"]
31262#[derive(Debug)]
31263pub struct BaseSocketSetReceiveBufferResponder {
31264    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
31265    tx_id: u32,
31266}
31267
31268/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
31269/// if the responder is dropped without sending a response, so that the client
31270/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
31271impl std::ops::Drop for BaseSocketSetReceiveBufferResponder {
31272    fn drop(&mut self) {
31273        self.control_handle.shutdown();
31274        // Safety: drops once, never accessed again
31275        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31276    }
31277}
31278
31279impl fidl::endpoints::Responder for BaseSocketSetReceiveBufferResponder {
31280    type ControlHandle = BaseSocketControlHandle;
31281
31282    fn control_handle(&self) -> &BaseSocketControlHandle {
31283        &self.control_handle
31284    }
31285
31286    fn drop_without_shutdown(mut self) {
31287        // Safety: drops once, never accessed again due to mem::forget
31288        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31289        // Prevent Drop from running (which would shut down the channel)
31290        std::mem::forget(self);
31291    }
31292}
31293
31294impl BaseSocketSetReceiveBufferResponder {
31295    /// Sends a response to the FIDL transaction.
31296    ///
31297    /// Sets the channel to shutdown if an error occurs.
31298    pub fn send(
31299        self,
31300        mut result: Result<(), fidl_fuchsia_posix::Errno>,
31301    ) -> Result<(), fidl::Error> {
31302        let _result = self.send_raw(result);
31303        if _result.is_err() {
31304            self.control_handle.shutdown();
31305        }
31306        self.drop_without_shutdown();
31307        _result
31308    }
31309
31310    /// Similar to "send" but does not shutdown the channel if an error occurs.
31311    pub fn send_no_shutdown_on_err(
31312        self,
31313        mut result: Result<(), fidl_fuchsia_posix::Errno>,
31314    ) -> Result<(), fidl::Error> {
31315        let _result = self.send_raw(result);
31316        self.drop_without_shutdown();
31317        _result
31318    }
31319
31320    fn send_raw(
31321        &self,
31322        mut result: Result<(), fidl_fuchsia_posix::Errno>,
31323    ) -> Result<(), fidl::Error> {
31324        self.control_handle.inner.send::<fidl::encoding::ResultType<
31325            fidl::encoding::EmptyStruct,
31326            fidl_fuchsia_posix::Errno,
31327        >>(
31328            result,
31329            self.tx_id,
31330            0x6b0cf2f1919c7001,
31331            fidl::encoding::DynamicFlags::empty(),
31332        )
31333    }
31334}
31335
31336#[must_use = "FIDL methods require a response to be sent"]
31337#[derive(Debug)]
31338pub struct BaseSocketGetReceiveBufferResponder {
31339    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
31340    tx_id: u32,
31341}
31342
31343/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
31344/// if the responder is dropped without sending a response, so that the client
31345/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
31346impl std::ops::Drop for BaseSocketGetReceiveBufferResponder {
31347    fn drop(&mut self) {
31348        self.control_handle.shutdown();
31349        // Safety: drops once, never accessed again
31350        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31351    }
31352}
31353
31354impl fidl::endpoints::Responder for BaseSocketGetReceiveBufferResponder {
31355    type ControlHandle = BaseSocketControlHandle;
31356
31357    fn control_handle(&self) -> &BaseSocketControlHandle {
31358        &self.control_handle
31359    }
31360
31361    fn drop_without_shutdown(mut self) {
31362        // Safety: drops once, never accessed again due to mem::forget
31363        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31364        // Prevent Drop from running (which would shut down the channel)
31365        std::mem::forget(self);
31366    }
31367}
31368
31369impl BaseSocketGetReceiveBufferResponder {
31370    /// Sends a response to the FIDL transaction.
31371    ///
31372    /// Sets the channel to shutdown if an error occurs.
31373    pub fn send(
31374        self,
31375        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
31376    ) -> Result<(), fidl::Error> {
31377        let _result = self.send_raw(result);
31378        if _result.is_err() {
31379            self.control_handle.shutdown();
31380        }
31381        self.drop_without_shutdown();
31382        _result
31383    }
31384
31385    /// Similar to "send" but does not shutdown the channel if an error occurs.
31386    pub fn send_no_shutdown_on_err(
31387        self,
31388        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
31389    ) -> Result<(), fidl::Error> {
31390        let _result = self.send_raw(result);
31391        self.drop_without_shutdown();
31392        _result
31393    }
31394
31395    fn send_raw(
31396        &self,
31397        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
31398    ) -> Result<(), fidl::Error> {
31399        self.control_handle.inner.send::<fidl::encoding::ResultType<
31400            BaseSocketGetReceiveBufferResponse,
31401            fidl_fuchsia_posix::Errno,
31402        >>(
31403            result.map(|value_bytes| (value_bytes,)),
31404            self.tx_id,
31405            0x14c1a4b64f709e5c,
31406            fidl::encoding::DynamicFlags::empty(),
31407        )
31408    }
31409}
31410
31411#[must_use = "FIDL methods require a response to be sent"]
31412#[derive(Debug)]
31413pub struct BaseSocketSetKeepAliveResponder {
31414    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
31415    tx_id: u32,
31416}
31417
31418/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
31419/// if the responder is dropped without sending a response, so that the client
31420/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
31421impl std::ops::Drop for BaseSocketSetKeepAliveResponder {
31422    fn drop(&mut self) {
31423        self.control_handle.shutdown();
31424        // Safety: drops once, never accessed again
31425        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31426    }
31427}
31428
31429impl fidl::endpoints::Responder for BaseSocketSetKeepAliveResponder {
31430    type ControlHandle = BaseSocketControlHandle;
31431
31432    fn control_handle(&self) -> &BaseSocketControlHandle {
31433        &self.control_handle
31434    }
31435
31436    fn drop_without_shutdown(mut self) {
31437        // Safety: drops once, never accessed again due to mem::forget
31438        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31439        // Prevent Drop from running (which would shut down the channel)
31440        std::mem::forget(self);
31441    }
31442}
31443
31444impl BaseSocketSetKeepAliveResponder {
31445    /// Sends a response to the FIDL transaction.
31446    ///
31447    /// Sets the channel to shutdown if an error occurs.
31448    pub fn send(
31449        self,
31450        mut result: Result<(), fidl_fuchsia_posix::Errno>,
31451    ) -> Result<(), fidl::Error> {
31452        let _result = self.send_raw(result);
31453        if _result.is_err() {
31454            self.control_handle.shutdown();
31455        }
31456        self.drop_without_shutdown();
31457        _result
31458    }
31459
31460    /// Similar to "send" but does not shutdown the channel if an error occurs.
31461    pub fn send_no_shutdown_on_err(
31462        self,
31463        mut result: Result<(), fidl_fuchsia_posix::Errno>,
31464    ) -> Result<(), fidl::Error> {
31465        let _result = self.send_raw(result);
31466        self.drop_without_shutdown();
31467        _result
31468    }
31469
31470    fn send_raw(
31471        &self,
31472        mut result: Result<(), fidl_fuchsia_posix::Errno>,
31473    ) -> Result<(), fidl::Error> {
31474        self.control_handle.inner.send::<fidl::encoding::ResultType<
31475            fidl::encoding::EmptyStruct,
31476            fidl_fuchsia_posix::Errno,
31477        >>(
31478            result,
31479            self.tx_id,
31480            0x572df8f0b920d2c7,
31481            fidl::encoding::DynamicFlags::empty(),
31482        )
31483    }
31484}
31485
31486#[must_use = "FIDL methods require a response to be sent"]
31487#[derive(Debug)]
31488pub struct BaseSocketGetKeepAliveResponder {
31489    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
31490    tx_id: u32,
31491}
31492
31493/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
31494/// if the responder is dropped without sending a response, so that the client
31495/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
31496impl std::ops::Drop for BaseSocketGetKeepAliveResponder {
31497    fn drop(&mut self) {
31498        self.control_handle.shutdown();
31499        // Safety: drops once, never accessed again
31500        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31501    }
31502}
31503
31504impl fidl::endpoints::Responder for BaseSocketGetKeepAliveResponder {
31505    type ControlHandle = BaseSocketControlHandle;
31506
31507    fn control_handle(&self) -> &BaseSocketControlHandle {
31508        &self.control_handle
31509    }
31510
31511    fn drop_without_shutdown(mut self) {
31512        // Safety: drops once, never accessed again due to mem::forget
31513        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31514        // Prevent Drop from running (which would shut down the channel)
31515        std::mem::forget(self);
31516    }
31517}
31518
31519impl BaseSocketGetKeepAliveResponder {
31520    /// Sends a response to the FIDL transaction.
31521    ///
31522    /// Sets the channel to shutdown if an error occurs.
31523    pub fn send(
31524        self,
31525        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
31526    ) -> Result<(), fidl::Error> {
31527        let _result = self.send_raw(result);
31528        if _result.is_err() {
31529            self.control_handle.shutdown();
31530        }
31531        self.drop_without_shutdown();
31532        _result
31533    }
31534
31535    /// Similar to "send" but does not shutdown the channel if an error occurs.
31536    pub fn send_no_shutdown_on_err(
31537        self,
31538        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
31539    ) -> Result<(), fidl::Error> {
31540        let _result = self.send_raw(result);
31541        self.drop_without_shutdown();
31542        _result
31543    }
31544
31545    fn send_raw(
31546        &self,
31547        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
31548    ) -> Result<(), fidl::Error> {
31549        self.control_handle.inner.send::<fidl::encoding::ResultType<
31550            BaseSocketGetKeepAliveResponse,
31551            fidl_fuchsia_posix::Errno,
31552        >>(
31553            result.map(|value| (value,)),
31554            self.tx_id,
31555            0x2dd29d3215f2c9d2,
31556            fidl::encoding::DynamicFlags::empty(),
31557        )
31558    }
31559}
31560
31561#[must_use = "FIDL methods require a response to be sent"]
31562#[derive(Debug)]
31563pub struct BaseSocketSetOutOfBandInlineResponder {
31564    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
31565    tx_id: u32,
31566}
31567
31568/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
31569/// if the responder is dropped without sending a response, so that the client
31570/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
31571impl std::ops::Drop for BaseSocketSetOutOfBandInlineResponder {
31572    fn drop(&mut self) {
31573        self.control_handle.shutdown();
31574        // Safety: drops once, never accessed again
31575        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31576    }
31577}
31578
31579impl fidl::endpoints::Responder for BaseSocketSetOutOfBandInlineResponder {
31580    type ControlHandle = BaseSocketControlHandle;
31581
31582    fn control_handle(&self) -> &BaseSocketControlHandle {
31583        &self.control_handle
31584    }
31585
31586    fn drop_without_shutdown(mut self) {
31587        // Safety: drops once, never accessed again due to mem::forget
31588        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31589        // Prevent Drop from running (which would shut down the channel)
31590        std::mem::forget(self);
31591    }
31592}
31593
31594impl BaseSocketSetOutOfBandInlineResponder {
31595    /// Sends a response to the FIDL transaction.
31596    ///
31597    /// Sets the channel to shutdown if an error occurs.
31598    pub fn send(
31599        self,
31600        mut result: Result<(), fidl_fuchsia_posix::Errno>,
31601    ) -> Result<(), fidl::Error> {
31602        let _result = self.send_raw(result);
31603        if _result.is_err() {
31604            self.control_handle.shutdown();
31605        }
31606        self.drop_without_shutdown();
31607        _result
31608    }
31609
31610    /// Similar to "send" but does not shutdown the channel if an error occurs.
31611    pub fn send_no_shutdown_on_err(
31612        self,
31613        mut result: Result<(), fidl_fuchsia_posix::Errno>,
31614    ) -> Result<(), fidl::Error> {
31615        let _result = self.send_raw(result);
31616        self.drop_without_shutdown();
31617        _result
31618    }
31619
31620    fn send_raw(
31621        &self,
31622        mut result: Result<(), fidl_fuchsia_posix::Errno>,
31623    ) -> Result<(), fidl::Error> {
31624        self.control_handle.inner.send::<fidl::encoding::ResultType<
31625            fidl::encoding::EmptyStruct,
31626            fidl_fuchsia_posix::Errno,
31627        >>(
31628            result,
31629            self.tx_id,
31630            0x3ecb49968bee439,
31631            fidl::encoding::DynamicFlags::empty(),
31632        )
31633    }
31634}
31635
31636#[must_use = "FIDL methods require a response to be sent"]
31637#[derive(Debug)]
31638pub struct BaseSocketGetOutOfBandInlineResponder {
31639    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
31640    tx_id: u32,
31641}
31642
31643/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
31644/// if the responder is dropped without sending a response, so that the client
31645/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
31646impl std::ops::Drop for BaseSocketGetOutOfBandInlineResponder {
31647    fn drop(&mut self) {
31648        self.control_handle.shutdown();
31649        // Safety: drops once, never accessed again
31650        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31651    }
31652}
31653
31654impl fidl::endpoints::Responder for BaseSocketGetOutOfBandInlineResponder {
31655    type ControlHandle = BaseSocketControlHandle;
31656
31657    fn control_handle(&self) -> &BaseSocketControlHandle {
31658        &self.control_handle
31659    }
31660
31661    fn drop_without_shutdown(mut self) {
31662        // Safety: drops once, never accessed again due to mem::forget
31663        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31664        // Prevent Drop from running (which would shut down the channel)
31665        std::mem::forget(self);
31666    }
31667}
31668
31669impl BaseSocketGetOutOfBandInlineResponder {
31670    /// Sends a response to the FIDL transaction.
31671    ///
31672    /// Sets the channel to shutdown if an error occurs.
31673    pub fn send(
31674        self,
31675        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
31676    ) -> Result<(), fidl::Error> {
31677        let _result = self.send_raw(result);
31678        if _result.is_err() {
31679            self.control_handle.shutdown();
31680        }
31681        self.drop_without_shutdown();
31682        _result
31683    }
31684
31685    /// Similar to "send" but does not shutdown the channel if an error occurs.
31686    pub fn send_no_shutdown_on_err(
31687        self,
31688        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
31689    ) -> Result<(), fidl::Error> {
31690        let _result = self.send_raw(result);
31691        self.drop_without_shutdown();
31692        _result
31693    }
31694
31695    fn send_raw(
31696        &self,
31697        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
31698    ) -> Result<(), fidl::Error> {
31699        self.control_handle.inner.send::<fidl::encoding::ResultType<
31700            BaseSocketGetOutOfBandInlineResponse,
31701            fidl_fuchsia_posix::Errno,
31702        >>(
31703            result.map(|value| (value,)),
31704            self.tx_id,
31705            0x348c1ab3aeca1745,
31706            fidl::encoding::DynamicFlags::empty(),
31707        )
31708    }
31709}
31710
31711#[must_use = "FIDL methods require a response to be sent"]
31712#[derive(Debug)]
31713pub struct BaseSocketSetNoCheckResponder {
31714    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
31715    tx_id: u32,
31716}
31717
31718/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
31719/// if the responder is dropped without sending a response, so that the client
31720/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
31721impl std::ops::Drop for BaseSocketSetNoCheckResponder {
31722    fn drop(&mut self) {
31723        self.control_handle.shutdown();
31724        // Safety: drops once, never accessed again
31725        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31726    }
31727}
31728
31729impl fidl::endpoints::Responder for BaseSocketSetNoCheckResponder {
31730    type ControlHandle = BaseSocketControlHandle;
31731
31732    fn control_handle(&self) -> &BaseSocketControlHandle {
31733        &self.control_handle
31734    }
31735
31736    fn drop_without_shutdown(mut self) {
31737        // Safety: drops once, never accessed again due to mem::forget
31738        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31739        // Prevent Drop from running (which would shut down the channel)
31740        std::mem::forget(self);
31741    }
31742}
31743
31744impl BaseSocketSetNoCheckResponder {
31745    /// Sends a response to the FIDL transaction.
31746    ///
31747    /// Sets the channel to shutdown if an error occurs.
31748    pub fn send(
31749        self,
31750        mut result: Result<(), fidl_fuchsia_posix::Errno>,
31751    ) -> Result<(), fidl::Error> {
31752        let _result = self.send_raw(result);
31753        if _result.is_err() {
31754            self.control_handle.shutdown();
31755        }
31756        self.drop_without_shutdown();
31757        _result
31758    }
31759
31760    /// Similar to "send" but does not shutdown the channel if an error occurs.
31761    pub fn send_no_shutdown_on_err(
31762        self,
31763        mut result: Result<(), fidl_fuchsia_posix::Errno>,
31764    ) -> Result<(), fidl::Error> {
31765        let _result = self.send_raw(result);
31766        self.drop_without_shutdown();
31767        _result
31768    }
31769
31770    fn send_raw(
31771        &self,
31772        mut result: Result<(), fidl_fuchsia_posix::Errno>,
31773    ) -> Result<(), fidl::Error> {
31774        self.control_handle.inner.send::<fidl::encoding::ResultType<
31775            fidl::encoding::EmptyStruct,
31776            fidl_fuchsia_posix::Errno,
31777        >>(
31778            result,
31779            self.tx_id,
31780            0x6bbf00c53a4c78c2,
31781            fidl::encoding::DynamicFlags::empty(),
31782        )
31783    }
31784}
31785
31786#[must_use = "FIDL methods require a response to be sent"]
31787#[derive(Debug)]
31788pub struct BaseSocketGetNoCheckResponder {
31789    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
31790    tx_id: u32,
31791}
31792
31793/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
31794/// if the responder is dropped without sending a response, so that the client
31795/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
31796impl std::ops::Drop for BaseSocketGetNoCheckResponder {
31797    fn drop(&mut self) {
31798        self.control_handle.shutdown();
31799        // Safety: drops once, never accessed again
31800        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31801    }
31802}
31803
31804impl fidl::endpoints::Responder for BaseSocketGetNoCheckResponder {
31805    type ControlHandle = BaseSocketControlHandle;
31806
31807    fn control_handle(&self) -> &BaseSocketControlHandle {
31808        &self.control_handle
31809    }
31810
31811    fn drop_without_shutdown(mut self) {
31812        // Safety: drops once, never accessed again due to mem::forget
31813        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31814        // Prevent Drop from running (which would shut down the channel)
31815        std::mem::forget(self);
31816    }
31817}
31818
31819impl BaseSocketGetNoCheckResponder {
31820    /// Sends a response to the FIDL transaction.
31821    ///
31822    /// Sets the channel to shutdown if an error occurs.
31823    pub fn send(
31824        self,
31825        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
31826    ) -> Result<(), fidl::Error> {
31827        let _result = self.send_raw(result);
31828        if _result.is_err() {
31829            self.control_handle.shutdown();
31830        }
31831        self.drop_without_shutdown();
31832        _result
31833    }
31834
31835    /// Similar to "send" but does not shutdown the channel if an error occurs.
31836    pub fn send_no_shutdown_on_err(
31837        self,
31838        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
31839    ) -> Result<(), fidl::Error> {
31840        let _result = self.send_raw(result);
31841        self.drop_without_shutdown();
31842        _result
31843    }
31844
31845    fn send_raw(
31846        &self,
31847        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
31848    ) -> Result<(), fidl::Error> {
31849        self.control_handle.inner.send::<fidl::encoding::ResultType<
31850            BaseSocketGetNoCheckResponse,
31851            fidl_fuchsia_posix::Errno,
31852        >>(
31853            result.map(|value| (value,)),
31854            self.tx_id,
31855            0x2cd4249286417694,
31856            fidl::encoding::DynamicFlags::empty(),
31857        )
31858    }
31859}
31860
31861#[must_use = "FIDL methods require a response to be sent"]
31862#[derive(Debug)]
31863pub struct BaseSocketSetLingerResponder {
31864    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
31865    tx_id: u32,
31866}
31867
31868/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
31869/// if the responder is dropped without sending a response, so that the client
31870/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
31871impl std::ops::Drop for BaseSocketSetLingerResponder {
31872    fn drop(&mut self) {
31873        self.control_handle.shutdown();
31874        // Safety: drops once, never accessed again
31875        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31876    }
31877}
31878
31879impl fidl::endpoints::Responder for BaseSocketSetLingerResponder {
31880    type ControlHandle = BaseSocketControlHandle;
31881
31882    fn control_handle(&self) -> &BaseSocketControlHandle {
31883        &self.control_handle
31884    }
31885
31886    fn drop_without_shutdown(mut self) {
31887        // Safety: drops once, never accessed again due to mem::forget
31888        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31889        // Prevent Drop from running (which would shut down the channel)
31890        std::mem::forget(self);
31891    }
31892}
31893
31894impl BaseSocketSetLingerResponder {
31895    /// Sends a response to the FIDL transaction.
31896    ///
31897    /// Sets the channel to shutdown if an error occurs.
31898    pub fn send(
31899        self,
31900        mut result: Result<(), fidl_fuchsia_posix::Errno>,
31901    ) -> Result<(), fidl::Error> {
31902        let _result = self.send_raw(result);
31903        if _result.is_err() {
31904            self.control_handle.shutdown();
31905        }
31906        self.drop_without_shutdown();
31907        _result
31908    }
31909
31910    /// Similar to "send" but does not shutdown the channel if an error occurs.
31911    pub fn send_no_shutdown_on_err(
31912        self,
31913        mut result: Result<(), fidl_fuchsia_posix::Errno>,
31914    ) -> Result<(), fidl::Error> {
31915        let _result = self.send_raw(result);
31916        self.drop_without_shutdown();
31917        _result
31918    }
31919
31920    fn send_raw(
31921        &self,
31922        mut result: Result<(), fidl_fuchsia_posix::Errno>,
31923    ) -> Result<(), fidl::Error> {
31924        self.control_handle.inner.send::<fidl::encoding::ResultType<
31925            fidl::encoding::EmptyStruct,
31926            fidl_fuchsia_posix::Errno,
31927        >>(
31928            result,
31929            self.tx_id,
31930            0x45386351246e998e,
31931            fidl::encoding::DynamicFlags::empty(),
31932        )
31933    }
31934}
31935
31936#[must_use = "FIDL methods require a response to be sent"]
31937#[derive(Debug)]
31938pub struct BaseSocketGetLingerResponder {
31939    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
31940    tx_id: u32,
31941}
31942
31943/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
31944/// if the responder is dropped without sending a response, so that the client
31945/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
31946impl std::ops::Drop for BaseSocketGetLingerResponder {
31947    fn drop(&mut self) {
31948        self.control_handle.shutdown();
31949        // Safety: drops once, never accessed again
31950        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31951    }
31952}
31953
31954impl fidl::endpoints::Responder for BaseSocketGetLingerResponder {
31955    type ControlHandle = BaseSocketControlHandle;
31956
31957    fn control_handle(&self) -> &BaseSocketControlHandle {
31958        &self.control_handle
31959    }
31960
31961    fn drop_without_shutdown(mut self) {
31962        // Safety: drops once, never accessed again due to mem::forget
31963        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
31964        // Prevent Drop from running (which would shut down the channel)
31965        std::mem::forget(self);
31966    }
31967}
31968
31969impl BaseSocketGetLingerResponder {
31970    /// Sends a response to the FIDL transaction.
31971    ///
31972    /// Sets the channel to shutdown if an error occurs.
31973    pub fn send(
31974        self,
31975        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
31976    ) -> Result<(), fidl::Error> {
31977        let _result = self.send_raw(result);
31978        if _result.is_err() {
31979            self.control_handle.shutdown();
31980        }
31981        self.drop_without_shutdown();
31982        _result
31983    }
31984
31985    /// Similar to "send" but does not shutdown the channel if an error occurs.
31986    pub fn send_no_shutdown_on_err(
31987        self,
31988        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
31989    ) -> Result<(), fidl::Error> {
31990        let _result = self.send_raw(result);
31991        self.drop_without_shutdown();
31992        _result
31993    }
31994
31995    fn send_raw(
31996        &self,
31997        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
31998    ) -> Result<(), fidl::Error> {
31999        self.control_handle.inner.send::<fidl::encoding::ResultType<
32000            BaseSocketGetLingerResponse,
32001            fidl_fuchsia_posix::Errno,
32002        >>(
32003            result,
32004            self.tx_id,
32005            0x48eb20fc5ccb0e45,
32006            fidl::encoding::DynamicFlags::empty(),
32007        )
32008    }
32009}
32010
32011#[must_use = "FIDL methods require a response to be sent"]
32012#[derive(Debug)]
32013pub struct BaseSocketSetReusePortResponder {
32014    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
32015    tx_id: u32,
32016}
32017
32018/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
32019/// if the responder is dropped without sending a response, so that the client
32020/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
32021impl std::ops::Drop for BaseSocketSetReusePortResponder {
32022    fn drop(&mut self) {
32023        self.control_handle.shutdown();
32024        // Safety: drops once, never accessed again
32025        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32026    }
32027}
32028
32029impl fidl::endpoints::Responder for BaseSocketSetReusePortResponder {
32030    type ControlHandle = BaseSocketControlHandle;
32031
32032    fn control_handle(&self) -> &BaseSocketControlHandle {
32033        &self.control_handle
32034    }
32035
32036    fn drop_without_shutdown(mut self) {
32037        // Safety: drops once, never accessed again due to mem::forget
32038        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32039        // Prevent Drop from running (which would shut down the channel)
32040        std::mem::forget(self);
32041    }
32042}
32043
32044impl BaseSocketSetReusePortResponder {
32045    /// Sends a response to the FIDL transaction.
32046    ///
32047    /// Sets the channel to shutdown if an error occurs.
32048    pub fn send(
32049        self,
32050        mut result: Result<(), fidl_fuchsia_posix::Errno>,
32051    ) -> Result<(), fidl::Error> {
32052        let _result = self.send_raw(result);
32053        if _result.is_err() {
32054            self.control_handle.shutdown();
32055        }
32056        self.drop_without_shutdown();
32057        _result
32058    }
32059
32060    /// Similar to "send" but does not shutdown the channel if an error occurs.
32061    pub fn send_no_shutdown_on_err(
32062        self,
32063        mut result: Result<(), fidl_fuchsia_posix::Errno>,
32064    ) -> Result<(), fidl::Error> {
32065        let _result = self.send_raw(result);
32066        self.drop_without_shutdown();
32067        _result
32068    }
32069
32070    fn send_raw(
32071        &self,
32072        mut result: Result<(), fidl_fuchsia_posix::Errno>,
32073    ) -> Result<(), fidl::Error> {
32074        self.control_handle.inner.send::<fidl::encoding::ResultType<
32075            fidl::encoding::EmptyStruct,
32076            fidl_fuchsia_posix::Errno,
32077        >>(
32078            result,
32079            self.tx_id,
32080            0x24dd3e5cb36d9ccb,
32081            fidl::encoding::DynamicFlags::empty(),
32082        )
32083    }
32084}
32085
32086#[must_use = "FIDL methods require a response to be sent"]
32087#[derive(Debug)]
32088pub struct BaseSocketGetReusePortResponder {
32089    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
32090    tx_id: u32,
32091}
32092
32093/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
32094/// if the responder is dropped without sending a response, so that the client
32095/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
32096impl std::ops::Drop for BaseSocketGetReusePortResponder {
32097    fn drop(&mut self) {
32098        self.control_handle.shutdown();
32099        // Safety: drops once, never accessed again
32100        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32101    }
32102}
32103
32104impl fidl::endpoints::Responder for BaseSocketGetReusePortResponder {
32105    type ControlHandle = BaseSocketControlHandle;
32106
32107    fn control_handle(&self) -> &BaseSocketControlHandle {
32108        &self.control_handle
32109    }
32110
32111    fn drop_without_shutdown(mut self) {
32112        // Safety: drops once, never accessed again due to mem::forget
32113        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32114        // Prevent Drop from running (which would shut down the channel)
32115        std::mem::forget(self);
32116    }
32117}
32118
32119impl BaseSocketGetReusePortResponder {
32120    /// Sends a response to the FIDL transaction.
32121    ///
32122    /// Sets the channel to shutdown if an error occurs.
32123    pub fn send(
32124        self,
32125        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
32126    ) -> Result<(), fidl::Error> {
32127        let _result = self.send_raw(result);
32128        if _result.is_err() {
32129            self.control_handle.shutdown();
32130        }
32131        self.drop_without_shutdown();
32132        _result
32133    }
32134
32135    /// Similar to "send" but does not shutdown the channel if an error occurs.
32136    pub fn send_no_shutdown_on_err(
32137        self,
32138        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
32139    ) -> Result<(), fidl::Error> {
32140        let _result = self.send_raw(result);
32141        self.drop_without_shutdown();
32142        _result
32143    }
32144
32145    fn send_raw(
32146        &self,
32147        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
32148    ) -> Result<(), fidl::Error> {
32149        self.control_handle.inner.send::<fidl::encoding::ResultType<
32150            BaseSocketGetReusePortResponse,
32151            fidl_fuchsia_posix::Errno,
32152        >>(
32153            result.map(|value| (value,)),
32154            self.tx_id,
32155            0x7a112c1ab54ff828,
32156            fidl::encoding::DynamicFlags::empty(),
32157        )
32158    }
32159}
32160
32161#[must_use = "FIDL methods require a response to be sent"]
32162#[derive(Debug)]
32163pub struct BaseSocketGetAcceptConnResponder {
32164    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
32165    tx_id: u32,
32166}
32167
32168/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
32169/// if the responder is dropped without sending a response, so that the client
32170/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
32171impl std::ops::Drop for BaseSocketGetAcceptConnResponder {
32172    fn drop(&mut self) {
32173        self.control_handle.shutdown();
32174        // Safety: drops once, never accessed again
32175        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32176    }
32177}
32178
32179impl fidl::endpoints::Responder for BaseSocketGetAcceptConnResponder {
32180    type ControlHandle = BaseSocketControlHandle;
32181
32182    fn control_handle(&self) -> &BaseSocketControlHandle {
32183        &self.control_handle
32184    }
32185
32186    fn drop_without_shutdown(mut self) {
32187        // Safety: drops once, never accessed again due to mem::forget
32188        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32189        // Prevent Drop from running (which would shut down the channel)
32190        std::mem::forget(self);
32191    }
32192}
32193
32194impl BaseSocketGetAcceptConnResponder {
32195    /// Sends a response to the FIDL transaction.
32196    ///
32197    /// Sets the channel to shutdown if an error occurs.
32198    pub fn send(
32199        self,
32200        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
32201    ) -> Result<(), fidl::Error> {
32202        let _result = self.send_raw(result);
32203        if _result.is_err() {
32204            self.control_handle.shutdown();
32205        }
32206        self.drop_without_shutdown();
32207        _result
32208    }
32209
32210    /// Similar to "send" but does not shutdown the channel if an error occurs.
32211    pub fn send_no_shutdown_on_err(
32212        self,
32213        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
32214    ) -> Result<(), fidl::Error> {
32215        let _result = self.send_raw(result);
32216        self.drop_without_shutdown();
32217        _result
32218    }
32219
32220    fn send_raw(
32221        &self,
32222        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
32223    ) -> Result<(), fidl::Error> {
32224        self.control_handle.inner.send::<fidl::encoding::ResultType<
32225            BaseSocketGetAcceptConnResponse,
32226            fidl_fuchsia_posix::Errno,
32227        >>(
32228            result.map(|value| (value,)),
32229            self.tx_id,
32230            0x67ce6db6c2ec8966,
32231            fidl::encoding::DynamicFlags::empty(),
32232        )
32233    }
32234}
32235
32236#[must_use = "FIDL methods require a response to be sent"]
32237#[derive(Debug)]
32238pub struct BaseSocketSetBindToDeviceResponder {
32239    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
32240    tx_id: u32,
32241}
32242
32243/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
32244/// if the responder is dropped without sending a response, so that the client
32245/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
32246impl std::ops::Drop for BaseSocketSetBindToDeviceResponder {
32247    fn drop(&mut self) {
32248        self.control_handle.shutdown();
32249        // Safety: drops once, never accessed again
32250        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32251    }
32252}
32253
32254impl fidl::endpoints::Responder for BaseSocketSetBindToDeviceResponder {
32255    type ControlHandle = BaseSocketControlHandle;
32256
32257    fn control_handle(&self) -> &BaseSocketControlHandle {
32258        &self.control_handle
32259    }
32260
32261    fn drop_without_shutdown(mut self) {
32262        // Safety: drops once, never accessed again due to mem::forget
32263        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32264        // Prevent Drop from running (which would shut down the channel)
32265        std::mem::forget(self);
32266    }
32267}
32268
32269impl BaseSocketSetBindToDeviceResponder {
32270    /// Sends a response to the FIDL transaction.
32271    ///
32272    /// Sets the channel to shutdown if an error occurs.
32273    pub fn send(
32274        self,
32275        mut result: Result<(), fidl_fuchsia_posix::Errno>,
32276    ) -> Result<(), fidl::Error> {
32277        let _result = self.send_raw(result);
32278        if _result.is_err() {
32279            self.control_handle.shutdown();
32280        }
32281        self.drop_without_shutdown();
32282        _result
32283    }
32284
32285    /// Similar to "send" but does not shutdown the channel if an error occurs.
32286    pub fn send_no_shutdown_on_err(
32287        self,
32288        mut result: Result<(), fidl_fuchsia_posix::Errno>,
32289    ) -> Result<(), fidl::Error> {
32290        let _result = self.send_raw(result);
32291        self.drop_without_shutdown();
32292        _result
32293    }
32294
32295    fn send_raw(
32296        &self,
32297        mut result: Result<(), fidl_fuchsia_posix::Errno>,
32298    ) -> Result<(), fidl::Error> {
32299        self.control_handle.inner.send::<fidl::encoding::ResultType<
32300            fidl::encoding::EmptyStruct,
32301            fidl_fuchsia_posix::Errno,
32302        >>(
32303            result,
32304            self.tx_id,
32305            0x2118b483f28aafc4,
32306            fidl::encoding::DynamicFlags::empty(),
32307        )
32308    }
32309}
32310
32311#[must_use = "FIDL methods require a response to be sent"]
32312#[derive(Debug)]
32313pub struct BaseSocketGetBindToDeviceResponder {
32314    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
32315    tx_id: u32,
32316}
32317
32318/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
32319/// if the responder is dropped without sending a response, so that the client
32320/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
32321impl std::ops::Drop for BaseSocketGetBindToDeviceResponder {
32322    fn drop(&mut self) {
32323        self.control_handle.shutdown();
32324        // Safety: drops once, never accessed again
32325        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32326    }
32327}
32328
32329impl fidl::endpoints::Responder for BaseSocketGetBindToDeviceResponder {
32330    type ControlHandle = BaseSocketControlHandle;
32331
32332    fn control_handle(&self) -> &BaseSocketControlHandle {
32333        &self.control_handle
32334    }
32335
32336    fn drop_without_shutdown(mut self) {
32337        // Safety: drops once, never accessed again due to mem::forget
32338        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32339        // Prevent Drop from running (which would shut down the channel)
32340        std::mem::forget(self);
32341    }
32342}
32343
32344impl BaseSocketGetBindToDeviceResponder {
32345    /// Sends a response to the FIDL transaction.
32346    ///
32347    /// Sets the channel to shutdown if an error occurs.
32348    pub fn send(
32349        self,
32350        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
32351    ) -> Result<(), fidl::Error> {
32352        let _result = self.send_raw(result);
32353        if _result.is_err() {
32354            self.control_handle.shutdown();
32355        }
32356        self.drop_without_shutdown();
32357        _result
32358    }
32359
32360    /// Similar to "send" but does not shutdown the channel if an error occurs.
32361    pub fn send_no_shutdown_on_err(
32362        self,
32363        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
32364    ) -> Result<(), fidl::Error> {
32365        let _result = self.send_raw(result);
32366        self.drop_without_shutdown();
32367        _result
32368    }
32369
32370    fn send_raw(
32371        &self,
32372        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
32373    ) -> Result<(), fidl::Error> {
32374        self.control_handle.inner.send::<fidl::encoding::ResultType<
32375            BaseSocketGetBindToDeviceResponse,
32376            fidl_fuchsia_posix::Errno,
32377        >>(
32378            result.map(|value| (value,)),
32379            self.tx_id,
32380            0x1ab1fbf0ef7906c8,
32381            fidl::encoding::DynamicFlags::empty(),
32382        )
32383    }
32384}
32385
32386#[must_use = "FIDL methods require a response to be sent"]
32387#[derive(Debug)]
32388pub struct BaseSocketSetBindToInterfaceIndexResponder {
32389    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
32390    tx_id: u32,
32391}
32392
32393/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
32394/// if the responder is dropped without sending a response, so that the client
32395/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
32396impl std::ops::Drop for BaseSocketSetBindToInterfaceIndexResponder {
32397    fn drop(&mut self) {
32398        self.control_handle.shutdown();
32399        // Safety: drops once, never accessed again
32400        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32401    }
32402}
32403
32404impl fidl::endpoints::Responder for BaseSocketSetBindToInterfaceIndexResponder {
32405    type ControlHandle = BaseSocketControlHandle;
32406
32407    fn control_handle(&self) -> &BaseSocketControlHandle {
32408        &self.control_handle
32409    }
32410
32411    fn drop_without_shutdown(mut self) {
32412        // Safety: drops once, never accessed again due to mem::forget
32413        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32414        // Prevent Drop from running (which would shut down the channel)
32415        std::mem::forget(self);
32416    }
32417}
32418
32419impl BaseSocketSetBindToInterfaceIndexResponder {
32420    /// Sends a response to the FIDL transaction.
32421    ///
32422    /// Sets the channel to shutdown if an error occurs.
32423    pub fn send(
32424        self,
32425        mut result: Result<(), fidl_fuchsia_posix::Errno>,
32426    ) -> Result<(), fidl::Error> {
32427        let _result = self.send_raw(result);
32428        if _result.is_err() {
32429            self.control_handle.shutdown();
32430        }
32431        self.drop_without_shutdown();
32432        _result
32433    }
32434
32435    /// Similar to "send" but does not shutdown the channel if an error occurs.
32436    pub fn send_no_shutdown_on_err(
32437        self,
32438        mut result: Result<(), fidl_fuchsia_posix::Errno>,
32439    ) -> Result<(), fidl::Error> {
32440        let _result = self.send_raw(result);
32441        self.drop_without_shutdown();
32442        _result
32443    }
32444
32445    fn send_raw(
32446        &self,
32447        mut result: Result<(), fidl_fuchsia_posix::Errno>,
32448    ) -> Result<(), fidl::Error> {
32449        self.control_handle.inner.send::<fidl::encoding::ResultType<
32450            fidl::encoding::EmptyStruct,
32451            fidl_fuchsia_posix::Errno,
32452        >>(
32453            result,
32454            self.tx_id,
32455            0x6e387a0def00821,
32456            fidl::encoding::DynamicFlags::empty(),
32457        )
32458    }
32459}
32460
32461#[must_use = "FIDL methods require a response to be sent"]
32462#[derive(Debug)]
32463pub struct BaseSocketGetBindToInterfaceIndexResponder {
32464    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
32465    tx_id: u32,
32466}
32467
32468/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
32469/// if the responder is dropped without sending a response, so that the client
32470/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
32471impl std::ops::Drop for BaseSocketGetBindToInterfaceIndexResponder {
32472    fn drop(&mut self) {
32473        self.control_handle.shutdown();
32474        // Safety: drops once, never accessed again
32475        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32476    }
32477}
32478
32479impl fidl::endpoints::Responder for BaseSocketGetBindToInterfaceIndexResponder {
32480    type ControlHandle = BaseSocketControlHandle;
32481
32482    fn control_handle(&self) -> &BaseSocketControlHandle {
32483        &self.control_handle
32484    }
32485
32486    fn drop_without_shutdown(mut self) {
32487        // Safety: drops once, never accessed again due to mem::forget
32488        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32489        // Prevent Drop from running (which would shut down the channel)
32490        std::mem::forget(self);
32491    }
32492}
32493
32494impl BaseSocketGetBindToInterfaceIndexResponder {
32495    /// Sends a response to the FIDL transaction.
32496    ///
32497    /// Sets the channel to shutdown if an error occurs.
32498    pub fn send(
32499        self,
32500        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
32501    ) -> Result<(), fidl::Error> {
32502        let _result = self.send_raw(result);
32503        if _result.is_err() {
32504            self.control_handle.shutdown();
32505        }
32506        self.drop_without_shutdown();
32507        _result
32508    }
32509
32510    /// Similar to "send" but does not shutdown the channel if an error occurs.
32511    pub fn send_no_shutdown_on_err(
32512        self,
32513        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
32514    ) -> Result<(), fidl::Error> {
32515        let _result = self.send_raw(result);
32516        self.drop_without_shutdown();
32517        _result
32518    }
32519
32520    fn send_raw(
32521        &self,
32522        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
32523    ) -> Result<(), fidl::Error> {
32524        self.control_handle.inner.send::<fidl::encoding::ResultType<
32525            BaseSocketGetBindToInterfaceIndexResponse,
32526            fidl_fuchsia_posix::Errno,
32527        >>(
32528            result.map(|value| (value,)),
32529            self.tx_id,
32530            0x59c31dd3e3078295,
32531            fidl::encoding::DynamicFlags::empty(),
32532        )
32533    }
32534}
32535
32536#[must_use = "FIDL methods require a response to be sent"]
32537#[derive(Debug)]
32538pub struct BaseSocketSetTimestampResponder {
32539    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
32540    tx_id: u32,
32541}
32542
32543/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
32544/// if the responder is dropped without sending a response, so that the client
32545/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
32546impl std::ops::Drop for BaseSocketSetTimestampResponder {
32547    fn drop(&mut self) {
32548        self.control_handle.shutdown();
32549        // Safety: drops once, never accessed again
32550        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32551    }
32552}
32553
32554impl fidl::endpoints::Responder for BaseSocketSetTimestampResponder {
32555    type ControlHandle = BaseSocketControlHandle;
32556
32557    fn control_handle(&self) -> &BaseSocketControlHandle {
32558        &self.control_handle
32559    }
32560
32561    fn drop_without_shutdown(mut self) {
32562        // Safety: drops once, never accessed again due to mem::forget
32563        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32564        // Prevent Drop from running (which would shut down the channel)
32565        std::mem::forget(self);
32566    }
32567}
32568
32569impl BaseSocketSetTimestampResponder {
32570    /// Sends a response to the FIDL transaction.
32571    ///
32572    /// Sets the channel to shutdown if an error occurs.
32573    pub fn send(
32574        self,
32575        mut result: Result<(), fidl_fuchsia_posix::Errno>,
32576    ) -> Result<(), fidl::Error> {
32577        let _result = self.send_raw(result);
32578        if _result.is_err() {
32579            self.control_handle.shutdown();
32580        }
32581        self.drop_without_shutdown();
32582        _result
32583    }
32584
32585    /// Similar to "send" but does not shutdown the channel if an error occurs.
32586    pub fn send_no_shutdown_on_err(
32587        self,
32588        mut result: Result<(), fidl_fuchsia_posix::Errno>,
32589    ) -> Result<(), fidl::Error> {
32590        let _result = self.send_raw(result);
32591        self.drop_without_shutdown();
32592        _result
32593    }
32594
32595    fn send_raw(
32596        &self,
32597        mut result: Result<(), fidl_fuchsia_posix::Errno>,
32598    ) -> Result<(), fidl::Error> {
32599        self.control_handle.inner.send::<fidl::encoding::ResultType<
32600            fidl::encoding::EmptyStruct,
32601            fidl_fuchsia_posix::Errno,
32602        >>(
32603            result,
32604            self.tx_id,
32605            0x285d6516c263d839,
32606            fidl::encoding::DynamicFlags::empty(),
32607        )
32608    }
32609}
32610
32611#[must_use = "FIDL methods require a response to be sent"]
32612#[derive(Debug)]
32613pub struct BaseSocketGetTimestampResponder {
32614    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
32615    tx_id: u32,
32616}
32617
32618/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
32619/// if the responder is dropped without sending a response, so that the client
32620/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
32621impl std::ops::Drop for BaseSocketGetTimestampResponder {
32622    fn drop(&mut self) {
32623        self.control_handle.shutdown();
32624        // Safety: drops once, never accessed again
32625        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32626    }
32627}
32628
32629impl fidl::endpoints::Responder for BaseSocketGetTimestampResponder {
32630    type ControlHandle = BaseSocketControlHandle;
32631
32632    fn control_handle(&self) -> &BaseSocketControlHandle {
32633        &self.control_handle
32634    }
32635
32636    fn drop_without_shutdown(mut self) {
32637        // Safety: drops once, never accessed again due to mem::forget
32638        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32639        // Prevent Drop from running (which would shut down the channel)
32640        std::mem::forget(self);
32641    }
32642}
32643
32644impl BaseSocketGetTimestampResponder {
32645    /// Sends a response to the FIDL transaction.
32646    ///
32647    /// Sets the channel to shutdown if an error occurs.
32648    pub fn send(
32649        self,
32650        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
32651    ) -> Result<(), fidl::Error> {
32652        let _result = self.send_raw(result);
32653        if _result.is_err() {
32654            self.control_handle.shutdown();
32655        }
32656        self.drop_without_shutdown();
32657        _result
32658    }
32659
32660    /// Similar to "send" but does not shutdown the channel if an error occurs.
32661    pub fn send_no_shutdown_on_err(
32662        self,
32663        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
32664    ) -> Result<(), fidl::Error> {
32665        let _result = self.send_raw(result);
32666        self.drop_without_shutdown();
32667        _result
32668    }
32669
32670    fn send_raw(
32671        &self,
32672        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
32673    ) -> Result<(), fidl::Error> {
32674        self.control_handle.inner.send::<fidl::encoding::ResultType<
32675            BaseSocketGetTimestampResponse,
32676            fidl_fuchsia_posix::Errno,
32677        >>(
32678            result.map(|value| (value,)),
32679            self.tx_id,
32680            0x49f2fffbbcc2bd27,
32681            fidl::encoding::DynamicFlags::empty(),
32682        )
32683    }
32684}
32685
32686#[must_use = "FIDL methods require a response to be sent"]
32687#[derive(Debug)]
32688pub struct BaseSocketSetMarkResponder {
32689    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
32690    tx_id: u32,
32691}
32692
32693/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
32694/// if the responder is dropped without sending a response, so that the client
32695/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
32696impl std::ops::Drop for BaseSocketSetMarkResponder {
32697    fn drop(&mut self) {
32698        self.control_handle.shutdown();
32699        // Safety: drops once, never accessed again
32700        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32701    }
32702}
32703
32704impl fidl::endpoints::Responder for BaseSocketSetMarkResponder {
32705    type ControlHandle = BaseSocketControlHandle;
32706
32707    fn control_handle(&self) -> &BaseSocketControlHandle {
32708        &self.control_handle
32709    }
32710
32711    fn drop_without_shutdown(mut self) {
32712        // Safety: drops once, never accessed again due to mem::forget
32713        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32714        // Prevent Drop from running (which would shut down the channel)
32715        std::mem::forget(self);
32716    }
32717}
32718
32719impl BaseSocketSetMarkResponder {
32720    /// Sends a response to the FIDL transaction.
32721    ///
32722    /// Sets the channel to shutdown if an error occurs.
32723    pub fn send(
32724        self,
32725        mut result: Result<(), fidl_fuchsia_posix::Errno>,
32726    ) -> Result<(), fidl::Error> {
32727        let _result = self.send_raw(result);
32728        if _result.is_err() {
32729            self.control_handle.shutdown();
32730        }
32731        self.drop_without_shutdown();
32732        _result
32733    }
32734
32735    /// Similar to "send" but does not shutdown the channel if an error occurs.
32736    pub fn send_no_shutdown_on_err(
32737        self,
32738        mut result: Result<(), fidl_fuchsia_posix::Errno>,
32739    ) -> Result<(), fidl::Error> {
32740        let _result = self.send_raw(result);
32741        self.drop_without_shutdown();
32742        _result
32743    }
32744
32745    fn send_raw(
32746        &self,
32747        mut result: Result<(), fidl_fuchsia_posix::Errno>,
32748    ) -> Result<(), fidl::Error> {
32749        self.control_handle.inner.send::<fidl::encoding::ResultType<
32750            fidl::encoding::EmptyStruct,
32751            fidl_fuchsia_posix::Errno,
32752        >>(
32753            result,
32754            self.tx_id,
32755            0x6ead6de09f653236,
32756            fidl::encoding::DynamicFlags::empty(),
32757        )
32758    }
32759}
32760
32761#[must_use = "FIDL methods require a response to be sent"]
32762#[derive(Debug)]
32763pub struct BaseSocketGetMarkResponder {
32764    control_handle: std::mem::ManuallyDrop<BaseSocketControlHandle>,
32765    tx_id: u32,
32766}
32767
32768/// Set the the channel to be shutdown (see [`BaseSocketControlHandle::shutdown`])
32769/// if the responder is dropped without sending a response, so that the client
32770/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
32771impl std::ops::Drop for BaseSocketGetMarkResponder {
32772    fn drop(&mut self) {
32773        self.control_handle.shutdown();
32774        // Safety: drops once, never accessed again
32775        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32776    }
32777}
32778
32779impl fidl::endpoints::Responder for BaseSocketGetMarkResponder {
32780    type ControlHandle = BaseSocketControlHandle;
32781
32782    fn control_handle(&self) -> &BaseSocketControlHandle {
32783        &self.control_handle
32784    }
32785
32786    fn drop_without_shutdown(mut self) {
32787        // Safety: drops once, never accessed again due to mem::forget
32788        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
32789        // Prevent Drop from running (which would shut down the channel)
32790        std::mem::forget(self);
32791    }
32792}
32793
32794impl BaseSocketGetMarkResponder {
32795    /// Sends a response to the FIDL transaction.
32796    ///
32797    /// Sets the channel to shutdown if an error occurs.
32798    pub fn send(
32799        self,
32800        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
32801    ) -> Result<(), fidl::Error> {
32802        let _result = self.send_raw(result);
32803        if _result.is_err() {
32804            self.control_handle.shutdown();
32805        }
32806        self.drop_without_shutdown();
32807        _result
32808    }
32809
32810    /// Similar to "send" but does not shutdown the channel if an error occurs.
32811    pub fn send_no_shutdown_on_err(
32812        self,
32813        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
32814    ) -> Result<(), fidl::Error> {
32815        let _result = self.send_raw(result);
32816        self.drop_without_shutdown();
32817        _result
32818    }
32819
32820    fn send_raw(
32821        &self,
32822        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
32823    ) -> Result<(), fidl::Error> {
32824        self.control_handle.inner.send::<fidl::encoding::ResultType<
32825            BaseSocketGetMarkResponse,
32826            fidl_fuchsia_posix::Errno,
32827        >>(
32828            result.map(|mark| (mark,)),
32829            self.tx_id,
32830            0x57a2752c61d93d47,
32831            fidl::encoding::DynamicFlags::empty(),
32832        )
32833    }
32834}
32835
32836#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
32837pub struct DatagramSocketMarker;
32838
32839impl fidl::endpoints::ProtocolMarker for DatagramSocketMarker {
32840    type Proxy = DatagramSocketProxy;
32841    type RequestStream = DatagramSocketRequestStream;
32842    #[cfg(target_os = "fuchsia")]
32843    type SynchronousProxy = DatagramSocketSynchronousProxy;
32844
32845    const DEBUG_NAME: &'static str = "fuchsia.posix.socket.DatagramSocket";
32846}
32847impl fidl::endpoints::DiscoverableProtocolMarker for DatagramSocketMarker {}
32848pub type DatagramSocketSendMsgPreflightResult =
32849    Result<DatagramSocketSendMsgPreflightResponse, fidl_fuchsia_posix::Errno>;
32850pub type DatagramSocketRecvMsgPostflightResult =
32851    Result<DatagramSocketRecvMsgPostflightResponse, fidl_fuchsia_posix::Errno>;
32852
32853pub trait DatagramSocketProxyInterface: Send + Sync {
32854    fn r#clone(
32855        &self,
32856        request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
32857    ) -> Result<(), fidl::Error>;
32858    type CloseResponseFut: std::future::Future<
32859            Output = Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error>,
32860        > + Send;
32861    fn r#close(&self) -> Self::CloseResponseFut;
32862    type QueryResponseFut: std::future::Future<Output = Result<Vec<u8>, fidl::Error>> + Send;
32863    fn r#query(&self) -> Self::QueryResponseFut;
32864    type SetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketSetReuseAddressResult, fidl::Error>>
32865        + Send;
32866    fn r#set_reuse_address(&self, value: bool) -> Self::SetReuseAddressResponseFut;
32867    type GetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketGetReuseAddressResult, fidl::Error>>
32868        + Send;
32869    fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut;
32870    type GetErrorResponseFut: std::future::Future<Output = Result<BaseSocketGetErrorResult, fidl::Error>>
32871        + Send;
32872    fn r#get_error(&self) -> Self::GetErrorResponseFut;
32873    type SetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketSetBroadcastResult, fidl::Error>>
32874        + Send;
32875    fn r#set_broadcast(&self, value: bool) -> Self::SetBroadcastResponseFut;
32876    type GetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketGetBroadcastResult, fidl::Error>>
32877        + Send;
32878    fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut;
32879    type SetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetSendBufferResult, fidl::Error>>
32880        + Send;
32881    fn r#set_send_buffer(&self, value_bytes: u64) -> Self::SetSendBufferResponseFut;
32882    type GetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetSendBufferResult, fidl::Error>>
32883        + Send;
32884    fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut;
32885    type SetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetReceiveBufferResult, fidl::Error>>
32886        + Send;
32887    fn r#set_receive_buffer(&self, value_bytes: u64) -> Self::SetReceiveBufferResponseFut;
32888    type GetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetReceiveBufferResult, fidl::Error>>
32889        + Send;
32890    fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut;
32891    type SetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketSetKeepAliveResult, fidl::Error>>
32892        + Send;
32893    fn r#set_keep_alive(&self, value: bool) -> Self::SetKeepAliveResponseFut;
32894    type GetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketGetKeepAliveResult, fidl::Error>>
32895        + Send;
32896    fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut;
32897    type SetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketSetOutOfBandInlineResult, fidl::Error>>
32898        + Send;
32899    fn r#set_out_of_band_inline(&self, value: bool) -> Self::SetOutOfBandInlineResponseFut;
32900    type GetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketGetOutOfBandInlineResult, fidl::Error>>
32901        + Send;
32902    fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut;
32903    type SetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketSetNoCheckResult, fidl::Error>>
32904        + Send;
32905    fn r#set_no_check(&self, value: bool) -> Self::SetNoCheckResponseFut;
32906    type GetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketGetNoCheckResult, fidl::Error>>
32907        + Send;
32908    fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut;
32909    type SetLingerResponseFut: std::future::Future<Output = Result<BaseSocketSetLingerResult, fidl::Error>>
32910        + Send;
32911    fn r#set_linger(&self, linger: bool, length_secs: u32) -> Self::SetLingerResponseFut;
32912    type GetLingerResponseFut: std::future::Future<Output = Result<BaseSocketGetLingerResult, fidl::Error>>
32913        + Send;
32914    fn r#get_linger(&self) -> Self::GetLingerResponseFut;
32915    type SetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketSetReusePortResult, fidl::Error>>
32916        + Send;
32917    fn r#set_reuse_port(&self, value: bool) -> Self::SetReusePortResponseFut;
32918    type GetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketGetReusePortResult, fidl::Error>>
32919        + Send;
32920    fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut;
32921    type GetAcceptConnResponseFut: std::future::Future<Output = Result<BaseSocketGetAcceptConnResult, fidl::Error>>
32922        + Send;
32923    fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut;
32924    type SetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToDeviceResult, fidl::Error>>
32925        + Send;
32926    fn r#set_bind_to_device(&self, value: &str) -> Self::SetBindToDeviceResponseFut;
32927    type GetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToDeviceResult, fidl::Error>>
32928        + Send;
32929    fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut;
32930    type SetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error>>
32931        + Send;
32932    fn r#set_bind_to_interface_index(&self, value: u64)
32933        -> Self::SetBindToInterfaceIndexResponseFut;
32934    type GetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error>>
32935        + Send;
32936    fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut;
32937    type SetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketSetTimestampResult, fidl::Error>>
32938        + Send;
32939    fn r#set_timestamp(&self, value: TimestampOption) -> Self::SetTimestampResponseFut;
32940    type GetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketGetTimestampResult, fidl::Error>>
32941        + Send;
32942    fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut;
32943    type SetMarkResponseFut: std::future::Future<Output = Result<BaseSocketSetMarkResult, fidl::Error>>
32944        + Send;
32945    fn r#set_mark(
32946        &self,
32947        domain: fidl_fuchsia_net::MarkDomain,
32948        mark: &OptionalUint32,
32949    ) -> Self::SetMarkResponseFut;
32950    type GetMarkResponseFut: std::future::Future<Output = Result<BaseSocketGetMarkResult, fidl::Error>>
32951        + Send;
32952    fn r#get_mark(&self, domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut;
32953    type BindResponseFut: std::future::Future<Output = Result<BaseNetworkSocketBindResult, fidl::Error>>
32954        + Send;
32955    fn r#bind(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut;
32956    type ConnectResponseFut: std::future::Future<Output = Result<BaseNetworkSocketConnectResult, fidl::Error>>
32957        + Send;
32958    fn r#connect(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut;
32959    type DisconnectResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDisconnectResult, fidl::Error>>
32960        + Send;
32961    fn r#disconnect(&self) -> Self::DisconnectResponseFut;
32962    type GetSockNameResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetSockNameResult, fidl::Error>>
32963        + Send;
32964    fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut;
32965    type GetPeerNameResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetPeerNameResult, fidl::Error>>
32966        + Send;
32967    fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut;
32968    type ShutdownResponseFut: std::future::Future<Output = Result<BaseNetworkSocketShutdownResult, fidl::Error>>
32969        + Send;
32970    fn r#shutdown(&self, mode: ShutdownMode) -> Self::ShutdownResponseFut;
32971    type SetIpTypeOfServiceResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error>>
32972        + Send;
32973    fn r#set_ip_type_of_service(&self, value: u8) -> Self::SetIpTypeOfServiceResponseFut;
32974    type GetIpTypeOfServiceResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error>>
32975        + Send;
32976    fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut;
32977    type SetIpTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTtlResult, fidl::Error>>
32978        + Send;
32979    fn r#set_ip_ttl(&self, value: &OptionalUint8) -> Self::SetIpTtlResponseFut;
32980    type GetIpTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTtlResult, fidl::Error>>
32981        + Send;
32982    fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut;
32983    type SetIpPacketInfoResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error>>
32984        + Send;
32985    fn r#set_ip_packet_info(&self, value: bool) -> Self::SetIpPacketInfoResponseFut;
32986    type GetIpPacketInfoResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error>>
32987        + Send;
32988    fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut;
32989    type SetIpReceiveTypeOfServiceResponseFut: std::future::Future<
32990            Output = Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error>,
32991        > + Send;
32992    fn r#set_ip_receive_type_of_service(
32993        &self,
32994        value: bool,
32995    ) -> Self::SetIpReceiveTypeOfServiceResponseFut;
32996    type GetIpReceiveTypeOfServiceResponseFut: std::future::Future<
32997            Output = Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error>,
32998        > + Send;
32999    fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut;
33000    type SetIpReceiveTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error>>
33001        + Send;
33002    fn r#set_ip_receive_ttl(&self, value: bool) -> Self::SetIpReceiveTtlResponseFut;
33003    type GetIpReceiveTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error>>
33004        + Send;
33005    fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut;
33006    type SetIpMulticastInterfaceResponseFut: std::future::Future<
33007            Output = Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error>,
33008        > + Send;
33009    fn r#set_ip_multicast_interface(
33010        &self,
33011        iface: u64,
33012        address: &fidl_fuchsia_net::Ipv4Address,
33013    ) -> Self::SetIpMulticastInterfaceResponseFut;
33014    type GetIpMulticastInterfaceResponseFut: std::future::Future<
33015            Output = Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error>,
33016        > + Send;
33017    fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut;
33018    type SetIpMulticastTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error>>
33019        + Send;
33020    fn r#set_ip_multicast_ttl(&self, value: &OptionalUint8) -> Self::SetIpMulticastTtlResponseFut;
33021    type GetIpMulticastTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error>>
33022        + Send;
33023    fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut;
33024    type SetIpMulticastLoopbackResponseFut: std::future::Future<
33025            Output = Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error>,
33026        > + Send;
33027    fn r#set_ip_multicast_loopback(&self, value: bool) -> Self::SetIpMulticastLoopbackResponseFut;
33028    type GetIpMulticastLoopbackResponseFut: std::future::Future<
33029            Output = Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error>,
33030        > + Send;
33031    fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut;
33032    type AddIpMembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error>>
33033        + Send;
33034    fn r#add_ip_membership(
33035        &self,
33036        membership: &IpMulticastMembership,
33037    ) -> Self::AddIpMembershipResponseFut;
33038    type DropIpMembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error>>
33039        + Send;
33040    fn r#drop_ip_membership(
33041        &self,
33042        membership: &IpMulticastMembership,
33043    ) -> Self::DropIpMembershipResponseFut;
33044    type SetIpTransparentResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error>>
33045        + Send;
33046    fn r#set_ip_transparent(&self, value: bool) -> Self::SetIpTransparentResponseFut;
33047    type GetIpTransparentResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error>>
33048        + Send;
33049    fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut;
33050    type SetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<
33051            Output = Result<
33052                BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
33053                fidl::Error,
33054            >,
33055        > + Send;
33056    fn r#set_ip_receive_original_destination_address(
33057        &self,
33058        value: bool,
33059    ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut;
33060    type GetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<
33061            Output = Result<
33062                BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
33063                fidl::Error,
33064            >,
33065        > + Send;
33066    fn r#get_ip_receive_original_destination_address(
33067        &self,
33068    ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut;
33069    type AddIpv6MembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error>>
33070        + Send;
33071    fn r#add_ipv6_membership(
33072        &self,
33073        membership: &Ipv6MulticastMembership,
33074    ) -> Self::AddIpv6MembershipResponseFut;
33075    type DropIpv6MembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error>>
33076        + Send;
33077    fn r#drop_ipv6_membership(
33078        &self,
33079        membership: &Ipv6MulticastMembership,
33080    ) -> Self::DropIpv6MembershipResponseFut;
33081    type SetIpv6MulticastInterfaceResponseFut: std::future::Future<
33082            Output = Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error>,
33083        > + Send;
33084    fn r#set_ipv6_multicast_interface(
33085        &self,
33086        value: u64,
33087    ) -> Self::SetIpv6MulticastInterfaceResponseFut;
33088    type GetIpv6MulticastInterfaceResponseFut: std::future::Future<
33089            Output = Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error>,
33090        > + Send;
33091    fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut;
33092    type SetIpv6UnicastHopsResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error>>
33093        + Send;
33094    fn r#set_ipv6_unicast_hops(&self, value: &OptionalUint8)
33095        -> Self::SetIpv6UnicastHopsResponseFut;
33096    type GetIpv6UnicastHopsResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error>>
33097        + Send;
33098    fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut;
33099    type SetIpv6ReceiveHopLimitResponseFut: std::future::Future<
33100            Output = Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error>,
33101        > + Send;
33102    fn r#set_ipv6_receive_hop_limit(&self, value: bool) -> Self::SetIpv6ReceiveHopLimitResponseFut;
33103    type GetIpv6ReceiveHopLimitResponseFut: std::future::Future<
33104            Output = Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error>,
33105        > + Send;
33106    fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut;
33107    type SetIpv6MulticastHopsResponseFut: std::future::Future<
33108            Output = Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error>,
33109        > + Send;
33110    fn r#set_ipv6_multicast_hops(
33111        &self,
33112        value: &OptionalUint8,
33113    ) -> Self::SetIpv6MulticastHopsResponseFut;
33114    type GetIpv6MulticastHopsResponseFut: std::future::Future<
33115            Output = Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error>,
33116        > + Send;
33117    fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut;
33118    type SetIpv6MulticastLoopbackResponseFut: std::future::Future<
33119            Output = Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error>,
33120        > + Send;
33121    fn r#set_ipv6_multicast_loopback(
33122        &self,
33123        value: bool,
33124    ) -> Self::SetIpv6MulticastLoopbackResponseFut;
33125    type GetIpv6MulticastLoopbackResponseFut: std::future::Future<
33126            Output = Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error>,
33127        > + Send;
33128    fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut;
33129    type SetIpv6OnlyResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error>>
33130        + Send;
33131    fn r#set_ipv6_only(&self, value: bool) -> Self::SetIpv6OnlyResponseFut;
33132    type GetIpv6OnlyResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error>>
33133        + Send;
33134    fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut;
33135    type SetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
33136            Output = Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error>,
33137        > + Send;
33138    fn r#set_ipv6_receive_traffic_class(
33139        &self,
33140        value: bool,
33141    ) -> Self::SetIpv6ReceiveTrafficClassResponseFut;
33142    type GetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
33143            Output = Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error>,
33144        > + Send;
33145    fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut;
33146    type SetIpv6TrafficClassResponseFut: std::future::Future<
33147            Output = Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error>,
33148        > + Send;
33149    fn r#set_ipv6_traffic_class(
33150        &self,
33151        value: &OptionalUint8,
33152    ) -> Self::SetIpv6TrafficClassResponseFut;
33153    type GetIpv6TrafficClassResponseFut: std::future::Future<
33154            Output = Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error>,
33155        > + Send;
33156    fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut;
33157    type SetIpv6ReceivePacketInfoResponseFut: std::future::Future<
33158            Output = Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error>,
33159        > + Send;
33160    fn r#set_ipv6_receive_packet_info(
33161        &self,
33162        value: bool,
33163    ) -> Self::SetIpv6ReceivePacketInfoResponseFut;
33164    type GetIpv6ReceivePacketInfoResponseFut: std::future::Future<
33165            Output = Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error>,
33166        > + Send;
33167    fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut;
33168    type GetOriginalDestinationResponseFut: std::future::Future<
33169            Output = Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error>,
33170        > + Send;
33171    fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut;
33172    type GetInfoResponseFut: std::future::Future<Output = Result<BaseDatagramSocketGetInfoResult, fidl::Error>>
33173        + Send;
33174    fn r#get_info(&self) -> Self::GetInfoResponseFut;
33175    type DescribeResponseFut: std::future::Future<Output = Result<DatagramSocketDescribeResponse, fidl::Error>>
33176        + Send;
33177    fn r#describe(&self) -> Self::DescribeResponseFut;
33178    type SendMsgPreflightResponseFut: std::future::Future<Output = Result<DatagramSocketSendMsgPreflightResult, fidl::Error>>
33179        + Send;
33180    fn r#send_msg_preflight(
33181        &self,
33182        payload: &DatagramSocketSendMsgPreflightRequest,
33183    ) -> Self::SendMsgPreflightResponseFut;
33184    type RecvMsgPostflightResponseFut: std::future::Future<Output = Result<DatagramSocketRecvMsgPostflightResult, fidl::Error>>
33185        + Send;
33186    fn r#recv_msg_postflight(&self) -> Self::RecvMsgPostflightResponseFut;
33187}
33188#[derive(Debug)]
33189#[cfg(target_os = "fuchsia")]
33190pub struct DatagramSocketSynchronousProxy {
33191    client: fidl::client::sync::Client,
33192}
33193
33194#[cfg(target_os = "fuchsia")]
33195impl fidl::endpoints::SynchronousProxy for DatagramSocketSynchronousProxy {
33196    type Proxy = DatagramSocketProxy;
33197    type Protocol = DatagramSocketMarker;
33198
33199    fn from_channel(inner: fidl::Channel) -> Self {
33200        Self::new(inner)
33201    }
33202
33203    fn into_channel(self) -> fidl::Channel {
33204        self.client.into_channel()
33205    }
33206
33207    fn as_channel(&self) -> &fidl::Channel {
33208        self.client.as_channel()
33209    }
33210}
33211
33212#[cfg(target_os = "fuchsia")]
33213impl DatagramSocketSynchronousProxy {
33214    pub fn new(channel: fidl::Channel) -> Self {
33215        let protocol_name = <DatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
33216        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
33217    }
33218
33219    pub fn into_channel(self) -> fidl::Channel {
33220        self.client.into_channel()
33221    }
33222
33223    /// Waits until an event arrives and returns it. It is safe for other
33224    /// threads to make concurrent requests while waiting for an event.
33225    pub fn wait_for_event(
33226        &self,
33227        deadline: zx::MonotonicInstant,
33228    ) -> Result<DatagramSocketEvent, fidl::Error> {
33229        DatagramSocketEvent::decode(self.client.wait_for_event(deadline)?)
33230    }
33231
33232    pub fn r#clone(
33233        &self,
33234        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
33235    ) -> Result<(), fidl::Error> {
33236        self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
33237            (request,),
33238            0x20d8a7aba2168a79,
33239            fidl::encoding::DynamicFlags::empty(),
33240        )
33241    }
33242
33243    /// Terminates the connection.
33244    ///
33245    /// After calling `Close`, the client must not send any other requests.
33246    ///
33247    /// Servers, after sending the status response, should close the connection
33248    /// regardless of status and without sending an epitaph.
33249    ///
33250    /// Closing the client end of the channel should be semantically equivalent
33251    /// to calling `Close` without knowing when the close has completed or its
33252    /// status.
33253    pub fn r#close(
33254        &self,
33255        ___deadline: zx::MonotonicInstant,
33256    ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
33257        let _response = self.client.send_query::<
33258            fidl::encoding::EmptyPayload,
33259            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
33260        >(
33261            (),
33262            0x5ac5d459ad7f657e,
33263            fidl::encoding::DynamicFlags::empty(),
33264            ___deadline,
33265        )?;
33266        Ok(_response.map(|x| x))
33267    }
33268
33269    pub fn r#query(&self, ___deadline: zx::MonotonicInstant) -> Result<Vec<u8>, fidl::Error> {
33270        let _response = self.client.send_query::<
33271            fidl::encoding::EmptyPayload,
33272            fidl_fuchsia_unknown::QueryableQueryResponse,
33273        >(
33274            (),
33275            0x2658edee9decfc06,
33276            fidl::encoding::DynamicFlags::empty(),
33277            ___deadline,
33278        )?;
33279        Ok(_response.protocol)
33280    }
33281
33282    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
33283    pub fn r#set_reuse_address(
33284        &self,
33285        mut value: bool,
33286        ___deadline: zx::MonotonicInstant,
33287    ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
33288        let _response =
33289            self.client.send_query::<BaseSocketSetReuseAddressRequest, fidl::encoding::ResultType<
33290                fidl::encoding::EmptyStruct,
33291                fidl_fuchsia_posix::Errno,
33292            >>(
33293                (value,),
33294                0x1fd74ee8b9a4a876,
33295                fidl::encoding::DynamicFlags::empty(),
33296                ___deadline,
33297            )?;
33298        Ok(_response.map(|x| x))
33299    }
33300
33301    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
33302    pub fn r#get_reuse_address(
33303        &self,
33304        ___deadline: zx::MonotonicInstant,
33305    ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
33306        let _response = self
33307            .client
33308            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33309                BaseSocketGetReuseAddressResponse,
33310                fidl_fuchsia_posix::Errno,
33311            >>(
33312                (), 0x67b7206b8d1bc0a5, fidl::encoding::DynamicFlags::empty(), ___deadline
33313            )?;
33314        Ok(_response.map(|x| x.value))
33315    }
33316
33317    /// Get `SOL_SOCKET` -> `SO_ERROR`.
33318    /// Returns the last error if there is an error set on the socket.
33319    pub fn r#get_error(
33320        &self,
33321        ___deadline: zx::MonotonicInstant,
33322    ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
33323        let _response =
33324            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33325                fidl::encoding::EmptyStruct,
33326                fidl_fuchsia_posix::Errno,
33327            >>(
33328                (),
33329                0x5aad39b33e5f6ebb,
33330                fidl::encoding::DynamicFlags::empty(),
33331                ___deadline,
33332            )?;
33333        Ok(_response.map(|x| x))
33334    }
33335
33336    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
33337    pub fn r#set_broadcast(
33338        &self,
33339        mut value: bool,
33340        ___deadline: zx::MonotonicInstant,
33341    ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
33342        let _response =
33343            self.client.send_query::<BaseSocketSetBroadcastRequest, fidl::encoding::ResultType<
33344                fidl::encoding::EmptyStruct,
33345                fidl_fuchsia_posix::Errno,
33346            >>(
33347                (value,),
33348                0x6023e081ce3cd947,
33349                fidl::encoding::DynamicFlags::empty(),
33350                ___deadline,
33351            )?;
33352        Ok(_response.map(|x| x))
33353    }
33354
33355    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
33356    pub fn r#get_broadcast(
33357        &self,
33358        ___deadline: zx::MonotonicInstant,
33359    ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
33360        let _response =
33361            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33362                BaseSocketGetBroadcastResponse,
33363                fidl_fuchsia_posix::Errno,
33364            >>(
33365                (),
33366                0x68796fc556f9780d,
33367                fidl::encoding::DynamicFlags::empty(),
33368                ___deadline,
33369            )?;
33370        Ok(_response.map(|x| x.value))
33371    }
33372
33373    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
33374    pub fn r#set_send_buffer(
33375        &self,
33376        mut value_bytes: u64,
33377        ___deadline: zx::MonotonicInstant,
33378    ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
33379        let _response =
33380            self.client.send_query::<BaseSocketSetSendBufferRequest, fidl::encoding::ResultType<
33381                fidl::encoding::EmptyStruct,
33382                fidl_fuchsia_posix::Errno,
33383            >>(
33384                (value_bytes,),
33385                0x756eac32d73a7a70,
33386                fidl::encoding::DynamicFlags::empty(),
33387                ___deadline,
33388            )?;
33389        Ok(_response.map(|x| x))
33390    }
33391
33392    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
33393    pub fn r#get_send_buffer(
33394        &self,
33395        ___deadline: zx::MonotonicInstant,
33396    ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
33397        let _response = self
33398            .client
33399            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33400                BaseSocketGetSendBufferResponse,
33401                fidl_fuchsia_posix::Errno,
33402            >>(
33403                (), 0x78a52fd9c7b2410b, fidl::encoding::DynamicFlags::empty(), ___deadline
33404            )?;
33405        Ok(_response.map(|x| x.value_bytes))
33406    }
33407
33408    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
33409    pub fn r#set_receive_buffer(
33410        &self,
33411        mut value_bytes: u64,
33412        ___deadline: zx::MonotonicInstant,
33413    ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
33414        let _response =
33415            self.client
33416                .send_query::<BaseSocketSetReceiveBufferRequest, fidl::encoding::ResultType<
33417                    fidl::encoding::EmptyStruct,
33418                    fidl_fuchsia_posix::Errno,
33419                >>(
33420                    (value_bytes,),
33421                    0x6b0cf2f1919c7001,
33422                    fidl::encoding::DynamicFlags::empty(),
33423                    ___deadline,
33424                )?;
33425        Ok(_response.map(|x| x))
33426    }
33427
33428    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
33429    pub fn r#get_receive_buffer(
33430        &self,
33431        ___deadline: zx::MonotonicInstant,
33432    ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
33433        let _response = self
33434            .client
33435            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33436                BaseSocketGetReceiveBufferResponse,
33437                fidl_fuchsia_posix::Errno,
33438            >>(
33439                (), 0x14c1a4b64f709e5c, fidl::encoding::DynamicFlags::empty(), ___deadline
33440            )?;
33441        Ok(_response.map(|x| x.value_bytes))
33442    }
33443
33444    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
33445    pub fn r#set_keep_alive(
33446        &self,
33447        mut value: bool,
33448        ___deadline: zx::MonotonicInstant,
33449    ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
33450        let _response =
33451            self.client.send_query::<BaseSocketSetKeepAliveRequest, fidl::encoding::ResultType<
33452                fidl::encoding::EmptyStruct,
33453                fidl_fuchsia_posix::Errno,
33454            >>(
33455                (value,),
33456                0x572df8f0b920d2c7,
33457                fidl::encoding::DynamicFlags::empty(),
33458                ___deadline,
33459            )?;
33460        Ok(_response.map(|x| x))
33461    }
33462
33463    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
33464    pub fn r#get_keep_alive(
33465        &self,
33466        ___deadline: zx::MonotonicInstant,
33467    ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
33468        let _response =
33469            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33470                BaseSocketGetKeepAliveResponse,
33471                fidl_fuchsia_posix::Errno,
33472            >>(
33473                (),
33474                0x2dd29d3215f2c9d2,
33475                fidl::encoding::DynamicFlags::empty(),
33476                ___deadline,
33477            )?;
33478        Ok(_response.map(|x| x.value))
33479    }
33480
33481    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
33482    pub fn r#set_out_of_band_inline(
33483        &self,
33484        mut value: bool,
33485        ___deadline: zx::MonotonicInstant,
33486    ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
33487        let _response =
33488            self.client
33489                .send_query::<BaseSocketSetOutOfBandInlineRequest, fidl::encoding::ResultType<
33490                    fidl::encoding::EmptyStruct,
33491                    fidl_fuchsia_posix::Errno,
33492                >>(
33493                    (value,),
33494                    0x3ecb49968bee439,
33495                    fidl::encoding::DynamicFlags::empty(),
33496                    ___deadline,
33497                )?;
33498        Ok(_response.map(|x| x))
33499    }
33500
33501    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
33502    pub fn r#get_out_of_band_inline(
33503        &self,
33504        ___deadline: zx::MonotonicInstant,
33505    ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
33506        let _response = self
33507            .client
33508            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33509                BaseSocketGetOutOfBandInlineResponse,
33510                fidl_fuchsia_posix::Errno,
33511            >>(
33512                (), 0x348c1ab3aeca1745, fidl::encoding::DynamicFlags::empty(), ___deadline
33513            )?;
33514        Ok(_response.map(|x| x.value))
33515    }
33516
33517    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
33518    pub fn r#set_no_check(
33519        &self,
33520        mut value: bool,
33521        ___deadline: zx::MonotonicInstant,
33522    ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
33523        let _response =
33524            self.client.send_query::<BaseSocketSetNoCheckRequest, fidl::encoding::ResultType<
33525                fidl::encoding::EmptyStruct,
33526                fidl_fuchsia_posix::Errno,
33527            >>(
33528                (value,),
33529                0x6bbf00c53a4c78c2,
33530                fidl::encoding::DynamicFlags::empty(),
33531                ___deadline,
33532            )?;
33533        Ok(_response.map(|x| x))
33534    }
33535
33536    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
33537    pub fn r#get_no_check(
33538        &self,
33539        ___deadline: zx::MonotonicInstant,
33540    ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
33541        let _response =
33542            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33543                BaseSocketGetNoCheckResponse,
33544                fidl_fuchsia_posix::Errno,
33545            >>(
33546                (),
33547                0x2cd4249286417694,
33548                fidl::encoding::DynamicFlags::empty(),
33549                ___deadline,
33550            )?;
33551        Ok(_response.map(|x| x.value))
33552    }
33553
33554    /// Set `SOL_SOCKET` -> `SO_LINGER`.
33555    pub fn r#set_linger(
33556        &self,
33557        mut linger: bool,
33558        mut length_secs: u32,
33559        ___deadline: zx::MonotonicInstant,
33560    ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
33561        let _response =
33562            self.client.send_query::<BaseSocketSetLingerRequest, fidl::encoding::ResultType<
33563                fidl::encoding::EmptyStruct,
33564                fidl_fuchsia_posix::Errno,
33565            >>(
33566                (linger, length_secs),
33567                0x45386351246e998e,
33568                fidl::encoding::DynamicFlags::empty(),
33569                ___deadline,
33570            )?;
33571        Ok(_response.map(|x| x))
33572    }
33573
33574    /// Get `SOL_SOCKET` -> `SO_LINGER`.
33575    pub fn r#get_linger(
33576        &self,
33577        ___deadline: zx::MonotonicInstant,
33578    ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
33579        let _response =
33580            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33581                BaseSocketGetLingerResponse,
33582                fidl_fuchsia_posix::Errno,
33583            >>(
33584                (),
33585                0x48eb20fc5ccb0e45,
33586                fidl::encoding::DynamicFlags::empty(),
33587                ___deadline,
33588            )?;
33589        Ok(_response.map(|x| (x.linger, x.length_secs)))
33590    }
33591
33592    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
33593    pub fn r#set_reuse_port(
33594        &self,
33595        mut value: bool,
33596        ___deadline: zx::MonotonicInstant,
33597    ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
33598        let _response =
33599            self.client.send_query::<BaseSocketSetReusePortRequest, fidl::encoding::ResultType<
33600                fidl::encoding::EmptyStruct,
33601                fidl_fuchsia_posix::Errno,
33602            >>(
33603                (value,),
33604                0x24dd3e5cb36d9ccb,
33605                fidl::encoding::DynamicFlags::empty(),
33606                ___deadline,
33607            )?;
33608        Ok(_response.map(|x| x))
33609    }
33610
33611    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
33612    pub fn r#get_reuse_port(
33613        &self,
33614        ___deadline: zx::MonotonicInstant,
33615    ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
33616        let _response =
33617            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33618                BaseSocketGetReusePortResponse,
33619                fidl_fuchsia_posix::Errno,
33620            >>(
33621                (),
33622                0x7a112c1ab54ff828,
33623                fidl::encoding::DynamicFlags::empty(),
33624                ___deadline,
33625            )?;
33626        Ok(_response.map(|x| x.value))
33627    }
33628
33629    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
33630    pub fn r#get_accept_conn(
33631        &self,
33632        ___deadline: zx::MonotonicInstant,
33633    ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
33634        let _response = self
33635            .client
33636            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33637                BaseSocketGetAcceptConnResponse,
33638                fidl_fuchsia_posix::Errno,
33639            >>(
33640                (), 0x67ce6db6c2ec8966, fidl::encoding::DynamicFlags::empty(), ___deadline
33641            )?;
33642        Ok(_response.map(|x| x.value))
33643    }
33644
33645    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
33646    pub fn r#set_bind_to_device(
33647        &self,
33648        mut value: &str,
33649        ___deadline: zx::MonotonicInstant,
33650    ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
33651        let _response =
33652            self.client.send_query::<BaseSocketSetBindToDeviceRequest, fidl::encoding::ResultType<
33653                fidl::encoding::EmptyStruct,
33654                fidl_fuchsia_posix::Errno,
33655            >>(
33656                (value,),
33657                0x2118b483f28aafc4,
33658                fidl::encoding::DynamicFlags::empty(),
33659                ___deadline,
33660            )?;
33661        Ok(_response.map(|x| x))
33662    }
33663
33664    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
33665    pub fn r#get_bind_to_device(
33666        &self,
33667        ___deadline: zx::MonotonicInstant,
33668    ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
33669        let _response = self
33670            .client
33671            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33672                BaseSocketGetBindToDeviceResponse,
33673                fidl_fuchsia_posix::Errno,
33674            >>(
33675                (), 0x1ab1fbf0ef7906c8, fidl::encoding::DynamicFlags::empty(), ___deadline
33676            )?;
33677        Ok(_response.map(|x| x.value))
33678    }
33679
33680    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
33681    /// If `value` is 0, this clears the bound interface.
33682    pub fn r#set_bind_to_interface_index(
33683        &self,
33684        mut value: u64,
33685        ___deadline: zx::MonotonicInstant,
33686    ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
33687        let _response =
33688            self.client
33689                .send_query::<BaseSocketSetBindToInterfaceIndexRequest, fidl::encoding::ResultType<
33690                    fidl::encoding::EmptyStruct,
33691                    fidl_fuchsia_posix::Errno,
33692                >>(
33693                    (value,),
33694                    0x6e387a0def00821,
33695                    fidl::encoding::DynamicFlags::empty(),
33696                    ___deadline,
33697                )?;
33698        Ok(_response.map(|x| x))
33699    }
33700
33701    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
33702    pub fn r#get_bind_to_interface_index(
33703        &self,
33704        ___deadline: zx::MonotonicInstant,
33705    ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
33706        let _response = self
33707            .client
33708            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33709                BaseSocketGetBindToInterfaceIndexResponse,
33710                fidl_fuchsia_posix::Errno,
33711            >>(
33712                (), 0x59c31dd3e3078295, fidl::encoding::DynamicFlags::empty(), ___deadline
33713            )?;
33714        Ok(_response.map(|x| x.value))
33715    }
33716
33717    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
33718    pub fn r#set_timestamp(
33719        &self,
33720        mut value: TimestampOption,
33721        ___deadline: zx::MonotonicInstant,
33722    ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
33723        let _response =
33724            self.client.send_query::<BaseSocketSetTimestampRequest, fidl::encoding::ResultType<
33725                fidl::encoding::EmptyStruct,
33726                fidl_fuchsia_posix::Errno,
33727            >>(
33728                (value,),
33729                0x285d6516c263d839,
33730                fidl::encoding::DynamicFlags::empty(),
33731                ___deadline,
33732            )?;
33733        Ok(_response.map(|x| x))
33734    }
33735
33736    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
33737    pub fn r#get_timestamp(
33738        &self,
33739        ___deadline: zx::MonotonicInstant,
33740    ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
33741        let _response =
33742            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33743                BaseSocketGetTimestampResponse,
33744                fidl_fuchsia_posix::Errno,
33745            >>(
33746                (),
33747                0x49f2fffbbcc2bd27,
33748                fidl::encoding::DynamicFlags::empty(),
33749                ___deadline,
33750            )?;
33751        Ok(_response.map(|x| x.value))
33752    }
33753
33754    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
33755    /// unlike the standard SO_MARK, this API has multiple mark domains and each
33756    /// mark can be set independently in each domain.
33757    pub fn r#set_mark(
33758        &self,
33759        mut domain: fidl_fuchsia_net::MarkDomain,
33760        mut mark: &OptionalUint32,
33761        ___deadline: zx::MonotonicInstant,
33762    ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
33763        let _response =
33764            self.client.send_query::<BaseSocketSetMarkRequest, fidl::encoding::ResultType<
33765                fidl::encoding::EmptyStruct,
33766                fidl_fuchsia_posix::Errno,
33767            >>(
33768                (domain, mark),
33769                0x6ead6de09f653236,
33770                fidl::encoding::DynamicFlags::empty(),
33771                ___deadline,
33772            )?;
33773        Ok(_response.map(|x| x))
33774    }
33775
33776    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
33777    /// unlike the standard SO_MARK, this API has multiple mark domains and each
33778    /// mark can be retrieved independently in each domain.
33779    pub fn r#get_mark(
33780        &self,
33781        mut domain: fidl_fuchsia_net::MarkDomain,
33782        ___deadline: zx::MonotonicInstant,
33783    ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
33784        let _response =
33785            self.client.send_query::<BaseSocketGetMarkRequest, fidl::encoding::ResultType<
33786                BaseSocketGetMarkResponse,
33787                fidl_fuchsia_posix::Errno,
33788            >>(
33789                (domain,),
33790                0x57a2752c61d93d47,
33791                fidl::encoding::DynamicFlags::empty(),
33792                ___deadline,
33793            )?;
33794        Ok(_response.map(|x| x.mark))
33795    }
33796
33797    /// Sets the local address used for the socket.
33798    pub fn r#bind(
33799        &self,
33800        mut addr: &fidl_fuchsia_net::SocketAddress,
33801        ___deadline: zx::MonotonicInstant,
33802    ) -> Result<BaseNetworkSocketBindResult, fidl::Error> {
33803        let _response =
33804            self.client.send_query::<BaseNetworkSocketBindRequest, fidl::encoding::ResultType<
33805                fidl::encoding::EmptyStruct,
33806                fidl_fuchsia_posix::Errno,
33807            >>(
33808                (addr,),
33809                0x4bc6400ae92125d,
33810                fidl::encoding::DynamicFlags::empty(),
33811                ___deadline,
33812            )?;
33813        Ok(_response.map(|x| x))
33814    }
33815
33816    /// Initiates a connection to a remote address.
33817    pub fn r#connect(
33818        &self,
33819        mut addr: &fidl_fuchsia_net::SocketAddress,
33820        ___deadline: zx::MonotonicInstant,
33821    ) -> Result<BaseNetworkSocketConnectResult, fidl::Error> {
33822        let _response =
33823            self.client.send_query::<BaseNetworkSocketConnectRequest, fidl::encoding::ResultType<
33824                fidl::encoding::EmptyStruct,
33825                fidl_fuchsia_posix::Errno,
33826            >>(
33827                (addr,),
33828                0x5f05f19bfdd38871,
33829                fidl::encoding::DynamicFlags::empty(),
33830                ___deadline,
33831            )?;
33832        Ok(_response.map(|x| x))
33833    }
33834
33835    /// Clears connection information from this socket.
33836    pub fn r#disconnect(
33837        &self,
33838        ___deadline: zx::MonotonicInstant,
33839    ) -> Result<BaseNetworkSocketDisconnectResult, fidl::Error> {
33840        let _response =
33841            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33842                fidl::encoding::EmptyStruct,
33843                fidl_fuchsia_posix::Errno,
33844            >>(
33845                (),
33846                0x74e63b91f7b29b2,
33847                fidl::encoding::DynamicFlags::empty(),
33848                ___deadline,
33849            )?;
33850        Ok(_response.map(|x| x))
33851    }
33852
33853    /// Retrieves the local socket address.
33854    pub fn r#get_sock_name(
33855        &self,
33856        ___deadline: zx::MonotonicInstant,
33857    ) -> Result<BaseNetworkSocketGetSockNameResult, fidl::Error> {
33858        let _response = self
33859            .client
33860            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33861                BaseNetworkSocketGetSockNameResponse,
33862                fidl_fuchsia_posix::Errno,
33863            >>(
33864                (), 0x475f23f84a1a4f85, fidl::encoding::DynamicFlags::empty(), ___deadline
33865            )?;
33866        Ok(_response.map(|x| x.addr))
33867    }
33868
33869    /// Retrieves the remote socket address.
33870    pub fn r#get_peer_name(
33871        &self,
33872        ___deadline: zx::MonotonicInstant,
33873    ) -> Result<BaseNetworkSocketGetPeerNameResult, fidl::Error> {
33874        let _response = self
33875            .client
33876            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33877                BaseNetworkSocketGetPeerNameResponse,
33878                fidl_fuchsia_posix::Errno,
33879            >>(
33880                (), 0x1ffecf4bd5b6432e, fidl::encoding::DynamicFlags::empty(), ___deadline
33881            )?;
33882        Ok(_response.map(|x| x.addr))
33883    }
33884
33885    /// Shuts down part of the socket.
33886    pub fn r#shutdown(
33887        &self,
33888        mut mode: ShutdownMode,
33889        ___deadline: zx::MonotonicInstant,
33890    ) -> Result<BaseNetworkSocketShutdownResult, fidl::Error> {
33891        let _response =
33892            self.client.send_query::<BaseNetworkSocketShutdownRequest, fidl::encoding::ResultType<
33893                fidl::encoding::EmptyStruct,
33894                fidl_fuchsia_posix::Errno,
33895            >>(
33896                (mode,),
33897                0x247f38b6db68c336,
33898                fidl::encoding::DynamicFlags::empty(),
33899                ___deadline,
33900            )?;
33901        Ok(_response.map(|x| x))
33902    }
33903
33904    /// Set `SOL_IP` -> `IP_TOS`.
33905    pub fn r#set_ip_type_of_service(
33906        &self,
33907        mut value: u8,
33908        ___deadline: zx::MonotonicInstant,
33909    ) -> Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error> {
33910        let _response = self.client.send_query::<
33911            BaseNetworkSocketSetIpTypeOfServiceRequest,
33912            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
33913        >(
33914            (value,),
33915            0x995c600475b6d46,
33916            fidl::encoding::DynamicFlags::empty(),
33917            ___deadline,
33918        )?;
33919        Ok(_response.map(|x| x))
33920    }
33921
33922    /// Get `SOL_IP` -> `IP_TOS`.
33923    pub fn r#get_ip_type_of_service(
33924        &self,
33925        ___deadline: zx::MonotonicInstant,
33926    ) -> Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error> {
33927        let _response = self
33928            .client
33929            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33930                BaseNetworkSocketGetIpTypeOfServiceResponse,
33931                fidl_fuchsia_posix::Errno,
33932            >>(
33933                (), 0x3814a04259f75fcb, fidl::encoding::DynamicFlags::empty(), ___deadline
33934            )?;
33935        Ok(_response.map(|x| x.value))
33936    }
33937
33938    /// Set `SOL_IP` -> `IP_TTL`.
33939    pub fn r#set_ip_ttl(
33940        &self,
33941        mut value: &OptionalUint8,
33942        ___deadline: zx::MonotonicInstant,
33943    ) -> Result<BaseNetworkSocketSetIpTtlResult, fidl::Error> {
33944        let _response =
33945            self.client.send_query::<BaseNetworkSocketSetIpTtlRequest, fidl::encoding::ResultType<
33946                fidl::encoding::EmptyStruct,
33947                fidl_fuchsia_posix::Errno,
33948            >>(
33949                (value,),
33950                0x29e2424b433ae1ef,
33951                fidl::encoding::DynamicFlags::empty(),
33952                ___deadline,
33953            )?;
33954        Ok(_response.map(|x| x))
33955    }
33956
33957    /// Get `SOL_IP` -> `IP_TTL`.
33958    pub fn r#get_ip_ttl(
33959        &self,
33960        ___deadline: zx::MonotonicInstant,
33961    ) -> Result<BaseNetworkSocketGetIpTtlResult, fidl::Error> {
33962        let _response = self
33963            .client
33964            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
33965                BaseNetworkSocketGetIpTtlResponse,
33966                fidl_fuchsia_posix::Errno,
33967            >>(
33968                (), 0x47e47fa1f24da471, fidl::encoding::DynamicFlags::empty(), ___deadline
33969            )?;
33970        Ok(_response.map(|x| x.value))
33971    }
33972
33973    /// Set `SOL_IP` -> `IP_PKTINFO`.
33974    pub fn r#set_ip_packet_info(
33975        &self,
33976        mut value: bool,
33977        ___deadline: zx::MonotonicInstant,
33978    ) -> Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error> {
33979        let _response =
33980            self.client
33981                .send_query::<BaseNetworkSocketSetIpPacketInfoRequest, fidl::encoding::ResultType<
33982                    fidl::encoding::EmptyStruct,
33983                    fidl_fuchsia_posix::Errno,
33984                >>(
33985                    (value,),
33986                    0x392d16bee20c0e16,
33987                    fidl::encoding::DynamicFlags::empty(),
33988                    ___deadline,
33989                )?;
33990        Ok(_response.map(|x| x))
33991    }
33992
33993    /// Get `SOL_IP` -> `IP_PKTINFO`.
33994    pub fn r#get_ip_packet_info(
33995        &self,
33996        ___deadline: zx::MonotonicInstant,
33997    ) -> Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error> {
33998        let _response = self
33999            .client
34000            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34001                BaseNetworkSocketGetIpPacketInfoResponse,
34002                fidl_fuchsia_posix::Errno,
34003            >>(
34004                (), 0x54b505f242280740, fidl::encoding::DynamicFlags::empty(), ___deadline
34005            )?;
34006        Ok(_response.map(|x| x.value))
34007    }
34008
34009    /// Set `SOL_IP` -> `IP_RECVTOS`.
34010    pub fn r#set_ip_receive_type_of_service(
34011        &self,
34012        mut value: bool,
34013        ___deadline: zx::MonotonicInstant,
34014    ) -> Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error> {
34015        let _response = self.client.send_query::<
34016            BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
34017            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
34018        >(
34019            (value,),
34020            0x6c4f6714995f84ef,
34021            fidl::encoding::DynamicFlags::empty(),
34022            ___deadline,
34023        )?;
34024        Ok(_response.map(|x| x))
34025    }
34026
34027    /// Get `SOL_IP` -> `IP_RECVTOS`.
34028    pub fn r#get_ip_receive_type_of_service(
34029        &self,
34030        ___deadline: zx::MonotonicInstant,
34031    ) -> Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error> {
34032        let _response = self
34033            .client
34034            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34035                BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
34036                fidl_fuchsia_posix::Errno,
34037            >>(
34038                (), 0x4158ba7dc2795960, fidl::encoding::DynamicFlags::empty(), ___deadline
34039            )?;
34040        Ok(_response.map(|x| x.value))
34041    }
34042
34043    /// Set `SOL_IP` -> `IP_RECVTTL`.
34044    pub fn r#set_ip_receive_ttl(
34045        &self,
34046        mut value: bool,
34047        ___deadline: zx::MonotonicInstant,
34048    ) -> Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error> {
34049        let _response =
34050            self.client
34051                .send_query::<BaseNetworkSocketSetIpReceiveTtlRequest, fidl::encoding::ResultType<
34052                    fidl::encoding::EmptyStruct,
34053                    fidl_fuchsia_posix::Errno,
34054                >>(
34055                    (value,),
34056                    0x46f15be0ce0ab82b,
34057                    fidl::encoding::DynamicFlags::empty(),
34058                    ___deadline,
34059                )?;
34060        Ok(_response.map(|x| x))
34061    }
34062
34063    /// Get `SOL_IP` -> `IP_RECVTTL`.
34064    pub fn r#get_ip_receive_ttl(
34065        &self,
34066        ___deadline: zx::MonotonicInstant,
34067    ) -> Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error> {
34068        let _response = self
34069            .client
34070            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34071                BaseNetworkSocketGetIpReceiveTtlResponse,
34072                fidl_fuchsia_posix::Errno,
34073            >>(
34074                (), 0x678ddd5a5dfa2eb5, fidl::encoding::DynamicFlags::empty(), ___deadline
34075            )?;
34076        Ok(_response.map(|x| x.value))
34077    }
34078
34079    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
34080    pub fn r#set_ip_multicast_interface(
34081        &self,
34082        mut iface: u64,
34083        mut address: &fidl_fuchsia_net::Ipv4Address,
34084        ___deadline: zx::MonotonicInstant,
34085    ) -> Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error> {
34086        let _response = self.client.send_query::<
34087            BaseNetworkSocketSetIpMulticastInterfaceRequest,
34088            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
34089        >(
34090            (iface, address,),
34091            0x752fbfa9b12befe,
34092            fidl::encoding::DynamicFlags::empty(),
34093            ___deadline,
34094        )?;
34095        Ok(_response.map(|x| x))
34096    }
34097
34098    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
34099    pub fn r#get_ip_multicast_interface(
34100        &self,
34101        ___deadline: zx::MonotonicInstant,
34102    ) -> Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error> {
34103        let _response = self
34104            .client
34105            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34106                BaseNetworkSocketGetIpMulticastInterfaceResponse,
34107                fidl_fuchsia_posix::Errno,
34108            >>(
34109                (), 0x320bd14c4df046c4, fidl::encoding::DynamicFlags::empty(), ___deadline
34110            )?;
34111        Ok(_response.map(|x| x.value))
34112    }
34113
34114    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
34115    pub fn r#set_ip_multicast_ttl(
34116        &self,
34117        mut value: &OptionalUint8,
34118        ___deadline: zx::MonotonicInstant,
34119    ) -> Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error> {
34120        let _response =
34121            self.client
34122                .send_query::<BaseNetworkSocketSetIpMulticastTtlRequest, fidl::encoding::ResultType<
34123                    fidl::encoding::EmptyStruct,
34124                    fidl_fuchsia_posix::Errno,
34125                >>(
34126                    (value,),
34127                    0x63134d53772916a1,
34128                    fidl::encoding::DynamicFlags::empty(),
34129                    ___deadline,
34130                )?;
34131        Ok(_response.map(|x| x))
34132    }
34133
34134    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
34135    pub fn r#get_ip_multicast_ttl(
34136        &self,
34137        ___deadline: zx::MonotonicInstant,
34138    ) -> Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error> {
34139        let _response = self
34140            .client
34141            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34142                BaseNetworkSocketGetIpMulticastTtlResponse,
34143                fidl_fuchsia_posix::Errno,
34144            >>(
34145                (), 0x4665cd378f39e1a, fidl::encoding::DynamicFlags::empty(), ___deadline
34146            )?;
34147        Ok(_response.map(|x| x.value))
34148    }
34149
34150    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
34151    pub fn r#set_ip_multicast_loopback(
34152        &self,
34153        mut value: bool,
34154        ___deadline: zx::MonotonicInstant,
34155    ) -> Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error> {
34156        let _response = self.client.send_query::<
34157            BaseNetworkSocketSetIpMulticastLoopbackRequest,
34158            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
34159        >(
34160            (value,),
34161            0x20c55c11f00943ea,
34162            fidl::encoding::DynamicFlags::empty(),
34163            ___deadline,
34164        )?;
34165        Ok(_response.map(|x| x))
34166    }
34167
34168    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
34169    pub fn r#get_ip_multicast_loopback(
34170        &self,
34171        ___deadline: zx::MonotonicInstant,
34172    ) -> Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error> {
34173        let _response = self
34174            .client
34175            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34176                BaseNetworkSocketGetIpMulticastLoopbackResponse,
34177                fidl_fuchsia_posix::Errno,
34178            >>(
34179                (), 0x3b6b26ff558298f2, fidl::encoding::DynamicFlags::empty(), ___deadline
34180            )?;
34181        Ok(_response.map(|x| x.value))
34182    }
34183
34184    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
34185    pub fn r#add_ip_membership(
34186        &self,
34187        mut membership: &IpMulticastMembership,
34188        ___deadline: zx::MonotonicInstant,
34189    ) -> Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error> {
34190        let _response =
34191            self.client
34192                .send_query::<BaseNetworkSocketAddIpMembershipRequest, fidl::encoding::ResultType<
34193                    fidl::encoding::EmptyStruct,
34194                    fidl_fuchsia_posix::Errno,
34195                >>(
34196                    (membership,),
34197                    0x76bc7df115a3b4d0,
34198                    fidl::encoding::DynamicFlags::empty(),
34199                    ___deadline,
34200                )?;
34201        Ok(_response.map(|x| x))
34202    }
34203
34204    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
34205    pub fn r#drop_ip_membership(
34206        &self,
34207        mut membership: &IpMulticastMembership,
34208        ___deadline: zx::MonotonicInstant,
34209    ) -> Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error> {
34210        let _response =
34211            self.client
34212                .send_query::<BaseNetworkSocketDropIpMembershipRequest, fidl::encoding::ResultType<
34213                    fidl::encoding::EmptyStruct,
34214                    fidl_fuchsia_posix::Errno,
34215                >>(
34216                    (membership,),
34217                    0x2888f3099188d03,
34218                    fidl::encoding::DynamicFlags::empty(),
34219                    ___deadline,
34220                )?;
34221        Ok(_response.map(|x| x))
34222    }
34223
34224    /// Set `SOL_IP` -> `IP_TRANSPARENT`
34225    pub fn r#set_ip_transparent(
34226        &self,
34227        mut value: bool,
34228        ___deadline: zx::MonotonicInstant,
34229    ) -> Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error> {
34230        let _response =
34231            self.client
34232                .send_query::<BaseNetworkSocketSetIpTransparentRequest, fidl::encoding::ResultType<
34233                    fidl::encoding::EmptyStruct,
34234                    fidl_fuchsia_posix::Errno,
34235                >>(
34236                    (value,),
34237                    0x1ae532b0c066e3a0,
34238                    fidl::encoding::DynamicFlags::empty(),
34239                    ___deadline,
34240                )?;
34241        Ok(_response.map(|x| x))
34242    }
34243
34244    /// Get `SOL_IP` -> `IP_TRANSPARENT`
34245    pub fn r#get_ip_transparent(
34246        &self,
34247        ___deadline: zx::MonotonicInstant,
34248    ) -> Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error> {
34249        let _response = self
34250            .client
34251            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34252                BaseNetworkSocketGetIpTransparentResponse,
34253                fidl_fuchsia_posix::Errno,
34254            >>(
34255                (), 0x51d43695962ebfb5, fidl::encoding::DynamicFlags::empty(), ___deadline
34256            )?;
34257        Ok(_response.map(|x| x.value))
34258    }
34259
34260    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
34261    pub fn r#set_ip_receive_original_destination_address(
34262        &self,
34263        mut value: bool,
34264        ___deadline: zx::MonotonicInstant,
34265    ) -> Result<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error> {
34266        let _response = self.client.send_query::<
34267            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
34268            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
34269        >(
34270            (value,),
34271            0x4722b4ce52f7840,
34272            fidl::encoding::DynamicFlags::empty(),
34273            ___deadline,
34274        )?;
34275        Ok(_response.map(|x| x))
34276    }
34277
34278    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
34279    pub fn r#get_ip_receive_original_destination_address(
34280        &self,
34281        ___deadline: zx::MonotonicInstant,
34282    ) -> Result<BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error> {
34283        let _response = self
34284            .client
34285            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34286                BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
34287                fidl_fuchsia_posix::Errno,
34288            >>(
34289                (), 0x2a0e7dc5d6bfdfe9, fidl::encoding::DynamicFlags::empty(), ___deadline
34290            )?;
34291        Ok(_response.map(|x| x.value))
34292    }
34293
34294    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
34295    pub fn r#add_ipv6_membership(
34296        &self,
34297        mut membership: &Ipv6MulticastMembership,
34298        ___deadline: zx::MonotonicInstant,
34299    ) -> Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error> {
34300        let _response =
34301            self.client
34302                .send_query::<BaseNetworkSocketAddIpv6MembershipRequest, fidl::encoding::ResultType<
34303                    fidl::encoding::EmptyStruct,
34304                    fidl_fuchsia_posix::Errno,
34305                >>(
34306                    (membership,),
34307                    0x7c94727acb4ea4b3,
34308                    fidl::encoding::DynamicFlags::empty(),
34309                    ___deadline,
34310                )?;
34311        Ok(_response.map(|x| x))
34312    }
34313
34314    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
34315    pub fn r#drop_ipv6_membership(
34316        &self,
34317        mut membership: &Ipv6MulticastMembership,
34318        ___deadline: zx::MonotonicInstant,
34319    ) -> Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error> {
34320        let _response = self.client.send_query::<
34321            BaseNetworkSocketDropIpv6MembershipRequest,
34322            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
34323        >(
34324            (membership,),
34325            0x42104c70ccaba304,
34326            fidl::encoding::DynamicFlags::empty(),
34327            ___deadline,
34328        )?;
34329        Ok(_response.map(|x| x))
34330    }
34331
34332    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
34333    pub fn r#set_ipv6_multicast_interface(
34334        &self,
34335        mut value: u64,
34336        ___deadline: zx::MonotonicInstant,
34337    ) -> Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error> {
34338        let _response = self.client.send_query::<
34339            BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
34340            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
34341        >(
34342            (value,),
34343            0x135f76db3774ab3b,
34344            fidl::encoding::DynamicFlags::empty(),
34345            ___deadline,
34346        )?;
34347        Ok(_response.map(|x| x))
34348    }
34349
34350    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
34351    pub fn r#get_ipv6_multicast_interface(
34352        &self,
34353        ___deadline: zx::MonotonicInstant,
34354    ) -> Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error> {
34355        let _response = self
34356            .client
34357            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34358                BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
34359                fidl_fuchsia_posix::Errno,
34360            >>(
34361                (), 0x1f26fcdd348f1882, fidl::encoding::DynamicFlags::empty(), ___deadline
34362            )?;
34363        Ok(_response.map(|x| x.value))
34364    }
34365
34366    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
34367    pub fn r#set_ipv6_unicast_hops(
34368        &self,
34369        mut value: &OptionalUint8,
34370        ___deadline: zx::MonotonicInstant,
34371    ) -> Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error> {
34372        let _response = self.client.send_query::<
34373            BaseNetworkSocketSetIpv6UnicastHopsRequest,
34374            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
34375        >(
34376            (value,),
34377            0x157d51e98f462859,
34378            fidl::encoding::DynamicFlags::empty(),
34379            ___deadline,
34380        )?;
34381        Ok(_response.map(|x| x))
34382    }
34383
34384    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
34385    pub fn r#get_ipv6_unicast_hops(
34386        &self,
34387        ___deadline: zx::MonotonicInstant,
34388    ) -> Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error> {
34389        let _response = self
34390            .client
34391            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34392                BaseNetworkSocketGetIpv6UnicastHopsResponse,
34393                fidl_fuchsia_posix::Errno,
34394            >>(
34395                (), 0x21f4641cad8bd8d2, fidl::encoding::DynamicFlags::empty(), ___deadline
34396            )?;
34397        Ok(_response.map(|x| x.value))
34398    }
34399
34400    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
34401    pub fn r#set_ipv6_receive_hop_limit(
34402        &self,
34403        mut value: bool,
34404        ___deadline: zx::MonotonicInstant,
34405    ) -> Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error> {
34406        let _response = self.client.send_query::<
34407            BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
34408            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
34409        >(
34410            (value,),
34411            0x5c24808ed2e84a1e,
34412            fidl::encoding::DynamicFlags::empty(),
34413            ___deadline,
34414        )?;
34415        Ok(_response.map(|x| x))
34416    }
34417
34418    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
34419    pub fn r#get_ipv6_receive_hop_limit(
34420        &self,
34421        ___deadline: zx::MonotonicInstant,
34422    ) -> Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error> {
34423        let _response = self
34424            .client
34425            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34426                BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
34427                fidl_fuchsia_posix::Errno,
34428            >>(
34429                (), 0x341e06689885b4c0, fidl::encoding::DynamicFlags::empty(), ___deadline
34430            )?;
34431        Ok(_response.map(|x| x.value))
34432    }
34433
34434    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
34435    pub fn r#set_ipv6_multicast_hops(
34436        &self,
34437        mut value: &OptionalUint8,
34438        ___deadline: zx::MonotonicInstant,
34439    ) -> Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error> {
34440        let _response = self.client.send_query::<
34441            BaseNetworkSocketSetIpv6MulticastHopsRequest,
34442            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
34443        >(
34444            (value,),
34445            0x25b9cd4d181f82c1,
34446            fidl::encoding::DynamicFlags::empty(),
34447            ___deadline,
34448        )?;
34449        Ok(_response.map(|x| x))
34450    }
34451
34452    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
34453    pub fn r#get_ipv6_multicast_hops(
34454        &self,
34455        ___deadline: zx::MonotonicInstant,
34456    ) -> Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error> {
34457        let _response = self
34458            .client
34459            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34460                BaseNetworkSocketGetIpv6MulticastHopsResponse,
34461                fidl_fuchsia_posix::Errno,
34462            >>(
34463                (), 0x52916948a365012a, fidl::encoding::DynamicFlags::empty(), ___deadline
34464            )?;
34465        Ok(_response.map(|x| x.value))
34466    }
34467
34468    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
34469    pub fn r#set_ipv6_multicast_loopback(
34470        &self,
34471        mut value: bool,
34472        ___deadline: zx::MonotonicInstant,
34473    ) -> Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error> {
34474        let _response = self.client.send_query::<
34475            BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
34476            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
34477        >(
34478            (value,),
34479            0x55701c409ff41b40,
34480            fidl::encoding::DynamicFlags::empty(),
34481            ___deadline,
34482        )?;
34483        Ok(_response.map(|x| x))
34484    }
34485
34486    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
34487    pub fn r#get_ipv6_multicast_loopback(
34488        &self,
34489        ___deadline: zx::MonotonicInstant,
34490    ) -> Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error> {
34491        let _response = self
34492            .client
34493            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34494                BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
34495                fidl_fuchsia_posix::Errno,
34496            >>(
34497                (), 0x4415b701fde319c3, fidl::encoding::DynamicFlags::empty(), ___deadline
34498            )?;
34499        Ok(_response.map(|x| x.value))
34500    }
34501
34502    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
34503    pub fn r#set_ipv6_only(
34504        &self,
34505        mut value: bool,
34506        ___deadline: zx::MonotonicInstant,
34507    ) -> Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
34508        let _response =
34509            self.client
34510                .send_query::<BaseNetworkSocketSetIpv6OnlyRequest, fidl::encoding::ResultType<
34511                    fidl::encoding::EmptyStruct,
34512                    fidl_fuchsia_posix::Errno,
34513                >>(
34514                    (value,),
34515                    0x4873f1364758cbba,
34516                    fidl::encoding::DynamicFlags::empty(),
34517                    ___deadline,
34518                )?;
34519        Ok(_response.map(|x| x))
34520    }
34521
34522    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
34523    pub fn r#get_ipv6_only(
34524        &self,
34525        ___deadline: zx::MonotonicInstant,
34526    ) -> Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
34527        let _response = self
34528            .client
34529            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34530                BaseNetworkSocketGetIpv6OnlyResponse,
34531                fidl_fuchsia_posix::Errno,
34532            >>(
34533                (), 0x4aa3340a1a26b89c, fidl::encoding::DynamicFlags::empty(), ___deadline
34534            )?;
34535        Ok(_response.map(|x| x.value))
34536    }
34537
34538    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
34539    pub fn r#set_ipv6_receive_traffic_class(
34540        &self,
34541        mut value: bool,
34542        ___deadline: zx::MonotonicInstant,
34543    ) -> Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error> {
34544        let _response = self.client.send_query::<
34545            BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
34546            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
34547        >(
34548            (value,),
34549            0x58f07c8788d099a0,
34550            fidl::encoding::DynamicFlags::empty(),
34551            ___deadline,
34552        )?;
34553        Ok(_response.map(|x| x))
34554    }
34555
34556    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
34557    pub fn r#get_ipv6_receive_traffic_class(
34558        &self,
34559        ___deadline: zx::MonotonicInstant,
34560    ) -> Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error> {
34561        let _response = self
34562            .client
34563            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34564                BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
34565                fidl_fuchsia_posix::Errno,
34566            >>(
34567                (), 0x2e334df1da553ffa, fidl::encoding::DynamicFlags::empty(), ___deadline
34568            )?;
34569        Ok(_response.map(|x| x.value))
34570    }
34571
34572    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
34573    pub fn r#set_ipv6_traffic_class(
34574        &self,
34575        mut value: &OptionalUint8,
34576        ___deadline: zx::MonotonicInstant,
34577    ) -> Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error> {
34578        let _response = self.client.send_query::<
34579            BaseNetworkSocketSetIpv6TrafficClassRequest,
34580            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
34581        >(
34582            (value,),
34583            0x6af077800c5a0b4f,
34584            fidl::encoding::DynamicFlags::empty(),
34585            ___deadline,
34586        )?;
34587        Ok(_response.map(|x| x))
34588    }
34589
34590    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
34591    pub fn r#get_ipv6_traffic_class(
34592        &self,
34593        ___deadline: zx::MonotonicInstant,
34594    ) -> Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error> {
34595        let _response = self
34596            .client
34597            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34598                BaseNetworkSocketGetIpv6TrafficClassResponse,
34599                fidl_fuchsia_posix::Errno,
34600            >>(
34601                (), 0x6baf6eed8fc2f04, fidl::encoding::DynamicFlags::empty(), ___deadline
34602            )?;
34603        Ok(_response.map(|x| x.value))
34604    }
34605
34606    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
34607    pub fn r#set_ipv6_receive_packet_info(
34608        &self,
34609        mut value: bool,
34610        ___deadline: zx::MonotonicInstant,
34611    ) -> Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error> {
34612        let _response = self.client.send_query::<
34613            BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
34614            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
34615        >(
34616            (value,),
34617            0x19259775b1a92768,
34618            fidl::encoding::DynamicFlags::empty(),
34619            ___deadline,
34620        )?;
34621        Ok(_response.map(|x| x))
34622    }
34623
34624    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
34625    pub fn r#get_ipv6_receive_packet_info(
34626        &self,
34627        ___deadline: zx::MonotonicInstant,
34628    ) -> Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error> {
34629        let _response = self
34630            .client
34631            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34632                BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
34633                fidl_fuchsia_posix::Errno,
34634            >>(
34635                (), 0x7acd4a2775baec75, fidl::encoding::DynamicFlags::empty(), ___deadline
34636            )?;
34637        Ok(_response.map(|x| x.value))
34638    }
34639
34640    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
34641    pub fn r#get_original_destination(
34642        &self,
34643        ___deadline: zx::MonotonicInstant,
34644    ) -> Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error> {
34645        let _response = self
34646            .client
34647            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34648                BaseNetworkSocketGetOriginalDestinationResponse,
34649                fidl_fuchsia_posix::Errno,
34650            >>(
34651                (), 0x38bf28f0dafdbac0, fidl::encoding::DynamicFlags::empty(), ___deadline
34652            )?;
34653        Ok(_response.map(|x| x.value))
34654    }
34655
34656    /// Retrieves creation information from the socket.
34657    ///
34658    /// - response `domain` the socket's associated domain.
34659    /// - response `proto` the socket's associated protocol.
34660    pub fn r#get_info(
34661        &self,
34662        ___deadline: zx::MonotonicInstant,
34663    ) -> Result<BaseDatagramSocketGetInfoResult, fidl::Error> {
34664        let _response = self
34665            .client
34666            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34667                BaseDatagramSocketGetInfoResponse,
34668                fidl_fuchsia_posix::Errno,
34669            >>(
34670                (), 0x48aa0a1f6a32d2ed, fidl::encoding::DynamicFlags::empty(), ___deadline
34671            )?;
34672        Ok(_response.map(|x| (x.domain, x.proto)))
34673    }
34674
34675    pub fn r#describe(
34676        &self,
34677        ___deadline: zx::MonotonicInstant,
34678    ) -> Result<DatagramSocketDescribeResponse, fidl::Error> {
34679        let _response = self
34680            .client
34681            .send_query::<fidl::encoding::EmptyPayload, DatagramSocketDescribeResponse>(
34682                (),
34683                0xbf1e2f0a86601f3,
34684                fidl::encoding::DynamicFlags::empty(),
34685                ___deadline,
34686            )?;
34687        Ok(_response)
34688    }
34689
34690    /// Validates that data can be sent.
34691    ///
34692    /// + request `args` the requested disposition of data to be sent.
34693    /// - response the constraints sent data must satisfy.
34694    /// * error the error code indicating the reason for validation failure.
34695    pub fn r#send_msg_preflight(
34696        &self,
34697        mut payload: &DatagramSocketSendMsgPreflightRequest,
34698        ___deadline: zx::MonotonicInstant,
34699    ) -> Result<DatagramSocketSendMsgPreflightResult, fidl::Error> {
34700        let _response = self
34701            .client
34702            .send_query::<DatagramSocketSendMsgPreflightRequest, fidl::encoding::ResultType<
34703                DatagramSocketSendMsgPreflightResponse,
34704                fidl_fuchsia_posix::Errno,
34705            >>(
34706                payload, 0x5362e668e777248a, fidl::encoding::DynamicFlags::empty(), ___deadline
34707            )?;
34708        Ok(_response.map(|x| x))
34709    }
34710
34711    /// Returns the set of requested control messages.
34712    ///
34713    /// - response the set of currently requested control messages.
34714    pub fn r#recv_msg_postflight(
34715        &self,
34716        ___deadline: zx::MonotonicInstant,
34717    ) -> Result<DatagramSocketRecvMsgPostflightResult, fidl::Error> {
34718        let _response = self
34719            .client
34720            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
34721                DatagramSocketRecvMsgPostflightResponse,
34722                fidl_fuchsia_posix::Errno,
34723            >>(
34724                (), 0x1a7cdeca5f3eb8e2, fidl::encoding::DynamicFlags::empty(), ___deadline
34725            )?;
34726        Ok(_response.map(|x| x))
34727    }
34728}
34729
34730#[cfg(target_os = "fuchsia")]
34731impl From<DatagramSocketSynchronousProxy> for zx::Handle {
34732    fn from(value: DatagramSocketSynchronousProxy) -> Self {
34733        value.into_channel().into()
34734    }
34735}
34736
34737#[cfg(target_os = "fuchsia")]
34738impl From<fidl::Channel> for DatagramSocketSynchronousProxy {
34739    fn from(value: fidl::Channel) -> Self {
34740        Self::new(value)
34741    }
34742}
34743
34744#[derive(Debug, Clone)]
34745pub struct DatagramSocketProxy {
34746    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
34747}
34748
34749impl fidl::endpoints::Proxy for DatagramSocketProxy {
34750    type Protocol = DatagramSocketMarker;
34751
34752    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
34753        Self::new(inner)
34754    }
34755
34756    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
34757        self.client.into_channel().map_err(|client| Self { client })
34758    }
34759
34760    fn as_channel(&self) -> &::fidl::AsyncChannel {
34761        self.client.as_channel()
34762    }
34763}
34764
34765impl DatagramSocketProxy {
34766    /// Create a new Proxy for fuchsia.posix.socket/DatagramSocket.
34767    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
34768        let protocol_name = <DatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
34769        Self { client: fidl::client::Client::new(channel, protocol_name) }
34770    }
34771
34772    /// Get a Stream of events from the remote end of the protocol.
34773    ///
34774    /// # Panics
34775    ///
34776    /// Panics if the event stream was already taken.
34777    pub fn take_event_stream(&self) -> DatagramSocketEventStream {
34778        DatagramSocketEventStream { event_receiver: self.client.take_event_receiver() }
34779    }
34780
34781    pub fn r#clone(
34782        &self,
34783        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
34784    ) -> Result<(), fidl::Error> {
34785        DatagramSocketProxyInterface::r#clone(self, request)
34786    }
34787
34788    /// Terminates the connection.
34789    ///
34790    /// After calling `Close`, the client must not send any other requests.
34791    ///
34792    /// Servers, after sending the status response, should close the connection
34793    /// regardless of status and without sending an epitaph.
34794    ///
34795    /// Closing the client end of the channel should be semantically equivalent
34796    /// to calling `Close` without knowing when the close has completed or its
34797    /// status.
34798    pub fn r#close(
34799        &self,
34800    ) -> fidl::client::QueryResponseFut<
34801        fidl_fuchsia_unknown::CloseableCloseResult,
34802        fidl::encoding::DefaultFuchsiaResourceDialect,
34803    > {
34804        DatagramSocketProxyInterface::r#close(self)
34805    }
34806
34807    pub fn r#query(
34808        &self,
34809    ) -> fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>
34810    {
34811        DatagramSocketProxyInterface::r#query(self)
34812    }
34813
34814    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
34815    pub fn r#set_reuse_address(
34816        &self,
34817        mut value: bool,
34818    ) -> fidl::client::QueryResponseFut<
34819        BaseSocketSetReuseAddressResult,
34820        fidl::encoding::DefaultFuchsiaResourceDialect,
34821    > {
34822        DatagramSocketProxyInterface::r#set_reuse_address(self, value)
34823    }
34824
34825    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
34826    pub fn r#get_reuse_address(
34827        &self,
34828    ) -> fidl::client::QueryResponseFut<
34829        BaseSocketGetReuseAddressResult,
34830        fidl::encoding::DefaultFuchsiaResourceDialect,
34831    > {
34832        DatagramSocketProxyInterface::r#get_reuse_address(self)
34833    }
34834
34835    /// Get `SOL_SOCKET` -> `SO_ERROR`.
34836    /// Returns the last error if there is an error set on the socket.
34837    pub fn r#get_error(
34838        &self,
34839    ) -> fidl::client::QueryResponseFut<
34840        BaseSocketGetErrorResult,
34841        fidl::encoding::DefaultFuchsiaResourceDialect,
34842    > {
34843        DatagramSocketProxyInterface::r#get_error(self)
34844    }
34845
34846    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
34847    pub fn r#set_broadcast(
34848        &self,
34849        mut value: bool,
34850    ) -> fidl::client::QueryResponseFut<
34851        BaseSocketSetBroadcastResult,
34852        fidl::encoding::DefaultFuchsiaResourceDialect,
34853    > {
34854        DatagramSocketProxyInterface::r#set_broadcast(self, value)
34855    }
34856
34857    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
34858    pub fn r#get_broadcast(
34859        &self,
34860    ) -> fidl::client::QueryResponseFut<
34861        BaseSocketGetBroadcastResult,
34862        fidl::encoding::DefaultFuchsiaResourceDialect,
34863    > {
34864        DatagramSocketProxyInterface::r#get_broadcast(self)
34865    }
34866
34867    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
34868    pub fn r#set_send_buffer(
34869        &self,
34870        mut value_bytes: u64,
34871    ) -> fidl::client::QueryResponseFut<
34872        BaseSocketSetSendBufferResult,
34873        fidl::encoding::DefaultFuchsiaResourceDialect,
34874    > {
34875        DatagramSocketProxyInterface::r#set_send_buffer(self, value_bytes)
34876    }
34877
34878    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
34879    pub fn r#get_send_buffer(
34880        &self,
34881    ) -> fidl::client::QueryResponseFut<
34882        BaseSocketGetSendBufferResult,
34883        fidl::encoding::DefaultFuchsiaResourceDialect,
34884    > {
34885        DatagramSocketProxyInterface::r#get_send_buffer(self)
34886    }
34887
34888    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
34889    pub fn r#set_receive_buffer(
34890        &self,
34891        mut value_bytes: u64,
34892    ) -> fidl::client::QueryResponseFut<
34893        BaseSocketSetReceiveBufferResult,
34894        fidl::encoding::DefaultFuchsiaResourceDialect,
34895    > {
34896        DatagramSocketProxyInterface::r#set_receive_buffer(self, value_bytes)
34897    }
34898
34899    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
34900    pub fn r#get_receive_buffer(
34901        &self,
34902    ) -> fidl::client::QueryResponseFut<
34903        BaseSocketGetReceiveBufferResult,
34904        fidl::encoding::DefaultFuchsiaResourceDialect,
34905    > {
34906        DatagramSocketProxyInterface::r#get_receive_buffer(self)
34907    }
34908
34909    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
34910    pub fn r#set_keep_alive(
34911        &self,
34912        mut value: bool,
34913    ) -> fidl::client::QueryResponseFut<
34914        BaseSocketSetKeepAliveResult,
34915        fidl::encoding::DefaultFuchsiaResourceDialect,
34916    > {
34917        DatagramSocketProxyInterface::r#set_keep_alive(self, value)
34918    }
34919
34920    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
34921    pub fn r#get_keep_alive(
34922        &self,
34923    ) -> fidl::client::QueryResponseFut<
34924        BaseSocketGetKeepAliveResult,
34925        fidl::encoding::DefaultFuchsiaResourceDialect,
34926    > {
34927        DatagramSocketProxyInterface::r#get_keep_alive(self)
34928    }
34929
34930    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
34931    pub fn r#set_out_of_band_inline(
34932        &self,
34933        mut value: bool,
34934    ) -> fidl::client::QueryResponseFut<
34935        BaseSocketSetOutOfBandInlineResult,
34936        fidl::encoding::DefaultFuchsiaResourceDialect,
34937    > {
34938        DatagramSocketProxyInterface::r#set_out_of_band_inline(self, value)
34939    }
34940
34941    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
34942    pub fn r#get_out_of_band_inline(
34943        &self,
34944    ) -> fidl::client::QueryResponseFut<
34945        BaseSocketGetOutOfBandInlineResult,
34946        fidl::encoding::DefaultFuchsiaResourceDialect,
34947    > {
34948        DatagramSocketProxyInterface::r#get_out_of_band_inline(self)
34949    }
34950
34951    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
34952    pub fn r#set_no_check(
34953        &self,
34954        mut value: bool,
34955    ) -> fidl::client::QueryResponseFut<
34956        BaseSocketSetNoCheckResult,
34957        fidl::encoding::DefaultFuchsiaResourceDialect,
34958    > {
34959        DatagramSocketProxyInterface::r#set_no_check(self, value)
34960    }
34961
34962    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
34963    pub fn r#get_no_check(
34964        &self,
34965    ) -> fidl::client::QueryResponseFut<
34966        BaseSocketGetNoCheckResult,
34967        fidl::encoding::DefaultFuchsiaResourceDialect,
34968    > {
34969        DatagramSocketProxyInterface::r#get_no_check(self)
34970    }
34971
34972    /// Set `SOL_SOCKET` -> `SO_LINGER`.
34973    pub fn r#set_linger(
34974        &self,
34975        mut linger: bool,
34976        mut length_secs: u32,
34977    ) -> fidl::client::QueryResponseFut<
34978        BaseSocketSetLingerResult,
34979        fidl::encoding::DefaultFuchsiaResourceDialect,
34980    > {
34981        DatagramSocketProxyInterface::r#set_linger(self, linger, length_secs)
34982    }
34983
34984    /// Get `SOL_SOCKET` -> `SO_LINGER`.
34985    pub fn r#get_linger(
34986        &self,
34987    ) -> fidl::client::QueryResponseFut<
34988        BaseSocketGetLingerResult,
34989        fidl::encoding::DefaultFuchsiaResourceDialect,
34990    > {
34991        DatagramSocketProxyInterface::r#get_linger(self)
34992    }
34993
34994    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
34995    pub fn r#set_reuse_port(
34996        &self,
34997        mut value: bool,
34998    ) -> fidl::client::QueryResponseFut<
34999        BaseSocketSetReusePortResult,
35000        fidl::encoding::DefaultFuchsiaResourceDialect,
35001    > {
35002        DatagramSocketProxyInterface::r#set_reuse_port(self, value)
35003    }
35004
35005    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
35006    pub fn r#get_reuse_port(
35007        &self,
35008    ) -> fidl::client::QueryResponseFut<
35009        BaseSocketGetReusePortResult,
35010        fidl::encoding::DefaultFuchsiaResourceDialect,
35011    > {
35012        DatagramSocketProxyInterface::r#get_reuse_port(self)
35013    }
35014
35015    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
35016    pub fn r#get_accept_conn(
35017        &self,
35018    ) -> fidl::client::QueryResponseFut<
35019        BaseSocketGetAcceptConnResult,
35020        fidl::encoding::DefaultFuchsiaResourceDialect,
35021    > {
35022        DatagramSocketProxyInterface::r#get_accept_conn(self)
35023    }
35024
35025    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
35026    pub fn r#set_bind_to_device(
35027        &self,
35028        mut value: &str,
35029    ) -> fidl::client::QueryResponseFut<
35030        BaseSocketSetBindToDeviceResult,
35031        fidl::encoding::DefaultFuchsiaResourceDialect,
35032    > {
35033        DatagramSocketProxyInterface::r#set_bind_to_device(self, value)
35034    }
35035
35036    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
35037    pub fn r#get_bind_to_device(
35038        &self,
35039    ) -> fidl::client::QueryResponseFut<
35040        BaseSocketGetBindToDeviceResult,
35041        fidl::encoding::DefaultFuchsiaResourceDialect,
35042    > {
35043        DatagramSocketProxyInterface::r#get_bind_to_device(self)
35044    }
35045
35046    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
35047    /// If `value` is 0, this clears the bound interface.
35048    pub fn r#set_bind_to_interface_index(
35049        &self,
35050        mut value: u64,
35051    ) -> fidl::client::QueryResponseFut<
35052        BaseSocketSetBindToInterfaceIndexResult,
35053        fidl::encoding::DefaultFuchsiaResourceDialect,
35054    > {
35055        DatagramSocketProxyInterface::r#set_bind_to_interface_index(self, value)
35056    }
35057
35058    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
35059    pub fn r#get_bind_to_interface_index(
35060        &self,
35061    ) -> fidl::client::QueryResponseFut<
35062        BaseSocketGetBindToInterfaceIndexResult,
35063        fidl::encoding::DefaultFuchsiaResourceDialect,
35064    > {
35065        DatagramSocketProxyInterface::r#get_bind_to_interface_index(self)
35066    }
35067
35068    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
35069    pub fn r#set_timestamp(
35070        &self,
35071        mut value: TimestampOption,
35072    ) -> fidl::client::QueryResponseFut<
35073        BaseSocketSetTimestampResult,
35074        fidl::encoding::DefaultFuchsiaResourceDialect,
35075    > {
35076        DatagramSocketProxyInterface::r#set_timestamp(self, value)
35077    }
35078
35079    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
35080    pub fn r#get_timestamp(
35081        &self,
35082    ) -> fidl::client::QueryResponseFut<
35083        BaseSocketGetTimestampResult,
35084        fidl::encoding::DefaultFuchsiaResourceDialect,
35085    > {
35086        DatagramSocketProxyInterface::r#get_timestamp(self)
35087    }
35088
35089    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
35090    /// unlike the standard SO_MARK, this API has multiple mark domains and each
35091    /// mark can be set independently in each domain.
35092    pub fn r#set_mark(
35093        &self,
35094        mut domain: fidl_fuchsia_net::MarkDomain,
35095        mut mark: &OptionalUint32,
35096    ) -> fidl::client::QueryResponseFut<
35097        BaseSocketSetMarkResult,
35098        fidl::encoding::DefaultFuchsiaResourceDialect,
35099    > {
35100        DatagramSocketProxyInterface::r#set_mark(self, domain, mark)
35101    }
35102
35103    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
35104    /// unlike the standard SO_MARK, this API has multiple mark domains and each
35105    /// mark can be retrieved independently in each domain.
35106    pub fn r#get_mark(
35107        &self,
35108        mut domain: fidl_fuchsia_net::MarkDomain,
35109    ) -> fidl::client::QueryResponseFut<
35110        BaseSocketGetMarkResult,
35111        fidl::encoding::DefaultFuchsiaResourceDialect,
35112    > {
35113        DatagramSocketProxyInterface::r#get_mark(self, domain)
35114    }
35115
35116    /// Sets the local address used for the socket.
35117    pub fn r#bind(
35118        &self,
35119        mut addr: &fidl_fuchsia_net::SocketAddress,
35120    ) -> fidl::client::QueryResponseFut<
35121        BaseNetworkSocketBindResult,
35122        fidl::encoding::DefaultFuchsiaResourceDialect,
35123    > {
35124        DatagramSocketProxyInterface::r#bind(self, addr)
35125    }
35126
35127    /// Initiates a connection to a remote address.
35128    pub fn r#connect(
35129        &self,
35130        mut addr: &fidl_fuchsia_net::SocketAddress,
35131    ) -> fidl::client::QueryResponseFut<
35132        BaseNetworkSocketConnectResult,
35133        fidl::encoding::DefaultFuchsiaResourceDialect,
35134    > {
35135        DatagramSocketProxyInterface::r#connect(self, addr)
35136    }
35137
35138    /// Clears connection information from this socket.
35139    pub fn r#disconnect(
35140        &self,
35141    ) -> fidl::client::QueryResponseFut<
35142        BaseNetworkSocketDisconnectResult,
35143        fidl::encoding::DefaultFuchsiaResourceDialect,
35144    > {
35145        DatagramSocketProxyInterface::r#disconnect(self)
35146    }
35147
35148    /// Retrieves the local socket address.
35149    pub fn r#get_sock_name(
35150        &self,
35151    ) -> fidl::client::QueryResponseFut<
35152        BaseNetworkSocketGetSockNameResult,
35153        fidl::encoding::DefaultFuchsiaResourceDialect,
35154    > {
35155        DatagramSocketProxyInterface::r#get_sock_name(self)
35156    }
35157
35158    /// Retrieves the remote socket address.
35159    pub fn r#get_peer_name(
35160        &self,
35161    ) -> fidl::client::QueryResponseFut<
35162        BaseNetworkSocketGetPeerNameResult,
35163        fidl::encoding::DefaultFuchsiaResourceDialect,
35164    > {
35165        DatagramSocketProxyInterface::r#get_peer_name(self)
35166    }
35167
35168    /// Shuts down part of the socket.
35169    pub fn r#shutdown(
35170        &self,
35171        mut mode: ShutdownMode,
35172    ) -> fidl::client::QueryResponseFut<
35173        BaseNetworkSocketShutdownResult,
35174        fidl::encoding::DefaultFuchsiaResourceDialect,
35175    > {
35176        DatagramSocketProxyInterface::r#shutdown(self, mode)
35177    }
35178
35179    /// Set `SOL_IP` -> `IP_TOS`.
35180    pub fn r#set_ip_type_of_service(
35181        &self,
35182        mut value: u8,
35183    ) -> fidl::client::QueryResponseFut<
35184        BaseNetworkSocketSetIpTypeOfServiceResult,
35185        fidl::encoding::DefaultFuchsiaResourceDialect,
35186    > {
35187        DatagramSocketProxyInterface::r#set_ip_type_of_service(self, value)
35188    }
35189
35190    /// Get `SOL_IP` -> `IP_TOS`.
35191    pub fn r#get_ip_type_of_service(
35192        &self,
35193    ) -> fidl::client::QueryResponseFut<
35194        BaseNetworkSocketGetIpTypeOfServiceResult,
35195        fidl::encoding::DefaultFuchsiaResourceDialect,
35196    > {
35197        DatagramSocketProxyInterface::r#get_ip_type_of_service(self)
35198    }
35199
35200    /// Set `SOL_IP` -> `IP_TTL`.
35201    pub fn r#set_ip_ttl(
35202        &self,
35203        mut value: &OptionalUint8,
35204    ) -> fidl::client::QueryResponseFut<
35205        BaseNetworkSocketSetIpTtlResult,
35206        fidl::encoding::DefaultFuchsiaResourceDialect,
35207    > {
35208        DatagramSocketProxyInterface::r#set_ip_ttl(self, value)
35209    }
35210
35211    /// Get `SOL_IP` -> `IP_TTL`.
35212    pub fn r#get_ip_ttl(
35213        &self,
35214    ) -> fidl::client::QueryResponseFut<
35215        BaseNetworkSocketGetIpTtlResult,
35216        fidl::encoding::DefaultFuchsiaResourceDialect,
35217    > {
35218        DatagramSocketProxyInterface::r#get_ip_ttl(self)
35219    }
35220
35221    /// Set `SOL_IP` -> `IP_PKTINFO`.
35222    pub fn r#set_ip_packet_info(
35223        &self,
35224        mut value: bool,
35225    ) -> fidl::client::QueryResponseFut<
35226        BaseNetworkSocketSetIpPacketInfoResult,
35227        fidl::encoding::DefaultFuchsiaResourceDialect,
35228    > {
35229        DatagramSocketProxyInterface::r#set_ip_packet_info(self, value)
35230    }
35231
35232    /// Get `SOL_IP` -> `IP_PKTINFO`.
35233    pub fn r#get_ip_packet_info(
35234        &self,
35235    ) -> fidl::client::QueryResponseFut<
35236        BaseNetworkSocketGetIpPacketInfoResult,
35237        fidl::encoding::DefaultFuchsiaResourceDialect,
35238    > {
35239        DatagramSocketProxyInterface::r#get_ip_packet_info(self)
35240    }
35241
35242    /// Set `SOL_IP` -> `IP_RECVTOS`.
35243    pub fn r#set_ip_receive_type_of_service(
35244        &self,
35245        mut value: bool,
35246    ) -> fidl::client::QueryResponseFut<
35247        BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
35248        fidl::encoding::DefaultFuchsiaResourceDialect,
35249    > {
35250        DatagramSocketProxyInterface::r#set_ip_receive_type_of_service(self, value)
35251    }
35252
35253    /// Get `SOL_IP` -> `IP_RECVTOS`.
35254    pub fn r#get_ip_receive_type_of_service(
35255        &self,
35256    ) -> fidl::client::QueryResponseFut<
35257        BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
35258        fidl::encoding::DefaultFuchsiaResourceDialect,
35259    > {
35260        DatagramSocketProxyInterface::r#get_ip_receive_type_of_service(self)
35261    }
35262
35263    /// Set `SOL_IP` -> `IP_RECVTTL`.
35264    pub fn r#set_ip_receive_ttl(
35265        &self,
35266        mut value: bool,
35267    ) -> fidl::client::QueryResponseFut<
35268        BaseNetworkSocketSetIpReceiveTtlResult,
35269        fidl::encoding::DefaultFuchsiaResourceDialect,
35270    > {
35271        DatagramSocketProxyInterface::r#set_ip_receive_ttl(self, value)
35272    }
35273
35274    /// Get `SOL_IP` -> `IP_RECVTTL`.
35275    pub fn r#get_ip_receive_ttl(
35276        &self,
35277    ) -> fidl::client::QueryResponseFut<
35278        BaseNetworkSocketGetIpReceiveTtlResult,
35279        fidl::encoding::DefaultFuchsiaResourceDialect,
35280    > {
35281        DatagramSocketProxyInterface::r#get_ip_receive_ttl(self)
35282    }
35283
35284    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
35285    pub fn r#set_ip_multicast_interface(
35286        &self,
35287        mut iface: u64,
35288        mut address: &fidl_fuchsia_net::Ipv4Address,
35289    ) -> fidl::client::QueryResponseFut<
35290        BaseNetworkSocketSetIpMulticastInterfaceResult,
35291        fidl::encoding::DefaultFuchsiaResourceDialect,
35292    > {
35293        DatagramSocketProxyInterface::r#set_ip_multicast_interface(self, iface, address)
35294    }
35295
35296    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
35297    pub fn r#get_ip_multicast_interface(
35298        &self,
35299    ) -> fidl::client::QueryResponseFut<
35300        BaseNetworkSocketGetIpMulticastInterfaceResult,
35301        fidl::encoding::DefaultFuchsiaResourceDialect,
35302    > {
35303        DatagramSocketProxyInterface::r#get_ip_multicast_interface(self)
35304    }
35305
35306    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
35307    pub fn r#set_ip_multicast_ttl(
35308        &self,
35309        mut value: &OptionalUint8,
35310    ) -> fidl::client::QueryResponseFut<
35311        BaseNetworkSocketSetIpMulticastTtlResult,
35312        fidl::encoding::DefaultFuchsiaResourceDialect,
35313    > {
35314        DatagramSocketProxyInterface::r#set_ip_multicast_ttl(self, value)
35315    }
35316
35317    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
35318    pub fn r#get_ip_multicast_ttl(
35319        &self,
35320    ) -> fidl::client::QueryResponseFut<
35321        BaseNetworkSocketGetIpMulticastTtlResult,
35322        fidl::encoding::DefaultFuchsiaResourceDialect,
35323    > {
35324        DatagramSocketProxyInterface::r#get_ip_multicast_ttl(self)
35325    }
35326
35327    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
35328    pub fn r#set_ip_multicast_loopback(
35329        &self,
35330        mut value: bool,
35331    ) -> fidl::client::QueryResponseFut<
35332        BaseNetworkSocketSetIpMulticastLoopbackResult,
35333        fidl::encoding::DefaultFuchsiaResourceDialect,
35334    > {
35335        DatagramSocketProxyInterface::r#set_ip_multicast_loopback(self, value)
35336    }
35337
35338    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
35339    pub fn r#get_ip_multicast_loopback(
35340        &self,
35341    ) -> fidl::client::QueryResponseFut<
35342        BaseNetworkSocketGetIpMulticastLoopbackResult,
35343        fidl::encoding::DefaultFuchsiaResourceDialect,
35344    > {
35345        DatagramSocketProxyInterface::r#get_ip_multicast_loopback(self)
35346    }
35347
35348    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
35349    pub fn r#add_ip_membership(
35350        &self,
35351        mut membership: &IpMulticastMembership,
35352    ) -> fidl::client::QueryResponseFut<
35353        BaseNetworkSocketAddIpMembershipResult,
35354        fidl::encoding::DefaultFuchsiaResourceDialect,
35355    > {
35356        DatagramSocketProxyInterface::r#add_ip_membership(self, membership)
35357    }
35358
35359    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
35360    pub fn r#drop_ip_membership(
35361        &self,
35362        mut membership: &IpMulticastMembership,
35363    ) -> fidl::client::QueryResponseFut<
35364        BaseNetworkSocketDropIpMembershipResult,
35365        fidl::encoding::DefaultFuchsiaResourceDialect,
35366    > {
35367        DatagramSocketProxyInterface::r#drop_ip_membership(self, membership)
35368    }
35369
35370    /// Set `SOL_IP` -> `IP_TRANSPARENT`
35371    pub fn r#set_ip_transparent(
35372        &self,
35373        mut value: bool,
35374    ) -> fidl::client::QueryResponseFut<
35375        BaseNetworkSocketSetIpTransparentResult,
35376        fidl::encoding::DefaultFuchsiaResourceDialect,
35377    > {
35378        DatagramSocketProxyInterface::r#set_ip_transparent(self, value)
35379    }
35380
35381    /// Get `SOL_IP` -> `IP_TRANSPARENT`
35382    pub fn r#get_ip_transparent(
35383        &self,
35384    ) -> fidl::client::QueryResponseFut<
35385        BaseNetworkSocketGetIpTransparentResult,
35386        fidl::encoding::DefaultFuchsiaResourceDialect,
35387    > {
35388        DatagramSocketProxyInterface::r#get_ip_transparent(self)
35389    }
35390
35391    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
35392    pub fn r#set_ip_receive_original_destination_address(
35393        &self,
35394        mut value: bool,
35395    ) -> fidl::client::QueryResponseFut<
35396        BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
35397        fidl::encoding::DefaultFuchsiaResourceDialect,
35398    > {
35399        DatagramSocketProxyInterface::r#set_ip_receive_original_destination_address(self, value)
35400    }
35401
35402    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
35403    pub fn r#get_ip_receive_original_destination_address(
35404        &self,
35405    ) -> fidl::client::QueryResponseFut<
35406        BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
35407        fidl::encoding::DefaultFuchsiaResourceDialect,
35408    > {
35409        DatagramSocketProxyInterface::r#get_ip_receive_original_destination_address(self)
35410    }
35411
35412    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
35413    pub fn r#add_ipv6_membership(
35414        &self,
35415        mut membership: &Ipv6MulticastMembership,
35416    ) -> fidl::client::QueryResponseFut<
35417        BaseNetworkSocketAddIpv6MembershipResult,
35418        fidl::encoding::DefaultFuchsiaResourceDialect,
35419    > {
35420        DatagramSocketProxyInterface::r#add_ipv6_membership(self, membership)
35421    }
35422
35423    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
35424    pub fn r#drop_ipv6_membership(
35425        &self,
35426        mut membership: &Ipv6MulticastMembership,
35427    ) -> fidl::client::QueryResponseFut<
35428        BaseNetworkSocketDropIpv6MembershipResult,
35429        fidl::encoding::DefaultFuchsiaResourceDialect,
35430    > {
35431        DatagramSocketProxyInterface::r#drop_ipv6_membership(self, membership)
35432    }
35433
35434    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
35435    pub fn r#set_ipv6_multicast_interface(
35436        &self,
35437        mut value: u64,
35438    ) -> fidl::client::QueryResponseFut<
35439        BaseNetworkSocketSetIpv6MulticastInterfaceResult,
35440        fidl::encoding::DefaultFuchsiaResourceDialect,
35441    > {
35442        DatagramSocketProxyInterface::r#set_ipv6_multicast_interface(self, value)
35443    }
35444
35445    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
35446    pub fn r#get_ipv6_multicast_interface(
35447        &self,
35448    ) -> fidl::client::QueryResponseFut<
35449        BaseNetworkSocketGetIpv6MulticastInterfaceResult,
35450        fidl::encoding::DefaultFuchsiaResourceDialect,
35451    > {
35452        DatagramSocketProxyInterface::r#get_ipv6_multicast_interface(self)
35453    }
35454
35455    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
35456    pub fn r#set_ipv6_unicast_hops(
35457        &self,
35458        mut value: &OptionalUint8,
35459    ) -> fidl::client::QueryResponseFut<
35460        BaseNetworkSocketSetIpv6UnicastHopsResult,
35461        fidl::encoding::DefaultFuchsiaResourceDialect,
35462    > {
35463        DatagramSocketProxyInterface::r#set_ipv6_unicast_hops(self, value)
35464    }
35465
35466    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
35467    pub fn r#get_ipv6_unicast_hops(
35468        &self,
35469    ) -> fidl::client::QueryResponseFut<
35470        BaseNetworkSocketGetIpv6UnicastHopsResult,
35471        fidl::encoding::DefaultFuchsiaResourceDialect,
35472    > {
35473        DatagramSocketProxyInterface::r#get_ipv6_unicast_hops(self)
35474    }
35475
35476    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
35477    pub fn r#set_ipv6_receive_hop_limit(
35478        &self,
35479        mut value: bool,
35480    ) -> fidl::client::QueryResponseFut<
35481        BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
35482        fidl::encoding::DefaultFuchsiaResourceDialect,
35483    > {
35484        DatagramSocketProxyInterface::r#set_ipv6_receive_hop_limit(self, value)
35485    }
35486
35487    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
35488    pub fn r#get_ipv6_receive_hop_limit(
35489        &self,
35490    ) -> fidl::client::QueryResponseFut<
35491        BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
35492        fidl::encoding::DefaultFuchsiaResourceDialect,
35493    > {
35494        DatagramSocketProxyInterface::r#get_ipv6_receive_hop_limit(self)
35495    }
35496
35497    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
35498    pub fn r#set_ipv6_multicast_hops(
35499        &self,
35500        mut value: &OptionalUint8,
35501    ) -> fidl::client::QueryResponseFut<
35502        BaseNetworkSocketSetIpv6MulticastHopsResult,
35503        fidl::encoding::DefaultFuchsiaResourceDialect,
35504    > {
35505        DatagramSocketProxyInterface::r#set_ipv6_multicast_hops(self, value)
35506    }
35507
35508    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
35509    pub fn r#get_ipv6_multicast_hops(
35510        &self,
35511    ) -> fidl::client::QueryResponseFut<
35512        BaseNetworkSocketGetIpv6MulticastHopsResult,
35513        fidl::encoding::DefaultFuchsiaResourceDialect,
35514    > {
35515        DatagramSocketProxyInterface::r#get_ipv6_multicast_hops(self)
35516    }
35517
35518    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
35519    pub fn r#set_ipv6_multicast_loopback(
35520        &self,
35521        mut value: bool,
35522    ) -> fidl::client::QueryResponseFut<
35523        BaseNetworkSocketSetIpv6MulticastLoopbackResult,
35524        fidl::encoding::DefaultFuchsiaResourceDialect,
35525    > {
35526        DatagramSocketProxyInterface::r#set_ipv6_multicast_loopback(self, value)
35527    }
35528
35529    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
35530    pub fn r#get_ipv6_multicast_loopback(
35531        &self,
35532    ) -> fidl::client::QueryResponseFut<
35533        BaseNetworkSocketGetIpv6MulticastLoopbackResult,
35534        fidl::encoding::DefaultFuchsiaResourceDialect,
35535    > {
35536        DatagramSocketProxyInterface::r#get_ipv6_multicast_loopback(self)
35537    }
35538
35539    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
35540    pub fn r#set_ipv6_only(
35541        &self,
35542        mut value: bool,
35543    ) -> fidl::client::QueryResponseFut<
35544        BaseNetworkSocketSetIpv6OnlyResult,
35545        fidl::encoding::DefaultFuchsiaResourceDialect,
35546    > {
35547        DatagramSocketProxyInterface::r#set_ipv6_only(self, value)
35548    }
35549
35550    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
35551    pub fn r#get_ipv6_only(
35552        &self,
35553    ) -> fidl::client::QueryResponseFut<
35554        BaseNetworkSocketGetIpv6OnlyResult,
35555        fidl::encoding::DefaultFuchsiaResourceDialect,
35556    > {
35557        DatagramSocketProxyInterface::r#get_ipv6_only(self)
35558    }
35559
35560    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
35561    pub fn r#set_ipv6_receive_traffic_class(
35562        &self,
35563        mut value: bool,
35564    ) -> fidl::client::QueryResponseFut<
35565        BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
35566        fidl::encoding::DefaultFuchsiaResourceDialect,
35567    > {
35568        DatagramSocketProxyInterface::r#set_ipv6_receive_traffic_class(self, value)
35569    }
35570
35571    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
35572    pub fn r#get_ipv6_receive_traffic_class(
35573        &self,
35574    ) -> fidl::client::QueryResponseFut<
35575        BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
35576        fidl::encoding::DefaultFuchsiaResourceDialect,
35577    > {
35578        DatagramSocketProxyInterface::r#get_ipv6_receive_traffic_class(self)
35579    }
35580
35581    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
35582    pub fn r#set_ipv6_traffic_class(
35583        &self,
35584        mut value: &OptionalUint8,
35585    ) -> fidl::client::QueryResponseFut<
35586        BaseNetworkSocketSetIpv6TrafficClassResult,
35587        fidl::encoding::DefaultFuchsiaResourceDialect,
35588    > {
35589        DatagramSocketProxyInterface::r#set_ipv6_traffic_class(self, value)
35590    }
35591
35592    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
35593    pub fn r#get_ipv6_traffic_class(
35594        &self,
35595    ) -> fidl::client::QueryResponseFut<
35596        BaseNetworkSocketGetIpv6TrafficClassResult,
35597        fidl::encoding::DefaultFuchsiaResourceDialect,
35598    > {
35599        DatagramSocketProxyInterface::r#get_ipv6_traffic_class(self)
35600    }
35601
35602    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
35603    pub fn r#set_ipv6_receive_packet_info(
35604        &self,
35605        mut value: bool,
35606    ) -> fidl::client::QueryResponseFut<
35607        BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
35608        fidl::encoding::DefaultFuchsiaResourceDialect,
35609    > {
35610        DatagramSocketProxyInterface::r#set_ipv6_receive_packet_info(self, value)
35611    }
35612
35613    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
35614    pub fn r#get_ipv6_receive_packet_info(
35615        &self,
35616    ) -> fidl::client::QueryResponseFut<
35617        BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
35618        fidl::encoding::DefaultFuchsiaResourceDialect,
35619    > {
35620        DatagramSocketProxyInterface::r#get_ipv6_receive_packet_info(self)
35621    }
35622
35623    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
35624    pub fn r#get_original_destination(
35625        &self,
35626    ) -> fidl::client::QueryResponseFut<
35627        BaseNetworkSocketGetOriginalDestinationResult,
35628        fidl::encoding::DefaultFuchsiaResourceDialect,
35629    > {
35630        DatagramSocketProxyInterface::r#get_original_destination(self)
35631    }
35632
35633    /// Retrieves creation information from the socket.
35634    ///
35635    /// - response `domain` the socket's associated domain.
35636    /// - response `proto` the socket's associated protocol.
35637    pub fn r#get_info(
35638        &self,
35639    ) -> fidl::client::QueryResponseFut<
35640        BaseDatagramSocketGetInfoResult,
35641        fidl::encoding::DefaultFuchsiaResourceDialect,
35642    > {
35643        DatagramSocketProxyInterface::r#get_info(self)
35644    }
35645
35646    pub fn r#describe(
35647        &self,
35648    ) -> fidl::client::QueryResponseFut<
35649        DatagramSocketDescribeResponse,
35650        fidl::encoding::DefaultFuchsiaResourceDialect,
35651    > {
35652        DatagramSocketProxyInterface::r#describe(self)
35653    }
35654
35655    /// Validates that data can be sent.
35656    ///
35657    /// + request `args` the requested disposition of data to be sent.
35658    /// - response the constraints sent data must satisfy.
35659    /// * error the error code indicating the reason for validation failure.
35660    pub fn r#send_msg_preflight(
35661        &self,
35662        mut payload: &DatagramSocketSendMsgPreflightRequest,
35663    ) -> fidl::client::QueryResponseFut<
35664        DatagramSocketSendMsgPreflightResult,
35665        fidl::encoding::DefaultFuchsiaResourceDialect,
35666    > {
35667        DatagramSocketProxyInterface::r#send_msg_preflight(self, payload)
35668    }
35669
35670    /// Returns the set of requested control messages.
35671    ///
35672    /// - response the set of currently requested control messages.
35673    pub fn r#recv_msg_postflight(
35674        &self,
35675    ) -> fidl::client::QueryResponseFut<
35676        DatagramSocketRecvMsgPostflightResult,
35677        fidl::encoding::DefaultFuchsiaResourceDialect,
35678    > {
35679        DatagramSocketProxyInterface::r#recv_msg_postflight(self)
35680    }
35681}
35682
35683impl DatagramSocketProxyInterface for DatagramSocketProxy {
35684    fn r#clone(
35685        &self,
35686        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
35687    ) -> Result<(), fidl::Error> {
35688        self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
35689            (request,),
35690            0x20d8a7aba2168a79,
35691            fidl::encoding::DynamicFlags::empty(),
35692        )
35693    }
35694
35695    type CloseResponseFut = fidl::client::QueryResponseFut<
35696        fidl_fuchsia_unknown::CloseableCloseResult,
35697        fidl::encoding::DefaultFuchsiaResourceDialect,
35698    >;
35699    fn r#close(&self) -> Self::CloseResponseFut {
35700        fn _decode(
35701            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
35702        ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
35703            let _response = fidl::client::decode_transaction_body::<
35704                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
35705                fidl::encoding::DefaultFuchsiaResourceDialect,
35706                0x5ac5d459ad7f657e,
35707            >(_buf?)?;
35708            Ok(_response.map(|x| x))
35709        }
35710        self.client.send_query_and_decode::<
35711            fidl::encoding::EmptyPayload,
35712            fidl_fuchsia_unknown::CloseableCloseResult,
35713        >(
35714            (),
35715            0x5ac5d459ad7f657e,
35716            fidl::encoding::DynamicFlags::empty(),
35717            _decode,
35718        )
35719    }
35720
35721    type QueryResponseFut =
35722        fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>;
35723    fn r#query(&self) -> Self::QueryResponseFut {
35724        fn _decode(
35725            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
35726        ) -> Result<Vec<u8>, fidl::Error> {
35727            let _response = fidl::client::decode_transaction_body::<
35728                fidl_fuchsia_unknown::QueryableQueryResponse,
35729                fidl::encoding::DefaultFuchsiaResourceDialect,
35730                0x2658edee9decfc06,
35731            >(_buf?)?;
35732            Ok(_response.protocol)
35733        }
35734        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<u8>>(
35735            (),
35736            0x2658edee9decfc06,
35737            fidl::encoding::DynamicFlags::empty(),
35738            _decode,
35739        )
35740    }
35741
35742    type SetReuseAddressResponseFut = fidl::client::QueryResponseFut<
35743        BaseSocketSetReuseAddressResult,
35744        fidl::encoding::DefaultFuchsiaResourceDialect,
35745    >;
35746    fn r#set_reuse_address(&self, mut value: bool) -> Self::SetReuseAddressResponseFut {
35747        fn _decode(
35748            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
35749        ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
35750            let _response = fidl::client::decode_transaction_body::<
35751                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
35752                fidl::encoding::DefaultFuchsiaResourceDialect,
35753                0x1fd74ee8b9a4a876,
35754            >(_buf?)?;
35755            Ok(_response.map(|x| x))
35756        }
35757        self.client.send_query_and_decode::<
35758            BaseSocketSetReuseAddressRequest,
35759            BaseSocketSetReuseAddressResult,
35760        >(
35761            (value,),
35762            0x1fd74ee8b9a4a876,
35763            fidl::encoding::DynamicFlags::empty(),
35764            _decode,
35765        )
35766    }
35767
35768    type GetReuseAddressResponseFut = fidl::client::QueryResponseFut<
35769        BaseSocketGetReuseAddressResult,
35770        fidl::encoding::DefaultFuchsiaResourceDialect,
35771    >;
35772    fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut {
35773        fn _decode(
35774            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
35775        ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
35776            let _response = fidl::client::decode_transaction_body::<
35777                fidl::encoding::ResultType<
35778                    BaseSocketGetReuseAddressResponse,
35779                    fidl_fuchsia_posix::Errno,
35780                >,
35781                fidl::encoding::DefaultFuchsiaResourceDialect,
35782                0x67b7206b8d1bc0a5,
35783            >(_buf?)?;
35784            Ok(_response.map(|x| x.value))
35785        }
35786        self.client
35787            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReuseAddressResult>(
35788                (),
35789                0x67b7206b8d1bc0a5,
35790                fidl::encoding::DynamicFlags::empty(),
35791                _decode,
35792            )
35793    }
35794
35795    type GetErrorResponseFut = fidl::client::QueryResponseFut<
35796        BaseSocketGetErrorResult,
35797        fidl::encoding::DefaultFuchsiaResourceDialect,
35798    >;
35799    fn r#get_error(&self) -> Self::GetErrorResponseFut {
35800        fn _decode(
35801            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
35802        ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
35803            let _response = fidl::client::decode_transaction_body::<
35804                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
35805                fidl::encoding::DefaultFuchsiaResourceDialect,
35806                0x5aad39b33e5f6ebb,
35807            >(_buf?)?;
35808            Ok(_response.map(|x| x))
35809        }
35810        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetErrorResult>(
35811            (),
35812            0x5aad39b33e5f6ebb,
35813            fidl::encoding::DynamicFlags::empty(),
35814            _decode,
35815        )
35816    }
35817
35818    type SetBroadcastResponseFut = fidl::client::QueryResponseFut<
35819        BaseSocketSetBroadcastResult,
35820        fidl::encoding::DefaultFuchsiaResourceDialect,
35821    >;
35822    fn r#set_broadcast(&self, mut value: bool) -> Self::SetBroadcastResponseFut {
35823        fn _decode(
35824            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
35825        ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
35826            let _response = fidl::client::decode_transaction_body::<
35827                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
35828                fidl::encoding::DefaultFuchsiaResourceDialect,
35829                0x6023e081ce3cd947,
35830            >(_buf?)?;
35831            Ok(_response.map(|x| x))
35832        }
35833        self.client
35834            .send_query_and_decode::<BaseSocketSetBroadcastRequest, BaseSocketSetBroadcastResult>(
35835                (value,),
35836                0x6023e081ce3cd947,
35837                fidl::encoding::DynamicFlags::empty(),
35838                _decode,
35839            )
35840    }
35841
35842    type GetBroadcastResponseFut = fidl::client::QueryResponseFut<
35843        BaseSocketGetBroadcastResult,
35844        fidl::encoding::DefaultFuchsiaResourceDialect,
35845    >;
35846    fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut {
35847        fn _decode(
35848            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
35849        ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
35850            let _response = fidl::client::decode_transaction_body::<
35851                fidl::encoding::ResultType<
35852                    BaseSocketGetBroadcastResponse,
35853                    fidl_fuchsia_posix::Errno,
35854                >,
35855                fidl::encoding::DefaultFuchsiaResourceDialect,
35856                0x68796fc556f9780d,
35857            >(_buf?)?;
35858            Ok(_response.map(|x| x.value))
35859        }
35860        self.client
35861            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBroadcastResult>(
35862                (),
35863                0x68796fc556f9780d,
35864                fidl::encoding::DynamicFlags::empty(),
35865                _decode,
35866            )
35867    }
35868
35869    type SetSendBufferResponseFut = fidl::client::QueryResponseFut<
35870        BaseSocketSetSendBufferResult,
35871        fidl::encoding::DefaultFuchsiaResourceDialect,
35872    >;
35873    fn r#set_send_buffer(&self, mut value_bytes: u64) -> Self::SetSendBufferResponseFut {
35874        fn _decode(
35875            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
35876        ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
35877            let _response = fidl::client::decode_transaction_body::<
35878                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
35879                fidl::encoding::DefaultFuchsiaResourceDialect,
35880                0x756eac32d73a7a70,
35881            >(_buf?)?;
35882            Ok(_response.map(|x| x))
35883        }
35884        self.client
35885            .send_query_and_decode::<BaseSocketSetSendBufferRequest, BaseSocketSetSendBufferResult>(
35886                (value_bytes,),
35887                0x756eac32d73a7a70,
35888                fidl::encoding::DynamicFlags::empty(),
35889                _decode,
35890            )
35891    }
35892
35893    type GetSendBufferResponseFut = fidl::client::QueryResponseFut<
35894        BaseSocketGetSendBufferResult,
35895        fidl::encoding::DefaultFuchsiaResourceDialect,
35896    >;
35897    fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut {
35898        fn _decode(
35899            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
35900        ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
35901            let _response = fidl::client::decode_transaction_body::<
35902                fidl::encoding::ResultType<
35903                    BaseSocketGetSendBufferResponse,
35904                    fidl_fuchsia_posix::Errno,
35905                >,
35906                fidl::encoding::DefaultFuchsiaResourceDialect,
35907                0x78a52fd9c7b2410b,
35908            >(_buf?)?;
35909            Ok(_response.map(|x| x.value_bytes))
35910        }
35911        self.client
35912            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetSendBufferResult>(
35913                (),
35914                0x78a52fd9c7b2410b,
35915                fidl::encoding::DynamicFlags::empty(),
35916                _decode,
35917            )
35918    }
35919
35920    type SetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
35921        BaseSocketSetReceiveBufferResult,
35922        fidl::encoding::DefaultFuchsiaResourceDialect,
35923    >;
35924    fn r#set_receive_buffer(&self, mut value_bytes: u64) -> Self::SetReceiveBufferResponseFut {
35925        fn _decode(
35926            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
35927        ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
35928            let _response = fidl::client::decode_transaction_body::<
35929                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
35930                fidl::encoding::DefaultFuchsiaResourceDialect,
35931                0x6b0cf2f1919c7001,
35932            >(_buf?)?;
35933            Ok(_response.map(|x| x))
35934        }
35935        self.client.send_query_and_decode::<
35936            BaseSocketSetReceiveBufferRequest,
35937            BaseSocketSetReceiveBufferResult,
35938        >(
35939            (value_bytes,),
35940            0x6b0cf2f1919c7001,
35941            fidl::encoding::DynamicFlags::empty(),
35942            _decode,
35943        )
35944    }
35945
35946    type GetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
35947        BaseSocketGetReceiveBufferResult,
35948        fidl::encoding::DefaultFuchsiaResourceDialect,
35949    >;
35950    fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut {
35951        fn _decode(
35952            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
35953        ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
35954            let _response = fidl::client::decode_transaction_body::<
35955                fidl::encoding::ResultType<
35956                    BaseSocketGetReceiveBufferResponse,
35957                    fidl_fuchsia_posix::Errno,
35958                >,
35959                fidl::encoding::DefaultFuchsiaResourceDialect,
35960                0x14c1a4b64f709e5c,
35961            >(_buf?)?;
35962            Ok(_response.map(|x| x.value_bytes))
35963        }
35964        self.client.send_query_and_decode::<
35965            fidl::encoding::EmptyPayload,
35966            BaseSocketGetReceiveBufferResult,
35967        >(
35968            (),
35969            0x14c1a4b64f709e5c,
35970            fidl::encoding::DynamicFlags::empty(),
35971            _decode,
35972        )
35973    }
35974
35975    type SetKeepAliveResponseFut = fidl::client::QueryResponseFut<
35976        BaseSocketSetKeepAliveResult,
35977        fidl::encoding::DefaultFuchsiaResourceDialect,
35978    >;
35979    fn r#set_keep_alive(&self, mut value: bool) -> Self::SetKeepAliveResponseFut {
35980        fn _decode(
35981            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
35982        ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
35983            let _response = fidl::client::decode_transaction_body::<
35984                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
35985                fidl::encoding::DefaultFuchsiaResourceDialect,
35986                0x572df8f0b920d2c7,
35987            >(_buf?)?;
35988            Ok(_response.map(|x| x))
35989        }
35990        self.client
35991            .send_query_and_decode::<BaseSocketSetKeepAliveRequest, BaseSocketSetKeepAliveResult>(
35992                (value,),
35993                0x572df8f0b920d2c7,
35994                fidl::encoding::DynamicFlags::empty(),
35995                _decode,
35996            )
35997    }
35998
35999    type GetKeepAliveResponseFut = fidl::client::QueryResponseFut<
36000        BaseSocketGetKeepAliveResult,
36001        fidl::encoding::DefaultFuchsiaResourceDialect,
36002    >;
36003    fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut {
36004        fn _decode(
36005            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36006        ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
36007            let _response = fidl::client::decode_transaction_body::<
36008                fidl::encoding::ResultType<
36009                    BaseSocketGetKeepAliveResponse,
36010                    fidl_fuchsia_posix::Errno,
36011                >,
36012                fidl::encoding::DefaultFuchsiaResourceDialect,
36013                0x2dd29d3215f2c9d2,
36014            >(_buf?)?;
36015            Ok(_response.map(|x| x.value))
36016        }
36017        self.client
36018            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetKeepAliveResult>(
36019                (),
36020                0x2dd29d3215f2c9d2,
36021                fidl::encoding::DynamicFlags::empty(),
36022                _decode,
36023            )
36024    }
36025
36026    type SetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
36027        BaseSocketSetOutOfBandInlineResult,
36028        fidl::encoding::DefaultFuchsiaResourceDialect,
36029    >;
36030    fn r#set_out_of_band_inline(&self, mut value: bool) -> Self::SetOutOfBandInlineResponseFut {
36031        fn _decode(
36032            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36033        ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
36034            let _response = fidl::client::decode_transaction_body::<
36035                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36036                fidl::encoding::DefaultFuchsiaResourceDialect,
36037                0x3ecb49968bee439,
36038            >(_buf?)?;
36039            Ok(_response.map(|x| x))
36040        }
36041        self.client.send_query_and_decode::<
36042            BaseSocketSetOutOfBandInlineRequest,
36043            BaseSocketSetOutOfBandInlineResult,
36044        >(
36045            (value,),
36046            0x3ecb49968bee439,
36047            fidl::encoding::DynamicFlags::empty(),
36048            _decode,
36049        )
36050    }
36051
36052    type GetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
36053        BaseSocketGetOutOfBandInlineResult,
36054        fidl::encoding::DefaultFuchsiaResourceDialect,
36055    >;
36056    fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut {
36057        fn _decode(
36058            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36059        ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
36060            let _response = fidl::client::decode_transaction_body::<
36061                fidl::encoding::ResultType<
36062                    BaseSocketGetOutOfBandInlineResponse,
36063                    fidl_fuchsia_posix::Errno,
36064                >,
36065                fidl::encoding::DefaultFuchsiaResourceDialect,
36066                0x348c1ab3aeca1745,
36067            >(_buf?)?;
36068            Ok(_response.map(|x| x.value))
36069        }
36070        self.client.send_query_and_decode::<
36071            fidl::encoding::EmptyPayload,
36072            BaseSocketGetOutOfBandInlineResult,
36073        >(
36074            (),
36075            0x348c1ab3aeca1745,
36076            fidl::encoding::DynamicFlags::empty(),
36077            _decode,
36078        )
36079    }
36080
36081    type SetNoCheckResponseFut = fidl::client::QueryResponseFut<
36082        BaseSocketSetNoCheckResult,
36083        fidl::encoding::DefaultFuchsiaResourceDialect,
36084    >;
36085    fn r#set_no_check(&self, mut value: bool) -> Self::SetNoCheckResponseFut {
36086        fn _decode(
36087            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36088        ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
36089            let _response = fidl::client::decode_transaction_body::<
36090                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36091                fidl::encoding::DefaultFuchsiaResourceDialect,
36092                0x6bbf00c53a4c78c2,
36093            >(_buf?)?;
36094            Ok(_response.map(|x| x))
36095        }
36096        self.client
36097            .send_query_and_decode::<BaseSocketSetNoCheckRequest, BaseSocketSetNoCheckResult>(
36098                (value,),
36099                0x6bbf00c53a4c78c2,
36100                fidl::encoding::DynamicFlags::empty(),
36101                _decode,
36102            )
36103    }
36104
36105    type GetNoCheckResponseFut = fidl::client::QueryResponseFut<
36106        BaseSocketGetNoCheckResult,
36107        fidl::encoding::DefaultFuchsiaResourceDialect,
36108    >;
36109    fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut {
36110        fn _decode(
36111            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36112        ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
36113            let _response = fidl::client::decode_transaction_body::<
36114                fidl::encoding::ResultType<BaseSocketGetNoCheckResponse, fidl_fuchsia_posix::Errno>,
36115                fidl::encoding::DefaultFuchsiaResourceDialect,
36116                0x2cd4249286417694,
36117            >(_buf?)?;
36118            Ok(_response.map(|x| x.value))
36119        }
36120        self.client
36121            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetNoCheckResult>(
36122                (),
36123                0x2cd4249286417694,
36124                fidl::encoding::DynamicFlags::empty(),
36125                _decode,
36126            )
36127    }
36128
36129    type SetLingerResponseFut = fidl::client::QueryResponseFut<
36130        BaseSocketSetLingerResult,
36131        fidl::encoding::DefaultFuchsiaResourceDialect,
36132    >;
36133    fn r#set_linger(&self, mut linger: bool, mut length_secs: u32) -> Self::SetLingerResponseFut {
36134        fn _decode(
36135            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36136        ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
36137            let _response = fidl::client::decode_transaction_body::<
36138                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36139                fidl::encoding::DefaultFuchsiaResourceDialect,
36140                0x45386351246e998e,
36141            >(_buf?)?;
36142            Ok(_response.map(|x| x))
36143        }
36144        self.client.send_query_and_decode::<BaseSocketSetLingerRequest, BaseSocketSetLingerResult>(
36145            (linger, length_secs),
36146            0x45386351246e998e,
36147            fidl::encoding::DynamicFlags::empty(),
36148            _decode,
36149        )
36150    }
36151
36152    type GetLingerResponseFut = fidl::client::QueryResponseFut<
36153        BaseSocketGetLingerResult,
36154        fidl::encoding::DefaultFuchsiaResourceDialect,
36155    >;
36156    fn r#get_linger(&self) -> Self::GetLingerResponseFut {
36157        fn _decode(
36158            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36159        ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
36160            let _response = fidl::client::decode_transaction_body::<
36161                fidl::encoding::ResultType<BaseSocketGetLingerResponse, fidl_fuchsia_posix::Errno>,
36162                fidl::encoding::DefaultFuchsiaResourceDialect,
36163                0x48eb20fc5ccb0e45,
36164            >(_buf?)?;
36165            Ok(_response.map(|x| (x.linger, x.length_secs)))
36166        }
36167        self.client
36168            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetLingerResult>(
36169                (),
36170                0x48eb20fc5ccb0e45,
36171                fidl::encoding::DynamicFlags::empty(),
36172                _decode,
36173            )
36174    }
36175
36176    type SetReusePortResponseFut = fidl::client::QueryResponseFut<
36177        BaseSocketSetReusePortResult,
36178        fidl::encoding::DefaultFuchsiaResourceDialect,
36179    >;
36180    fn r#set_reuse_port(&self, mut value: bool) -> Self::SetReusePortResponseFut {
36181        fn _decode(
36182            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36183        ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
36184            let _response = fidl::client::decode_transaction_body::<
36185                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36186                fidl::encoding::DefaultFuchsiaResourceDialect,
36187                0x24dd3e5cb36d9ccb,
36188            >(_buf?)?;
36189            Ok(_response.map(|x| x))
36190        }
36191        self.client
36192            .send_query_and_decode::<BaseSocketSetReusePortRequest, BaseSocketSetReusePortResult>(
36193                (value,),
36194                0x24dd3e5cb36d9ccb,
36195                fidl::encoding::DynamicFlags::empty(),
36196                _decode,
36197            )
36198    }
36199
36200    type GetReusePortResponseFut = fidl::client::QueryResponseFut<
36201        BaseSocketGetReusePortResult,
36202        fidl::encoding::DefaultFuchsiaResourceDialect,
36203    >;
36204    fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut {
36205        fn _decode(
36206            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36207        ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
36208            let _response = fidl::client::decode_transaction_body::<
36209                fidl::encoding::ResultType<
36210                    BaseSocketGetReusePortResponse,
36211                    fidl_fuchsia_posix::Errno,
36212                >,
36213                fidl::encoding::DefaultFuchsiaResourceDialect,
36214                0x7a112c1ab54ff828,
36215            >(_buf?)?;
36216            Ok(_response.map(|x| x.value))
36217        }
36218        self.client
36219            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReusePortResult>(
36220                (),
36221                0x7a112c1ab54ff828,
36222                fidl::encoding::DynamicFlags::empty(),
36223                _decode,
36224            )
36225    }
36226
36227    type GetAcceptConnResponseFut = fidl::client::QueryResponseFut<
36228        BaseSocketGetAcceptConnResult,
36229        fidl::encoding::DefaultFuchsiaResourceDialect,
36230    >;
36231    fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut {
36232        fn _decode(
36233            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36234        ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
36235            let _response = fidl::client::decode_transaction_body::<
36236                fidl::encoding::ResultType<
36237                    BaseSocketGetAcceptConnResponse,
36238                    fidl_fuchsia_posix::Errno,
36239                >,
36240                fidl::encoding::DefaultFuchsiaResourceDialect,
36241                0x67ce6db6c2ec8966,
36242            >(_buf?)?;
36243            Ok(_response.map(|x| x.value))
36244        }
36245        self.client
36246            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetAcceptConnResult>(
36247                (),
36248                0x67ce6db6c2ec8966,
36249                fidl::encoding::DynamicFlags::empty(),
36250                _decode,
36251            )
36252    }
36253
36254    type SetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
36255        BaseSocketSetBindToDeviceResult,
36256        fidl::encoding::DefaultFuchsiaResourceDialect,
36257    >;
36258    fn r#set_bind_to_device(&self, mut value: &str) -> Self::SetBindToDeviceResponseFut {
36259        fn _decode(
36260            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36261        ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
36262            let _response = fidl::client::decode_transaction_body::<
36263                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36264                fidl::encoding::DefaultFuchsiaResourceDialect,
36265                0x2118b483f28aafc4,
36266            >(_buf?)?;
36267            Ok(_response.map(|x| x))
36268        }
36269        self.client.send_query_and_decode::<
36270            BaseSocketSetBindToDeviceRequest,
36271            BaseSocketSetBindToDeviceResult,
36272        >(
36273            (value,),
36274            0x2118b483f28aafc4,
36275            fidl::encoding::DynamicFlags::empty(),
36276            _decode,
36277        )
36278    }
36279
36280    type GetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
36281        BaseSocketGetBindToDeviceResult,
36282        fidl::encoding::DefaultFuchsiaResourceDialect,
36283    >;
36284    fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut {
36285        fn _decode(
36286            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36287        ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
36288            let _response = fidl::client::decode_transaction_body::<
36289                fidl::encoding::ResultType<
36290                    BaseSocketGetBindToDeviceResponse,
36291                    fidl_fuchsia_posix::Errno,
36292                >,
36293                fidl::encoding::DefaultFuchsiaResourceDialect,
36294                0x1ab1fbf0ef7906c8,
36295            >(_buf?)?;
36296            Ok(_response.map(|x| x.value))
36297        }
36298        self.client
36299            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBindToDeviceResult>(
36300                (),
36301                0x1ab1fbf0ef7906c8,
36302                fidl::encoding::DynamicFlags::empty(),
36303                _decode,
36304            )
36305    }
36306
36307    type SetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
36308        BaseSocketSetBindToInterfaceIndexResult,
36309        fidl::encoding::DefaultFuchsiaResourceDialect,
36310    >;
36311    fn r#set_bind_to_interface_index(
36312        &self,
36313        mut value: u64,
36314    ) -> Self::SetBindToInterfaceIndexResponseFut {
36315        fn _decode(
36316            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36317        ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
36318            let _response = fidl::client::decode_transaction_body::<
36319                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36320                fidl::encoding::DefaultFuchsiaResourceDialect,
36321                0x6e387a0def00821,
36322            >(_buf?)?;
36323            Ok(_response.map(|x| x))
36324        }
36325        self.client.send_query_and_decode::<
36326            BaseSocketSetBindToInterfaceIndexRequest,
36327            BaseSocketSetBindToInterfaceIndexResult,
36328        >(
36329            (value,),
36330            0x6e387a0def00821,
36331            fidl::encoding::DynamicFlags::empty(),
36332            _decode,
36333        )
36334    }
36335
36336    type GetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
36337        BaseSocketGetBindToInterfaceIndexResult,
36338        fidl::encoding::DefaultFuchsiaResourceDialect,
36339    >;
36340    fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut {
36341        fn _decode(
36342            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36343        ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
36344            let _response = fidl::client::decode_transaction_body::<
36345                fidl::encoding::ResultType<
36346                    BaseSocketGetBindToInterfaceIndexResponse,
36347                    fidl_fuchsia_posix::Errno,
36348                >,
36349                fidl::encoding::DefaultFuchsiaResourceDialect,
36350                0x59c31dd3e3078295,
36351            >(_buf?)?;
36352            Ok(_response.map(|x| x.value))
36353        }
36354        self.client.send_query_and_decode::<
36355            fidl::encoding::EmptyPayload,
36356            BaseSocketGetBindToInterfaceIndexResult,
36357        >(
36358            (),
36359            0x59c31dd3e3078295,
36360            fidl::encoding::DynamicFlags::empty(),
36361            _decode,
36362        )
36363    }
36364
36365    type SetTimestampResponseFut = fidl::client::QueryResponseFut<
36366        BaseSocketSetTimestampResult,
36367        fidl::encoding::DefaultFuchsiaResourceDialect,
36368    >;
36369    fn r#set_timestamp(&self, mut value: TimestampOption) -> Self::SetTimestampResponseFut {
36370        fn _decode(
36371            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36372        ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
36373            let _response = fidl::client::decode_transaction_body::<
36374                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36375                fidl::encoding::DefaultFuchsiaResourceDialect,
36376                0x285d6516c263d839,
36377            >(_buf?)?;
36378            Ok(_response.map(|x| x))
36379        }
36380        self.client
36381            .send_query_and_decode::<BaseSocketSetTimestampRequest, BaseSocketSetTimestampResult>(
36382                (value,),
36383                0x285d6516c263d839,
36384                fidl::encoding::DynamicFlags::empty(),
36385                _decode,
36386            )
36387    }
36388
36389    type GetTimestampResponseFut = fidl::client::QueryResponseFut<
36390        BaseSocketGetTimestampResult,
36391        fidl::encoding::DefaultFuchsiaResourceDialect,
36392    >;
36393    fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut {
36394        fn _decode(
36395            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36396        ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
36397            let _response = fidl::client::decode_transaction_body::<
36398                fidl::encoding::ResultType<
36399                    BaseSocketGetTimestampResponse,
36400                    fidl_fuchsia_posix::Errno,
36401                >,
36402                fidl::encoding::DefaultFuchsiaResourceDialect,
36403                0x49f2fffbbcc2bd27,
36404            >(_buf?)?;
36405            Ok(_response.map(|x| x.value))
36406        }
36407        self.client
36408            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetTimestampResult>(
36409                (),
36410                0x49f2fffbbcc2bd27,
36411                fidl::encoding::DynamicFlags::empty(),
36412                _decode,
36413            )
36414    }
36415
36416    type SetMarkResponseFut = fidl::client::QueryResponseFut<
36417        BaseSocketSetMarkResult,
36418        fidl::encoding::DefaultFuchsiaResourceDialect,
36419    >;
36420    fn r#set_mark(
36421        &self,
36422        mut domain: fidl_fuchsia_net::MarkDomain,
36423        mut mark: &OptionalUint32,
36424    ) -> Self::SetMarkResponseFut {
36425        fn _decode(
36426            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36427        ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
36428            let _response = fidl::client::decode_transaction_body::<
36429                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36430                fidl::encoding::DefaultFuchsiaResourceDialect,
36431                0x6ead6de09f653236,
36432            >(_buf?)?;
36433            Ok(_response.map(|x| x))
36434        }
36435        self.client.send_query_and_decode::<BaseSocketSetMarkRequest, BaseSocketSetMarkResult>(
36436            (domain, mark),
36437            0x6ead6de09f653236,
36438            fidl::encoding::DynamicFlags::empty(),
36439            _decode,
36440        )
36441    }
36442
36443    type GetMarkResponseFut = fidl::client::QueryResponseFut<
36444        BaseSocketGetMarkResult,
36445        fidl::encoding::DefaultFuchsiaResourceDialect,
36446    >;
36447    fn r#get_mark(&self, mut domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut {
36448        fn _decode(
36449            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36450        ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
36451            let _response = fidl::client::decode_transaction_body::<
36452                fidl::encoding::ResultType<BaseSocketGetMarkResponse, fidl_fuchsia_posix::Errno>,
36453                fidl::encoding::DefaultFuchsiaResourceDialect,
36454                0x57a2752c61d93d47,
36455            >(_buf?)?;
36456            Ok(_response.map(|x| x.mark))
36457        }
36458        self.client.send_query_and_decode::<BaseSocketGetMarkRequest, BaseSocketGetMarkResult>(
36459            (domain,),
36460            0x57a2752c61d93d47,
36461            fidl::encoding::DynamicFlags::empty(),
36462            _decode,
36463        )
36464    }
36465
36466    type BindResponseFut = fidl::client::QueryResponseFut<
36467        BaseNetworkSocketBindResult,
36468        fidl::encoding::DefaultFuchsiaResourceDialect,
36469    >;
36470    fn r#bind(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut {
36471        fn _decode(
36472            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36473        ) -> Result<BaseNetworkSocketBindResult, fidl::Error> {
36474            let _response = fidl::client::decode_transaction_body::<
36475                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36476                fidl::encoding::DefaultFuchsiaResourceDialect,
36477                0x4bc6400ae92125d,
36478            >(_buf?)?;
36479            Ok(_response.map(|x| x))
36480        }
36481        self.client
36482            .send_query_and_decode::<BaseNetworkSocketBindRequest, BaseNetworkSocketBindResult>(
36483                (addr,),
36484                0x4bc6400ae92125d,
36485                fidl::encoding::DynamicFlags::empty(),
36486                _decode,
36487            )
36488    }
36489
36490    type ConnectResponseFut = fidl::client::QueryResponseFut<
36491        BaseNetworkSocketConnectResult,
36492        fidl::encoding::DefaultFuchsiaResourceDialect,
36493    >;
36494    fn r#connect(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut {
36495        fn _decode(
36496            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36497        ) -> Result<BaseNetworkSocketConnectResult, fidl::Error> {
36498            let _response = fidl::client::decode_transaction_body::<
36499                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36500                fidl::encoding::DefaultFuchsiaResourceDialect,
36501                0x5f05f19bfdd38871,
36502            >(_buf?)?;
36503            Ok(_response.map(|x| x))
36504        }
36505        self.client.send_query_and_decode::<
36506            BaseNetworkSocketConnectRequest,
36507            BaseNetworkSocketConnectResult,
36508        >(
36509            (addr,),
36510            0x5f05f19bfdd38871,
36511            fidl::encoding::DynamicFlags::empty(),
36512            _decode,
36513        )
36514    }
36515
36516    type DisconnectResponseFut = fidl::client::QueryResponseFut<
36517        BaseNetworkSocketDisconnectResult,
36518        fidl::encoding::DefaultFuchsiaResourceDialect,
36519    >;
36520    fn r#disconnect(&self) -> Self::DisconnectResponseFut {
36521        fn _decode(
36522            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36523        ) -> Result<BaseNetworkSocketDisconnectResult, fidl::Error> {
36524            let _response = fidl::client::decode_transaction_body::<
36525                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36526                fidl::encoding::DefaultFuchsiaResourceDialect,
36527                0x74e63b91f7b29b2,
36528            >(_buf?)?;
36529            Ok(_response.map(|x| x))
36530        }
36531        self.client.send_query_and_decode::<
36532            fidl::encoding::EmptyPayload,
36533            BaseNetworkSocketDisconnectResult,
36534        >(
36535            (),
36536            0x74e63b91f7b29b2,
36537            fidl::encoding::DynamicFlags::empty(),
36538            _decode,
36539        )
36540    }
36541
36542    type GetSockNameResponseFut = fidl::client::QueryResponseFut<
36543        BaseNetworkSocketGetSockNameResult,
36544        fidl::encoding::DefaultFuchsiaResourceDialect,
36545    >;
36546    fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut {
36547        fn _decode(
36548            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36549        ) -> Result<BaseNetworkSocketGetSockNameResult, fidl::Error> {
36550            let _response = fidl::client::decode_transaction_body::<
36551                fidl::encoding::ResultType<
36552                    BaseNetworkSocketGetSockNameResponse,
36553                    fidl_fuchsia_posix::Errno,
36554                >,
36555                fidl::encoding::DefaultFuchsiaResourceDialect,
36556                0x475f23f84a1a4f85,
36557            >(_buf?)?;
36558            Ok(_response.map(|x| x.addr))
36559        }
36560        self.client.send_query_and_decode::<
36561            fidl::encoding::EmptyPayload,
36562            BaseNetworkSocketGetSockNameResult,
36563        >(
36564            (),
36565            0x475f23f84a1a4f85,
36566            fidl::encoding::DynamicFlags::empty(),
36567            _decode,
36568        )
36569    }
36570
36571    type GetPeerNameResponseFut = fidl::client::QueryResponseFut<
36572        BaseNetworkSocketGetPeerNameResult,
36573        fidl::encoding::DefaultFuchsiaResourceDialect,
36574    >;
36575    fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut {
36576        fn _decode(
36577            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36578        ) -> Result<BaseNetworkSocketGetPeerNameResult, fidl::Error> {
36579            let _response = fidl::client::decode_transaction_body::<
36580                fidl::encoding::ResultType<
36581                    BaseNetworkSocketGetPeerNameResponse,
36582                    fidl_fuchsia_posix::Errno,
36583                >,
36584                fidl::encoding::DefaultFuchsiaResourceDialect,
36585                0x1ffecf4bd5b6432e,
36586            >(_buf?)?;
36587            Ok(_response.map(|x| x.addr))
36588        }
36589        self.client.send_query_and_decode::<
36590            fidl::encoding::EmptyPayload,
36591            BaseNetworkSocketGetPeerNameResult,
36592        >(
36593            (),
36594            0x1ffecf4bd5b6432e,
36595            fidl::encoding::DynamicFlags::empty(),
36596            _decode,
36597        )
36598    }
36599
36600    type ShutdownResponseFut = fidl::client::QueryResponseFut<
36601        BaseNetworkSocketShutdownResult,
36602        fidl::encoding::DefaultFuchsiaResourceDialect,
36603    >;
36604    fn r#shutdown(&self, mut mode: ShutdownMode) -> Self::ShutdownResponseFut {
36605        fn _decode(
36606            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36607        ) -> Result<BaseNetworkSocketShutdownResult, fidl::Error> {
36608            let _response = fidl::client::decode_transaction_body::<
36609                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36610                fidl::encoding::DefaultFuchsiaResourceDialect,
36611                0x247f38b6db68c336,
36612            >(_buf?)?;
36613            Ok(_response.map(|x| x))
36614        }
36615        self.client.send_query_and_decode::<
36616            BaseNetworkSocketShutdownRequest,
36617            BaseNetworkSocketShutdownResult,
36618        >(
36619            (mode,),
36620            0x247f38b6db68c336,
36621            fidl::encoding::DynamicFlags::empty(),
36622            _decode,
36623        )
36624    }
36625
36626    type SetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
36627        BaseNetworkSocketSetIpTypeOfServiceResult,
36628        fidl::encoding::DefaultFuchsiaResourceDialect,
36629    >;
36630    fn r#set_ip_type_of_service(&self, mut value: u8) -> Self::SetIpTypeOfServiceResponseFut {
36631        fn _decode(
36632            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36633        ) -> Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error> {
36634            let _response = fidl::client::decode_transaction_body::<
36635                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36636                fidl::encoding::DefaultFuchsiaResourceDialect,
36637                0x995c600475b6d46,
36638            >(_buf?)?;
36639            Ok(_response.map(|x| x))
36640        }
36641        self.client.send_query_and_decode::<
36642            BaseNetworkSocketSetIpTypeOfServiceRequest,
36643            BaseNetworkSocketSetIpTypeOfServiceResult,
36644        >(
36645            (value,),
36646            0x995c600475b6d46,
36647            fidl::encoding::DynamicFlags::empty(),
36648            _decode,
36649        )
36650    }
36651
36652    type GetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
36653        BaseNetworkSocketGetIpTypeOfServiceResult,
36654        fidl::encoding::DefaultFuchsiaResourceDialect,
36655    >;
36656    fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut {
36657        fn _decode(
36658            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36659        ) -> Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error> {
36660            let _response = fidl::client::decode_transaction_body::<
36661                fidl::encoding::ResultType<
36662                    BaseNetworkSocketGetIpTypeOfServiceResponse,
36663                    fidl_fuchsia_posix::Errno,
36664                >,
36665                fidl::encoding::DefaultFuchsiaResourceDialect,
36666                0x3814a04259f75fcb,
36667            >(_buf?)?;
36668            Ok(_response.map(|x| x.value))
36669        }
36670        self.client.send_query_and_decode::<
36671            fidl::encoding::EmptyPayload,
36672            BaseNetworkSocketGetIpTypeOfServiceResult,
36673        >(
36674            (),
36675            0x3814a04259f75fcb,
36676            fidl::encoding::DynamicFlags::empty(),
36677            _decode,
36678        )
36679    }
36680
36681    type SetIpTtlResponseFut = fidl::client::QueryResponseFut<
36682        BaseNetworkSocketSetIpTtlResult,
36683        fidl::encoding::DefaultFuchsiaResourceDialect,
36684    >;
36685    fn r#set_ip_ttl(&self, mut value: &OptionalUint8) -> Self::SetIpTtlResponseFut {
36686        fn _decode(
36687            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36688        ) -> Result<BaseNetworkSocketSetIpTtlResult, fidl::Error> {
36689            let _response = fidl::client::decode_transaction_body::<
36690                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36691                fidl::encoding::DefaultFuchsiaResourceDialect,
36692                0x29e2424b433ae1ef,
36693            >(_buf?)?;
36694            Ok(_response.map(|x| x))
36695        }
36696        self.client.send_query_and_decode::<
36697            BaseNetworkSocketSetIpTtlRequest,
36698            BaseNetworkSocketSetIpTtlResult,
36699        >(
36700            (value,),
36701            0x29e2424b433ae1ef,
36702            fidl::encoding::DynamicFlags::empty(),
36703            _decode,
36704        )
36705    }
36706
36707    type GetIpTtlResponseFut = fidl::client::QueryResponseFut<
36708        BaseNetworkSocketGetIpTtlResult,
36709        fidl::encoding::DefaultFuchsiaResourceDialect,
36710    >;
36711    fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut {
36712        fn _decode(
36713            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36714        ) -> Result<BaseNetworkSocketGetIpTtlResult, fidl::Error> {
36715            let _response = fidl::client::decode_transaction_body::<
36716                fidl::encoding::ResultType<
36717                    BaseNetworkSocketGetIpTtlResponse,
36718                    fidl_fuchsia_posix::Errno,
36719                >,
36720                fidl::encoding::DefaultFuchsiaResourceDialect,
36721                0x47e47fa1f24da471,
36722            >(_buf?)?;
36723            Ok(_response.map(|x| x.value))
36724        }
36725        self.client
36726            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseNetworkSocketGetIpTtlResult>(
36727                (),
36728                0x47e47fa1f24da471,
36729                fidl::encoding::DynamicFlags::empty(),
36730                _decode,
36731            )
36732    }
36733
36734    type SetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
36735        BaseNetworkSocketSetIpPacketInfoResult,
36736        fidl::encoding::DefaultFuchsiaResourceDialect,
36737    >;
36738    fn r#set_ip_packet_info(&self, mut value: bool) -> Self::SetIpPacketInfoResponseFut {
36739        fn _decode(
36740            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36741        ) -> Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error> {
36742            let _response = fidl::client::decode_transaction_body::<
36743                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36744                fidl::encoding::DefaultFuchsiaResourceDialect,
36745                0x392d16bee20c0e16,
36746            >(_buf?)?;
36747            Ok(_response.map(|x| x))
36748        }
36749        self.client.send_query_and_decode::<
36750            BaseNetworkSocketSetIpPacketInfoRequest,
36751            BaseNetworkSocketSetIpPacketInfoResult,
36752        >(
36753            (value,),
36754            0x392d16bee20c0e16,
36755            fidl::encoding::DynamicFlags::empty(),
36756            _decode,
36757        )
36758    }
36759
36760    type GetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
36761        BaseNetworkSocketGetIpPacketInfoResult,
36762        fidl::encoding::DefaultFuchsiaResourceDialect,
36763    >;
36764    fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut {
36765        fn _decode(
36766            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36767        ) -> Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error> {
36768            let _response = fidl::client::decode_transaction_body::<
36769                fidl::encoding::ResultType<
36770                    BaseNetworkSocketGetIpPacketInfoResponse,
36771                    fidl_fuchsia_posix::Errno,
36772                >,
36773                fidl::encoding::DefaultFuchsiaResourceDialect,
36774                0x54b505f242280740,
36775            >(_buf?)?;
36776            Ok(_response.map(|x| x.value))
36777        }
36778        self.client.send_query_and_decode::<
36779            fidl::encoding::EmptyPayload,
36780            BaseNetworkSocketGetIpPacketInfoResult,
36781        >(
36782            (),
36783            0x54b505f242280740,
36784            fidl::encoding::DynamicFlags::empty(),
36785            _decode,
36786        )
36787    }
36788
36789    type SetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
36790        BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
36791        fidl::encoding::DefaultFuchsiaResourceDialect,
36792    >;
36793    fn r#set_ip_receive_type_of_service(
36794        &self,
36795        mut value: bool,
36796    ) -> Self::SetIpReceiveTypeOfServiceResponseFut {
36797        fn _decode(
36798            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36799        ) -> Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error> {
36800            let _response = fidl::client::decode_transaction_body::<
36801                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36802                fidl::encoding::DefaultFuchsiaResourceDialect,
36803                0x6c4f6714995f84ef,
36804            >(_buf?)?;
36805            Ok(_response.map(|x| x))
36806        }
36807        self.client.send_query_and_decode::<
36808            BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
36809            BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
36810        >(
36811            (value,),
36812            0x6c4f6714995f84ef,
36813            fidl::encoding::DynamicFlags::empty(),
36814            _decode,
36815        )
36816    }
36817
36818    type GetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
36819        BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
36820        fidl::encoding::DefaultFuchsiaResourceDialect,
36821    >;
36822    fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut {
36823        fn _decode(
36824            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36825        ) -> Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error> {
36826            let _response = fidl::client::decode_transaction_body::<
36827                fidl::encoding::ResultType<
36828                    BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
36829                    fidl_fuchsia_posix::Errno,
36830                >,
36831                fidl::encoding::DefaultFuchsiaResourceDialect,
36832                0x4158ba7dc2795960,
36833            >(_buf?)?;
36834            Ok(_response.map(|x| x.value))
36835        }
36836        self.client.send_query_and_decode::<
36837            fidl::encoding::EmptyPayload,
36838            BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
36839        >(
36840            (),
36841            0x4158ba7dc2795960,
36842            fidl::encoding::DynamicFlags::empty(),
36843            _decode,
36844        )
36845    }
36846
36847    type SetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
36848        BaseNetworkSocketSetIpReceiveTtlResult,
36849        fidl::encoding::DefaultFuchsiaResourceDialect,
36850    >;
36851    fn r#set_ip_receive_ttl(&self, mut value: bool) -> Self::SetIpReceiveTtlResponseFut {
36852        fn _decode(
36853            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36854        ) -> Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error> {
36855            let _response = fidl::client::decode_transaction_body::<
36856                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36857                fidl::encoding::DefaultFuchsiaResourceDialect,
36858                0x46f15be0ce0ab82b,
36859            >(_buf?)?;
36860            Ok(_response.map(|x| x))
36861        }
36862        self.client.send_query_and_decode::<
36863            BaseNetworkSocketSetIpReceiveTtlRequest,
36864            BaseNetworkSocketSetIpReceiveTtlResult,
36865        >(
36866            (value,),
36867            0x46f15be0ce0ab82b,
36868            fidl::encoding::DynamicFlags::empty(),
36869            _decode,
36870        )
36871    }
36872
36873    type GetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
36874        BaseNetworkSocketGetIpReceiveTtlResult,
36875        fidl::encoding::DefaultFuchsiaResourceDialect,
36876    >;
36877    fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut {
36878        fn _decode(
36879            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36880        ) -> Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error> {
36881            let _response = fidl::client::decode_transaction_body::<
36882                fidl::encoding::ResultType<
36883                    BaseNetworkSocketGetIpReceiveTtlResponse,
36884                    fidl_fuchsia_posix::Errno,
36885                >,
36886                fidl::encoding::DefaultFuchsiaResourceDialect,
36887                0x678ddd5a5dfa2eb5,
36888            >(_buf?)?;
36889            Ok(_response.map(|x| x.value))
36890        }
36891        self.client.send_query_and_decode::<
36892            fidl::encoding::EmptyPayload,
36893            BaseNetworkSocketGetIpReceiveTtlResult,
36894        >(
36895            (),
36896            0x678ddd5a5dfa2eb5,
36897            fidl::encoding::DynamicFlags::empty(),
36898            _decode,
36899        )
36900    }
36901
36902    type SetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
36903        BaseNetworkSocketSetIpMulticastInterfaceResult,
36904        fidl::encoding::DefaultFuchsiaResourceDialect,
36905    >;
36906    fn r#set_ip_multicast_interface(
36907        &self,
36908        mut iface: u64,
36909        mut address: &fidl_fuchsia_net::Ipv4Address,
36910    ) -> Self::SetIpMulticastInterfaceResponseFut {
36911        fn _decode(
36912            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36913        ) -> Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error> {
36914            let _response = fidl::client::decode_transaction_body::<
36915                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36916                fidl::encoding::DefaultFuchsiaResourceDialect,
36917                0x752fbfa9b12befe,
36918            >(_buf?)?;
36919            Ok(_response.map(|x| x))
36920        }
36921        self.client.send_query_and_decode::<
36922            BaseNetworkSocketSetIpMulticastInterfaceRequest,
36923            BaseNetworkSocketSetIpMulticastInterfaceResult,
36924        >(
36925            (iface, address,),
36926            0x752fbfa9b12befe,
36927            fidl::encoding::DynamicFlags::empty(),
36928            _decode,
36929        )
36930    }
36931
36932    type GetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
36933        BaseNetworkSocketGetIpMulticastInterfaceResult,
36934        fidl::encoding::DefaultFuchsiaResourceDialect,
36935    >;
36936    fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut {
36937        fn _decode(
36938            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36939        ) -> Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error> {
36940            let _response = fidl::client::decode_transaction_body::<
36941                fidl::encoding::ResultType<
36942                    BaseNetworkSocketGetIpMulticastInterfaceResponse,
36943                    fidl_fuchsia_posix::Errno,
36944                >,
36945                fidl::encoding::DefaultFuchsiaResourceDialect,
36946                0x320bd14c4df046c4,
36947            >(_buf?)?;
36948            Ok(_response.map(|x| x.value))
36949        }
36950        self.client.send_query_and_decode::<
36951            fidl::encoding::EmptyPayload,
36952            BaseNetworkSocketGetIpMulticastInterfaceResult,
36953        >(
36954            (),
36955            0x320bd14c4df046c4,
36956            fidl::encoding::DynamicFlags::empty(),
36957            _decode,
36958        )
36959    }
36960
36961    type SetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
36962        BaseNetworkSocketSetIpMulticastTtlResult,
36963        fidl::encoding::DefaultFuchsiaResourceDialect,
36964    >;
36965    fn r#set_ip_multicast_ttl(
36966        &self,
36967        mut value: &OptionalUint8,
36968    ) -> Self::SetIpMulticastTtlResponseFut {
36969        fn _decode(
36970            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36971        ) -> Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error> {
36972            let _response = fidl::client::decode_transaction_body::<
36973                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
36974                fidl::encoding::DefaultFuchsiaResourceDialect,
36975                0x63134d53772916a1,
36976            >(_buf?)?;
36977            Ok(_response.map(|x| x))
36978        }
36979        self.client.send_query_and_decode::<
36980            BaseNetworkSocketSetIpMulticastTtlRequest,
36981            BaseNetworkSocketSetIpMulticastTtlResult,
36982        >(
36983            (value,),
36984            0x63134d53772916a1,
36985            fidl::encoding::DynamicFlags::empty(),
36986            _decode,
36987        )
36988    }
36989
36990    type GetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
36991        BaseNetworkSocketGetIpMulticastTtlResult,
36992        fidl::encoding::DefaultFuchsiaResourceDialect,
36993    >;
36994    fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut {
36995        fn _decode(
36996            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
36997        ) -> Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error> {
36998            let _response = fidl::client::decode_transaction_body::<
36999                fidl::encoding::ResultType<
37000                    BaseNetworkSocketGetIpMulticastTtlResponse,
37001                    fidl_fuchsia_posix::Errno,
37002                >,
37003                fidl::encoding::DefaultFuchsiaResourceDialect,
37004                0x4665cd378f39e1a,
37005            >(_buf?)?;
37006            Ok(_response.map(|x| x.value))
37007        }
37008        self.client.send_query_and_decode::<
37009            fidl::encoding::EmptyPayload,
37010            BaseNetworkSocketGetIpMulticastTtlResult,
37011        >(
37012            (),
37013            0x4665cd378f39e1a,
37014            fidl::encoding::DynamicFlags::empty(),
37015            _decode,
37016        )
37017    }
37018
37019    type SetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
37020        BaseNetworkSocketSetIpMulticastLoopbackResult,
37021        fidl::encoding::DefaultFuchsiaResourceDialect,
37022    >;
37023    fn r#set_ip_multicast_loopback(
37024        &self,
37025        mut value: bool,
37026    ) -> Self::SetIpMulticastLoopbackResponseFut {
37027        fn _decode(
37028            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37029        ) -> Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error> {
37030            let _response = fidl::client::decode_transaction_body::<
37031                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37032                fidl::encoding::DefaultFuchsiaResourceDialect,
37033                0x20c55c11f00943ea,
37034            >(_buf?)?;
37035            Ok(_response.map(|x| x))
37036        }
37037        self.client.send_query_and_decode::<
37038            BaseNetworkSocketSetIpMulticastLoopbackRequest,
37039            BaseNetworkSocketSetIpMulticastLoopbackResult,
37040        >(
37041            (value,),
37042            0x20c55c11f00943ea,
37043            fidl::encoding::DynamicFlags::empty(),
37044            _decode,
37045        )
37046    }
37047
37048    type GetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
37049        BaseNetworkSocketGetIpMulticastLoopbackResult,
37050        fidl::encoding::DefaultFuchsiaResourceDialect,
37051    >;
37052    fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut {
37053        fn _decode(
37054            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37055        ) -> Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error> {
37056            let _response = fidl::client::decode_transaction_body::<
37057                fidl::encoding::ResultType<
37058                    BaseNetworkSocketGetIpMulticastLoopbackResponse,
37059                    fidl_fuchsia_posix::Errno,
37060                >,
37061                fidl::encoding::DefaultFuchsiaResourceDialect,
37062                0x3b6b26ff558298f2,
37063            >(_buf?)?;
37064            Ok(_response.map(|x| x.value))
37065        }
37066        self.client.send_query_and_decode::<
37067            fidl::encoding::EmptyPayload,
37068            BaseNetworkSocketGetIpMulticastLoopbackResult,
37069        >(
37070            (),
37071            0x3b6b26ff558298f2,
37072            fidl::encoding::DynamicFlags::empty(),
37073            _decode,
37074        )
37075    }
37076
37077    type AddIpMembershipResponseFut = fidl::client::QueryResponseFut<
37078        BaseNetworkSocketAddIpMembershipResult,
37079        fidl::encoding::DefaultFuchsiaResourceDialect,
37080    >;
37081    fn r#add_ip_membership(
37082        &self,
37083        mut membership: &IpMulticastMembership,
37084    ) -> Self::AddIpMembershipResponseFut {
37085        fn _decode(
37086            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37087        ) -> Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error> {
37088            let _response = fidl::client::decode_transaction_body::<
37089                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37090                fidl::encoding::DefaultFuchsiaResourceDialect,
37091                0x76bc7df115a3b4d0,
37092            >(_buf?)?;
37093            Ok(_response.map(|x| x))
37094        }
37095        self.client.send_query_and_decode::<
37096            BaseNetworkSocketAddIpMembershipRequest,
37097            BaseNetworkSocketAddIpMembershipResult,
37098        >(
37099            (membership,),
37100            0x76bc7df115a3b4d0,
37101            fidl::encoding::DynamicFlags::empty(),
37102            _decode,
37103        )
37104    }
37105
37106    type DropIpMembershipResponseFut = fidl::client::QueryResponseFut<
37107        BaseNetworkSocketDropIpMembershipResult,
37108        fidl::encoding::DefaultFuchsiaResourceDialect,
37109    >;
37110    fn r#drop_ip_membership(
37111        &self,
37112        mut membership: &IpMulticastMembership,
37113    ) -> Self::DropIpMembershipResponseFut {
37114        fn _decode(
37115            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37116        ) -> Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error> {
37117            let _response = fidl::client::decode_transaction_body::<
37118                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37119                fidl::encoding::DefaultFuchsiaResourceDialect,
37120                0x2888f3099188d03,
37121            >(_buf?)?;
37122            Ok(_response.map(|x| x))
37123        }
37124        self.client.send_query_and_decode::<
37125            BaseNetworkSocketDropIpMembershipRequest,
37126            BaseNetworkSocketDropIpMembershipResult,
37127        >(
37128            (membership,),
37129            0x2888f3099188d03,
37130            fidl::encoding::DynamicFlags::empty(),
37131            _decode,
37132        )
37133    }
37134
37135    type SetIpTransparentResponseFut = fidl::client::QueryResponseFut<
37136        BaseNetworkSocketSetIpTransparentResult,
37137        fidl::encoding::DefaultFuchsiaResourceDialect,
37138    >;
37139    fn r#set_ip_transparent(&self, mut value: bool) -> Self::SetIpTransparentResponseFut {
37140        fn _decode(
37141            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37142        ) -> Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error> {
37143            let _response = fidl::client::decode_transaction_body::<
37144                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37145                fidl::encoding::DefaultFuchsiaResourceDialect,
37146                0x1ae532b0c066e3a0,
37147            >(_buf?)?;
37148            Ok(_response.map(|x| x))
37149        }
37150        self.client.send_query_and_decode::<
37151            BaseNetworkSocketSetIpTransparentRequest,
37152            BaseNetworkSocketSetIpTransparentResult,
37153        >(
37154            (value,),
37155            0x1ae532b0c066e3a0,
37156            fidl::encoding::DynamicFlags::empty(),
37157            _decode,
37158        )
37159    }
37160
37161    type GetIpTransparentResponseFut = fidl::client::QueryResponseFut<
37162        BaseNetworkSocketGetIpTransparentResult,
37163        fidl::encoding::DefaultFuchsiaResourceDialect,
37164    >;
37165    fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut {
37166        fn _decode(
37167            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37168        ) -> Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error> {
37169            let _response = fidl::client::decode_transaction_body::<
37170                fidl::encoding::ResultType<
37171                    BaseNetworkSocketGetIpTransparentResponse,
37172                    fidl_fuchsia_posix::Errno,
37173                >,
37174                fidl::encoding::DefaultFuchsiaResourceDialect,
37175                0x51d43695962ebfb5,
37176            >(_buf?)?;
37177            Ok(_response.map(|x| x.value))
37178        }
37179        self.client.send_query_and_decode::<
37180            fidl::encoding::EmptyPayload,
37181            BaseNetworkSocketGetIpTransparentResult,
37182        >(
37183            (),
37184            0x51d43695962ebfb5,
37185            fidl::encoding::DynamicFlags::empty(),
37186            _decode,
37187        )
37188    }
37189
37190    type SetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
37191        BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
37192        fidl::encoding::DefaultFuchsiaResourceDialect,
37193    >;
37194    fn r#set_ip_receive_original_destination_address(
37195        &self,
37196        mut value: bool,
37197    ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut {
37198        fn _decode(
37199            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37200        ) -> Result<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error>
37201        {
37202            let _response = fidl::client::decode_transaction_body::<
37203                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37204                fidl::encoding::DefaultFuchsiaResourceDialect,
37205                0x4722b4ce52f7840,
37206            >(_buf?)?;
37207            Ok(_response.map(|x| x))
37208        }
37209        self.client.send_query_and_decode::<
37210            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
37211            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
37212        >(
37213            (value,),
37214            0x4722b4ce52f7840,
37215            fidl::encoding::DynamicFlags::empty(),
37216            _decode,
37217        )
37218    }
37219
37220    type GetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
37221        BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
37222        fidl::encoding::DefaultFuchsiaResourceDialect,
37223    >;
37224    fn r#get_ip_receive_original_destination_address(
37225        &self,
37226    ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut {
37227        fn _decode(
37228            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37229        ) -> Result<BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error>
37230        {
37231            let _response = fidl::client::decode_transaction_body::<
37232                fidl::encoding::ResultType<
37233                    BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
37234                    fidl_fuchsia_posix::Errno,
37235                >,
37236                fidl::encoding::DefaultFuchsiaResourceDialect,
37237                0x2a0e7dc5d6bfdfe9,
37238            >(_buf?)?;
37239            Ok(_response.map(|x| x.value))
37240        }
37241        self.client.send_query_and_decode::<
37242            fidl::encoding::EmptyPayload,
37243            BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
37244        >(
37245            (),
37246            0x2a0e7dc5d6bfdfe9,
37247            fidl::encoding::DynamicFlags::empty(),
37248            _decode,
37249        )
37250    }
37251
37252    type AddIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
37253        BaseNetworkSocketAddIpv6MembershipResult,
37254        fidl::encoding::DefaultFuchsiaResourceDialect,
37255    >;
37256    fn r#add_ipv6_membership(
37257        &self,
37258        mut membership: &Ipv6MulticastMembership,
37259    ) -> Self::AddIpv6MembershipResponseFut {
37260        fn _decode(
37261            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37262        ) -> Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error> {
37263            let _response = fidl::client::decode_transaction_body::<
37264                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37265                fidl::encoding::DefaultFuchsiaResourceDialect,
37266                0x7c94727acb4ea4b3,
37267            >(_buf?)?;
37268            Ok(_response.map(|x| x))
37269        }
37270        self.client.send_query_and_decode::<
37271            BaseNetworkSocketAddIpv6MembershipRequest,
37272            BaseNetworkSocketAddIpv6MembershipResult,
37273        >(
37274            (membership,),
37275            0x7c94727acb4ea4b3,
37276            fidl::encoding::DynamicFlags::empty(),
37277            _decode,
37278        )
37279    }
37280
37281    type DropIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
37282        BaseNetworkSocketDropIpv6MembershipResult,
37283        fidl::encoding::DefaultFuchsiaResourceDialect,
37284    >;
37285    fn r#drop_ipv6_membership(
37286        &self,
37287        mut membership: &Ipv6MulticastMembership,
37288    ) -> Self::DropIpv6MembershipResponseFut {
37289        fn _decode(
37290            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37291        ) -> Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error> {
37292            let _response = fidl::client::decode_transaction_body::<
37293                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37294                fidl::encoding::DefaultFuchsiaResourceDialect,
37295                0x42104c70ccaba304,
37296            >(_buf?)?;
37297            Ok(_response.map(|x| x))
37298        }
37299        self.client.send_query_and_decode::<
37300            BaseNetworkSocketDropIpv6MembershipRequest,
37301            BaseNetworkSocketDropIpv6MembershipResult,
37302        >(
37303            (membership,),
37304            0x42104c70ccaba304,
37305            fidl::encoding::DynamicFlags::empty(),
37306            _decode,
37307        )
37308    }
37309
37310    type SetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
37311        BaseNetworkSocketSetIpv6MulticastInterfaceResult,
37312        fidl::encoding::DefaultFuchsiaResourceDialect,
37313    >;
37314    fn r#set_ipv6_multicast_interface(
37315        &self,
37316        mut value: u64,
37317    ) -> Self::SetIpv6MulticastInterfaceResponseFut {
37318        fn _decode(
37319            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37320        ) -> Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error> {
37321            let _response = fidl::client::decode_transaction_body::<
37322                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37323                fidl::encoding::DefaultFuchsiaResourceDialect,
37324                0x135f76db3774ab3b,
37325            >(_buf?)?;
37326            Ok(_response.map(|x| x))
37327        }
37328        self.client.send_query_and_decode::<
37329            BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
37330            BaseNetworkSocketSetIpv6MulticastInterfaceResult,
37331        >(
37332            (value,),
37333            0x135f76db3774ab3b,
37334            fidl::encoding::DynamicFlags::empty(),
37335            _decode,
37336        )
37337    }
37338
37339    type GetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
37340        BaseNetworkSocketGetIpv6MulticastInterfaceResult,
37341        fidl::encoding::DefaultFuchsiaResourceDialect,
37342    >;
37343    fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut {
37344        fn _decode(
37345            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37346        ) -> Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error> {
37347            let _response = fidl::client::decode_transaction_body::<
37348                fidl::encoding::ResultType<
37349                    BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
37350                    fidl_fuchsia_posix::Errno,
37351                >,
37352                fidl::encoding::DefaultFuchsiaResourceDialect,
37353                0x1f26fcdd348f1882,
37354            >(_buf?)?;
37355            Ok(_response.map(|x| x.value))
37356        }
37357        self.client.send_query_and_decode::<
37358            fidl::encoding::EmptyPayload,
37359            BaseNetworkSocketGetIpv6MulticastInterfaceResult,
37360        >(
37361            (),
37362            0x1f26fcdd348f1882,
37363            fidl::encoding::DynamicFlags::empty(),
37364            _decode,
37365        )
37366    }
37367
37368    type SetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
37369        BaseNetworkSocketSetIpv6UnicastHopsResult,
37370        fidl::encoding::DefaultFuchsiaResourceDialect,
37371    >;
37372    fn r#set_ipv6_unicast_hops(
37373        &self,
37374        mut value: &OptionalUint8,
37375    ) -> Self::SetIpv6UnicastHopsResponseFut {
37376        fn _decode(
37377            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37378        ) -> Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error> {
37379            let _response = fidl::client::decode_transaction_body::<
37380                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37381                fidl::encoding::DefaultFuchsiaResourceDialect,
37382                0x157d51e98f462859,
37383            >(_buf?)?;
37384            Ok(_response.map(|x| x))
37385        }
37386        self.client.send_query_and_decode::<
37387            BaseNetworkSocketSetIpv6UnicastHopsRequest,
37388            BaseNetworkSocketSetIpv6UnicastHopsResult,
37389        >(
37390            (value,),
37391            0x157d51e98f462859,
37392            fidl::encoding::DynamicFlags::empty(),
37393            _decode,
37394        )
37395    }
37396
37397    type GetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
37398        BaseNetworkSocketGetIpv6UnicastHopsResult,
37399        fidl::encoding::DefaultFuchsiaResourceDialect,
37400    >;
37401    fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut {
37402        fn _decode(
37403            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37404        ) -> Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error> {
37405            let _response = fidl::client::decode_transaction_body::<
37406                fidl::encoding::ResultType<
37407                    BaseNetworkSocketGetIpv6UnicastHopsResponse,
37408                    fidl_fuchsia_posix::Errno,
37409                >,
37410                fidl::encoding::DefaultFuchsiaResourceDialect,
37411                0x21f4641cad8bd8d2,
37412            >(_buf?)?;
37413            Ok(_response.map(|x| x.value))
37414        }
37415        self.client.send_query_and_decode::<
37416            fidl::encoding::EmptyPayload,
37417            BaseNetworkSocketGetIpv6UnicastHopsResult,
37418        >(
37419            (),
37420            0x21f4641cad8bd8d2,
37421            fidl::encoding::DynamicFlags::empty(),
37422            _decode,
37423        )
37424    }
37425
37426    type SetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
37427        BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
37428        fidl::encoding::DefaultFuchsiaResourceDialect,
37429    >;
37430    fn r#set_ipv6_receive_hop_limit(
37431        &self,
37432        mut value: bool,
37433    ) -> Self::SetIpv6ReceiveHopLimitResponseFut {
37434        fn _decode(
37435            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37436        ) -> Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error> {
37437            let _response = fidl::client::decode_transaction_body::<
37438                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37439                fidl::encoding::DefaultFuchsiaResourceDialect,
37440                0x5c24808ed2e84a1e,
37441            >(_buf?)?;
37442            Ok(_response.map(|x| x))
37443        }
37444        self.client.send_query_and_decode::<
37445            BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
37446            BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
37447        >(
37448            (value,),
37449            0x5c24808ed2e84a1e,
37450            fidl::encoding::DynamicFlags::empty(),
37451            _decode,
37452        )
37453    }
37454
37455    type GetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
37456        BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
37457        fidl::encoding::DefaultFuchsiaResourceDialect,
37458    >;
37459    fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut {
37460        fn _decode(
37461            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37462        ) -> Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error> {
37463            let _response = fidl::client::decode_transaction_body::<
37464                fidl::encoding::ResultType<
37465                    BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
37466                    fidl_fuchsia_posix::Errno,
37467                >,
37468                fidl::encoding::DefaultFuchsiaResourceDialect,
37469                0x341e06689885b4c0,
37470            >(_buf?)?;
37471            Ok(_response.map(|x| x.value))
37472        }
37473        self.client.send_query_and_decode::<
37474            fidl::encoding::EmptyPayload,
37475            BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
37476        >(
37477            (),
37478            0x341e06689885b4c0,
37479            fidl::encoding::DynamicFlags::empty(),
37480            _decode,
37481        )
37482    }
37483
37484    type SetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
37485        BaseNetworkSocketSetIpv6MulticastHopsResult,
37486        fidl::encoding::DefaultFuchsiaResourceDialect,
37487    >;
37488    fn r#set_ipv6_multicast_hops(
37489        &self,
37490        mut value: &OptionalUint8,
37491    ) -> Self::SetIpv6MulticastHopsResponseFut {
37492        fn _decode(
37493            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37494        ) -> Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error> {
37495            let _response = fidl::client::decode_transaction_body::<
37496                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37497                fidl::encoding::DefaultFuchsiaResourceDialect,
37498                0x25b9cd4d181f82c1,
37499            >(_buf?)?;
37500            Ok(_response.map(|x| x))
37501        }
37502        self.client.send_query_and_decode::<
37503            BaseNetworkSocketSetIpv6MulticastHopsRequest,
37504            BaseNetworkSocketSetIpv6MulticastHopsResult,
37505        >(
37506            (value,),
37507            0x25b9cd4d181f82c1,
37508            fidl::encoding::DynamicFlags::empty(),
37509            _decode,
37510        )
37511    }
37512
37513    type GetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
37514        BaseNetworkSocketGetIpv6MulticastHopsResult,
37515        fidl::encoding::DefaultFuchsiaResourceDialect,
37516    >;
37517    fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut {
37518        fn _decode(
37519            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37520        ) -> Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error> {
37521            let _response = fidl::client::decode_transaction_body::<
37522                fidl::encoding::ResultType<
37523                    BaseNetworkSocketGetIpv6MulticastHopsResponse,
37524                    fidl_fuchsia_posix::Errno,
37525                >,
37526                fidl::encoding::DefaultFuchsiaResourceDialect,
37527                0x52916948a365012a,
37528            >(_buf?)?;
37529            Ok(_response.map(|x| x.value))
37530        }
37531        self.client.send_query_and_decode::<
37532            fidl::encoding::EmptyPayload,
37533            BaseNetworkSocketGetIpv6MulticastHopsResult,
37534        >(
37535            (),
37536            0x52916948a365012a,
37537            fidl::encoding::DynamicFlags::empty(),
37538            _decode,
37539        )
37540    }
37541
37542    type SetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
37543        BaseNetworkSocketSetIpv6MulticastLoopbackResult,
37544        fidl::encoding::DefaultFuchsiaResourceDialect,
37545    >;
37546    fn r#set_ipv6_multicast_loopback(
37547        &self,
37548        mut value: bool,
37549    ) -> Self::SetIpv6MulticastLoopbackResponseFut {
37550        fn _decode(
37551            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37552        ) -> Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error> {
37553            let _response = fidl::client::decode_transaction_body::<
37554                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37555                fidl::encoding::DefaultFuchsiaResourceDialect,
37556                0x55701c409ff41b40,
37557            >(_buf?)?;
37558            Ok(_response.map(|x| x))
37559        }
37560        self.client.send_query_and_decode::<
37561            BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
37562            BaseNetworkSocketSetIpv6MulticastLoopbackResult,
37563        >(
37564            (value,),
37565            0x55701c409ff41b40,
37566            fidl::encoding::DynamicFlags::empty(),
37567            _decode,
37568        )
37569    }
37570
37571    type GetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
37572        BaseNetworkSocketGetIpv6MulticastLoopbackResult,
37573        fidl::encoding::DefaultFuchsiaResourceDialect,
37574    >;
37575    fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut {
37576        fn _decode(
37577            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37578        ) -> Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error> {
37579            let _response = fidl::client::decode_transaction_body::<
37580                fidl::encoding::ResultType<
37581                    BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
37582                    fidl_fuchsia_posix::Errno,
37583                >,
37584                fidl::encoding::DefaultFuchsiaResourceDialect,
37585                0x4415b701fde319c3,
37586            >(_buf?)?;
37587            Ok(_response.map(|x| x.value))
37588        }
37589        self.client.send_query_and_decode::<
37590            fidl::encoding::EmptyPayload,
37591            BaseNetworkSocketGetIpv6MulticastLoopbackResult,
37592        >(
37593            (),
37594            0x4415b701fde319c3,
37595            fidl::encoding::DynamicFlags::empty(),
37596            _decode,
37597        )
37598    }
37599
37600    type SetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
37601        BaseNetworkSocketSetIpv6OnlyResult,
37602        fidl::encoding::DefaultFuchsiaResourceDialect,
37603    >;
37604    fn r#set_ipv6_only(&self, mut value: bool) -> Self::SetIpv6OnlyResponseFut {
37605        fn _decode(
37606            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37607        ) -> Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
37608            let _response = fidl::client::decode_transaction_body::<
37609                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37610                fidl::encoding::DefaultFuchsiaResourceDialect,
37611                0x4873f1364758cbba,
37612            >(_buf?)?;
37613            Ok(_response.map(|x| x))
37614        }
37615        self.client.send_query_and_decode::<
37616            BaseNetworkSocketSetIpv6OnlyRequest,
37617            BaseNetworkSocketSetIpv6OnlyResult,
37618        >(
37619            (value,),
37620            0x4873f1364758cbba,
37621            fidl::encoding::DynamicFlags::empty(),
37622            _decode,
37623        )
37624    }
37625
37626    type GetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
37627        BaseNetworkSocketGetIpv6OnlyResult,
37628        fidl::encoding::DefaultFuchsiaResourceDialect,
37629    >;
37630    fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut {
37631        fn _decode(
37632            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37633        ) -> Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
37634            let _response = fidl::client::decode_transaction_body::<
37635                fidl::encoding::ResultType<
37636                    BaseNetworkSocketGetIpv6OnlyResponse,
37637                    fidl_fuchsia_posix::Errno,
37638                >,
37639                fidl::encoding::DefaultFuchsiaResourceDialect,
37640                0x4aa3340a1a26b89c,
37641            >(_buf?)?;
37642            Ok(_response.map(|x| x.value))
37643        }
37644        self.client.send_query_and_decode::<
37645            fidl::encoding::EmptyPayload,
37646            BaseNetworkSocketGetIpv6OnlyResult,
37647        >(
37648            (),
37649            0x4aa3340a1a26b89c,
37650            fidl::encoding::DynamicFlags::empty(),
37651            _decode,
37652        )
37653    }
37654
37655    type SetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
37656        BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
37657        fidl::encoding::DefaultFuchsiaResourceDialect,
37658    >;
37659    fn r#set_ipv6_receive_traffic_class(
37660        &self,
37661        mut value: bool,
37662    ) -> Self::SetIpv6ReceiveTrafficClassResponseFut {
37663        fn _decode(
37664            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37665        ) -> Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error> {
37666            let _response = fidl::client::decode_transaction_body::<
37667                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37668                fidl::encoding::DefaultFuchsiaResourceDialect,
37669                0x58f07c8788d099a0,
37670            >(_buf?)?;
37671            Ok(_response.map(|x| x))
37672        }
37673        self.client.send_query_and_decode::<
37674            BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
37675            BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
37676        >(
37677            (value,),
37678            0x58f07c8788d099a0,
37679            fidl::encoding::DynamicFlags::empty(),
37680            _decode,
37681        )
37682    }
37683
37684    type GetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
37685        BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
37686        fidl::encoding::DefaultFuchsiaResourceDialect,
37687    >;
37688    fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut {
37689        fn _decode(
37690            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37691        ) -> Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error> {
37692            let _response = fidl::client::decode_transaction_body::<
37693                fidl::encoding::ResultType<
37694                    BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
37695                    fidl_fuchsia_posix::Errno,
37696                >,
37697                fidl::encoding::DefaultFuchsiaResourceDialect,
37698                0x2e334df1da553ffa,
37699            >(_buf?)?;
37700            Ok(_response.map(|x| x.value))
37701        }
37702        self.client.send_query_and_decode::<
37703            fidl::encoding::EmptyPayload,
37704            BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
37705        >(
37706            (),
37707            0x2e334df1da553ffa,
37708            fidl::encoding::DynamicFlags::empty(),
37709            _decode,
37710        )
37711    }
37712
37713    type SetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
37714        BaseNetworkSocketSetIpv6TrafficClassResult,
37715        fidl::encoding::DefaultFuchsiaResourceDialect,
37716    >;
37717    fn r#set_ipv6_traffic_class(
37718        &self,
37719        mut value: &OptionalUint8,
37720    ) -> Self::SetIpv6TrafficClassResponseFut {
37721        fn _decode(
37722            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37723        ) -> Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error> {
37724            let _response = fidl::client::decode_transaction_body::<
37725                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37726                fidl::encoding::DefaultFuchsiaResourceDialect,
37727                0x6af077800c5a0b4f,
37728            >(_buf?)?;
37729            Ok(_response.map(|x| x))
37730        }
37731        self.client.send_query_and_decode::<
37732            BaseNetworkSocketSetIpv6TrafficClassRequest,
37733            BaseNetworkSocketSetIpv6TrafficClassResult,
37734        >(
37735            (value,),
37736            0x6af077800c5a0b4f,
37737            fidl::encoding::DynamicFlags::empty(),
37738            _decode,
37739        )
37740    }
37741
37742    type GetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
37743        BaseNetworkSocketGetIpv6TrafficClassResult,
37744        fidl::encoding::DefaultFuchsiaResourceDialect,
37745    >;
37746    fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut {
37747        fn _decode(
37748            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37749        ) -> Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error> {
37750            let _response = fidl::client::decode_transaction_body::<
37751                fidl::encoding::ResultType<
37752                    BaseNetworkSocketGetIpv6TrafficClassResponse,
37753                    fidl_fuchsia_posix::Errno,
37754                >,
37755                fidl::encoding::DefaultFuchsiaResourceDialect,
37756                0x6baf6eed8fc2f04,
37757            >(_buf?)?;
37758            Ok(_response.map(|x| x.value))
37759        }
37760        self.client.send_query_and_decode::<
37761            fidl::encoding::EmptyPayload,
37762            BaseNetworkSocketGetIpv6TrafficClassResult,
37763        >(
37764            (),
37765            0x6baf6eed8fc2f04,
37766            fidl::encoding::DynamicFlags::empty(),
37767            _decode,
37768        )
37769    }
37770
37771    type SetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
37772        BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
37773        fidl::encoding::DefaultFuchsiaResourceDialect,
37774    >;
37775    fn r#set_ipv6_receive_packet_info(
37776        &self,
37777        mut value: bool,
37778    ) -> Self::SetIpv6ReceivePacketInfoResponseFut {
37779        fn _decode(
37780            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37781        ) -> Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error> {
37782            let _response = fidl::client::decode_transaction_body::<
37783                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
37784                fidl::encoding::DefaultFuchsiaResourceDialect,
37785                0x19259775b1a92768,
37786            >(_buf?)?;
37787            Ok(_response.map(|x| x))
37788        }
37789        self.client.send_query_and_decode::<
37790            BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
37791            BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
37792        >(
37793            (value,),
37794            0x19259775b1a92768,
37795            fidl::encoding::DynamicFlags::empty(),
37796            _decode,
37797        )
37798    }
37799
37800    type GetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
37801        BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
37802        fidl::encoding::DefaultFuchsiaResourceDialect,
37803    >;
37804    fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut {
37805        fn _decode(
37806            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37807        ) -> Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error> {
37808            let _response = fidl::client::decode_transaction_body::<
37809                fidl::encoding::ResultType<
37810                    BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
37811                    fidl_fuchsia_posix::Errno,
37812                >,
37813                fidl::encoding::DefaultFuchsiaResourceDialect,
37814                0x7acd4a2775baec75,
37815            >(_buf?)?;
37816            Ok(_response.map(|x| x.value))
37817        }
37818        self.client.send_query_and_decode::<
37819            fidl::encoding::EmptyPayload,
37820            BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
37821        >(
37822            (),
37823            0x7acd4a2775baec75,
37824            fidl::encoding::DynamicFlags::empty(),
37825            _decode,
37826        )
37827    }
37828
37829    type GetOriginalDestinationResponseFut = fidl::client::QueryResponseFut<
37830        BaseNetworkSocketGetOriginalDestinationResult,
37831        fidl::encoding::DefaultFuchsiaResourceDialect,
37832    >;
37833    fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut {
37834        fn _decode(
37835            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37836        ) -> Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error> {
37837            let _response = fidl::client::decode_transaction_body::<
37838                fidl::encoding::ResultType<
37839                    BaseNetworkSocketGetOriginalDestinationResponse,
37840                    fidl_fuchsia_posix::Errno,
37841                >,
37842                fidl::encoding::DefaultFuchsiaResourceDialect,
37843                0x38bf28f0dafdbac0,
37844            >(_buf?)?;
37845            Ok(_response.map(|x| x.value))
37846        }
37847        self.client.send_query_and_decode::<
37848            fidl::encoding::EmptyPayload,
37849            BaseNetworkSocketGetOriginalDestinationResult,
37850        >(
37851            (),
37852            0x38bf28f0dafdbac0,
37853            fidl::encoding::DynamicFlags::empty(),
37854            _decode,
37855        )
37856    }
37857
37858    type GetInfoResponseFut = fidl::client::QueryResponseFut<
37859        BaseDatagramSocketGetInfoResult,
37860        fidl::encoding::DefaultFuchsiaResourceDialect,
37861    >;
37862    fn r#get_info(&self) -> Self::GetInfoResponseFut {
37863        fn _decode(
37864            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37865        ) -> Result<BaseDatagramSocketGetInfoResult, fidl::Error> {
37866            let _response = fidl::client::decode_transaction_body::<
37867                fidl::encoding::ResultType<
37868                    BaseDatagramSocketGetInfoResponse,
37869                    fidl_fuchsia_posix::Errno,
37870                >,
37871                fidl::encoding::DefaultFuchsiaResourceDialect,
37872                0x48aa0a1f6a32d2ed,
37873            >(_buf?)?;
37874            Ok(_response.map(|x| (x.domain, x.proto)))
37875        }
37876        self.client
37877            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseDatagramSocketGetInfoResult>(
37878                (),
37879                0x48aa0a1f6a32d2ed,
37880                fidl::encoding::DynamicFlags::empty(),
37881                _decode,
37882            )
37883    }
37884
37885    type DescribeResponseFut = fidl::client::QueryResponseFut<
37886        DatagramSocketDescribeResponse,
37887        fidl::encoding::DefaultFuchsiaResourceDialect,
37888    >;
37889    fn r#describe(&self) -> Self::DescribeResponseFut {
37890        fn _decode(
37891            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37892        ) -> Result<DatagramSocketDescribeResponse, fidl::Error> {
37893            let _response = fidl::client::decode_transaction_body::<
37894                DatagramSocketDescribeResponse,
37895                fidl::encoding::DefaultFuchsiaResourceDialect,
37896                0xbf1e2f0a86601f3,
37897            >(_buf?)?;
37898            Ok(_response)
37899        }
37900        self.client
37901            .send_query_and_decode::<fidl::encoding::EmptyPayload, DatagramSocketDescribeResponse>(
37902                (),
37903                0xbf1e2f0a86601f3,
37904                fidl::encoding::DynamicFlags::empty(),
37905                _decode,
37906            )
37907    }
37908
37909    type SendMsgPreflightResponseFut = fidl::client::QueryResponseFut<
37910        DatagramSocketSendMsgPreflightResult,
37911        fidl::encoding::DefaultFuchsiaResourceDialect,
37912    >;
37913    fn r#send_msg_preflight(
37914        &self,
37915        mut payload: &DatagramSocketSendMsgPreflightRequest,
37916    ) -> Self::SendMsgPreflightResponseFut {
37917        fn _decode(
37918            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37919        ) -> Result<DatagramSocketSendMsgPreflightResult, fidl::Error> {
37920            let _response = fidl::client::decode_transaction_body::<
37921                fidl::encoding::ResultType<
37922                    DatagramSocketSendMsgPreflightResponse,
37923                    fidl_fuchsia_posix::Errno,
37924                >,
37925                fidl::encoding::DefaultFuchsiaResourceDialect,
37926                0x5362e668e777248a,
37927            >(_buf?)?;
37928            Ok(_response.map(|x| x))
37929        }
37930        self.client.send_query_and_decode::<
37931            DatagramSocketSendMsgPreflightRequest,
37932            DatagramSocketSendMsgPreflightResult,
37933        >(
37934            payload,
37935            0x5362e668e777248a,
37936            fidl::encoding::DynamicFlags::empty(),
37937            _decode,
37938        )
37939    }
37940
37941    type RecvMsgPostflightResponseFut = fidl::client::QueryResponseFut<
37942        DatagramSocketRecvMsgPostflightResult,
37943        fidl::encoding::DefaultFuchsiaResourceDialect,
37944    >;
37945    fn r#recv_msg_postflight(&self) -> Self::RecvMsgPostflightResponseFut {
37946        fn _decode(
37947            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
37948        ) -> Result<DatagramSocketRecvMsgPostflightResult, fidl::Error> {
37949            let _response = fidl::client::decode_transaction_body::<
37950                fidl::encoding::ResultType<
37951                    DatagramSocketRecvMsgPostflightResponse,
37952                    fidl_fuchsia_posix::Errno,
37953                >,
37954                fidl::encoding::DefaultFuchsiaResourceDialect,
37955                0x1a7cdeca5f3eb8e2,
37956            >(_buf?)?;
37957            Ok(_response.map(|x| x))
37958        }
37959        self.client.send_query_and_decode::<
37960            fidl::encoding::EmptyPayload,
37961            DatagramSocketRecvMsgPostflightResult,
37962        >(
37963            (),
37964            0x1a7cdeca5f3eb8e2,
37965            fidl::encoding::DynamicFlags::empty(),
37966            _decode,
37967        )
37968    }
37969}
37970
37971pub struct DatagramSocketEventStream {
37972    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
37973}
37974
37975impl std::marker::Unpin for DatagramSocketEventStream {}
37976
37977impl futures::stream::FusedStream for DatagramSocketEventStream {
37978    fn is_terminated(&self) -> bool {
37979        self.event_receiver.is_terminated()
37980    }
37981}
37982
37983impl futures::Stream for DatagramSocketEventStream {
37984    type Item = Result<DatagramSocketEvent, fidl::Error>;
37985
37986    fn poll_next(
37987        mut self: std::pin::Pin<&mut Self>,
37988        cx: &mut std::task::Context<'_>,
37989    ) -> std::task::Poll<Option<Self::Item>> {
37990        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
37991            &mut self.event_receiver,
37992            cx
37993        )?) {
37994            Some(buf) => std::task::Poll::Ready(Some(DatagramSocketEvent::decode(buf))),
37995            None => std::task::Poll::Ready(None),
37996        }
37997    }
37998}
37999
38000#[derive(Debug)]
38001pub enum DatagramSocketEvent {}
38002
38003impl DatagramSocketEvent {
38004    /// Decodes a message buffer as a [`DatagramSocketEvent`].
38005    fn decode(
38006        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
38007    ) -> Result<DatagramSocketEvent, fidl::Error> {
38008        let (bytes, _handles) = buf.split_mut();
38009        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
38010        debug_assert_eq!(tx_header.tx_id, 0);
38011        match tx_header.ordinal {
38012            _ => Err(fidl::Error::UnknownOrdinal {
38013                ordinal: tx_header.ordinal,
38014                protocol_name:
38015                    <DatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
38016            }),
38017        }
38018    }
38019}
38020
38021/// A Stream of incoming requests for fuchsia.posix.socket/DatagramSocket.
38022pub struct DatagramSocketRequestStream {
38023    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
38024    is_terminated: bool,
38025}
38026
38027impl std::marker::Unpin for DatagramSocketRequestStream {}
38028
38029impl futures::stream::FusedStream for DatagramSocketRequestStream {
38030    fn is_terminated(&self) -> bool {
38031        self.is_terminated
38032    }
38033}
38034
38035impl fidl::endpoints::RequestStream for DatagramSocketRequestStream {
38036    type Protocol = DatagramSocketMarker;
38037    type ControlHandle = DatagramSocketControlHandle;
38038
38039    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
38040        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
38041    }
38042
38043    fn control_handle(&self) -> Self::ControlHandle {
38044        DatagramSocketControlHandle { inner: self.inner.clone() }
38045    }
38046
38047    fn into_inner(
38048        self,
38049    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
38050    {
38051        (self.inner, self.is_terminated)
38052    }
38053
38054    fn from_inner(
38055        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
38056        is_terminated: bool,
38057    ) -> Self {
38058        Self { inner, is_terminated }
38059    }
38060}
38061
38062impl futures::Stream for DatagramSocketRequestStream {
38063    type Item = Result<DatagramSocketRequest, fidl::Error>;
38064
38065    fn poll_next(
38066        mut self: std::pin::Pin<&mut Self>,
38067        cx: &mut std::task::Context<'_>,
38068    ) -> std::task::Poll<Option<Self::Item>> {
38069        let this = &mut *self;
38070        if this.inner.check_shutdown(cx) {
38071            this.is_terminated = true;
38072            return std::task::Poll::Ready(None);
38073        }
38074        if this.is_terminated {
38075            panic!("polled DatagramSocketRequestStream after completion");
38076        }
38077        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
38078            |bytes, handles| {
38079                match this.inner.channel().read_etc(cx, bytes, handles) {
38080                    std::task::Poll::Ready(Ok(())) => {}
38081                    std::task::Poll::Pending => return std::task::Poll::Pending,
38082                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
38083                        this.is_terminated = true;
38084                        return std::task::Poll::Ready(None);
38085                    }
38086                    std::task::Poll::Ready(Err(e)) => {
38087                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
38088                            e.into(),
38089                        ))))
38090                    }
38091                }
38092
38093                // A message has been received from the channel
38094                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
38095
38096                std::task::Poll::Ready(Some(match header.ordinal {
38097                    0x20d8a7aba2168a79 => {
38098                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
38099                        let mut req = fidl::new_empty!(
38100                            fidl_fuchsia_unknown::CloneableCloneRequest,
38101                            fidl::encoding::DefaultFuchsiaResourceDialect
38102                        );
38103                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_unknown::CloneableCloneRequest>(&header, _body_bytes, handles, &mut req)?;
38104                        let control_handle =
38105                            DatagramSocketControlHandle { inner: this.inner.clone() };
38106                        Ok(DatagramSocketRequest::Clone { request: req.request, control_handle })
38107                    }
38108                    0x5ac5d459ad7f657e => {
38109                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38110                        let mut req = fidl::new_empty!(
38111                            fidl::encoding::EmptyPayload,
38112                            fidl::encoding::DefaultFuchsiaResourceDialect
38113                        );
38114                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38115                        let control_handle =
38116                            DatagramSocketControlHandle { inner: this.inner.clone() };
38117                        Ok(DatagramSocketRequest::Close {
38118                            responder: DatagramSocketCloseResponder {
38119                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38120                                tx_id: header.tx_id,
38121                            },
38122                        })
38123                    }
38124                    0x2658edee9decfc06 => {
38125                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38126                        let mut req = fidl::new_empty!(
38127                            fidl::encoding::EmptyPayload,
38128                            fidl::encoding::DefaultFuchsiaResourceDialect
38129                        );
38130                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38131                        let control_handle =
38132                            DatagramSocketControlHandle { inner: this.inner.clone() };
38133                        Ok(DatagramSocketRequest::Query {
38134                            responder: DatagramSocketQueryResponder {
38135                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38136                                tx_id: header.tx_id,
38137                            },
38138                        })
38139                    }
38140                    0x1fd74ee8b9a4a876 => {
38141                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38142                        let mut req = fidl::new_empty!(
38143                            BaseSocketSetReuseAddressRequest,
38144                            fidl::encoding::DefaultFuchsiaResourceDialect
38145                        );
38146                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReuseAddressRequest>(&header, _body_bytes, handles, &mut req)?;
38147                        let control_handle =
38148                            DatagramSocketControlHandle { inner: this.inner.clone() };
38149                        Ok(DatagramSocketRequest::SetReuseAddress {
38150                            value: req.value,
38151
38152                            responder: DatagramSocketSetReuseAddressResponder {
38153                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38154                                tx_id: header.tx_id,
38155                            },
38156                        })
38157                    }
38158                    0x67b7206b8d1bc0a5 => {
38159                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38160                        let mut req = fidl::new_empty!(
38161                            fidl::encoding::EmptyPayload,
38162                            fidl::encoding::DefaultFuchsiaResourceDialect
38163                        );
38164                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38165                        let control_handle =
38166                            DatagramSocketControlHandle { inner: this.inner.clone() };
38167                        Ok(DatagramSocketRequest::GetReuseAddress {
38168                            responder: DatagramSocketGetReuseAddressResponder {
38169                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38170                                tx_id: header.tx_id,
38171                            },
38172                        })
38173                    }
38174                    0x5aad39b33e5f6ebb => {
38175                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38176                        let mut req = fidl::new_empty!(
38177                            fidl::encoding::EmptyPayload,
38178                            fidl::encoding::DefaultFuchsiaResourceDialect
38179                        );
38180                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38181                        let control_handle =
38182                            DatagramSocketControlHandle { inner: this.inner.clone() };
38183                        Ok(DatagramSocketRequest::GetError {
38184                            responder: DatagramSocketGetErrorResponder {
38185                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38186                                tx_id: header.tx_id,
38187                            },
38188                        })
38189                    }
38190                    0x6023e081ce3cd947 => {
38191                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38192                        let mut req = fidl::new_empty!(
38193                            BaseSocketSetBroadcastRequest,
38194                            fidl::encoding::DefaultFuchsiaResourceDialect
38195                        );
38196                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBroadcastRequest>(&header, _body_bytes, handles, &mut req)?;
38197                        let control_handle =
38198                            DatagramSocketControlHandle { inner: this.inner.clone() };
38199                        Ok(DatagramSocketRequest::SetBroadcast {
38200                            value: req.value,
38201
38202                            responder: DatagramSocketSetBroadcastResponder {
38203                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38204                                tx_id: header.tx_id,
38205                            },
38206                        })
38207                    }
38208                    0x68796fc556f9780d => {
38209                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38210                        let mut req = fidl::new_empty!(
38211                            fidl::encoding::EmptyPayload,
38212                            fidl::encoding::DefaultFuchsiaResourceDialect
38213                        );
38214                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38215                        let control_handle =
38216                            DatagramSocketControlHandle { inner: this.inner.clone() };
38217                        Ok(DatagramSocketRequest::GetBroadcast {
38218                            responder: DatagramSocketGetBroadcastResponder {
38219                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38220                                tx_id: header.tx_id,
38221                            },
38222                        })
38223                    }
38224                    0x756eac32d73a7a70 => {
38225                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38226                        let mut req = fidl::new_empty!(
38227                            BaseSocketSetSendBufferRequest,
38228                            fidl::encoding::DefaultFuchsiaResourceDialect
38229                        );
38230                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetSendBufferRequest>(&header, _body_bytes, handles, &mut req)?;
38231                        let control_handle =
38232                            DatagramSocketControlHandle { inner: this.inner.clone() };
38233                        Ok(DatagramSocketRequest::SetSendBuffer {
38234                            value_bytes: req.value_bytes,
38235
38236                            responder: DatagramSocketSetSendBufferResponder {
38237                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38238                                tx_id: header.tx_id,
38239                            },
38240                        })
38241                    }
38242                    0x78a52fd9c7b2410b => {
38243                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38244                        let mut req = fidl::new_empty!(
38245                            fidl::encoding::EmptyPayload,
38246                            fidl::encoding::DefaultFuchsiaResourceDialect
38247                        );
38248                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38249                        let control_handle =
38250                            DatagramSocketControlHandle { inner: this.inner.clone() };
38251                        Ok(DatagramSocketRequest::GetSendBuffer {
38252                            responder: DatagramSocketGetSendBufferResponder {
38253                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38254                                tx_id: header.tx_id,
38255                            },
38256                        })
38257                    }
38258                    0x6b0cf2f1919c7001 => {
38259                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38260                        let mut req = fidl::new_empty!(
38261                            BaseSocketSetReceiveBufferRequest,
38262                            fidl::encoding::DefaultFuchsiaResourceDialect
38263                        );
38264                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReceiveBufferRequest>(&header, _body_bytes, handles, &mut req)?;
38265                        let control_handle =
38266                            DatagramSocketControlHandle { inner: this.inner.clone() };
38267                        Ok(DatagramSocketRequest::SetReceiveBuffer {
38268                            value_bytes: req.value_bytes,
38269
38270                            responder: DatagramSocketSetReceiveBufferResponder {
38271                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38272                                tx_id: header.tx_id,
38273                            },
38274                        })
38275                    }
38276                    0x14c1a4b64f709e5c => {
38277                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38278                        let mut req = fidl::new_empty!(
38279                            fidl::encoding::EmptyPayload,
38280                            fidl::encoding::DefaultFuchsiaResourceDialect
38281                        );
38282                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38283                        let control_handle =
38284                            DatagramSocketControlHandle { inner: this.inner.clone() };
38285                        Ok(DatagramSocketRequest::GetReceiveBuffer {
38286                            responder: DatagramSocketGetReceiveBufferResponder {
38287                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38288                                tx_id: header.tx_id,
38289                            },
38290                        })
38291                    }
38292                    0x572df8f0b920d2c7 => {
38293                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38294                        let mut req = fidl::new_empty!(
38295                            BaseSocketSetKeepAliveRequest,
38296                            fidl::encoding::DefaultFuchsiaResourceDialect
38297                        );
38298                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetKeepAliveRequest>(&header, _body_bytes, handles, &mut req)?;
38299                        let control_handle =
38300                            DatagramSocketControlHandle { inner: this.inner.clone() };
38301                        Ok(DatagramSocketRequest::SetKeepAlive {
38302                            value: req.value,
38303
38304                            responder: DatagramSocketSetKeepAliveResponder {
38305                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38306                                tx_id: header.tx_id,
38307                            },
38308                        })
38309                    }
38310                    0x2dd29d3215f2c9d2 => {
38311                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38312                        let mut req = fidl::new_empty!(
38313                            fidl::encoding::EmptyPayload,
38314                            fidl::encoding::DefaultFuchsiaResourceDialect
38315                        );
38316                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38317                        let control_handle =
38318                            DatagramSocketControlHandle { inner: this.inner.clone() };
38319                        Ok(DatagramSocketRequest::GetKeepAlive {
38320                            responder: DatagramSocketGetKeepAliveResponder {
38321                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38322                                tx_id: header.tx_id,
38323                            },
38324                        })
38325                    }
38326                    0x3ecb49968bee439 => {
38327                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38328                        let mut req = fidl::new_empty!(
38329                            BaseSocketSetOutOfBandInlineRequest,
38330                            fidl::encoding::DefaultFuchsiaResourceDialect
38331                        );
38332                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetOutOfBandInlineRequest>(&header, _body_bytes, handles, &mut req)?;
38333                        let control_handle =
38334                            DatagramSocketControlHandle { inner: this.inner.clone() };
38335                        Ok(DatagramSocketRequest::SetOutOfBandInline {
38336                            value: req.value,
38337
38338                            responder: DatagramSocketSetOutOfBandInlineResponder {
38339                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38340                                tx_id: header.tx_id,
38341                            },
38342                        })
38343                    }
38344                    0x348c1ab3aeca1745 => {
38345                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38346                        let mut req = fidl::new_empty!(
38347                            fidl::encoding::EmptyPayload,
38348                            fidl::encoding::DefaultFuchsiaResourceDialect
38349                        );
38350                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38351                        let control_handle =
38352                            DatagramSocketControlHandle { inner: this.inner.clone() };
38353                        Ok(DatagramSocketRequest::GetOutOfBandInline {
38354                            responder: DatagramSocketGetOutOfBandInlineResponder {
38355                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38356                                tx_id: header.tx_id,
38357                            },
38358                        })
38359                    }
38360                    0x6bbf00c53a4c78c2 => {
38361                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38362                        let mut req = fidl::new_empty!(
38363                            BaseSocketSetNoCheckRequest,
38364                            fidl::encoding::DefaultFuchsiaResourceDialect
38365                        );
38366                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetNoCheckRequest>(&header, _body_bytes, handles, &mut req)?;
38367                        let control_handle =
38368                            DatagramSocketControlHandle { inner: this.inner.clone() };
38369                        Ok(DatagramSocketRequest::SetNoCheck {
38370                            value: req.value,
38371
38372                            responder: DatagramSocketSetNoCheckResponder {
38373                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38374                                tx_id: header.tx_id,
38375                            },
38376                        })
38377                    }
38378                    0x2cd4249286417694 => {
38379                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38380                        let mut req = fidl::new_empty!(
38381                            fidl::encoding::EmptyPayload,
38382                            fidl::encoding::DefaultFuchsiaResourceDialect
38383                        );
38384                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38385                        let control_handle =
38386                            DatagramSocketControlHandle { inner: this.inner.clone() };
38387                        Ok(DatagramSocketRequest::GetNoCheck {
38388                            responder: DatagramSocketGetNoCheckResponder {
38389                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38390                                tx_id: header.tx_id,
38391                            },
38392                        })
38393                    }
38394                    0x45386351246e998e => {
38395                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38396                        let mut req = fidl::new_empty!(
38397                            BaseSocketSetLingerRequest,
38398                            fidl::encoding::DefaultFuchsiaResourceDialect
38399                        );
38400                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetLingerRequest>(&header, _body_bytes, handles, &mut req)?;
38401                        let control_handle =
38402                            DatagramSocketControlHandle { inner: this.inner.clone() };
38403                        Ok(DatagramSocketRequest::SetLinger {
38404                            linger: req.linger,
38405                            length_secs: req.length_secs,
38406
38407                            responder: DatagramSocketSetLingerResponder {
38408                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38409                                tx_id: header.tx_id,
38410                            },
38411                        })
38412                    }
38413                    0x48eb20fc5ccb0e45 => {
38414                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38415                        let mut req = fidl::new_empty!(
38416                            fidl::encoding::EmptyPayload,
38417                            fidl::encoding::DefaultFuchsiaResourceDialect
38418                        );
38419                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38420                        let control_handle =
38421                            DatagramSocketControlHandle { inner: this.inner.clone() };
38422                        Ok(DatagramSocketRequest::GetLinger {
38423                            responder: DatagramSocketGetLingerResponder {
38424                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38425                                tx_id: header.tx_id,
38426                            },
38427                        })
38428                    }
38429                    0x24dd3e5cb36d9ccb => {
38430                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38431                        let mut req = fidl::new_empty!(
38432                            BaseSocketSetReusePortRequest,
38433                            fidl::encoding::DefaultFuchsiaResourceDialect
38434                        );
38435                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReusePortRequest>(&header, _body_bytes, handles, &mut req)?;
38436                        let control_handle =
38437                            DatagramSocketControlHandle { inner: this.inner.clone() };
38438                        Ok(DatagramSocketRequest::SetReusePort {
38439                            value: req.value,
38440
38441                            responder: DatagramSocketSetReusePortResponder {
38442                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38443                                tx_id: header.tx_id,
38444                            },
38445                        })
38446                    }
38447                    0x7a112c1ab54ff828 => {
38448                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38449                        let mut req = fidl::new_empty!(
38450                            fidl::encoding::EmptyPayload,
38451                            fidl::encoding::DefaultFuchsiaResourceDialect
38452                        );
38453                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38454                        let control_handle =
38455                            DatagramSocketControlHandle { inner: this.inner.clone() };
38456                        Ok(DatagramSocketRequest::GetReusePort {
38457                            responder: DatagramSocketGetReusePortResponder {
38458                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38459                                tx_id: header.tx_id,
38460                            },
38461                        })
38462                    }
38463                    0x67ce6db6c2ec8966 => {
38464                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38465                        let mut req = fidl::new_empty!(
38466                            fidl::encoding::EmptyPayload,
38467                            fidl::encoding::DefaultFuchsiaResourceDialect
38468                        );
38469                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38470                        let control_handle =
38471                            DatagramSocketControlHandle { inner: this.inner.clone() };
38472                        Ok(DatagramSocketRequest::GetAcceptConn {
38473                            responder: DatagramSocketGetAcceptConnResponder {
38474                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38475                                tx_id: header.tx_id,
38476                            },
38477                        })
38478                    }
38479                    0x2118b483f28aafc4 => {
38480                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38481                        let mut req = fidl::new_empty!(
38482                            BaseSocketSetBindToDeviceRequest,
38483                            fidl::encoding::DefaultFuchsiaResourceDialect
38484                        );
38485                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToDeviceRequest>(&header, _body_bytes, handles, &mut req)?;
38486                        let control_handle =
38487                            DatagramSocketControlHandle { inner: this.inner.clone() };
38488                        Ok(DatagramSocketRequest::SetBindToDevice {
38489                            value: req.value,
38490
38491                            responder: DatagramSocketSetBindToDeviceResponder {
38492                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38493                                tx_id: header.tx_id,
38494                            },
38495                        })
38496                    }
38497                    0x1ab1fbf0ef7906c8 => {
38498                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38499                        let mut req = fidl::new_empty!(
38500                            fidl::encoding::EmptyPayload,
38501                            fidl::encoding::DefaultFuchsiaResourceDialect
38502                        );
38503                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38504                        let control_handle =
38505                            DatagramSocketControlHandle { inner: this.inner.clone() };
38506                        Ok(DatagramSocketRequest::GetBindToDevice {
38507                            responder: DatagramSocketGetBindToDeviceResponder {
38508                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38509                                tx_id: header.tx_id,
38510                            },
38511                        })
38512                    }
38513                    0x6e387a0def00821 => {
38514                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38515                        let mut req = fidl::new_empty!(
38516                            BaseSocketSetBindToInterfaceIndexRequest,
38517                            fidl::encoding::DefaultFuchsiaResourceDialect
38518                        );
38519                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToInterfaceIndexRequest>(&header, _body_bytes, handles, &mut req)?;
38520                        let control_handle =
38521                            DatagramSocketControlHandle { inner: this.inner.clone() };
38522                        Ok(DatagramSocketRequest::SetBindToInterfaceIndex {
38523                            value: req.value,
38524
38525                            responder: DatagramSocketSetBindToInterfaceIndexResponder {
38526                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38527                                tx_id: header.tx_id,
38528                            },
38529                        })
38530                    }
38531                    0x59c31dd3e3078295 => {
38532                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38533                        let mut req = fidl::new_empty!(
38534                            fidl::encoding::EmptyPayload,
38535                            fidl::encoding::DefaultFuchsiaResourceDialect
38536                        );
38537                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38538                        let control_handle =
38539                            DatagramSocketControlHandle { inner: this.inner.clone() };
38540                        Ok(DatagramSocketRequest::GetBindToInterfaceIndex {
38541                            responder: DatagramSocketGetBindToInterfaceIndexResponder {
38542                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38543                                tx_id: header.tx_id,
38544                            },
38545                        })
38546                    }
38547                    0x285d6516c263d839 => {
38548                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38549                        let mut req = fidl::new_empty!(
38550                            BaseSocketSetTimestampRequest,
38551                            fidl::encoding::DefaultFuchsiaResourceDialect
38552                        );
38553                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetTimestampRequest>(&header, _body_bytes, handles, &mut req)?;
38554                        let control_handle =
38555                            DatagramSocketControlHandle { inner: this.inner.clone() };
38556                        Ok(DatagramSocketRequest::SetTimestamp {
38557                            value: req.value,
38558
38559                            responder: DatagramSocketSetTimestampResponder {
38560                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38561                                tx_id: header.tx_id,
38562                            },
38563                        })
38564                    }
38565                    0x49f2fffbbcc2bd27 => {
38566                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38567                        let mut req = fidl::new_empty!(
38568                            fidl::encoding::EmptyPayload,
38569                            fidl::encoding::DefaultFuchsiaResourceDialect
38570                        );
38571                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38572                        let control_handle =
38573                            DatagramSocketControlHandle { inner: this.inner.clone() };
38574                        Ok(DatagramSocketRequest::GetTimestamp {
38575                            responder: DatagramSocketGetTimestampResponder {
38576                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38577                                tx_id: header.tx_id,
38578                            },
38579                        })
38580                    }
38581                    0x6ead6de09f653236 => {
38582                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38583                        let mut req = fidl::new_empty!(
38584                            BaseSocketSetMarkRequest,
38585                            fidl::encoding::DefaultFuchsiaResourceDialect
38586                        );
38587                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
38588                        let control_handle =
38589                            DatagramSocketControlHandle { inner: this.inner.clone() };
38590                        Ok(DatagramSocketRequest::SetMark {
38591                            domain: req.domain,
38592                            mark: req.mark,
38593
38594                            responder: DatagramSocketSetMarkResponder {
38595                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38596                                tx_id: header.tx_id,
38597                            },
38598                        })
38599                    }
38600                    0x57a2752c61d93d47 => {
38601                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38602                        let mut req = fidl::new_empty!(
38603                            BaseSocketGetMarkRequest,
38604                            fidl::encoding::DefaultFuchsiaResourceDialect
38605                        );
38606                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketGetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
38607                        let control_handle =
38608                            DatagramSocketControlHandle { inner: this.inner.clone() };
38609                        Ok(DatagramSocketRequest::GetMark {
38610                            domain: req.domain,
38611
38612                            responder: DatagramSocketGetMarkResponder {
38613                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38614                                tx_id: header.tx_id,
38615                            },
38616                        })
38617                    }
38618                    0x4bc6400ae92125d => {
38619                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38620                        let mut req = fidl::new_empty!(
38621                            BaseNetworkSocketBindRequest,
38622                            fidl::encoding::DefaultFuchsiaResourceDialect
38623                        );
38624                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketBindRequest>(&header, _body_bytes, handles, &mut req)?;
38625                        let control_handle =
38626                            DatagramSocketControlHandle { inner: this.inner.clone() };
38627                        Ok(DatagramSocketRequest::Bind {
38628                            addr: req.addr,
38629
38630                            responder: DatagramSocketBindResponder {
38631                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38632                                tx_id: header.tx_id,
38633                            },
38634                        })
38635                    }
38636                    0x5f05f19bfdd38871 => {
38637                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38638                        let mut req = fidl::new_empty!(
38639                            BaseNetworkSocketConnectRequest,
38640                            fidl::encoding::DefaultFuchsiaResourceDialect
38641                        );
38642                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketConnectRequest>(&header, _body_bytes, handles, &mut req)?;
38643                        let control_handle =
38644                            DatagramSocketControlHandle { inner: this.inner.clone() };
38645                        Ok(DatagramSocketRequest::Connect {
38646                            addr: req.addr,
38647
38648                            responder: DatagramSocketConnectResponder {
38649                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38650                                tx_id: header.tx_id,
38651                            },
38652                        })
38653                    }
38654                    0x74e63b91f7b29b2 => {
38655                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38656                        let mut req = fidl::new_empty!(
38657                            fidl::encoding::EmptyPayload,
38658                            fidl::encoding::DefaultFuchsiaResourceDialect
38659                        );
38660                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38661                        let control_handle =
38662                            DatagramSocketControlHandle { inner: this.inner.clone() };
38663                        Ok(DatagramSocketRequest::Disconnect {
38664                            responder: DatagramSocketDisconnectResponder {
38665                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38666                                tx_id: header.tx_id,
38667                            },
38668                        })
38669                    }
38670                    0x475f23f84a1a4f85 => {
38671                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38672                        let mut req = fidl::new_empty!(
38673                            fidl::encoding::EmptyPayload,
38674                            fidl::encoding::DefaultFuchsiaResourceDialect
38675                        );
38676                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38677                        let control_handle =
38678                            DatagramSocketControlHandle { inner: this.inner.clone() };
38679                        Ok(DatagramSocketRequest::GetSockName {
38680                            responder: DatagramSocketGetSockNameResponder {
38681                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38682                                tx_id: header.tx_id,
38683                            },
38684                        })
38685                    }
38686                    0x1ffecf4bd5b6432e => {
38687                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38688                        let mut req = fidl::new_empty!(
38689                            fidl::encoding::EmptyPayload,
38690                            fidl::encoding::DefaultFuchsiaResourceDialect
38691                        );
38692                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38693                        let control_handle =
38694                            DatagramSocketControlHandle { inner: this.inner.clone() };
38695                        Ok(DatagramSocketRequest::GetPeerName {
38696                            responder: DatagramSocketGetPeerNameResponder {
38697                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38698                                tx_id: header.tx_id,
38699                            },
38700                        })
38701                    }
38702                    0x247f38b6db68c336 => {
38703                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38704                        let mut req = fidl::new_empty!(
38705                            BaseNetworkSocketShutdownRequest,
38706                            fidl::encoding::DefaultFuchsiaResourceDialect
38707                        );
38708                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketShutdownRequest>(&header, _body_bytes, handles, &mut req)?;
38709                        let control_handle =
38710                            DatagramSocketControlHandle { inner: this.inner.clone() };
38711                        Ok(DatagramSocketRequest::Shutdown {
38712                            mode: req.mode,
38713
38714                            responder: DatagramSocketShutdownResponder {
38715                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38716                                tx_id: header.tx_id,
38717                            },
38718                        })
38719                    }
38720                    0x995c600475b6d46 => {
38721                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38722                        let mut req = fidl::new_empty!(
38723                            BaseNetworkSocketSetIpTypeOfServiceRequest,
38724                            fidl::encoding::DefaultFuchsiaResourceDialect
38725                        );
38726                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
38727                        let control_handle =
38728                            DatagramSocketControlHandle { inner: this.inner.clone() };
38729                        Ok(DatagramSocketRequest::SetIpTypeOfService {
38730                            value: req.value,
38731
38732                            responder: DatagramSocketSetIpTypeOfServiceResponder {
38733                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38734                                tx_id: header.tx_id,
38735                            },
38736                        })
38737                    }
38738                    0x3814a04259f75fcb => {
38739                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38740                        let mut req = fidl::new_empty!(
38741                            fidl::encoding::EmptyPayload,
38742                            fidl::encoding::DefaultFuchsiaResourceDialect
38743                        );
38744                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38745                        let control_handle =
38746                            DatagramSocketControlHandle { inner: this.inner.clone() };
38747                        Ok(DatagramSocketRequest::GetIpTypeOfService {
38748                            responder: DatagramSocketGetIpTypeOfServiceResponder {
38749                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38750                                tx_id: header.tx_id,
38751                            },
38752                        })
38753                    }
38754                    0x29e2424b433ae1ef => {
38755                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38756                        let mut req = fidl::new_empty!(
38757                            BaseNetworkSocketSetIpTtlRequest,
38758                            fidl::encoding::DefaultFuchsiaResourceDialect
38759                        );
38760                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTtlRequest>(&header, _body_bytes, handles, &mut req)?;
38761                        let control_handle =
38762                            DatagramSocketControlHandle { inner: this.inner.clone() };
38763                        Ok(DatagramSocketRequest::SetIpTtl {
38764                            value: req.value,
38765
38766                            responder: DatagramSocketSetIpTtlResponder {
38767                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38768                                tx_id: header.tx_id,
38769                            },
38770                        })
38771                    }
38772                    0x47e47fa1f24da471 => {
38773                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38774                        let mut req = fidl::new_empty!(
38775                            fidl::encoding::EmptyPayload,
38776                            fidl::encoding::DefaultFuchsiaResourceDialect
38777                        );
38778                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38779                        let control_handle =
38780                            DatagramSocketControlHandle { inner: this.inner.clone() };
38781                        Ok(DatagramSocketRequest::GetIpTtl {
38782                            responder: DatagramSocketGetIpTtlResponder {
38783                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38784                                tx_id: header.tx_id,
38785                            },
38786                        })
38787                    }
38788                    0x392d16bee20c0e16 => {
38789                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38790                        let mut req = fidl::new_empty!(
38791                            BaseNetworkSocketSetIpPacketInfoRequest,
38792                            fidl::encoding::DefaultFuchsiaResourceDialect
38793                        );
38794                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpPacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
38795                        let control_handle =
38796                            DatagramSocketControlHandle { inner: this.inner.clone() };
38797                        Ok(DatagramSocketRequest::SetIpPacketInfo {
38798                            value: req.value,
38799
38800                            responder: DatagramSocketSetIpPacketInfoResponder {
38801                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38802                                tx_id: header.tx_id,
38803                            },
38804                        })
38805                    }
38806                    0x54b505f242280740 => {
38807                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38808                        let mut req = fidl::new_empty!(
38809                            fidl::encoding::EmptyPayload,
38810                            fidl::encoding::DefaultFuchsiaResourceDialect
38811                        );
38812                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38813                        let control_handle =
38814                            DatagramSocketControlHandle { inner: this.inner.clone() };
38815                        Ok(DatagramSocketRequest::GetIpPacketInfo {
38816                            responder: DatagramSocketGetIpPacketInfoResponder {
38817                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38818                                tx_id: header.tx_id,
38819                            },
38820                        })
38821                    }
38822                    0x6c4f6714995f84ef => {
38823                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38824                        let mut req = fidl::new_empty!(
38825                            BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
38826                            fidl::encoding::DefaultFuchsiaResourceDialect
38827                        );
38828                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
38829                        let control_handle =
38830                            DatagramSocketControlHandle { inner: this.inner.clone() };
38831                        Ok(DatagramSocketRequest::SetIpReceiveTypeOfService {
38832                            value: req.value,
38833
38834                            responder: DatagramSocketSetIpReceiveTypeOfServiceResponder {
38835                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38836                                tx_id: header.tx_id,
38837                            },
38838                        })
38839                    }
38840                    0x4158ba7dc2795960 => {
38841                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38842                        let mut req = fidl::new_empty!(
38843                            fidl::encoding::EmptyPayload,
38844                            fidl::encoding::DefaultFuchsiaResourceDialect
38845                        );
38846                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38847                        let control_handle =
38848                            DatagramSocketControlHandle { inner: this.inner.clone() };
38849                        Ok(DatagramSocketRequest::GetIpReceiveTypeOfService {
38850                            responder: DatagramSocketGetIpReceiveTypeOfServiceResponder {
38851                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38852                                tx_id: header.tx_id,
38853                            },
38854                        })
38855                    }
38856                    0x46f15be0ce0ab82b => {
38857                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38858                        let mut req = fidl::new_empty!(
38859                            BaseNetworkSocketSetIpReceiveTtlRequest,
38860                            fidl::encoding::DefaultFuchsiaResourceDialect
38861                        );
38862                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveTtlRequest>(&header, _body_bytes, handles, &mut req)?;
38863                        let control_handle =
38864                            DatagramSocketControlHandle { inner: this.inner.clone() };
38865                        Ok(DatagramSocketRequest::SetIpReceiveTtl {
38866                            value: req.value,
38867
38868                            responder: DatagramSocketSetIpReceiveTtlResponder {
38869                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38870                                tx_id: header.tx_id,
38871                            },
38872                        })
38873                    }
38874                    0x678ddd5a5dfa2eb5 => {
38875                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38876                        let mut req = fidl::new_empty!(
38877                            fidl::encoding::EmptyPayload,
38878                            fidl::encoding::DefaultFuchsiaResourceDialect
38879                        );
38880                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38881                        let control_handle =
38882                            DatagramSocketControlHandle { inner: this.inner.clone() };
38883                        Ok(DatagramSocketRequest::GetIpReceiveTtl {
38884                            responder: DatagramSocketGetIpReceiveTtlResponder {
38885                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38886                                tx_id: header.tx_id,
38887                            },
38888                        })
38889                    }
38890                    0x752fbfa9b12befe => {
38891                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38892                        let mut req = fidl::new_empty!(
38893                            BaseNetworkSocketSetIpMulticastInterfaceRequest,
38894                            fidl::encoding::DefaultFuchsiaResourceDialect
38895                        );
38896                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
38897                        let control_handle =
38898                            DatagramSocketControlHandle { inner: this.inner.clone() };
38899                        Ok(DatagramSocketRequest::SetIpMulticastInterface {
38900                            iface: req.iface,
38901                            address: req.address,
38902
38903                            responder: DatagramSocketSetIpMulticastInterfaceResponder {
38904                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38905                                tx_id: header.tx_id,
38906                            },
38907                        })
38908                    }
38909                    0x320bd14c4df046c4 => {
38910                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38911                        let mut req = fidl::new_empty!(
38912                            fidl::encoding::EmptyPayload,
38913                            fidl::encoding::DefaultFuchsiaResourceDialect
38914                        );
38915                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38916                        let control_handle =
38917                            DatagramSocketControlHandle { inner: this.inner.clone() };
38918                        Ok(DatagramSocketRequest::GetIpMulticastInterface {
38919                            responder: DatagramSocketGetIpMulticastInterfaceResponder {
38920                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38921                                tx_id: header.tx_id,
38922                            },
38923                        })
38924                    }
38925                    0x63134d53772916a1 => {
38926                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38927                        let mut req = fidl::new_empty!(
38928                            BaseNetworkSocketSetIpMulticastTtlRequest,
38929                            fidl::encoding::DefaultFuchsiaResourceDialect
38930                        );
38931                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastTtlRequest>(&header, _body_bytes, handles, &mut req)?;
38932                        let control_handle =
38933                            DatagramSocketControlHandle { inner: this.inner.clone() };
38934                        Ok(DatagramSocketRequest::SetIpMulticastTtl {
38935                            value: req.value,
38936
38937                            responder: DatagramSocketSetIpMulticastTtlResponder {
38938                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38939                                tx_id: header.tx_id,
38940                            },
38941                        })
38942                    }
38943                    0x4665cd378f39e1a => {
38944                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38945                        let mut req = fidl::new_empty!(
38946                            fidl::encoding::EmptyPayload,
38947                            fidl::encoding::DefaultFuchsiaResourceDialect
38948                        );
38949                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38950                        let control_handle =
38951                            DatagramSocketControlHandle { inner: this.inner.clone() };
38952                        Ok(DatagramSocketRequest::GetIpMulticastTtl {
38953                            responder: DatagramSocketGetIpMulticastTtlResponder {
38954                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38955                                tx_id: header.tx_id,
38956                            },
38957                        })
38958                    }
38959                    0x20c55c11f00943ea => {
38960                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38961                        let mut req = fidl::new_empty!(
38962                            BaseNetworkSocketSetIpMulticastLoopbackRequest,
38963                            fidl::encoding::DefaultFuchsiaResourceDialect
38964                        );
38965                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
38966                        let control_handle =
38967                            DatagramSocketControlHandle { inner: this.inner.clone() };
38968                        Ok(DatagramSocketRequest::SetIpMulticastLoopback {
38969                            value: req.value,
38970
38971                            responder: DatagramSocketSetIpMulticastLoopbackResponder {
38972                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38973                                tx_id: header.tx_id,
38974                            },
38975                        })
38976                    }
38977                    0x3b6b26ff558298f2 => {
38978                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38979                        let mut req = fidl::new_empty!(
38980                            fidl::encoding::EmptyPayload,
38981                            fidl::encoding::DefaultFuchsiaResourceDialect
38982                        );
38983                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
38984                        let control_handle =
38985                            DatagramSocketControlHandle { inner: this.inner.clone() };
38986                        Ok(DatagramSocketRequest::GetIpMulticastLoopback {
38987                            responder: DatagramSocketGetIpMulticastLoopbackResponder {
38988                                control_handle: std::mem::ManuallyDrop::new(control_handle),
38989                                tx_id: header.tx_id,
38990                            },
38991                        })
38992                    }
38993                    0x76bc7df115a3b4d0 => {
38994                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
38995                        let mut req = fidl::new_empty!(
38996                            BaseNetworkSocketAddIpMembershipRequest,
38997                            fidl::encoding::DefaultFuchsiaResourceDialect
38998                        );
38999                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketAddIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
39000                        let control_handle =
39001                            DatagramSocketControlHandle { inner: this.inner.clone() };
39002                        Ok(DatagramSocketRequest::AddIpMembership {
39003                            membership: req.membership,
39004
39005                            responder: DatagramSocketAddIpMembershipResponder {
39006                                control_handle: std::mem::ManuallyDrop::new(control_handle),
39007                                tx_id: header.tx_id,
39008                            },
39009                        })
39010                    }
39011                    0x2888f3099188d03 => {
39012                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39013                        let mut req = fidl::new_empty!(
39014                            BaseNetworkSocketDropIpMembershipRequest,
39015                            fidl::encoding::DefaultFuchsiaResourceDialect
39016                        );
39017                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketDropIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
39018                        let control_handle =
39019                            DatagramSocketControlHandle { inner: this.inner.clone() };
39020                        Ok(DatagramSocketRequest::DropIpMembership {
39021                            membership: req.membership,
39022
39023                            responder: DatagramSocketDropIpMembershipResponder {
39024                                control_handle: std::mem::ManuallyDrop::new(control_handle),
39025                                tx_id: header.tx_id,
39026                            },
39027                        })
39028                    }
39029                    0x1ae532b0c066e3a0 => {
39030                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39031                        let mut req = fidl::new_empty!(
39032                            BaseNetworkSocketSetIpTransparentRequest,
39033                            fidl::encoding::DefaultFuchsiaResourceDialect
39034                        );
39035                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTransparentRequest>(&header, _body_bytes, handles, &mut req)?;
39036                        let control_handle =
39037                            DatagramSocketControlHandle { inner: this.inner.clone() };
39038                        Ok(DatagramSocketRequest::SetIpTransparent {
39039                            value: req.value,
39040
39041                            responder: DatagramSocketSetIpTransparentResponder {
39042                                control_handle: std::mem::ManuallyDrop::new(control_handle),
39043                                tx_id: header.tx_id,
39044                            },
39045                        })
39046                    }
39047                    0x51d43695962ebfb5 => {
39048                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39049                        let mut req = fidl::new_empty!(
39050                            fidl::encoding::EmptyPayload,
39051                            fidl::encoding::DefaultFuchsiaResourceDialect
39052                        );
39053                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
39054                        let control_handle =
39055                            DatagramSocketControlHandle { inner: this.inner.clone() };
39056                        Ok(DatagramSocketRequest::GetIpTransparent {
39057                            responder: DatagramSocketGetIpTransparentResponder {
39058                                control_handle: std::mem::ManuallyDrop::new(control_handle),
39059                                tx_id: header.tx_id,
39060                            },
39061                        })
39062                    }
39063                    0x4722b4ce52f7840 => {
39064                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39065                        let mut req = fidl::new_empty!(
39066                            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
39067                            fidl::encoding::DefaultFuchsiaResourceDialect
39068                        );
39069                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest>(&header, _body_bytes, handles, &mut req)?;
39070                        let control_handle =
39071                            DatagramSocketControlHandle { inner: this.inner.clone() };
39072                        Ok(DatagramSocketRequest::SetIpReceiveOriginalDestinationAddress {
39073                            value: req.value,
39074
39075                            responder:
39076                                DatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
39077                                    control_handle: std::mem::ManuallyDrop::new(control_handle),
39078                                    tx_id: header.tx_id,
39079                                },
39080                        })
39081                    }
39082                    0x2a0e7dc5d6bfdfe9 => {
39083                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39084                        let mut req = fidl::new_empty!(
39085                            fidl::encoding::EmptyPayload,
39086                            fidl::encoding::DefaultFuchsiaResourceDialect
39087                        );
39088                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
39089                        let control_handle =
39090                            DatagramSocketControlHandle { inner: this.inner.clone() };
39091                        Ok(DatagramSocketRequest::GetIpReceiveOriginalDestinationAddress {
39092                            responder:
39093                                DatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
39094                                    control_handle: std::mem::ManuallyDrop::new(control_handle),
39095                                    tx_id: header.tx_id,
39096                                },
39097                        })
39098                    }
39099                    0x7c94727acb4ea4b3 => {
39100                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39101                        let mut req = fidl::new_empty!(
39102                            BaseNetworkSocketAddIpv6MembershipRequest,
39103                            fidl::encoding::DefaultFuchsiaResourceDialect
39104                        );
39105                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketAddIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
39106                        let control_handle =
39107                            DatagramSocketControlHandle { inner: this.inner.clone() };
39108                        Ok(DatagramSocketRequest::AddIpv6Membership {
39109                            membership: req.membership,
39110
39111                            responder: DatagramSocketAddIpv6MembershipResponder {
39112                                control_handle: std::mem::ManuallyDrop::new(control_handle),
39113                                tx_id: header.tx_id,
39114                            },
39115                        })
39116                    }
39117                    0x42104c70ccaba304 => {
39118                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39119                        let mut req = fidl::new_empty!(
39120                            BaseNetworkSocketDropIpv6MembershipRequest,
39121                            fidl::encoding::DefaultFuchsiaResourceDialect
39122                        );
39123                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketDropIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
39124                        let control_handle =
39125                            DatagramSocketControlHandle { inner: this.inner.clone() };
39126                        Ok(DatagramSocketRequest::DropIpv6Membership {
39127                            membership: req.membership,
39128
39129                            responder: DatagramSocketDropIpv6MembershipResponder {
39130                                control_handle: std::mem::ManuallyDrop::new(control_handle),
39131                                tx_id: header.tx_id,
39132                            },
39133                        })
39134                    }
39135                    0x135f76db3774ab3b => {
39136                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39137                        let mut req = fidl::new_empty!(
39138                            BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
39139                            fidl::encoding::DefaultFuchsiaResourceDialect
39140                        );
39141                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
39142                        let control_handle =
39143                            DatagramSocketControlHandle { inner: this.inner.clone() };
39144                        Ok(DatagramSocketRequest::SetIpv6MulticastInterface {
39145                            value: req.value,
39146
39147                            responder: DatagramSocketSetIpv6MulticastInterfaceResponder {
39148                                control_handle: std::mem::ManuallyDrop::new(control_handle),
39149                                tx_id: header.tx_id,
39150                            },
39151                        })
39152                    }
39153                    0x1f26fcdd348f1882 => {
39154                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39155                        let mut req = fidl::new_empty!(
39156                            fidl::encoding::EmptyPayload,
39157                            fidl::encoding::DefaultFuchsiaResourceDialect
39158                        );
39159                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
39160                        let control_handle =
39161                            DatagramSocketControlHandle { inner: this.inner.clone() };
39162                        Ok(DatagramSocketRequest::GetIpv6MulticastInterface {
39163                            responder: DatagramSocketGetIpv6MulticastInterfaceResponder {
39164                                control_handle: std::mem::ManuallyDrop::new(control_handle),
39165                                tx_id: header.tx_id,
39166                            },
39167                        })
39168                    }
39169                    0x157d51e98f462859 => {
39170                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39171                        let mut req = fidl::new_empty!(
39172                            BaseNetworkSocketSetIpv6UnicastHopsRequest,
39173                            fidl::encoding::DefaultFuchsiaResourceDialect
39174                        );
39175                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6UnicastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
39176                        let control_handle =
39177                            DatagramSocketControlHandle { inner: this.inner.clone() };
39178                        Ok(DatagramSocketRequest::SetIpv6UnicastHops {
39179                            value: req.value,
39180
39181                            responder: DatagramSocketSetIpv6UnicastHopsResponder {
39182                                control_handle: std::mem::ManuallyDrop::new(control_handle),
39183                                tx_id: header.tx_id,
39184                            },
39185                        })
39186                    }
39187                    0x21f4641cad8bd8d2 => {
39188                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39189                        let mut req = fidl::new_empty!(
39190                            fidl::encoding::EmptyPayload,
39191                            fidl::encoding::DefaultFuchsiaResourceDialect
39192                        );
39193                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
39194                        let control_handle =
39195                            DatagramSocketControlHandle { inner: this.inner.clone() };
39196                        Ok(DatagramSocketRequest::GetIpv6UnicastHops {
39197                            responder: DatagramSocketGetIpv6UnicastHopsResponder {
39198                                control_handle: std::mem::ManuallyDrop::new(control_handle),
39199                                tx_id: header.tx_id,
39200                            },
39201                        })
39202                    }
39203                    0x5c24808ed2e84a1e => {
39204                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39205                        let mut req = fidl::new_empty!(
39206                            BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
39207                            fidl::encoding::DefaultFuchsiaResourceDialect
39208                        );
39209                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceiveHopLimitRequest>(&header, _body_bytes, handles, &mut req)?;
39210                        let control_handle =
39211                            DatagramSocketControlHandle { inner: this.inner.clone() };
39212                        Ok(DatagramSocketRequest::SetIpv6ReceiveHopLimit {
39213                            value: req.value,
39214
39215                            responder: DatagramSocketSetIpv6ReceiveHopLimitResponder {
39216                                control_handle: std::mem::ManuallyDrop::new(control_handle),
39217                                tx_id: header.tx_id,
39218                            },
39219                        })
39220                    }
39221                    0x341e06689885b4c0 => {
39222                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39223                        let mut req = fidl::new_empty!(
39224                            fidl::encoding::EmptyPayload,
39225                            fidl::encoding::DefaultFuchsiaResourceDialect
39226                        );
39227                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
39228                        let control_handle =
39229                            DatagramSocketControlHandle { inner: this.inner.clone() };
39230                        Ok(DatagramSocketRequest::GetIpv6ReceiveHopLimit {
39231                            responder: DatagramSocketGetIpv6ReceiveHopLimitResponder {
39232                                control_handle: std::mem::ManuallyDrop::new(control_handle),
39233                                tx_id: header.tx_id,
39234                            },
39235                        })
39236                    }
39237                    0x25b9cd4d181f82c1 => {
39238                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39239                        let mut req = fidl::new_empty!(
39240                            BaseNetworkSocketSetIpv6MulticastHopsRequest,
39241                            fidl::encoding::DefaultFuchsiaResourceDialect
39242                        );
39243                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
39244                        let control_handle =
39245                            DatagramSocketControlHandle { inner: this.inner.clone() };
39246                        Ok(DatagramSocketRequest::SetIpv6MulticastHops {
39247                            value: req.value,
39248
39249                            responder: DatagramSocketSetIpv6MulticastHopsResponder {
39250                                control_handle: std::mem::ManuallyDrop::new(control_handle),
39251                                tx_id: header.tx_id,
39252                            },
39253                        })
39254                    }
39255                    0x52916948a365012a => {
39256                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39257                        let mut req = fidl::new_empty!(
39258                            fidl::encoding::EmptyPayload,
39259                            fidl::encoding::DefaultFuchsiaResourceDialect
39260                        );
39261                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
39262                        let control_handle =
39263                            DatagramSocketControlHandle { inner: this.inner.clone() };
39264                        Ok(DatagramSocketRequest::GetIpv6MulticastHops {
39265                            responder: DatagramSocketGetIpv6MulticastHopsResponder {
39266                                control_handle: std::mem::ManuallyDrop::new(control_handle),
39267                                tx_id: header.tx_id,
39268                            },
39269                        })
39270                    }
39271                    0x55701c409ff41b40 => {
39272                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39273                        let mut req = fidl::new_empty!(
39274                            BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
39275                            fidl::encoding::DefaultFuchsiaResourceDialect
39276                        );
39277                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
39278                        let control_handle =
39279                            DatagramSocketControlHandle { inner: this.inner.clone() };
39280                        Ok(DatagramSocketRequest::SetIpv6MulticastLoopback {
39281                            value: req.value,
39282
39283                            responder: DatagramSocketSetIpv6MulticastLoopbackResponder {
39284                                control_handle: std::mem::ManuallyDrop::new(control_handle),
39285                                tx_id: header.tx_id,
39286                            },
39287                        })
39288                    }
39289                    0x4415b701fde319c3 => {
39290                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39291                        let mut req = fidl::new_empty!(
39292                            fidl::encoding::EmptyPayload,
39293                            fidl::encoding::DefaultFuchsiaResourceDialect
39294                        );
39295                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
39296                        let control_handle =
39297                            DatagramSocketControlHandle { inner: this.inner.clone() };
39298                        Ok(DatagramSocketRequest::GetIpv6MulticastLoopback {
39299                            responder: DatagramSocketGetIpv6MulticastLoopbackResponder {
39300                                control_handle: std::mem::ManuallyDrop::new(control_handle),
39301                                tx_id: header.tx_id,
39302                            },
39303                        })
39304                    }
39305                    0x4873f1364758cbba => {
39306                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39307                        let mut req = fidl::new_empty!(
39308                            BaseNetworkSocketSetIpv6OnlyRequest,
39309                            fidl::encoding::DefaultFuchsiaResourceDialect
39310                        );
39311                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6OnlyRequest>(&header, _body_bytes, handles, &mut req)?;
39312                        let control_handle =
39313                            DatagramSocketControlHandle { inner: this.inner.clone() };
39314                        Ok(DatagramSocketRequest::SetIpv6Only {
39315                            value: req.value,
39316
39317                            responder: DatagramSocketSetIpv6OnlyResponder {
39318                                control_handle: std::mem::ManuallyDrop::new(control_handle),
39319                                tx_id: header.tx_id,
39320                            },
39321                        })
39322                    }
39323                    0x4aa3340a1a26b89c => {
39324                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39325                        let mut req = fidl::new_empty!(
39326                            fidl::encoding::EmptyPayload,
39327                            fidl::encoding::DefaultFuchsiaResourceDialect
39328                        );
39329                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
39330                        let control_handle =
39331                            DatagramSocketControlHandle { inner: this.inner.clone() };
39332                        Ok(DatagramSocketRequest::GetIpv6Only {
39333                            responder: DatagramSocketGetIpv6OnlyResponder {
39334                                control_handle: std::mem::ManuallyDrop::new(control_handle),
39335                                tx_id: header.tx_id,
39336                            },
39337                        })
39338                    }
39339                    0x58f07c8788d099a0 => {
39340                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39341                        let mut req = fidl::new_empty!(
39342                            BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
39343                            fidl::encoding::DefaultFuchsiaResourceDialect
39344                        );
39345                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
39346                        let control_handle =
39347                            DatagramSocketControlHandle { inner: this.inner.clone() };
39348                        Ok(DatagramSocketRequest::SetIpv6ReceiveTrafficClass {
39349                            value: req.value,
39350
39351                            responder: DatagramSocketSetIpv6ReceiveTrafficClassResponder {
39352                                control_handle: std::mem::ManuallyDrop::new(control_handle),
39353                                tx_id: header.tx_id,
39354                            },
39355                        })
39356                    }
39357                    0x2e334df1da553ffa => {
39358                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39359                        let mut req = fidl::new_empty!(
39360                            fidl::encoding::EmptyPayload,
39361                            fidl::encoding::DefaultFuchsiaResourceDialect
39362                        );
39363                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
39364                        let control_handle =
39365                            DatagramSocketControlHandle { inner: this.inner.clone() };
39366                        Ok(DatagramSocketRequest::GetIpv6ReceiveTrafficClass {
39367                            responder: DatagramSocketGetIpv6ReceiveTrafficClassResponder {
39368                                control_handle: std::mem::ManuallyDrop::new(control_handle),
39369                                tx_id: header.tx_id,
39370                            },
39371                        })
39372                    }
39373                    0x6af077800c5a0b4f => {
39374                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39375                        let mut req = fidl::new_empty!(
39376                            BaseNetworkSocketSetIpv6TrafficClassRequest,
39377                            fidl::encoding::DefaultFuchsiaResourceDialect
39378                        );
39379                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6TrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
39380                        let control_handle =
39381                            DatagramSocketControlHandle { inner: this.inner.clone() };
39382                        Ok(DatagramSocketRequest::SetIpv6TrafficClass {
39383                            value: req.value,
39384
39385                            responder: DatagramSocketSetIpv6TrafficClassResponder {
39386                                control_handle: std::mem::ManuallyDrop::new(control_handle),
39387                                tx_id: header.tx_id,
39388                            },
39389                        })
39390                    }
39391                    0x6baf6eed8fc2f04 => {
39392                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39393                        let mut req = fidl::new_empty!(
39394                            fidl::encoding::EmptyPayload,
39395                            fidl::encoding::DefaultFuchsiaResourceDialect
39396                        );
39397                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
39398                        let control_handle =
39399                            DatagramSocketControlHandle { inner: this.inner.clone() };
39400                        Ok(DatagramSocketRequest::GetIpv6TrafficClass {
39401                            responder: DatagramSocketGetIpv6TrafficClassResponder {
39402                                control_handle: std::mem::ManuallyDrop::new(control_handle),
39403                                tx_id: header.tx_id,
39404                            },
39405                        })
39406                    }
39407                    0x19259775b1a92768 => {
39408                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39409                        let mut req = fidl::new_empty!(
39410                            BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
39411                            fidl::encoding::DefaultFuchsiaResourceDialect
39412                        );
39413                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceivePacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
39414                        let control_handle =
39415                            DatagramSocketControlHandle { inner: this.inner.clone() };
39416                        Ok(DatagramSocketRequest::SetIpv6ReceivePacketInfo {
39417                            value: req.value,
39418
39419                            responder: DatagramSocketSetIpv6ReceivePacketInfoResponder {
39420                                control_handle: std::mem::ManuallyDrop::new(control_handle),
39421                                tx_id: header.tx_id,
39422                            },
39423                        })
39424                    }
39425                    0x7acd4a2775baec75 => {
39426                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39427                        let mut req = fidl::new_empty!(
39428                            fidl::encoding::EmptyPayload,
39429                            fidl::encoding::DefaultFuchsiaResourceDialect
39430                        );
39431                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
39432                        let control_handle =
39433                            DatagramSocketControlHandle { inner: this.inner.clone() };
39434                        Ok(DatagramSocketRequest::GetIpv6ReceivePacketInfo {
39435                            responder: DatagramSocketGetIpv6ReceivePacketInfoResponder {
39436                                control_handle: std::mem::ManuallyDrop::new(control_handle),
39437                                tx_id: header.tx_id,
39438                            },
39439                        })
39440                    }
39441                    0x38bf28f0dafdbac0 => {
39442                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39443                        let mut req = fidl::new_empty!(
39444                            fidl::encoding::EmptyPayload,
39445                            fidl::encoding::DefaultFuchsiaResourceDialect
39446                        );
39447                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
39448                        let control_handle =
39449                            DatagramSocketControlHandle { inner: this.inner.clone() };
39450                        Ok(DatagramSocketRequest::GetOriginalDestination {
39451                            responder: DatagramSocketGetOriginalDestinationResponder {
39452                                control_handle: std::mem::ManuallyDrop::new(control_handle),
39453                                tx_id: header.tx_id,
39454                            },
39455                        })
39456                    }
39457                    0x48aa0a1f6a32d2ed => {
39458                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39459                        let mut req = fidl::new_empty!(
39460                            fidl::encoding::EmptyPayload,
39461                            fidl::encoding::DefaultFuchsiaResourceDialect
39462                        );
39463                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
39464                        let control_handle =
39465                            DatagramSocketControlHandle { inner: this.inner.clone() };
39466                        Ok(DatagramSocketRequest::GetInfo {
39467                            responder: DatagramSocketGetInfoResponder {
39468                                control_handle: std::mem::ManuallyDrop::new(control_handle),
39469                                tx_id: header.tx_id,
39470                            },
39471                        })
39472                    }
39473                    0xbf1e2f0a86601f3 => {
39474                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39475                        let mut req = fidl::new_empty!(
39476                            fidl::encoding::EmptyPayload,
39477                            fidl::encoding::DefaultFuchsiaResourceDialect
39478                        );
39479                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
39480                        let control_handle =
39481                            DatagramSocketControlHandle { inner: this.inner.clone() };
39482                        Ok(DatagramSocketRequest::Describe {
39483                            responder: DatagramSocketDescribeResponder {
39484                                control_handle: std::mem::ManuallyDrop::new(control_handle),
39485                                tx_id: header.tx_id,
39486                            },
39487                        })
39488                    }
39489                    0x5362e668e777248a => {
39490                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39491                        let mut req = fidl::new_empty!(
39492                            DatagramSocketSendMsgPreflightRequest,
39493                            fidl::encoding::DefaultFuchsiaResourceDialect
39494                        );
39495                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DatagramSocketSendMsgPreflightRequest>(&header, _body_bytes, handles, &mut req)?;
39496                        let control_handle =
39497                            DatagramSocketControlHandle { inner: this.inner.clone() };
39498                        Ok(DatagramSocketRequest::SendMsgPreflight {
39499                            payload: req,
39500                            responder: DatagramSocketSendMsgPreflightResponder {
39501                                control_handle: std::mem::ManuallyDrop::new(control_handle),
39502                                tx_id: header.tx_id,
39503                            },
39504                        })
39505                    }
39506                    0x1a7cdeca5f3eb8e2 => {
39507                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
39508                        let mut req = fidl::new_empty!(
39509                            fidl::encoding::EmptyPayload,
39510                            fidl::encoding::DefaultFuchsiaResourceDialect
39511                        );
39512                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
39513                        let control_handle =
39514                            DatagramSocketControlHandle { inner: this.inner.clone() };
39515                        Ok(DatagramSocketRequest::RecvMsgPostflight {
39516                            responder: DatagramSocketRecvMsgPostflightResponder {
39517                                control_handle: std::mem::ManuallyDrop::new(control_handle),
39518                                tx_id: header.tx_id,
39519                            },
39520                        })
39521                    }
39522                    _ => Err(fidl::Error::UnknownOrdinal {
39523                        ordinal: header.ordinal,
39524                        protocol_name:
39525                            <DatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
39526                    }),
39527                }))
39528            },
39529        )
39530    }
39531}
39532
39533/// A datagram socket.
39534#[derive(Debug)]
39535pub enum DatagramSocketRequest {
39536    Clone {
39537        request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
39538        control_handle: DatagramSocketControlHandle,
39539    },
39540    /// Terminates the connection.
39541    ///
39542    /// After calling `Close`, the client must not send any other requests.
39543    ///
39544    /// Servers, after sending the status response, should close the connection
39545    /// regardless of status and without sending an epitaph.
39546    ///
39547    /// Closing the client end of the channel should be semantically equivalent
39548    /// to calling `Close` without knowing when the close has completed or its
39549    /// status.
39550    Close {
39551        responder: DatagramSocketCloseResponder,
39552    },
39553    Query {
39554        responder: DatagramSocketQueryResponder,
39555    },
39556    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
39557    SetReuseAddress {
39558        value: bool,
39559        responder: DatagramSocketSetReuseAddressResponder,
39560    },
39561    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
39562    GetReuseAddress {
39563        responder: DatagramSocketGetReuseAddressResponder,
39564    },
39565    /// Get `SOL_SOCKET` -> `SO_ERROR`.
39566    /// Returns the last error if there is an error set on the socket.
39567    GetError {
39568        responder: DatagramSocketGetErrorResponder,
39569    },
39570    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
39571    SetBroadcast {
39572        value: bool,
39573        responder: DatagramSocketSetBroadcastResponder,
39574    },
39575    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
39576    GetBroadcast {
39577        responder: DatagramSocketGetBroadcastResponder,
39578    },
39579    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
39580    SetSendBuffer {
39581        value_bytes: u64,
39582        responder: DatagramSocketSetSendBufferResponder,
39583    },
39584    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
39585    GetSendBuffer {
39586        responder: DatagramSocketGetSendBufferResponder,
39587    },
39588    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
39589    SetReceiveBuffer {
39590        value_bytes: u64,
39591        responder: DatagramSocketSetReceiveBufferResponder,
39592    },
39593    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
39594    GetReceiveBuffer {
39595        responder: DatagramSocketGetReceiveBufferResponder,
39596    },
39597    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
39598    SetKeepAlive {
39599        value: bool,
39600        responder: DatagramSocketSetKeepAliveResponder,
39601    },
39602    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
39603    GetKeepAlive {
39604        responder: DatagramSocketGetKeepAliveResponder,
39605    },
39606    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
39607    SetOutOfBandInline {
39608        value: bool,
39609        responder: DatagramSocketSetOutOfBandInlineResponder,
39610    },
39611    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
39612    GetOutOfBandInline {
39613        responder: DatagramSocketGetOutOfBandInlineResponder,
39614    },
39615    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
39616    SetNoCheck {
39617        value: bool,
39618        responder: DatagramSocketSetNoCheckResponder,
39619    },
39620    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
39621    GetNoCheck {
39622        responder: DatagramSocketGetNoCheckResponder,
39623    },
39624    /// Set `SOL_SOCKET` -> `SO_LINGER`.
39625    SetLinger {
39626        linger: bool,
39627        length_secs: u32,
39628        responder: DatagramSocketSetLingerResponder,
39629    },
39630    /// Get `SOL_SOCKET` -> `SO_LINGER`.
39631    GetLinger {
39632        responder: DatagramSocketGetLingerResponder,
39633    },
39634    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
39635    SetReusePort {
39636        value: bool,
39637        responder: DatagramSocketSetReusePortResponder,
39638    },
39639    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
39640    GetReusePort {
39641        responder: DatagramSocketGetReusePortResponder,
39642    },
39643    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
39644    GetAcceptConn {
39645        responder: DatagramSocketGetAcceptConnResponder,
39646    },
39647    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
39648    SetBindToDevice {
39649        value: String,
39650        responder: DatagramSocketSetBindToDeviceResponder,
39651    },
39652    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
39653    GetBindToDevice {
39654        responder: DatagramSocketGetBindToDeviceResponder,
39655    },
39656    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
39657    /// If `value` is 0, this clears the bound interface.
39658    SetBindToInterfaceIndex {
39659        value: u64,
39660        responder: DatagramSocketSetBindToInterfaceIndexResponder,
39661    },
39662    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
39663    GetBindToInterfaceIndex {
39664        responder: DatagramSocketGetBindToInterfaceIndexResponder,
39665    },
39666    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
39667    SetTimestamp {
39668        value: TimestampOption,
39669        responder: DatagramSocketSetTimestampResponder,
39670    },
39671    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
39672    GetTimestamp {
39673        responder: DatagramSocketGetTimestampResponder,
39674    },
39675    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
39676    /// unlike the standard SO_MARK, this API has multiple mark domains and each
39677    /// mark can be set independently in each domain.
39678    SetMark {
39679        domain: fidl_fuchsia_net::MarkDomain,
39680        mark: OptionalUint32,
39681        responder: DatagramSocketSetMarkResponder,
39682    },
39683    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
39684    /// unlike the standard SO_MARK, this API has multiple mark domains and each
39685    /// mark can be retrieved independently in each domain.
39686    GetMark {
39687        domain: fidl_fuchsia_net::MarkDomain,
39688        responder: DatagramSocketGetMarkResponder,
39689    },
39690    /// Sets the local address used for the socket.
39691    Bind {
39692        addr: fidl_fuchsia_net::SocketAddress,
39693        responder: DatagramSocketBindResponder,
39694    },
39695    /// Initiates a connection to a remote address.
39696    Connect {
39697        addr: fidl_fuchsia_net::SocketAddress,
39698        responder: DatagramSocketConnectResponder,
39699    },
39700    /// Clears connection information from this socket.
39701    Disconnect {
39702        responder: DatagramSocketDisconnectResponder,
39703    },
39704    /// Retrieves the local socket address.
39705    GetSockName {
39706        responder: DatagramSocketGetSockNameResponder,
39707    },
39708    /// Retrieves the remote socket address.
39709    GetPeerName {
39710        responder: DatagramSocketGetPeerNameResponder,
39711    },
39712    /// Shuts down part of the socket.
39713    Shutdown {
39714        mode: ShutdownMode,
39715        responder: DatagramSocketShutdownResponder,
39716    },
39717    /// Set `SOL_IP` -> `IP_TOS`.
39718    SetIpTypeOfService {
39719        value: u8,
39720        responder: DatagramSocketSetIpTypeOfServiceResponder,
39721    },
39722    /// Get `SOL_IP` -> `IP_TOS`.
39723    GetIpTypeOfService {
39724        responder: DatagramSocketGetIpTypeOfServiceResponder,
39725    },
39726    /// Set `SOL_IP` -> `IP_TTL`.
39727    SetIpTtl {
39728        value: OptionalUint8,
39729        responder: DatagramSocketSetIpTtlResponder,
39730    },
39731    /// Get `SOL_IP` -> `IP_TTL`.
39732    GetIpTtl {
39733        responder: DatagramSocketGetIpTtlResponder,
39734    },
39735    /// Set `SOL_IP` -> `IP_PKTINFO`.
39736    SetIpPacketInfo {
39737        value: bool,
39738        responder: DatagramSocketSetIpPacketInfoResponder,
39739    },
39740    /// Get `SOL_IP` -> `IP_PKTINFO`.
39741    GetIpPacketInfo {
39742        responder: DatagramSocketGetIpPacketInfoResponder,
39743    },
39744    /// Set `SOL_IP` -> `IP_RECVTOS`.
39745    SetIpReceiveTypeOfService {
39746        value: bool,
39747        responder: DatagramSocketSetIpReceiveTypeOfServiceResponder,
39748    },
39749    /// Get `SOL_IP` -> `IP_RECVTOS`.
39750    GetIpReceiveTypeOfService {
39751        responder: DatagramSocketGetIpReceiveTypeOfServiceResponder,
39752    },
39753    /// Set `SOL_IP` -> `IP_RECVTTL`.
39754    SetIpReceiveTtl {
39755        value: bool,
39756        responder: DatagramSocketSetIpReceiveTtlResponder,
39757    },
39758    /// Get `SOL_IP` -> `IP_RECVTTL`.
39759    GetIpReceiveTtl {
39760        responder: DatagramSocketGetIpReceiveTtlResponder,
39761    },
39762    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
39763    SetIpMulticastInterface {
39764        iface: u64,
39765        address: fidl_fuchsia_net::Ipv4Address,
39766        responder: DatagramSocketSetIpMulticastInterfaceResponder,
39767    },
39768    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
39769    GetIpMulticastInterface {
39770        responder: DatagramSocketGetIpMulticastInterfaceResponder,
39771    },
39772    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
39773    SetIpMulticastTtl {
39774        value: OptionalUint8,
39775        responder: DatagramSocketSetIpMulticastTtlResponder,
39776    },
39777    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
39778    GetIpMulticastTtl {
39779        responder: DatagramSocketGetIpMulticastTtlResponder,
39780    },
39781    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
39782    SetIpMulticastLoopback {
39783        value: bool,
39784        responder: DatagramSocketSetIpMulticastLoopbackResponder,
39785    },
39786    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
39787    GetIpMulticastLoopback {
39788        responder: DatagramSocketGetIpMulticastLoopbackResponder,
39789    },
39790    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
39791    AddIpMembership {
39792        membership: IpMulticastMembership,
39793        responder: DatagramSocketAddIpMembershipResponder,
39794    },
39795    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
39796    DropIpMembership {
39797        membership: IpMulticastMembership,
39798        responder: DatagramSocketDropIpMembershipResponder,
39799    },
39800    /// Set `SOL_IP` -> `IP_TRANSPARENT`
39801    SetIpTransparent {
39802        value: bool,
39803        responder: DatagramSocketSetIpTransparentResponder,
39804    },
39805    /// Get `SOL_IP` -> `IP_TRANSPARENT`
39806    GetIpTransparent {
39807        responder: DatagramSocketGetIpTransparentResponder,
39808    },
39809    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
39810    SetIpReceiveOriginalDestinationAddress {
39811        value: bool,
39812        responder: DatagramSocketSetIpReceiveOriginalDestinationAddressResponder,
39813    },
39814    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
39815    GetIpReceiveOriginalDestinationAddress {
39816        responder: DatagramSocketGetIpReceiveOriginalDestinationAddressResponder,
39817    },
39818    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
39819    AddIpv6Membership {
39820        membership: Ipv6MulticastMembership,
39821        responder: DatagramSocketAddIpv6MembershipResponder,
39822    },
39823    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
39824    DropIpv6Membership {
39825        membership: Ipv6MulticastMembership,
39826        responder: DatagramSocketDropIpv6MembershipResponder,
39827    },
39828    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
39829    SetIpv6MulticastInterface {
39830        value: u64,
39831        responder: DatagramSocketSetIpv6MulticastInterfaceResponder,
39832    },
39833    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
39834    GetIpv6MulticastInterface {
39835        responder: DatagramSocketGetIpv6MulticastInterfaceResponder,
39836    },
39837    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
39838    SetIpv6UnicastHops {
39839        value: OptionalUint8,
39840        responder: DatagramSocketSetIpv6UnicastHopsResponder,
39841    },
39842    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
39843    GetIpv6UnicastHops {
39844        responder: DatagramSocketGetIpv6UnicastHopsResponder,
39845    },
39846    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
39847    SetIpv6ReceiveHopLimit {
39848        value: bool,
39849        responder: DatagramSocketSetIpv6ReceiveHopLimitResponder,
39850    },
39851    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
39852    GetIpv6ReceiveHopLimit {
39853        responder: DatagramSocketGetIpv6ReceiveHopLimitResponder,
39854    },
39855    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
39856    SetIpv6MulticastHops {
39857        value: OptionalUint8,
39858        responder: DatagramSocketSetIpv6MulticastHopsResponder,
39859    },
39860    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
39861    GetIpv6MulticastHops {
39862        responder: DatagramSocketGetIpv6MulticastHopsResponder,
39863    },
39864    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
39865    SetIpv6MulticastLoopback {
39866        value: bool,
39867        responder: DatagramSocketSetIpv6MulticastLoopbackResponder,
39868    },
39869    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
39870    GetIpv6MulticastLoopback {
39871        responder: DatagramSocketGetIpv6MulticastLoopbackResponder,
39872    },
39873    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
39874    SetIpv6Only {
39875        value: bool,
39876        responder: DatagramSocketSetIpv6OnlyResponder,
39877    },
39878    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
39879    GetIpv6Only {
39880        responder: DatagramSocketGetIpv6OnlyResponder,
39881    },
39882    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
39883    SetIpv6ReceiveTrafficClass {
39884        value: bool,
39885        responder: DatagramSocketSetIpv6ReceiveTrafficClassResponder,
39886    },
39887    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
39888    GetIpv6ReceiveTrafficClass {
39889        responder: DatagramSocketGetIpv6ReceiveTrafficClassResponder,
39890    },
39891    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
39892    SetIpv6TrafficClass {
39893        value: OptionalUint8,
39894        responder: DatagramSocketSetIpv6TrafficClassResponder,
39895    },
39896    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
39897    GetIpv6TrafficClass {
39898        responder: DatagramSocketGetIpv6TrafficClassResponder,
39899    },
39900    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
39901    SetIpv6ReceivePacketInfo {
39902        value: bool,
39903        responder: DatagramSocketSetIpv6ReceivePacketInfoResponder,
39904    },
39905    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
39906    GetIpv6ReceivePacketInfo {
39907        responder: DatagramSocketGetIpv6ReceivePacketInfoResponder,
39908    },
39909    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
39910    GetOriginalDestination {
39911        responder: DatagramSocketGetOriginalDestinationResponder,
39912    },
39913    /// Retrieves creation information from the socket.
39914    ///
39915    /// - response `domain` the socket's associated domain.
39916    /// - response `proto` the socket's associated protocol.
39917    GetInfo {
39918        responder: DatagramSocketGetInfoResponder,
39919    },
39920    Describe {
39921        responder: DatagramSocketDescribeResponder,
39922    },
39923    /// Validates that data can be sent.
39924    ///
39925    /// + request `args` the requested disposition of data to be sent.
39926    /// - response the constraints sent data must satisfy.
39927    /// * error the error code indicating the reason for validation failure.
39928    SendMsgPreflight {
39929        payload: DatagramSocketSendMsgPreflightRequest,
39930        responder: DatagramSocketSendMsgPreflightResponder,
39931    },
39932    /// Returns the set of requested control messages.
39933    ///
39934    /// - response the set of currently requested control messages.
39935    RecvMsgPostflight {
39936        responder: DatagramSocketRecvMsgPostflightResponder,
39937    },
39938}
39939
39940impl DatagramSocketRequest {
39941    #[allow(irrefutable_let_patterns)]
39942    pub fn into_clone(
39943        self,
39944    ) -> Option<(
39945        fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
39946        DatagramSocketControlHandle,
39947    )> {
39948        if let DatagramSocketRequest::Clone { request, control_handle } = self {
39949            Some((request, control_handle))
39950        } else {
39951            None
39952        }
39953    }
39954
39955    #[allow(irrefutable_let_patterns)]
39956    pub fn into_close(self) -> Option<(DatagramSocketCloseResponder)> {
39957        if let DatagramSocketRequest::Close { responder } = self {
39958            Some((responder))
39959        } else {
39960            None
39961        }
39962    }
39963
39964    #[allow(irrefutable_let_patterns)]
39965    pub fn into_query(self) -> Option<(DatagramSocketQueryResponder)> {
39966        if let DatagramSocketRequest::Query { responder } = self {
39967            Some((responder))
39968        } else {
39969            None
39970        }
39971    }
39972
39973    #[allow(irrefutable_let_patterns)]
39974    pub fn into_set_reuse_address(self) -> Option<(bool, DatagramSocketSetReuseAddressResponder)> {
39975        if let DatagramSocketRequest::SetReuseAddress { value, responder } = self {
39976            Some((value, responder))
39977        } else {
39978            None
39979        }
39980    }
39981
39982    #[allow(irrefutable_let_patterns)]
39983    pub fn into_get_reuse_address(self) -> Option<(DatagramSocketGetReuseAddressResponder)> {
39984        if let DatagramSocketRequest::GetReuseAddress { responder } = self {
39985            Some((responder))
39986        } else {
39987            None
39988        }
39989    }
39990
39991    #[allow(irrefutable_let_patterns)]
39992    pub fn into_get_error(self) -> Option<(DatagramSocketGetErrorResponder)> {
39993        if let DatagramSocketRequest::GetError { responder } = self {
39994            Some((responder))
39995        } else {
39996            None
39997        }
39998    }
39999
40000    #[allow(irrefutable_let_patterns)]
40001    pub fn into_set_broadcast(self) -> Option<(bool, DatagramSocketSetBroadcastResponder)> {
40002        if let DatagramSocketRequest::SetBroadcast { value, responder } = self {
40003            Some((value, responder))
40004        } else {
40005            None
40006        }
40007    }
40008
40009    #[allow(irrefutable_let_patterns)]
40010    pub fn into_get_broadcast(self) -> Option<(DatagramSocketGetBroadcastResponder)> {
40011        if let DatagramSocketRequest::GetBroadcast { responder } = self {
40012            Some((responder))
40013        } else {
40014            None
40015        }
40016    }
40017
40018    #[allow(irrefutable_let_patterns)]
40019    pub fn into_set_send_buffer(self) -> Option<(u64, DatagramSocketSetSendBufferResponder)> {
40020        if let DatagramSocketRequest::SetSendBuffer { value_bytes, responder } = self {
40021            Some((value_bytes, responder))
40022        } else {
40023            None
40024        }
40025    }
40026
40027    #[allow(irrefutable_let_patterns)]
40028    pub fn into_get_send_buffer(self) -> Option<(DatagramSocketGetSendBufferResponder)> {
40029        if let DatagramSocketRequest::GetSendBuffer { responder } = self {
40030            Some((responder))
40031        } else {
40032            None
40033        }
40034    }
40035
40036    #[allow(irrefutable_let_patterns)]
40037    pub fn into_set_receive_buffer(self) -> Option<(u64, DatagramSocketSetReceiveBufferResponder)> {
40038        if let DatagramSocketRequest::SetReceiveBuffer { value_bytes, responder } = self {
40039            Some((value_bytes, responder))
40040        } else {
40041            None
40042        }
40043    }
40044
40045    #[allow(irrefutable_let_patterns)]
40046    pub fn into_get_receive_buffer(self) -> Option<(DatagramSocketGetReceiveBufferResponder)> {
40047        if let DatagramSocketRequest::GetReceiveBuffer { responder } = self {
40048            Some((responder))
40049        } else {
40050            None
40051        }
40052    }
40053
40054    #[allow(irrefutable_let_patterns)]
40055    pub fn into_set_keep_alive(self) -> Option<(bool, DatagramSocketSetKeepAliveResponder)> {
40056        if let DatagramSocketRequest::SetKeepAlive { value, responder } = self {
40057            Some((value, responder))
40058        } else {
40059            None
40060        }
40061    }
40062
40063    #[allow(irrefutable_let_patterns)]
40064    pub fn into_get_keep_alive(self) -> Option<(DatagramSocketGetKeepAliveResponder)> {
40065        if let DatagramSocketRequest::GetKeepAlive { responder } = self {
40066            Some((responder))
40067        } else {
40068            None
40069        }
40070    }
40071
40072    #[allow(irrefutable_let_patterns)]
40073    pub fn into_set_out_of_band_inline(
40074        self,
40075    ) -> Option<(bool, DatagramSocketSetOutOfBandInlineResponder)> {
40076        if let DatagramSocketRequest::SetOutOfBandInline { value, responder } = self {
40077            Some((value, responder))
40078        } else {
40079            None
40080        }
40081    }
40082
40083    #[allow(irrefutable_let_patterns)]
40084    pub fn into_get_out_of_band_inline(
40085        self,
40086    ) -> Option<(DatagramSocketGetOutOfBandInlineResponder)> {
40087        if let DatagramSocketRequest::GetOutOfBandInline { responder } = self {
40088            Some((responder))
40089        } else {
40090            None
40091        }
40092    }
40093
40094    #[allow(irrefutable_let_patterns)]
40095    pub fn into_set_no_check(self) -> Option<(bool, DatagramSocketSetNoCheckResponder)> {
40096        if let DatagramSocketRequest::SetNoCheck { value, responder } = self {
40097            Some((value, responder))
40098        } else {
40099            None
40100        }
40101    }
40102
40103    #[allow(irrefutable_let_patterns)]
40104    pub fn into_get_no_check(self) -> Option<(DatagramSocketGetNoCheckResponder)> {
40105        if let DatagramSocketRequest::GetNoCheck { responder } = self {
40106            Some((responder))
40107        } else {
40108            None
40109        }
40110    }
40111
40112    #[allow(irrefutable_let_patterns)]
40113    pub fn into_set_linger(self) -> Option<(bool, u32, DatagramSocketSetLingerResponder)> {
40114        if let DatagramSocketRequest::SetLinger { linger, length_secs, responder } = self {
40115            Some((linger, length_secs, responder))
40116        } else {
40117            None
40118        }
40119    }
40120
40121    #[allow(irrefutable_let_patterns)]
40122    pub fn into_get_linger(self) -> Option<(DatagramSocketGetLingerResponder)> {
40123        if let DatagramSocketRequest::GetLinger { responder } = self {
40124            Some((responder))
40125        } else {
40126            None
40127        }
40128    }
40129
40130    #[allow(irrefutable_let_patterns)]
40131    pub fn into_set_reuse_port(self) -> Option<(bool, DatagramSocketSetReusePortResponder)> {
40132        if let DatagramSocketRequest::SetReusePort { value, responder } = self {
40133            Some((value, responder))
40134        } else {
40135            None
40136        }
40137    }
40138
40139    #[allow(irrefutable_let_patterns)]
40140    pub fn into_get_reuse_port(self) -> Option<(DatagramSocketGetReusePortResponder)> {
40141        if let DatagramSocketRequest::GetReusePort { responder } = self {
40142            Some((responder))
40143        } else {
40144            None
40145        }
40146    }
40147
40148    #[allow(irrefutable_let_patterns)]
40149    pub fn into_get_accept_conn(self) -> Option<(DatagramSocketGetAcceptConnResponder)> {
40150        if let DatagramSocketRequest::GetAcceptConn { responder } = self {
40151            Some((responder))
40152        } else {
40153            None
40154        }
40155    }
40156
40157    #[allow(irrefutable_let_patterns)]
40158    pub fn into_set_bind_to_device(
40159        self,
40160    ) -> Option<(String, DatagramSocketSetBindToDeviceResponder)> {
40161        if let DatagramSocketRequest::SetBindToDevice { value, responder } = self {
40162            Some((value, responder))
40163        } else {
40164            None
40165        }
40166    }
40167
40168    #[allow(irrefutable_let_patterns)]
40169    pub fn into_get_bind_to_device(self) -> Option<(DatagramSocketGetBindToDeviceResponder)> {
40170        if let DatagramSocketRequest::GetBindToDevice { responder } = self {
40171            Some((responder))
40172        } else {
40173            None
40174        }
40175    }
40176
40177    #[allow(irrefutable_let_patterns)]
40178    pub fn into_set_bind_to_interface_index(
40179        self,
40180    ) -> Option<(u64, DatagramSocketSetBindToInterfaceIndexResponder)> {
40181        if let DatagramSocketRequest::SetBindToInterfaceIndex { value, responder } = self {
40182            Some((value, responder))
40183        } else {
40184            None
40185        }
40186    }
40187
40188    #[allow(irrefutable_let_patterns)]
40189    pub fn into_get_bind_to_interface_index(
40190        self,
40191    ) -> Option<(DatagramSocketGetBindToInterfaceIndexResponder)> {
40192        if let DatagramSocketRequest::GetBindToInterfaceIndex { responder } = self {
40193            Some((responder))
40194        } else {
40195            None
40196        }
40197    }
40198
40199    #[allow(irrefutable_let_patterns)]
40200    pub fn into_set_timestamp(
40201        self,
40202    ) -> Option<(TimestampOption, DatagramSocketSetTimestampResponder)> {
40203        if let DatagramSocketRequest::SetTimestamp { value, responder } = self {
40204            Some((value, responder))
40205        } else {
40206            None
40207        }
40208    }
40209
40210    #[allow(irrefutable_let_patterns)]
40211    pub fn into_get_timestamp(self) -> Option<(DatagramSocketGetTimestampResponder)> {
40212        if let DatagramSocketRequest::GetTimestamp { responder } = self {
40213            Some((responder))
40214        } else {
40215            None
40216        }
40217    }
40218
40219    #[allow(irrefutable_let_patterns)]
40220    pub fn into_set_mark(
40221        self,
40222    ) -> Option<(fidl_fuchsia_net::MarkDomain, OptionalUint32, DatagramSocketSetMarkResponder)>
40223    {
40224        if let DatagramSocketRequest::SetMark { domain, mark, responder } = self {
40225            Some((domain, mark, responder))
40226        } else {
40227            None
40228        }
40229    }
40230
40231    #[allow(irrefutable_let_patterns)]
40232    pub fn into_get_mark(
40233        self,
40234    ) -> Option<(fidl_fuchsia_net::MarkDomain, DatagramSocketGetMarkResponder)> {
40235        if let DatagramSocketRequest::GetMark { domain, responder } = self {
40236            Some((domain, responder))
40237        } else {
40238            None
40239        }
40240    }
40241
40242    #[allow(irrefutable_let_patterns)]
40243    pub fn into_bind(
40244        self,
40245    ) -> Option<(fidl_fuchsia_net::SocketAddress, DatagramSocketBindResponder)> {
40246        if let DatagramSocketRequest::Bind { addr, responder } = self {
40247            Some((addr, responder))
40248        } else {
40249            None
40250        }
40251    }
40252
40253    #[allow(irrefutable_let_patterns)]
40254    pub fn into_connect(
40255        self,
40256    ) -> Option<(fidl_fuchsia_net::SocketAddress, DatagramSocketConnectResponder)> {
40257        if let DatagramSocketRequest::Connect { addr, responder } = self {
40258            Some((addr, responder))
40259        } else {
40260            None
40261        }
40262    }
40263
40264    #[allow(irrefutable_let_patterns)]
40265    pub fn into_disconnect(self) -> Option<(DatagramSocketDisconnectResponder)> {
40266        if let DatagramSocketRequest::Disconnect { responder } = self {
40267            Some((responder))
40268        } else {
40269            None
40270        }
40271    }
40272
40273    #[allow(irrefutable_let_patterns)]
40274    pub fn into_get_sock_name(self) -> Option<(DatagramSocketGetSockNameResponder)> {
40275        if let DatagramSocketRequest::GetSockName { responder } = self {
40276            Some((responder))
40277        } else {
40278            None
40279        }
40280    }
40281
40282    #[allow(irrefutable_let_patterns)]
40283    pub fn into_get_peer_name(self) -> Option<(DatagramSocketGetPeerNameResponder)> {
40284        if let DatagramSocketRequest::GetPeerName { responder } = self {
40285            Some((responder))
40286        } else {
40287            None
40288        }
40289    }
40290
40291    #[allow(irrefutable_let_patterns)]
40292    pub fn into_shutdown(self) -> Option<(ShutdownMode, DatagramSocketShutdownResponder)> {
40293        if let DatagramSocketRequest::Shutdown { mode, responder } = self {
40294            Some((mode, responder))
40295        } else {
40296            None
40297        }
40298    }
40299
40300    #[allow(irrefutable_let_patterns)]
40301    pub fn into_set_ip_type_of_service(
40302        self,
40303    ) -> Option<(u8, DatagramSocketSetIpTypeOfServiceResponder)> {
40304        if let DatagramSocketRequest::SetIpTypeOfService { value, responder } = self {
40305            Some((value, responder))
40306        } else {
40307            None
40308        }
40309    }
40310
40311    #[allow(irrefutable_let_patterns)]
40312    pub fn into_get_ip_type_of_service(
40313        self,
40314    ) -> Option<(DatagramSocketGetIpTypeOfServiceResponder)> {
40315        if let DatagramSocketRequest::GetIpTypeOfService { responder } = self {
40316            Some((responder))
40317        } else {
40318            None
40319        }
40320    }
40321
40322    #[allow(irrefutable_let_patterns)]
40323    pub fn into_set_ip_ttl(self) -> Option<(OptionalUint8, DatagramSocketSetIpTtlResponder)> {
40324        if let DatagramSocketRequest::SetIpTtl { value, responder } = self {
40325            Some((value, responder))
40326        } else {
40327            None
40328        }
40329    }
40330
40331    #[allow(irrefutable_let_patterns)]
40332    pub fn into_get_ip_ttl(self) -> Option<(DatagramSocketGetIpTtlResponder)> {
40333        if let DatagramSocketRequest::GetIpTtl { responder } = self {
40334            Some((responder))
40335        } else {
40336            None
40337        }
40338    }
40339
40340    #[allow(irrefutable_let_patterns)]
40341    pub fn into_set_ip_packet_info(self) -> Option<(bool, DatagramSocketSetIpPacketInfoResponder)> {
40342        if let DatagramSocketRequest::SetIpPacketInfo { value, responder } = self {
40343            Some((value, responder))
40344        } else {
40345            None
40346        }
40347    }
40348
40349    #[allow(irrefutable_let_patterns)]
40350    pub fn into_get_ip_packet_info(self) -> Option<(DatagramSocketGetIpPacketInfoResponder)> {
40351        if let DatagramSocketRequest::GetIpPacketInfo { responder } = self {
40352            Some((responder))
40353        } else {
40354            None
40355        }
40356    }
40357
40358    #[allow(irrefutable_let_patterns)]
40359    pub fn into_set_ip_receive_type_of_service(
40360        self,
40361    ) -> Option<(bool, DatagramSocketSetIpReceiveTypeOfServiceResponder)> {
40362        if let DatagramSocketRequest::SetIpReceiveTypeOfService { value, responder } = self {
40363            Some((value, responder))
40364        } else {
40365            None
40366        }
40367    }
40368
40369    #[allow(irrefutable_let_patterns)]
40370    pub fn into_get_ip_receive_type_of_service(
40371        self,
40372    ) -> Option<(DatagramSocketGetIpReceiveTypeOfServiceResponder)> {
40373        if let DatagramSocketRequest::GetIpReceiveTypeOfService { responder } = self {
40374            Some((responder))
40375        } else {
40376            None
40377        }
40378    }
40379
40380    #[allow(irrefutable_let_patterns)]
40381    pub fn into_set_ip_receive_ttl(self) -> Option<(bool, DatagramSocketSetIpReceiveTtlResponder)> {
40382        if let DatagramSocketRequest::SetIpReceiveTtl { value, responder } = self {
40383            Some((value, responder))
40384        } else {
40385            None
40386        }
40387    }
40388
40389    #[allow(irrefutable_let_patterns)]
40390    pub fn into_get_ip_receive_ttl(self) -> Option<(DatagramSocketGetIpReceiveTtlResponder)> {
40391        if let DatagramSocketRequest::GetIpReceiveTtl { responder } = self {
40392            Some((responder))
40393        } else {
40394            None
40395        }
40396    }
40397
40398    #[allow(irrefutable_let_patterns)]
40399    pub fn into_set_ip_multicast_interface(
40400        self,
40401    ) -> Option<(u64, fidl_fuchsia_net::Ipv4Address, DatagramSocketSetIpMulticastInterfaceResponder)>
40402    {
40403        if let DatagramSocketRequest::SetIpMulticastInterface { iface, address, responder } = self {
40404            Some((iface, address, responder))
40405        } else {
40406            None
40407        }
40408    }
40409
40410    #[allow(irrefutable_let_patterns)]
40411    pub fn into_get_ip_multicast_interface(
40412        self,
40413    ) -> Option<(DatagramSocketGetIpMulticastInterfaceResponder)> {
40414        if let DatagramSocketRequest::GetIpMulticastInterface { responder } = self {
40415            Some((responder))
40416        } else {
40417            None
40418        }
40419    }
40420
40421    #[allow(irrefutable_let_patterns)]
40422    pub fn into_set_ip_multicast_ttl(
40423        self,
40424    ) -> Option<(OptionalUint8, DatagramSocketSetIpMulticastTtlResponder)> {
40425        if let DatagramSocketRequest::SetIpMulticastTtl { value, responder } = self {
40426            Some((value, responder))
40427        } else {
40428            None
40429        }
40430    }
40431
40432    #[allow(irrefutable_let_patterns)]
40433    pub fn into_get_ip_multicast_ttl(self) -> Option<(DatagramSocketGetIpMulticastTtlResponder)> {
40434        if let DatagramSocketRequest::GetIpMulticastTtl { responder } = self {
40435            Some((responder))
40436        } else {
40437            None
40438        }
40439    }
40440
40441    #[allow(irrefutable_let_patterns)]
40442    pub fn into_set_ip_multicast_loopback(
40443        self,
40444    ) -> Option<(bool, DatagramSocketSetIpMulticastLoopbackResponder)> {
40445        if let DatagramSocketRequest::SetIpMulticastLoopback { value, responder } = self {
40446            Some((value, responder))
40447        } else {
40448            None
40449        }
40450    }
40451
40452    #[allow(irrefutable_let_patterns)]
40453    pub fn into_get_ip_multicast_loopback(
40454        self,
40455    ) -> Option<(DatagramSocketGetIpMulticastLoopbackResponder)> {
40456        if let DatagramSocketRequest::GetIpMulticastLoopback { responder } = self {
40457            Some((responder))
40458        } else {
40459            None
40460        }
40461    }
40462
40463    #[allow(irrefutable_let_patterns)]
40464    pub fn into_add_ip_membership(
40465        self,
40466    ) -> Option<(IpMulticastMembership, DatagramSocketAddIpMembershipResponder)> {
40467        if let DatagramSocketRequest::AddIpMembership { membership, responder } = self {
40468            Some((membership, responder))
40469        } else {
40470            None
40471        }
40472    }
40473
40474    #[allow(irrefutable_let_patterns)]
40475    pub fn into_drop_ip_membership(
40476        self,
40477    ) -> Option<(IpMulticastMembership, DatagramSocketDropIpMembershipResponder)> {
40478        if let DatagramSocketRequest::DropIpMembership { membership, responder } = self {
40479            Some((membership, responder))
40480        } else {
40481            None
40482        }
40483    }
40484
40485    #[allow(irrefutable_let_patterns)]
40486    pub fn into_set_ip_transparent(
40487        self,
40488    ) -> Option<(bool, DatagramSocketSetIpTransparentResponder)> {
40489        if let DatagramSocketRequest::SetIpTransparent { value, responder } = self {
40490            Some((value, responder))
40491        } else {
40492            None
40493        }
40494    }
40495
40496    #[allow(irrefutable_let_patterns)]
40497    pub fn into_get_ip_transparent(self) -> Option<(DatagramSocketGetIpTransparentResponder)> {
40498        if let DatagramSocketRequest::GetIpTransparent { responder } = self {
40499            Some((responder))
40500        } else {
40501            None
40502        }
40503    }
40504
40505    #[allow(irrefutable_let_patterns)]
40506    pub fn into_set_ip_receive_original_destination_address(
40507        self,
40508    ) -> Option<(bool, DatagramSocketSetIpReceiveOriginalDestinationAddressResponder)> {
40509        if let DatagramSocketRequest::SetIpReceiveOriginalDestinationAddress { value, responder } =
40510            self
40511        {
40512            Some((value, responder))
40513        } else {
40514            None
40515        }
40516    }
40517
40518    #[allow(irrefutable_let_patterns)]
40519    pub fn into_get_ip_receive_original_destination_address(
40520        self,
40521    ) -> Option<(DatagramSocketGetIpReceiveOriginalDestinationAddressResponder)> {
40522        if let DatagramSocketRequest::GetIpReceiveOriginalDestinationAddress { responder } = self {
40523            Some((responder))
40524        } else {
40525            None
40526        }
40527    }
40528
40529    #[allow(irrefutable_let_patterns)]
40530    pub fn into_add_ipv6_membership(
40531        self,
40532    ) -> Option<(Ipv6MulticastMembership, DatagramSocketAddIpv6MembershipResponder)> {
40533        if let DatagramSocketRequest::AddIpv6Membership { membership, responder } = self {
40534            Some((membership, responder))
40535        } else {
40536            None
40537        }
40538    }
40539
40540    #[allow(irrefutable_let_patterns)]
40541    pub fn into_drop_ipv6_membership(
40542        self,
40543    ) -> Option<(Ipv6MulticastMembership, DatagramSocketDropIpv6MembershipResponder)> {
40544        if let DatagramSocketRequest::DropIpv6Membership { membership, responder } = self {
40545            Some((membership, responder))
40546        } else {
40547            None
40548        }
40549    }
40550
40551    #[allow(irrefutable_let_patterns)]
40552    pub fn into_set_ipv6_multicast_interface(
40553        self,
40554    ) -> Option<(u64, DatagramSocketSetIpv6MulticastInterfaceResponder)> {
40555        if let DatagramSocketRequest::SetIpv6MulticastInterface { value, responder } = self {
40556            Some((value, responder))
40557        } else {
40558            None
40559        }
40560    }
40561
40562    #[allow(irrefutable_let_patterns)]
40563    pub fn into_get_ipv6_multicast_interface(
40564        self,
40565    ) -> Option<(DatagramSocketGetIpv6MulticastInterfaceResponder)> {
40566        if let DatagramSocketRequest::GetIpv6MulticastInterface { responder } = self {
40567            Some((responder))
40568        } else {
40569            None
40570        }
40571    }
40572
40573    #[allow(irrefutable_let_patterns)]
40574    pub fn into_set_ipv6_unicast_hops(
40575        self,
40576    ) -> Option<(OptionalUint8, DatagramSocketSetIpv6UnicastHopsResponder)> {
40577        if let DatagramSocketRequest::SetIpv6UnicastHops { value, responder } = self {
40578            Some((value, responder))
40579        } else {
40580            None
40581        }
40582    }
40583
40584    #[allow(irrefutable_let_patterns)]
40585    pub fn into_get_ipv6_unicast_hops(self) -> Option<(DatagramSocketGetIpv6UnicastHopsResponder)> {
40586        if let DatagramSocketRequest::GetIpv6UnicastHops { responder } = self {
40587            Some((responder))
40588        } else {
40589            None
40590        }
40591    }
40592
40593    #[allow(irrefutable_let_patterns)]
40594    pub fn into_set_ipv6_receive_hop_limit(
40595        self,
40596    ) -> Option<(bool, DatagramSocketSetIpv6ReceiveHopLimitResponder)> {
40597        if let DatagramSocketRequest::SetIpv6ReceiveHopLimit { value, responder } = self {
40598            Some((value, responder))
40599        } else {
40600            None
40601        }
40602    }
40603
40604    #[allow(irrefutable_let_patterns)]
40605    pub fn into_get_ipv6_receive_hop_limit(
40606        self,
40607    ) -> Option<(DatagramSocketGetIpv6ReceiveHopLimitResponder)> {
40608        if let DatagramSocketRequest::GetIpv6ReceiveHopLimit { responder } = self {
40609            Some((responder))
40610        } else {
40611            None
40612        }
40613    }
40614
40615    #[allow(irrefutable_let_patterns)]
40616    pub fn into_set_ipv6_multicast_hops(
40617        self,
40618    ) -> Option<(OptionalUint8, DatagramSocketSetIpv6MulticastHopsResponder)> {
40619        if let DatagramSocketRequest::SetIpv6MulticastHops { value, responder } = self {
40620            Some((value, responder))
40621        } else {
40622            None
40623        }
40624    }
40625
40626    #[allow(irrefutable_let_patterns)]
40627    pub fn into_get_ipv6_multicast_hops(
40628        self,
40629    ) -> Option<(DatagramSocketGetIpv6MulticastHopsResponder)> {
40630        if let DatagramSocketRequest::GetIpv6MulticastHops { responder } = self {
40631            Some((responder))
40632        } else {
40633            None
40634        }
40635    }
40636
40637    #[allow(irrefutable_let_patterns)]
40638    pub fn into_set_ipv6_multicast_loopback(
40639        self,
40640    ) -> Option<(bool, DatagramSocketSetIpv6MulticastLoopbackResponder)> {
40641        if let DatagramSocketRequest::SetIpv6MulticastLoopback { value, responder } = self {
40642            Some((value, responder))
40643        } else {
40644            None
40645        }
40646    }
40647
40648    #[allow(irrefutable_let_patterns)]
40649    pub fn into_get_ipv6_multicast_loopback(
40650        self,
40651    ) -> Option<(DatagramSocketGetIpv6MulticastLoopbackResponder)> {
40652        if let DatagramSocketRequest::GetIpv6MulticastLoopback { responder } = self {
40653            Some((responder))
40654        } else {
40655            None
40656        }
40657    }
40658
40659    #[allow(irrefutable_let_patterns)]
40660    pub fn into_set_ipv6_only(self) -> Option<(bool, DatagramSocketSetIpv6OnlyResponder)> {
40661        if let DatagramSocketRequest::SetIpv6Only { value, responder } = self {
40662            Some((value, responder))
40663        } else {
40664            None
40665        }
40666    }
40667
40668    #[allow(irrefutable_let_patterns)]
40669    pub fn into_get_ipv6_only(self) -> Option<(DatagramSocketGetIpv6OnlyResponder)> {
40670        if let DatagramSocketRequest::GetIpv6Only { responder } = self {
40671            Some((responder))
40672        } else {
40673            None
40674        }
40675    }
40676
40677    #[allow(irrefutable_let_patterns)]
40678    pub fn into_set_ipv6_receive_traffic_class(
40679        self,
40680    ) -> Option<(bool, DatagramSocketSetIpv6ReceiveTrafficClassResponder)> {
40681        if let DatagramSocketRequest::SetIpv6ReceiveTrafficClass { value, responder } = self {
40682            Some((value, responder))
40683        } else {
40684            None
40685        }
40686    }
40687
40688    #[allow(irrefutable_let_patterns)]
40689    pub fn into_get_ipv6_receive_traffic_class(
40690        self,
40691    ) -> Option<(DatagramSocketGetIpv6ReceiveTrafficClassResponder)> {
40692        if let DatagramSocketRequest::GetIpv6ReceiveTrafficClass { responder } = self {
40693            Some((responder))
40694        } else {
40695            None
40696        }
40697    }
40698
40699    #[allow(irrefutable_let_patterns)]
40700    pub fn into_set_ipv6_traffic_class(
40701        self,
40702    ) -> Option<(OptionalUint8, DatagramSocketSetIpv6TrafficClassResponder)> {
40703        if let DatagramSocketRequest::SetIpv6TrafficClass { value, responder } = self {
40704            Some((value, responder))
40705        } else {
40706            None
40707        }
40708    }
40709
40710    #[allow(irrefutable_let_patterns)]
40711    pub fn into_get_ipv6_traffic_class(
40712        self,
40713    ) -> Option<(DatagramSocketGetIpv6TrafficClassResponder)> {
40714        if let DatagramSocketRequest::GetIpv6TrafficClass { responder } = self {
40715            Some((responder))
40716        } else {
40717            None
40718        }
40719    }
40720
40721    #[allow(irrefutable_let_patterns)]
40722    pub fn into_set_ipv6_receive_packet_info(
40723        self,
40724    ) -> Option<(bool, DatagramSocketSetIpv6ReceivePacketInfoResponder)> {
40725        if let DatagramSocketRequest::SetIpv6ReceivePacketInfo { value, responder } = self {
40726            Some((value, responder))
40727        } else {
40728            None
40729        }
40730    }
40731
40732    #[allow(irrefutable_let_patterns)]
40733    pub fn into_get_ipv6_receive_packet_info(
40734        self,
40735    ) -> Option<(DatagramSocketGetIpv6ReceivePacketInfoResponder)> {
40736        if let DatagramSocketRequest::GetIpv6ReceivePacketInfo { responder } = self {
40737            Some((responder))
40738        } else {
40739            None
40740        }
40741    }
40742
40743    #[allow(irrefutable_let_patterns)]
40744    pub fn into_get_original_destination(
40745        self,
40746    ) -> Option<(DatagramSocketGetOriginalDestinationResponder)> {
40747        if let DatagramSocketRequest::GetOriginalDestination { responder } = self {
40748            Some((responder))
40749        } else {
40750            None
40751        }
40752    }
40753
40754    #[allow(irrefutable_let_patterns)]
40755    pub fn into_get_info(self) -> Option<(DatagramSocketGetInfoResponder)> {
40756        if let DatagramSocketRequest::GetInfo { responder } = self {
40757            Some((responder))
40758        } else {
40759            None
40760        }
40761    }
40762
40763    #[allow(irrefutable_let_patterns)]
40764    pub fn into_describe(self) -> Option<(DatagramSocketDescribeResponder)> {
40765        if let DatagramSocketRequest::Describe { responder } = self {
40766            Some((responder))
40767        } else {
40768            None
40769        }
40770    }
40771
40772    #[allow(irrefutable_let_patterns)]
40773    pub fn into_send_msg_preflight(
40774        self,
40775    ) -> Option<(DatagramSocketSendMsgPreflightRequest, DatagramSocketSendMsgPreflightResponder)>
40776    {
40777        if let DatagramSocketRequest::SendMsgPreflight { payload, responder } = self {
40778            Some((payload, responder))
40779        } else {
40780            None
40781        }
40782    }
40783
40784    #[allow(irrefutable_let_patterns)]
40785    pub fn into_recv_msg_postflight(self) -> Option<(DatagramSocketRecvMsgPostflightResponder)> {
40786        if let DatagramSocketRequest::RecvMsgPostflight { responder } = self {
40787            Some((responder))
40788        } else {
40789            None
40790        }
40791    }
40792
40793    /// Name of the method defined in FIDL
40794    pub fn method_name(&self) -> &'static str {
40795        match *self {
40796            DatagramSocketRequest::Clone { .. } => "clone",
40797            DatagramSocketRequest::Close { .. } => "close",
40798            DatagramSocketRequest::Query { .. } => "query",
40799            DatagramSocketRequest::SetReuseAddress { .. } => "set_reuse_address",
40800            DatagramSocketRequest::GetReuseAddress { .. } => "get_reuse_address",
40801            DatagramSocketRequest::GetError { .. } => "get_error",
40802            DatagramSocketRequest::SetBroadcast { .. } => "set_broadcast",
40803            DatagramSocketRequest::GetBroadcast { .. } => "get_broadcast",
40804            DatagramSocketRequest::SetSendBuffer { .. } => "set_send_buffer",
40805            DatagramSocketRequest::GetSendBuffer { .. } => "get_send_buffer",
40806            DatagramSocketRequest::SetReceiveBuffer { .. } => "set_receive_buffer",
40807            DatagramSocketRequest::GetReceiveBuffer { .. } => "get_receive_buffer",
40808            DatagramSocketRequest::SetKeepAlive { .. } => "set_keep_alive",
40809            DatagramSocketRequest::GetKeepAlive { .. } => "get_keep_alive",
40810            DatagramSocketRequest::SetOutOfBandInline { .. } => "set_out_of_band_inline",
40811            DatagramSocketRequest::GetOutOfBandInline { .. } => "get_out_of_band_inline",
40812            DatagramSocketRequest::SetNoCheck { .. } => "set_no_check",
40813            DatagramSocketRequest::GetNoCheck { .. } => "get_no_check",
40814            DatagramSocketRequest::SetLinger { .. } => "set_linger",
40815            DatagramSocketRequest::GetLinger { .. } => "get_linger",
40816            DatagramSocketRequest::SetReusePort { .. } => "set_reuse_port",
40817            DatagramSocketRequest::GetReusePort { .. } => "get_reuse_port",
40818            DatagramSocketRequest::GetAcceptConn { .. } => "get_accept_conn",
40819            DatagramSocketRequest::SetBindToDevice { .. } => "set_bind_to_device",
40820            DatagramSocketRequest::GetBindToDevice { .. } => "get_bind_to_device",
40821            DatagramSocketRequest::SetBindToInterfaceIndex { .. } => "set_bind_to_interface_index",
40822            DatagramSocketRequest::GetBindToInterfaceIndex { .. } => "get_bind_to_interface_index",
40823            DatagramSocketRequest::SetTimestamp { .. } => "set_timestamp",
40824            DatagramSocketRequest::GetTimestamp { .. } => "get_timestamp",
40825            DatagramSocketRequest::SetMark { .. } => "set_mark",
40826            DatagramSocketRequest::GetMark { .. } => "get_mark",
40827            DatagramSocketRequest::Bind { .. } => "bind",
40828            DatagramSocketRequest::Connect { .. } => "connect",
40829            DatagramSocketRequest::Disconnect { .. } => "disconnect",
40830            DatagramSocketRequest::GetSockName { .. } => "get_sock_name",
40831            DatagramSocketRequest::GetPeerName { .. } => "get_peer_name",
40832            DatagramSocketRequest::Shutdown { .. } => "shutdown",
40833            DatagramSocketRequest::SetIpTypeOfService { .. } => "set_ip_type_of_service",
40834            DatagramSocketRequest::GetIpTypeOfService { .. } => "get_ip_type_of_service",
40835            DatagramSocketRequest::SetIpTtl { .. } => "set_ip_ttl",
40836            DatagramSocketRequest::GetIpTtl { .. } => "get_ip_ttl",
40837            DatagramSocketRequest::SetIpPacketInfo { .. } => "set_ip_packet_info",
40838            DatagramSocketRequest::GetIpPacketInfo { .. } => "get_ip_packet_info",
40839            DatagramSocketRequest::SetIpReceiveTypeOfService { .. } => {
40840                "set_ip_receive_type_of_service"
40841            }
40842            DatagramSocketRequest::GetIpReceiveTypeOfService { .. } => {
40843                "get_ip_receive_type_of_service"
40844            }
40845            DatagramSocketRequest::SetIpReceiveTtl { .. } => "set_ip_receive_ttl",
40846            DatagramSocketRequest::GetIpReceiveTtl { .. } => "get_ip_receive_ttl",
40847            DatagramSocketRequest::SetIpMulticastInterface { .. } => "set_ip_multicast_interface",
40848            DatagramSocketRequest::GetIpMulticastInterface { .. } => "get_ip_multicast_interface",
40849            DatagramSocketRequest::SetIpMulticastTtl { .. } => "set_ip_multicast_ttl",
40850            DatagramSocketRequest::GetIpMulticastTtl { .. } => "get_ip_multicast_ttl",
40851            DatagramSocketRequest::SetIpMulticastLoopback { .. } => "set_ip_multicast_loopback",
40852            DatagramSocketRequest::GetIpMulticastLoopback { .. } => "get_ip_multicast_loopback",
40853            DatagramSocketRequest::AddIpMembership { .. } => "add_ip_membership",
40854            DatagramSocketRequest::DropIpMembership { .. } => "drop_ip_membership",
40855            DatagramSocketRequest::SetIpTransparent { .. } => "set_ip_transparent",
40856            DatagramSocketRequest::GetIpTransparent { .. } => "get_ip_transparent",
40857            DatagramSocketRequest::SetIpReceiveOriginalDestinationAddress { .. } => {
40858                "set_ip_receive_original_destination_address"
40859            }
40860            DatagramSocketRequest::GetIpReceiveOriginalDestinationAddress { .. } => {
40861                "get_ip_receive_original_destination_address"
40862            }
40863            DatagramSocketRequest::AddIpv6Membership { .. } => "add_ipv6_membership",
40864            DatagramSocketRequest::DropIpv6Membership { .. } => "drop_ipv6_membership",
40865            DatagramSocketRequest::SetIpv6MulticastInterface { .. } => {
40866                "set_ipv6_multicast_interface"
40867            }
40868            DatagramSocketRequest::GetIpv6MulticastInterface { .. } => {
40869                "get_ipv6_multicast_interface"
40870            }
40871            DatagramSocketRequest::SetIpv6UnicastHops { .. } => "set_ipv6_unicast_hops",
40872            DatagramSocketRequest::GetIpv6UnicastHops { .. } => "get_ipv6_unicast_hops",
40873            DatagramSocketRequest::SetIpv6ReceiveHopLimit { .. } => "set_ipv6_receive_hop_limit",
40874            DatagramSocketRequest::GetIpv6ReceiveHopLimit { .. } => "get_ipv6_receive_hop_limit",
40875            DatagramSocketRequest::SetIpv6MulticastHops { .. } => "set_ipv6_multicast_hops",
40876            DatagramSocketRequest::GetIpv6MulticastHops { .. } => "get_ipv6_multicast_hops",
40877            DatagramSocketRequest::SetIpv6MulticastLoopback { .. } => "set_ipv6_multicast_loopback",
40878            DatagramSocketRequest::GetIpv6MulticastLoopback { .. } => "get_ipv6_multicast_loopback",
40879            DatagramSocketRequest::SetIpv6Only { .. } => "set_ipv6_only",
40880            DatagramSocketRequest::GetIpv6Only { .. } => "get_ipv6_only",
40881            DatagramSocketRequest::SetIpv6ReceiveTrafficClass { .. } => {
40882                "set_ipv6_receive_traffic_class"
40883            }
40884            DatagramSocketRequest::GetIpv6ReceiveTrafficClass { .. } => {
40885                "get_ipv6_receive_traffic_class"
40886            }
40887            DatagramSocketRequest::SetIpv6TrafficClass { .. } => "set_ipv6_traffic_class",
40888            DatagramSocketRequest::GetIpv6TrafficClass { .. } => "get_ipv6_traffic_class",
40889            DatagramSocketRequest::SetIpv6ReceivePacketInfo { .. } => {
40890                "set_ipv6_receive_packet_info"
40891            }
40892            DatagramSocketRequest::GetIpv6ReceivePacketInfo { .. } => {
40893                "get_ipv6_receive_packet_info"
40894            }
40895            DatagramSocketRequest::GetOriginalDestination { .. } => "get_original_destination",
40896            DatagramSocketRequest::GetInfo { .. } => "get_info",
40897            DatagramSocketRequest::Describe { .. } => "describe",
40898            DatagramSocketRequest::SendMsgPreflight { .. } => "send_msg_preflight",
40899            DatagramSocketRequest::RecvMsgPostflight { .. } => "recv_msg_postflight",
40900        }
40901    }
40902}
40903
40904#[derive(Debug, Clone)]
40905pub struct DatagramSocketControlHandle {
40906    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
40907}
40908
40909impl fidl::endpoints::ControlHandle for DatagramSocketControlHandle {
40910    fn shutdown(&self) {
40911        self.inner.shutdown()
40912    }
40913    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
40914        self.inner.shutdown_with_epitaph(status)
40915    }
40916
40917    fn is_closed(&self) -> bool {
40918        self.inner.channel().is_closed()
40919    }
40920    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
40921        self.inner.channel().on_closed()
40922    }
40923
40924    #[cfg(target_os = "fuchsia")]
40925    fn signal_peer(
40926        &self,
40927        clear_mask: zx::Signals,
40928        set_mask: zx::Signals,
40929    ) -> Result<(), zx_status::Status> {
40930        use fidl::Peered;
40931        self.inner.channel().signal_peer(clear_mask, set_mask)
40932    }
40933}
40934
40935impl DatagramSocketControlHandle {}
40936
40937#[must_use = "FIDL methods require a response to be sent"]
40938#[derive(Debug)]
40939pub struct DatagramSocketCloseResponder {
40940    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
40941    tx_id: u32,
40942}
40943
40944/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
40945/// if the responder is dropped without sending a response, so that the client
40946/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
40947impl std::ops::Drop for DatagramSocketCloseResponder {
40948    fn drop(&mut self) {
40949        self.control_handle.shutdown();
40950        // Safety: drops once, never accessed again
40951        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
40952    }
40953}
40954
40955impl fidl::endpoints::Responder for DatagramSocketCloseResponder {
40956    type ControlHandle = DatagramSocketControlHandle;
40957
40958    fn control_handle(&self) -> &DatagramSocketControlHandle {
40959        &self.control_handle
40960    }
40961
40962    fn drop_without_shutdown(mut self) {
40963        // Safety: drops once, never accessed again due to mem::forget
40964        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
40965        // Prevent Drop from running (which would shut down the channel)
40966        std::mem::forget(self);
40967    }
40968}
40969
40970impl DatagramSocketCloseResponder {
40971    /// Sends a response to the FIDL transaction.
40972    ///
40973    /// Sets the channel to shutdown if an error occurs.
40974    pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
40975        let _result = self.send_raw(result);
40976        if _result.is_err() {
40977            self.control_handle.shutdown();
40978        }
40979        self.drop_without_shutdown();
40980        _result
40981    }
40982
40983    /// Similar to "send" but does not shutdown the channel if an error occurs.
40984    pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
40985        let _result = self.send_raw(result);
40986        self.drop_without_shutdown();
40987        _result
40988    }
40989
40990    fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
40991        self.control_handle
40992            .inner
40993            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
40994                result,
40995                self.tx_id,
40996                0x5ac5d459ad7f657e,
40997                fidl::encoding::DynamicFlags::empty(),
40998            )
40999    }
41000}
41001
41002#[must_use = "FIDL methods require a response to be sent"]
41003#[derive(Debug)]
41004pub struct DatagramSocketQueryResponder {
41005    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
41006    tx_id: u32,
41007}
41008
41009/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
41010/// if the responder is dropped without sending a response, so that the client
41011/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
41012impl std::ops::Drop for DatagramSocketQueryResponder {
41013    fn drop(&mut self) {
41014        self.control_handle.shutdown();
41015        // Safety: drops once, never accessed again
41016        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41017    }
41018}
41019
41020impl fidl::endpoints::Responder for DatagramSocketQueryResponder {
41021    type ControlHandle = DatagramSocketControlHandle;
41022
41023    fn control_handle(&self) -> &DatagramSocketControlHandle {
41024        &self.control_handle
41025    }
41026
41027    fn drop_without_shutdown(mut self) {
41028        // Safety: drops once, never accessed again due to mem::forget
41029        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41030        // Prevent Drop from running (which would shut down the channel)
41031        std::mem::forget(self);
41032    }
41033}
41034
41035impl DatagramSocketQueryResponder {
41036    /// Sends a response to the FIDL transaction.
41037    ///
41038    /// Sets the channel to shutdown if an error occurs.
41039    pub fn send(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
41040        let _result = self.send_raw(protocol);
41041        if _result.is_err() {
41042            self.control_handle.shutdown();
41043        }
41044        self.drop_without_shutdown();
41045        _result
41046    }
41047
41048    /// Similar to "send" but does not shutdown the channel if an error occurs.
41049    pub fn send_no_shutdown_on_err(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
41050        let _result = self.send_raw(protocol);
41051        self.drop_without_shutdown();
41052        _result
41053    }
41054
41055    fn send_raw(&self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
41056        self.control_handle.inner.send::<fidl_fuchsia_unknown::QueryableQueryResponse>(
41057            (protocol,),
41058            self.tx_id,
41059            0x2658edee9decfc06,
41060            fidl::encoding::DynamicFlags::empty(),
41061        )
41062    }
41063}
41064
41065#[must_use = "FIDL methods require a response to be sent"]
41066#[derive(Debug)]
41067pub struct DatagramSocketSetReuseAddressResponder {
41068    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
41069    tx_id: u32,
41070}
41071
41072/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
41073/// if the responder is dropped without sending a response, so that the client
41074/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
41075impl std::ops::Drop for DatagramSocketSetReuseAddressResponder {
41076    fn drop(&mut self) {
41077        self.control_handle.shutdown();
41078        // Safety: drops once, never accessed again
41079        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41080    }
41081}
41082
41083impl fidl::endpoints::Responder for DatagramSocketSetReuseAddressResponder {
41084    type ControlHandle = DatagramSocketControlHandle;
41085
41086    fn control_handle(&self) -> &DatagramSocketControlHandle {
41087        &self.control_handle
41088    }
41089
41090    fn drop_without_shutdown(mut self) {
41091        // Safety: drops once, never accessed again due to mem::forget
41092        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41093        // Prevent Drop from running (which would shut down the channel)
41094        std::mem::forget(self);
41095    }
41096}
41097
41098impl DatagramSocketSetReuseAddressResponder {
41099    /// Sends a response to the FIDL transaction.
41100    ///
41101    /// Sets the channel to shutdown if an error occurs.
41102    pub fn send(
41103        self,
41104        mut result: Result<(), fidl_fuchsia_posix::Errno>,
41105    ) -> Result<(), fidl::Error> {
41106        let _result = self.send_raw(result);
41107        if _result.is_err() {
41108            self.control_handle.shutdown();
41109        }
41110        self.drop_without_shutdown();
41111        _result
41112    }
41113
41114    /// Similar to "send" but does not shutdown the channel if an error occurs.
41115    pub fn send_no_shutdown_on_err(
41116        self,
41117        mut result: Result<(), fidl_fuchsia_posix::Errno>,
41118    ) -> Result<(), fidl::Error> {
41119        let _result = self.send_raw(result);
41120        self.drop_without_shutdown();
41121        _result
41122    }
41123
41124    fn send_raw(
41125        &self,
41126        mut result: Result<(), fidl_fuchsia_posix::Errno>,
41127    ) -> Result<(), fidl::Error> {
41128        self.control_handle.inner.send::<fidl::encoding::ResultType<
41129            fidl::encoding::EmptyStruct,
41130            fidl_fuchsia_posix::Errno,
41131        >>(
41132            result,
41133            self.tx_id,
41134            0x1fd74ee8b9a4a876,
41135            fidl::encoding::DynamicFlags::empty(),
41136        )
41137    }
41138}
41139
41140#[must_use = "FIDL methods require a response to be sent"]
41141#[derive(Debug)]
41142pub struct DatagramSocketGetReuseAddressResponder {
41143    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
41144    tx_id: u32,
41145}
41146
41147/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
41148/// if the responder is dropped without sending a response, so that the client
41149/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
41150impl std::ops::Drop for DatagramSocketGetReuseAddressResponder {
41151    fn drop(&mut self) {
41152        self.control_handle.shutdown();
41153        // Safety: drops once, never accessed again
41154        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41155    }
41156}
41157
41158impl fidl::endpoints::Responder for DatagramSocketGetReuseAddressResponder {
41159    type ControlHandle = DatagramSocketControlHandle;
41160
41161    fn control_handle(&self) -> &DatagramSocketControlHandle {
41162        &self.control_handle
41163    }
41164
41165    fn drop_without_shutdown(mut self) {
41166        // Safety: drops once, never accessed again due to mem::forget
41167        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41168        // Prevent Drop from running (which would shut down the channel)
41169        std::mem::forget(self);
41170    }
41171}
41172
41173impl DatagramSocketGetReuseAddressResponder {
41174    /// Sends a response to the FIDL transaction.
41175    ///
41176    /// Sets the channel to shutdown if an error occurs.
41177    pub fn send(
41178        self,
41179        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
41180    ) -> Result<(), fidl::Error> {
41181        let _result = self.send_raw(result);
41182        if _result.is_err() {
41183            self.control_handle.shutdown();
41184        }
41185        self.drop_without_shutdown();
41186        _result
41187    }
41188
41189    /// Similar to "send" but does not shutdown the channel if an error occurs.
41190    pub fn send_no_shutdown_on_err(
41191        self,
41192        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
41193    ) -> Result<(), fidl::Error> {
41194        let _result = self.send_raw(result);
41195        self.drop_without_shutdown();
41196        _result
41197    }
41198
41199    fn send_raw(
41200        &self,
41201        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
41202    ) -> Result<(), fidl::Error> {
41203        self.control_handle.inner.send::<fidl::encoding::ResultType<
41204            BaseSocketGetReuseAddressResponse,
41205            fidl_fuchsia_posix::Errno,
41206        >>(
41207            result.map(|value| (value,)),
41208            self.tx_id,
41209            0x67b7206b8d1bc0a5,
41210            fidl::encoding::DynamicFlags::empty(),
41211        )
41212    }
41213}
41214
41215#[must_use = "FIDL methods require a response to be sent"]
41216#[derive(Debug)]
41217pub struct DatagramSocketGetErrorResponder {
41218    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
41219    tx_id: u32,
41220}
41221
41222/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
41223/// if the responder is dropped without sending a response, so that the client
41224/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
41225impl std::ops::Drop for DatagramSocketGetErrorResponder {
41226    fn drop(&mut self) {
41227        self.control_handle.shutdown();
41228        // Safety: drops once, never accessed again
41229        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41230    }
41231}
41232
41233impl fidl::endpoints::Responder for DatagramSocketGetErrorResponder {
41234    type ControlHandle = DatagramSocketControlHandle;
41235
41236    fn control_handle(&self) -> &DatagramSocketControlHandle {
41237        &self.control_handle
41238    }
41239
41240    fn drop_without_shutdown(mut self) {
41241        // Safety: drops once, never accessed again due to mem::forget
41242        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41243        // Prevent Drop from running (which would shut down the channel)
41244        std::mem::forget(self);
41245    }
41246}
41247
41248impl DatagramSocketGetErrorResponder {
41249    /// Sends a response to the FIDL transaction.
41250    ///
41251    /// Sets the channel to shutdown if an error occurs.
41252    pub fn send(
41253        self,
41254        mut result: Result<(), fidl_fuchsia_posix::Errno>,
41255    ) -> Result<(), fidl::Error> {
41256        let _result = self.send_raw(result);
41257        if _result.is_err() {
41258            self.control_handle.shutdown();
41259        }
41260        self.drop_without_shutdown();
41261        _result
41262    }
41263
41264    /// Similar to "send" but does not shutdown the channel if an error occurs.
41265    pub fn send_no_shutdown_on_err(
41266        self,
41267        mut result: Result<(), fidl_fuchsia_posix::Errno>,
41268    ) -> Result<(), fidl::Error> {
41269        let _result = self.send_raw(result);
41270        self.drop_without_shutdown();
41271        _result
41272    }
41273
41274    fn send_raw(
41275        &self,
41276        mut result: Result<(), fidl_fuchsia_posix::Errno>,
41277    ) -> Result<(), fidl::Error> {
41278        self.control_handle.inner.send::<fidl::encoding::ResultType<
41279            fidl::encoding::EmptyStruct,
41280            fidl_fuchsia_posix::Errno,
41281        >>(
41282            result,
41283            self.tx_id,
41284            0x5aad39b33e5f6ebb,
41285            fidl::encoding::DynamicFlags::empty(),
41286        )
41287    }
41288}
41289
41290#[must_use = "FIDL methods require a response to be sent"]
41291#[derive(Debug)]
41292pub struct DatagramSocketSetBroadcastResponder {
41293    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
41294    tx_id: u32,
41295}
41296
41297/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
41298/// if the responder is dropped without sending a response, so that the client
41299/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
41300impl std::ops::Drop for DatagramSocketSetBroadcastResponder {
41301    fn drop(&mut self) {
41302        self.control_handle.shutdown();
41303        // Safety: drops once, never accessed again
41304        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41305    }
41306}
41307
41308impl fidl::endpoints::Responder for DatagramSocketSetBroadcastResponder {
41309    type ControlHandle = DatagramSocketControlHandle;
41310
41311    fn control_handle(&self) -> &DatagramSocketControlHandle {
41312        &self.control_handle
41313    }
41314
41315    fn drop_without_shutdown(mut self) {
41316        // Safety: drops once, never accessed again due to mem::forget
41317        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41318        // Prevent Drop from running (which would shut down the channel)
41319        std::mem::forget(self);
41320    }
41321}
41322
41323impl DatagramSocketSetBroadcastResponder {
41324    /// Sends a response to the FIDL transaction.
41325    ///
41326    /// Sets the channel to shutdown if an error occurs.
41327    pub fn send(
41328        self,
41329        mut result: Result<(), fidl_fuchsia_posix::Errno>,
41330    ) -> Result<(), fidl::Error> {
41331        let _result = self.send_raw(result);
41332        if _result.is_err() {
41333            self.control_handle.shutdown();
41334        }
41335        self.drop_without_shutdown();
41336        _result
41337    }
41338
41339    /// Similar to "send" but does not shutdown the channel if an error occurs.
41340    pub fn send_no_shutdown_on_err(
41341        self,
41342        mut result: Result<(), fidl_fuchsia_posix::Errno>,
41343    ) -> Result<(), fidl::Error> {
41344        let _result = self.send_raw(result);
41345        self.drop_without_shutdown();
41346        _result
41347    }
41348
41349    fn send_raw(
41350        &self,
41351        mut result: Result<(), fidl_fuchsia_posix::Errno>,
41352    ) -> Result<(), fidl::Error> {
41353        self.control_handle.inner.send::<fidl::encoding::ResultType<
41354            fidl::encoding::EmptyStruct,
41355            fidl_fuchsia_posix::Errno,
41356        >>(
41357            result,
41358            self.tx_id,
41359            0x6023e081ce3cd947,
41360            fidl::encoding::DynamicFlags::empty(),
41361        )
41362    }
41363}
41364
41365#[must_use = "FIDL methods require a response to be sent"]
41366#[derive(Debug)]
41367pub struct DatagramSocketGetBroadcastResponder {
41368    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
41369    tx_id: u32,
41370}
41371
41372/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
41373/// if the responder is dropped without sending a response, so that the client
41374/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
41375impl std::ops::Drop for DatagramSocketGetBroadcastResponder {
41376    fn drop(&mut self) {
41377        self.control_handle.shutdown();
41378        // Safety: drops once, never accessed again
41379        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41380    }
41381}
41382
41383impl fidl::endpoints::Responder for DatagramSocketGetBroadcastResponder {
41384    type ControlHandle = DatagramSocketControlHandle;
41385
41386    fn control_handle(&self) -> &DatagramSocketControlHandle {
41387        &self.control_handle
41388    }
41389
41390    fn drop_without_shutdown(mut self) {
41391        // Safety: drops once, never accessed again due to mem::forget
41392        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41393        // Prevent Drop from running (which would shut down the channel)
41394        std::mem::forget(self);
41395    }
41396}
41397
41398impl DatagramSocketGetBroadcastResponder {
41399    /// Sends a response to the FIDL transaction.
41400    ///
41401    /// Sets the channel to shutdown if an error occurs.
41402    pub fn send(
41403        self,
41404        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
41405    ) -> Result<(), fidl::Error> {
41406        let _result = self.send_raw(result);
41407        if _result.is_err() {
41408            self.control_handle.shutdown();
41409        }
41410        self.drop_without_shutdown();
41411        _result
41412    }
41413
41414    /// Similar to "send" but does not shutdown the channel if an error occurs.
41415    pub fn send_no_shutdown_on_err(
41416        self,
41417        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
41418    ) -> Result<(), fidl::Error> {
41419        let _result = self.send_raw(result);
41420        self.drop_without_shutdown();
41421        _result
41422    }
41423
41424    fn send_raw(
41425        &self,
41426        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
41427    ) -> Result<(), fidl::Error> {
41428        self.control_handle.inner.send::<fidl::encoding::ResultType<
41429            BaseSocketGetBroadcastResponse,
41430            fidl_fuchsia_posix::Errno,
41431        >>(
41432            result.map(|value| (value,)),
41433            self.tx_id,
41434            0x68796fc556f9780d,
41435            fidl::encoding::DynamicFlags::empty(),
41436        )
41437    }
41438}
41439
41440#[must_use = "FIDL methods require a response to be sent"]
41441#[derive(Debug)]
41442pub struct DatagramSocketSetSendBufferResponder {
41443    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
41444    tx_id: u32,
41445}
41446
41447/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
41448/// if the responder is dropped without sending a response, so that the client
41449/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
41450impl std::ops::Drop for DatagramSocketSetSendBufferResponder {
41451    fn drop(&mut self) {
41452        self.control_handle.shutdown();
41453        // Safety: drops once, never accessed again
41454        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41455    }
41456}
41457
41458impl fidl::endpoints::Responder for DatagramSocketSetSendBufferResponder {
41459    type ControlHandle = DatagramSocketControlHandle;
41460
41461    fn control_handle(&self) -> &DatagramSocketControlHandle {
41462        &self.control_handle
41463    }
41464
41465    fn drop_without_shutdown(mut self) {
41466        // Safety: drops once, never accessed again due to mem::forget
41467        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41468        // Prevent Drop from running (which would shut down the channel)
41469        std::mem::forget(self);
41470    }
41471}
41472
41473impl DatagramSocketSetSendBufferResponder {
41474    /// Sends a response to the FIDL transaction.
41475    ///
41476    /// Sets the channel to shutdown if an error occurs.
41477    pub fn send(
41478        self,
41479        mut result: Result<(), fidl_fuchsia_posix::Errno>,
41480    ) -> Result<(), fidl::Error> {
41481        let _result = self.send_raw(result);
41482        if _result.is_err() {
41483            self.control_handle.shutdown();
41484        }
41485        self.drop_without_shutdown();
41486        _result
41487    }
41488
41489    /// Similar to "send" but does not shutdown the channel if an error occurs.
41490    pub fn send_no_shutdown_on_err(
41491        self,
41492        mut result: Result<(), fidl_fuchsia_posix::Errno>,
41493    ) -> Result<(), fidl::Error> {
41494        let _result = self.send_raw(result);
41495        self.drop_without_shutdown();
41496        _result
41497    }
41498
41499    fn send_raw(
41500        &self,
41501        mut result: Result<(), fidl_fuchsia_posix::Errno>,
41502    ) -> Result<(), fidl::Error> {
41503        self.control_handle.inner.send::<fidl::encoding::ResultType<
41504            fidl::encoding::EmptyStruct,
41505            fidl_fuchsia_posix::Errno,
41506        >>(
41507            result,
41508            self.tx_id,
41509            0x756eac32d73a7a70,
41510            fidl::encoding::DynamicFlags::empty(),
41511        )
41512    }
41513}
41514
41515#[must_use = "FIDL methods require a response to be sent"]
41516#[derive(Debug)]
41517pub struct DatagramSocketGetSendBufferResponder {
41518    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
41519    tx_id: u32,
41520}
41521
41522/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
41523/// if the responder is dropped without sending a response, so that the client
41524/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
41525impl std::ops::Drop for DatagramSocketGetSendBufferResponder {
41526    fn drop(&mut self) {
41527        self.control_handle.shutdown();
41528        // Safety: drops once, never accessed again
41529        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41530    }
41531}
41532
41533impl fidl::endpoints::Responder for DatagramSocketGetSendBufferResponder {
41534    type ControlHandle = DatagramSocketControlHandle;
41535
41536    fn control_handle(&self) -> &DatagramSocketControlHandle {
41537        &self.control_handle
41538    }
41539
41540    fn drop_without_shutdown(mut self) {
41541        // Safety: drops once, never accessed again due to mem::forget
41542        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41543        // Prevent Drop from running (which would shut down the channel)
41544        std::mem::forget(self);
41545    }
41546}
41547
41548impl DatagramSocketGetSendBufferResponder {
41549    /// Sends a response to the FIDL transaction.
41550    ///
41551    /// Sets the channel to shutdown if an error occurs.
41552    pub fn send(
41553        self,
41554        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
41555    ) -> Result<(), fidl::Error> {
41556        let _result = self.send_raw(result);
41557        if _result.is_err() {
41558            self.control_handle.shutdown();
41559        }
41560        self.drop_without_shutdown();
41561        _result
41562    }
41563
41564    /// Similar to "send" but does not shutdown the channel if an error occurs.
41565    pub fn send_no_shutdown_on_err(
41566        self,
41567        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
41568    ) -> Result<(), fidl::Error> {
41569        let _result = self.send_raw(result);
41570        self.drop_without_shutdown();
41571        _result
41572    }
41573
41574    fn send_raw(
41575        &self,
41576        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
41577    ) -> Result<(), fidl::Error> {
41578        self.control_handle.inner.send::<fidl::encoding::ResultType<
41579            BaseSocketGetSendBufferResponse,
41580            fidl_fuchsia_posix::Errno,
41581        >>(
41582            result.map(|value_bytes| (value_bytes,)),
41583            self.tx_id,
41584            0x78a52fd9c7b2410b,
41585            fidl::encoding::DynamicFlags::empty(),
41586        )
41587    }
41588}
41589
41590#[must_use = "FIDL methods require a response to be sent"]
41591#[derive(Debug)]
41592pub struct DatagramSocketSetReceiveBufferResponder {
41593    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
41594    tx_id: u32,
41595}
41596
41597/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
41598/// if the responder is dropped without sending a response, so that the client
41599/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
41600impl std::ops::Drop for DatagramSocketSetReceiveBufferResponder {
41601    fn drop(&mut self) {
41602        self.control_handle.shutdown();
41603        // Safety: drops once, never accessed again
41604        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41605    }
41606}
41607
41608impl fidl::endpoints::Responder for DatagramSocketSetReceiveBufferResponder {
41609    type ControlHandle = DatagramSocketControlHandle;
41610
41611    fn control_handle(&self) -> &DatagramSocketControlHandle {
41612        &self.control_handle
41613    }
41614
41615    fn drop_without_shutdown(mut self) {
41616        // Safety: drops once, never accessed again due to mem::forget
41617        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41618        // Prevent Drop from running (which would shut down the channel)
41619        std::mem::forget(self);
41620    }
41621}
41622
41623impl DatagramSocketSetReceiveBufferResponder {
41624    /// Sends a response to the FIDL transaction.
41625    ///
41626    /// Sets the channel to shutdown if an error occurs.
41627    pub fn send(
41628        self,
41629        mut result: Result<(), fidl_fuchsia_posix::Errno>,
41630    ) -> Result<(), fidl::Error> {
41631        let _result = self.send_raw(result);
41632        if _result.is_err() {
41633            self.control_handle.shutdown();
41634        }
41635        self.drop_without_shutdown();
41636        _result
41637    }
41638
41639    /// Similar to "send" but does not shutdown the channel if an error occurs.
41640    pub fn send_no_shutdown_on_err(
41641        self,
41642        mut result: Result<(), fidl_fuchsia_posix::Errno>,
41643    ) -> Result<(), fidl::Error> {
41644        let _result = self.send_raw(result);
41645        self.drop_without_shutdown();
41646        _result
41647    }
41648
41649    fn send_raw(
41650        &self,
41651        mut result: Result<(), fidl_fuchsia_posix::Errno>,
41652    ) -> Result<(), fidl::Error> {
41653        self.control_handle.inner.send::<fidl::encoding::ResultType<
41654            fidl::encoding::EmptyStruct,
41655            fidl_fuchsia_posix::Errno,
41656        >>(
41657            result,
41658            self.tx_id,
41659            0x6b0cf2f1919c7001,
41660            fidl::encoding::DynamicFlags::empty(),
41661        )
41662    }
41663}
41664
41665#[must_use = "FIDL methods require a response to be sent"]
41666#[derive(Debug)]
41667pub struct DatagramSocketGetReceiveBufferResponder {
41668    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
41669    tx_id: u32,
41670}
41671
41672/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
41673/// if the responder is dropped without sending a response, so that the client
41674/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
41675impl std::ops::Drop for DatagramSocketGetReceiveBufferResponder {
41676    fn drop(&mut self) {
41677        self.control_handle.shutdown();
41678        // Safety: drops once, never accessed again
41679        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41680    }
41681}
41682
41683impl fidl::endpoints::Responder for DatagramSocketGetReceiveBufferResponder {
41684    type ControlHandle = DatagramSocketControlHandle;
41685
41686    fn control_handle(&self) -> &DatagramSocketControlHandle {
41687        &self.control_handle
41688    }
41689
41690    fn drop_without_shutdown(mut self) {
41691        // Safety: drops once, never accessed again due to mem::forget
41692        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41693        // Prevent Drop from running (which would shut down the channel)
41694        std::mem::forget(self);
41695    }
41696}
41697
41698impl DatagramSocketGetReceiveBufferResponder {
41699    /// Sends a response to the FIDL transaction.
41700    ///
41701    /// Sets the channel to shutdown if an error occurs.
41702    pub fn send(
41703        self,
41704        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
41705    ) -> Result<(), fidl::Error> {
41706        let _result = self.send_raw(result);
41707        if _result.is_err() {
41708            self.control_handle.shutdown();
41709        }
41710        self.drop_without_shutdown();
41711        _result
41712    }
41713
41714    /// Similar to "send" but does not shutdown the channel if an error occurs.
41715    pub fn send_no_shutdown_on_err(
41716        self,
41717        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
41718    ) -> Result<(), fidl::Error> {
41719        let _result = self.send_raw(result);
41720        self.drop_without_shutdown();
41721        _result
41722    }
41723
41724    fn send_raw(
41725        &self,
41726        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
41727    ) -> Result<(), fidl::Error> {
41728        self.control_handle.inner.send::<fidl::encoding::ResultType<
41729            BaseSocketGetReceiveBufferResponse,
41730            fidl_fuchsia_posix::Errno,
41731        >>(
41732            result.map(|value_bytes| (value_bytes,)),
41733            self.tx_id,
41734            0x14c1a4b64f709e5c,
41735            fidl::encoding::DynamicFlags::empty(),
41736        )
41737    }
41738}
41739
41740#[must_use = "FIDL methods require a response to be sent"]
41741#[derive(Debug)]
41742pub struct DatagramSocketSetKeepAliveResponder {
41743    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
41744    tx_id: u32,
41745}
41746
41747/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
41748/// if the responder is dropped without sending a response, so that the client
41749/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
41750impl std::ops::Drop for DatagramSocketSetKeepAliveResponder {
41751    fn drop(&mut self) {
41752        self.control_handle.shutdown();
41753        // Safety: drops once, never accessed again
41754        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41755    }
41756}
41757
41758impl fidl::endpoints::Responder for DatagramSocketSetKeepAliveResponder {
41759    type ControlHandle = DatagramSocketControlHandle;
41760
41761    fn control_handle(&self) -> &DatagramSocketControlHandle {
41762        &self.control_handle
41763    }
41764
41765    fn drop_without_shutdown(mut self) {
41766        // Safety: drops once, never accessed again due to mem::forget
41767        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41768        // Prevent Drop from running (which would shut down the channel)
41769        std::mem::forget(self);
41770    }
41771}
41772
41773impl DatagramSocketSetKeepAliveResponder {
41774    /// Sends a response to the FIDL transaction.
41775    ///
41776    /// Sets the channel to shutdown if an error occurs.
41777    pub fn send(
41778        self,
41779        mut result: Result<(), fidl_fuchsia_posix::Errno>,
41780    ) -> Result<(), fidl::Error> {
41781        let _result = self.send_raw(result);
41782        if _result.is_err() {
41783            self.control_handle.shutdown();
41784        }
41785        self.drop_without_shutdown();
41786        _result
41787    }
41788
41789    /// Similar to "send" but does not shutdown the channel if an error occurs.
41790    pub fn send_no_shutdown_on_err(
41791        self,
41792        mut result: Result<(), fidl_fuchsia_posix::Errno>,
41793    ) -> Result<(), fidl::Error> {
41794        let _result = self.send_raw(result);
41795        self.drop_without_shutdown();
41796        _result
41797    }
41798
41799    fn send_raw(
41800        &self,
41801        mut result: Result<(), fidl_fuchsia_posix::Errno>,
41802    ) -> Result<(), fidl::Error> {
41803        self.control_handle.inner.send::<fidl::encoding::ResultType<
41804            fidl::encoding::EmptyStruct,
41805            fidl_fuchsia_posix::Errno,
41806        >>(
41807            result,
41808            self.tx_id,
41809            0x572df8f0b920d2c7,
41810            fidl::encoding::DynamicFlags::empty(),
41811        )
41812    }
41813}
41814
41815#[must_use = "FIDL methods require a response to be sent"]
41816#[derive(Debug)]
41817pub struct DatagramSocketGetKeepAliveResponder {
41818    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
41819    tx_id: u32,
41820}
41821
41822/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
41823/// if the responder is dropped without sending a response, so that the client
41824/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
41825impl std::ops::Drop for DatagramSocketGetKeepAliveResponder {
41826    fn drop(&mut self) {
41827        self.control_handle.shutdown();
41828        // Safety: drops once, never accessed again
41829        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41830    }
41831}
41832
41833impl fidl::endpoints::Responder for DatagramSocketGetKeepAliveResponder {
41834    type ControlHandle = DatagramSocketControlHandle;
41835
41836    fn control_handle(&self) -> &DatagramSocketControlHandle {
41837        &self.control_handle
41838    }
41839
41840    fn drop_without_shutdown(mut self) {
41841        // Safety: drops once, never accessed again due to mem::forget
41842        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41843        // Prevent Drop from running (which would shut down the channel)
41844        std::mem::forget(self);
41845    }
41846}
41847
41848impl DatagramSocketGetKeepAliveResponder {
41849    /// Sends a response to the FIDL transaction.
41850    ///
41851    /// Sets the channel to shutdown if an error occurs.
41852    pub fn send(
41853        self,
41854        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
41855    ) -> Result<(), fidl::Error> {
41856        let _result = self.send_raw(result);
41857        if _result.is_err() {
41858            self.control_handle.shutdown();
41859        }
41860        self.drop_without_shutdown();
41861        _result
41862    }
41863
41864    /// Similar to "send" but does not shutdown the channel if an error occurs.
41865    pub fn send_no_shutdown_on_err(
41866        self,
41867        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
41868    ) -> Result<(), fidl::Error> {
41869        let _result = self.send_raw(result);
41870        self.drop_without_shutdown();
41871        _result
41872    }
41873
41874    fn send_raw(
41875        &self,
41876        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
41877    ) -> Result<(), fidl::Error> {
41878        self.control_handle.inner.send::<fidl::encoding::ResultType<
41879            BaseSocketGetKeepAliveResponse,
41880            fidl_fuchsia_posix::Errno,
41881        >>(
41882            result.map(|value| (value,)),
41883            self.tx_id,
41884            0x2dd29d3215f2c9d2,
41885            fidl::encoding::DynamicFlags::empty(),
41886        )
41887    }
41888}
41889
41890#[must_use = "FIDL methods require a response to be sent"]
41891#[derive(Debug)]
41892pub struct DatagramSocketSetOutOfBandInlineResponder {
41893    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
41894    tx_id: u32,
41895}
41896
41897/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
41898/// if the responder is dropped without sending a response, so that the client
41899/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
41900impl std::ops::Drop for DatagramSocketSetOutOfBandInlineResponder {
41901    fn drop(&mut self) {
41902        self.control_handle.shutdown();
41903        // Safety: drops once, never accessed again
41904        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41905    }
41906}
41907
41908impl fidl::endpoints::Responder for DatagramSocketSetOutOfBandInlineResponder {
41909    type ControlHandle = DatagramSocketControlHandle;
41910
41911    fn control_handle(&self) -> &DatagramSocketControlHandle {
41912        &self.control_handle
41913    }
41914
41915    fn drop_without_shutdown(mut self) {
41916        // Safety: drops once, never accessed again due to mem::forget
41917        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41918        // Prevent Drop from running (which would shut down the channel)
41919        std::mem::forget(self);
41920    }
41921}
41922
41923impl DatagramSocketSetOutOfBandInlineResponder {
41924    /// Sends a response to the FIDL transaction.
41925    ///
41926    /// Sets the channel to shutdown if an error occurs.
41927    pub fn send(
41928        self,
41929        mut result: Result<(), fidl_fuchsia_posix::Errno>,
41930    ) -> Result<(), fidl::Error> {
41931        let _result = self.send_raw(result);
41932        if _result.is_err() {
41933            self.control_handle.shutdown();
41934        }
41935        self.drop_without_shutdown();
41936        _result
41937    }
41938
41939    /// Similar to "send" but does not shutdown the channel if an error occurs.
41940    pub fn send_no_shutdown_on_err(
41941        self,
41942        mut result: Result<(), fidl_fuchsia_posix::Errno>,
41943    ) -> Result<(), fidl::Error> {
41944        let _result = self.send_raw(result);
41945        self.drop_without_shutdown();
41946        _result
41947    }
41948
41949    fn send_raw(
41950        &self,
41951        mut result: Result<(), fidl_fuchsia_posix::Errno>,
41952    ) -> Result<(), fidl::Error> {
41953        self.control_handle.inner.send::<fidl::encoding::ResultType<
41954            fidl::encoding::EmptyStruct,
41955            fidl_fuchsia_posix::Errno,
41956        >>(
41957            result,
41958            self.tx_id,
41959            0x3ecb49968bee439,
41960            fidl::encoding::DynamicFlags::empty(),
41961        )
41962    }
41963}
41964
41965#[must_use = "FIDL methods require a response to be sent"]
41966#[derive(Debug)]
41967pub struct DatagramSocketGetOutOfBandInlineResponder {
41968    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
41969    tx_id: u32,
41970}
41971
41972/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
41973/// if the responder is dropped without sending a response, so that the client
41974/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
41975impl std::ops::Drop for DatagramSocketGetOutOfBandInlineResponder {
41976    fn drop(&mut self) {
41977        self.control_handle.shutdown();
41978        // Safety: drops once, never accessed again
41979        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41980    }
41981}
41982
41983impl fidl::endpoints::Responder for DatagramSocketGetOutOfBandInlineResponder {
41984    type ControlHandle = DatagramSocketControlHandle;
41985
41986    fn control_handle(&self) -> &DatagramSocketControlHandle {
41987        &self.control_handle
41988    }
41989
41990    fn drop_without_shutdown(mut self) {
41991        // Safety: drops once, never accessed again due to mem::forget
41992        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
41993        // Prevent Drop from running (which would shut down the channel)
41994        std::mem::forget(self);
41995    }
41996}
41997
41998impl DatagramSocketGetOutOfBandInlineResponder {
41999    /// Sends a response to the FIDL transaction.
42000    ///
42001    /// Sets the channel to shutdown if an error occurs.
42002    pub fn send(
42003        self,
42004        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
42005    ) -> Result<(), fidl::Error> {
42006        let _result = self.send_raw(result);
42007        if _result.is_err() {
42008            self.control_handle.shutdown();
42009        }
42010        self.drop_without_shutdown();
42011        _result
42012    }
42013
42014    /// Similar to "send" but does not shutdown the channel if an error occurs.
42015    pub fn send_no_shutdown_on_err(
42016        self,
42017        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
42018    ) -> Result<(), fidl::Error> {
42019        let _result = self.send_raw(result);
42020        self.drop_without_shutdown();
42021        _result
42022    }
42023
42024    fn send_raw(
42025        &self,
42026        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
42027    ) -> Result<(), fidl::Error> {
42028        self.control_handle.inner.send::<fidl::encoding::ResultType<
42029            BaseSocketGetOutOfBandInlineResponse,
42030            fidl_fuchsia_posix::Errno,
42031        >>(
42032            result.map(|value| (value,)),
42033            self.tx_id,
42034            0x348c1ab3aeca1745,
42035            fidl::encoding::DynamicFlags::empty(),
42036        )
42037    }
42038}
42039
42040#[must_use = "FIDL methods require a response to be sent"]
42041#[derive(Debug)]
42042pub struct DatagramSocketSetNoCheckResponder {
42043    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
42044    tx_id: u32,
42045}
42046
42047/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
42048/// if the responder is dropped without sending a response, so that the client
42049/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
42050impl std::ops::Drop for DatagramSocketSetNoCheckResponder {
42051    fn drop(&mut self) {
42052        self.control_handle.shutdown();
42053        // Safety: drops once, never accessed again
42054        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42055    }
42056}
42057
42058impl fidl::endpoints::Responder for DatagramSocketSetNoCheckResponder {
42059    type ControlHandle = DatagramSocketControlHandle;
42060
42061    fn control_handle(&self) -> &DatagramSocketControlHandle {
42062        &self.control_handle
42063    }
42064
42065    fn drop_without_shutdown(mut self) {
42066        // Safety: drops once, never accessed again due to mem::forget
42067        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42068        // Prevent Drop from running (which would shut down the channel)
42069        std::mem::forget(self);
42070    }
42071}
42072
42073impl DatagramSocketSetNoCheckResponder {
42074    /// Sends a response to the FIDL transaction.
42075    ///
42076    /// Sets the channel to shutdown if an error occurs.
42077    pub fn send(
42078        self,
42079        mut result: Result<(), fidl_fuchsia_posix::Errno>,
42080    ) -> Result<(), fidl::Error> {
42081        let _result = self.send_raw(result);
42082        if _result.is_err() {
42083            self.control_handle.shutdown();
42084        }
42085        self.drop_without_shutdown();
42086        _result
42087    }
42088
42089    /// Similar to "send" but does not shutdown the channel if an error occurs.
42090    pub fn send_no_shutdown_on_err(
42091        self,
42092        mut result: Result<(), fidl_fuchsia_posix::Errno>,
42093    ) -> Result<(), fidl::Error> {
42094        let _result = self.send_raw(result);
42095        self.drop_without_shutdown();
42096        _result
42097    }
42098
42099    fn send_raw(
42100        &self,
42101        mut result: Result<(), fidl_fuchsia_posix::Errno>,
42102    ) -> Result<(), fidl::Error> {
42103        self.control_handle.inner.send::<fidl::encoding::ResultType<
42104            fidl::encoding::EmptyStruct,
42105            fidl_fuchsia_posix::Errno,
42106        >>(
42107            result,
42108            self.tx_id,
42109            0x6bbf00c53a4c78c2,
42110            fidl::encoding::DynamicFlags::empty(),
42111        )
42112    }
42113}
42114
42115#[must_use = "FIDL methods require a response to be sent"]
42116#[derive(Debug)]
42117pub struct DatagramSocketGetNoCheckResponder {
42118    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
42119    tx_id: u32,
42120}
42121
42122/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
42123/// if the responder is dropped without sending a response, so that the client
42124/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
42125impl std::ops::Drop for DatagramSocketGetNoCheckResponder {
42126    fn drop(&mut self) {
42127        self.control_handle.shutdown();
42128        // Safety: drops once, never accessed again
42129        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42130    }
42131}
42132
42133impl fidl::endpoints::Responder for DatagramSocketGetNoCheckResponder {
42134    type ControlHandle = DatagramSocketControlHandle;
42135
42136    fn control_handle(&self) -> &DatagramSocketControlHandle {
42137        &self.control_handle
42138    }
42139
42140    fn drop_without_shutdown(mut self) {
42141        // Safety: drops once, never accessed again due to mem::forget
42142        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42143        // Prevent Drop from running (which would shut down the channel)
42144        std::mem::forget(self);
42145    }
42146}
42147
42148impl DatagramSocketGetNoCheckResponder {
42149    /// Sends a response to the FIDL transaction.
42150    ///
42151    /// Sets the channel to shutdown if an error occurs.
42152    pub fn send(
42153        self,
42154        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
42155    ) -> Result<(), fidl::Error> {
42156        let _result = self.send_raw(result);
42157        if _result.is_err() {
42158            self.control_handle.shutdown();
42159        }
42160        self.drop_without_shutdown();
42161        _result
42162    }
42163
42164    /// Similar to "send" but does not shutdown the channel if an error occurs.
42165    pub fn send_no_shutdown_on_err(
42166        self,
42167        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
42168    ) -> Result<(), fidl::Error> {
42169        let _result = self.send_raw(result);
42170        self.drop_without_shutdown();
42171        _result
42172    }
42173
42174    fn send_raw(
42175        &self,
42176        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
42177    ) -> Result<(), fidl::Error> {
42178        self.control_handle.inner.send::<fidl::encoding::ResultType<
42179            BaseSocketGetNoCheckResponse,
42180            fidl_fuchsia_posix::Errno,
42181        >>(
42182            result.map(|value| (value,)),
42183            self.tx_id,
42184            0x2cd4249286417694,
42185            fidl::encoding::DynamicFlags::empty(),
42186        )
42187    }
42188}
42189
42190#[must_use = "FIDL methods require a response to be sent"]
42191#[derive(Debug)]
42192pub struct DatagramSocketSetLingerResponder {
42193    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
42194    tx_id: u32,
42195}
42196
42197/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
42198/// if the responder is dropped without sending a response, so that the client
42199/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
42200impl std::ops::Drop for DatagramSocketSetLingerResponder {
42201    fn drop(&mut self) {
42202        self.control_handle.shutdown();
42203        // Safety: drops once, never accessed again
42204        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42205    }
42206}
42207
42208impl fidl::endpoints::Responder for DatagramSocketSetLingerResponder {
42209    type ControlHandle = DatagramSocketControlHandle;
42210
42211    fn control_handle(&self) -> &DatagramSocketControlHandle {
42212        &self.control_handle
42213    }
42214
42215    fn drop_without_shutdown(mut self) {
42216        // Safety: drops once, never accessed again due to mem::forget
42217        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42218        // Prevent Drop from running (which would shut down the channel)
42219        std::mem::forget(self);
42220    }
42221}
42222
42223impl DatagramSocketSetLingerResponder {
42224    /// Sends a response to the FIDL transaction.
42225    ///
42226    /// Sets the channel to shutdown if an error occurs.
42227    pub fn send(
42228        self,
42229        mut result: Result<(), fidl_fuchsia_posix::Errno>,
42230    ) -> Result<(), fidl::Error> {
42231        let _result = self.send_raw(result);
42232        if _result.is_err() {
42233            self.control_handle.shutdown();
42234        }
42235        self.drop_without_shutdown();
42236        _result
42237    }
42238
42239    /// Similar to "send" but does not shutdown the channel if an error occurs.
42240    pub fn send_no_shutdown_on_err(
42241        self,
42242        mut result: Result<(), fidl_fuchsia_posix::Errno>,
42243    ) -> Result<(), fidl::Error> {
42244        let _result = self.send_raw(result);
42245        self.drop_without_shutdown();
42246        _result
42247    }
42248
42249    fn send_raw(
42250        &self,
42251        mut result: Result<(), fidl_fuchsia_posix::Errno>,
42252    ) -> Result<(), fidl::Error> {
42253        self.control_handle.inner.send::<fidl::encoding::ResultType<
42254            fidl::encoding::EmptyStruct,
42255            fidl_fuchsia_posix::Errno,
42256        >>(
42257            result,
42258            self.tx_id,
42259            0x45386351246e998e,
42260            fidl::encoding::DynamicFlags::empty(),
42261        )
42262    }
42263}
42264
42265#[must_use = "FIDL methods require a response to be sent"]
42266#[derive(Debug)]
42267pub struct DatagramSocketGetLingerResponder {
42268    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
42269    tx_id: u32,
42270}
42271
42272/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
42273/// if the responder is dropped without sending a response, so that the client
42274/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
42275impl std::ops::Drop for DatagramSocketGetLingerResponder {
42276    fn drop(&mut self) {
42277        self.control_handle.shutdown();
42278        // Safety: drops once, never accessed again
42279        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42280    }
42281}
42282
42283impl fidl::endpoints::Responder for DatagramSocketGetLingerResponder {
42284    type ControlHandle = DatagramSocketControlHandle;
42285
42286    fn control_handle(&self) -> &DatagramSocketControlHandle {
42287        &self.control_handle
42288    }
42289
42290    fn drop_without_shutdown(mut self) {
42291        // Safety: drops once, never accessed again due to mem::forget
42292        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42293        // Prevent Drop from running (which would shut down the channel)
42294        std::mem::forget(self);
42295    }
42296}
42297
42298impl DatagramSocketGetLingerResponder {
42299    /// Sends a response to the FIDL transaction.
42300    ///
42301    /// Sets the channel to shutdown if an error occurs.
42302    pub fn send(
42303        self,
42304        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
42305    ) -> Result<(), fidl::Error> {
42306        let _result = self.send_raw(result);
42307        if _result.is_err() {
42308            self.control_handle.shutdown();
42309        }
42310        self.drop_without_shutdown();
42311        _result
42312    }
42313
42314    /// Similar to "send" but does not shutdown the channel if an error occurs.
42315    pub fn send_no_shutdown_on_err(
42316        self,
42317        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
42318    ) -> Result<(), fidl::Error> {
42319        let _result = self.send_raw(result);
42320        self.drop_without_shutdown();
42321        _result
42322    }
42323
42324    fn send_raw(
42325        &self,
42326        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
42327    ) -> Result<(), fidl::Error> {
42328        self.control_handle.inner.send::<fidl::encoding::ResultType<
42329            BaseSocketGetLingerResponse,
42330            fidl_fuchsia_posix::Errno,
42331        >>(
42332            result,
42333            self.tx_id,
42334            0x48eb20fc5ccb0e45,
42335            fidl::encoding::DynamicFlags::empty(),
42336        )
42337    }
42338}
42339
42340#[must_use = "FIDL methods require a response to be sent"]
42341#[derive(Debug)]
42342pub struct DatagramSocketSetReusePortResponder {
42343    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
42344    tx_id: u32,
42345}
42346
42347/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
42348/// if the responder is dropped without sending a response, so that the client
42349/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
42350impl std::ops::Drop for DatagramSocketSetReusePortResponder {
42351    fn drop(&mut self) {
42352        self.control_handle.shutdown();
42353        // Safety: drops once, never accessed again
42354        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42355    }
42356}
42357
42358impl fidl::endpoints::Responder for DatagramSocketSetReusePortResponder {
42359    type ControlHandle = DatagramSocketControlHandle;
42360
42361    fn control_handle(&self) -> &DatagramSocketControlHandle {
42362        &self.control_handle
42363    }
42364
42365    fn drop_without_shutdown(mut self) {
42366        // Safety: drops once, never accessed again due to mem::forget
42367        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42368        // Prevent Drop from running (which would shut down the channel)
42369        std::mem::forget(self);
42370    }
42371}
42372
42373impl DatagramSocketSetReusePortResponder {
42374    /// Sends a response to the FIDL transaction.
42375    ///
42376    /// Sets the channel to shutdown if an error occurs.
42377    pub fn send(
42378        self,
42379        mut result: Result<(), fidl_fuchsia_posix::Errno>,
42380    ) -> Result<(), fidl::Error> {
42381        let _result = self.send_raw(result);
42382        if _result.is_err() {
42383            self.control_handle.shutdown();
42384        }
42385        self.drop_without_shutdown();
42386        _result
42387    }
42388
42389    /// Similar to "send" but does not shutdown the channel if an error occurs.
42390    pub fn send_no_shutdown_on_err(
42391        self,
42392        mut result: Result<(), fidl_fuchsia_posix::Errno>,
42393    ) -> Result<(), fidl::Error> {
42394        let _result = self.send_raw(result);
42395        self.drop_without_shutdown();
42396        _result
42397    }
42398
42399    fn send_raw(
42400        &self,
42401        mut result: Result<(), fidl_fuchsia_posix::Errno>,
42402    ) -> Result<(), fidl::Error> {
42403        self.control_handle.inner.send::<fidl::encoding::ResultType<
42404            fidl::encoding::EmptyStruct,
42405            fidl_fuchsia_posix::Errno,
42406        >>(
42407            result,
42408            self.tx_id,
42409            0x24dd3e5cb36d9ccb,
42410            fidl::encoding::DynamicFlags::empty(),
42411        )
42412    }
42413}
42414
42415#[must_use = "FIDL methods require a response to be sent"]
42416#[derive(Debug)]
42417pub struct DatagramSocketGetReusePortResponder {
42418    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
42419    tx_id: u32,
42420}
42421
42422/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
42423/// if the responder is dropped without sending a response, so that the client
42424/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
42425impl std::ops::Drop for DatagramSocketGetReusePortResponder {
42426    fn drop(&mut self) {
42427        self.control_handle.shutdown();
42428        // Safety: drops once, never accessed again
42429        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42430    }
42431}
42432
42433impl fidl::endpoints::Responder for DatagramSocketGetReusePortResponder {
42434    type ControlHandle = DatagramSocketControlHandle;
42435
42436    fn control_handle(&self) -> &DatagramSocketControlHandle {
42437        &self.control_handle
42438    }
42439
42440    fn drop_without_shutdown(mut self) {
42441        // Safety: drops once, never accessed again due to mem::forget
42442        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42443        // Prevent Drop from running (which would shut down the channel)
42444        std::mem::forget(self);
42445    }
42446}
42447
42448impl DatagramSocketGetReusePortResponder {
42449    /// Sends a response to the FIDL transaction.
42450    ///
42451    /// Sets the channel to shutdown if an error occurs.
42452    pub fn send(
42453        self,
42454        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
42455    ) -> Result<(), fidl::Error> {
42456        let _result = self.send_raw(result);
42457        if _result.is_err() {
42458            self.control_handle.shutdown();
42459        }
42460        self.drop_without_shutdown();
42461        _result
42462    }
42463
42464    /// Similar to "send" but does not shutdown the channel if an error occurs.
42465    pub fn send_no_shutdown_on_err(
42466        self,
42467        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
42468    ) -> Result<(), fidl::Error> {
42469        let _result = self.send_raw(result);
42470        self.drop_without_shutdown();
42471        _result
42472    }
42473
42474    fn send_raw(
42475        &self,
42476        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
42477    ) -> Result<(), fidl::Error> {
42478        self.control_handle.inner.send::<fidl::encoding::ResultType<
42479            BaseSocketGetReusePortResponse,
42480            fidl_fuchsia_posix::Errno,
42481        >>(
42482            result.map(|value| (value,)),
42483            self.tx_id,
42484            0x7a112c1ab54ff828,
42485            fidl::encoding::DynamicFlags::empty(),
42486        )
42487    }
42488}
42489
42490#[must_use = "FIDL methods require a response to be sent"]
42491#[derive(Debug)]
42492pub struct DatagramSocketGetAcceptConnResponder {
42493    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
42494    tx_id: u32,
42495}
42496
42497/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
42498/// if the responder is dropped without sending a response, so that the client
42499/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
42500impl std::ops::Drop for DatagramSocketGetAcceptConnResponder {
42501    fn drop(&mut self) {
42502        self.control_handle.shutdown();
42503        // Safety: drops once, never accessed again
42504        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42505    }
42506}
42507
42508impl fidl::endpoints::Responder for DatagramSocketGetAcceptConnResponder {
42509    type ControlHandle = DatagramSocketControlHandle;
42510
42511    fn control_handle(&self) -> &DatagramSocketControlHandle {
42512        &self.control_handle
42513    }
42514
42515    fn drop_without_shutdown(mut self) {
42516        // Safety: drops once, never accessed again due to mem::forget
42517        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42518        // Prevent Drop from running (which would shut down the channel)
42519        std::mem::forget(self);
42520    }
42521}
42522
42523impl DatagramSocketGetAcceptConnResponder {
42524    /// Sends a response to the FIDL transaction.
42525    ///
42526    /// Sets the channel to shutdown if an error occurs.
42527    pub fn send(
42528        self,
42529        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
42530    ) -> Result<(), fidl::Error> {
42531        let _result = self.send_raw(result);
42532        if _result.is_err() {
42533            self.control_handle.shutdown();
42534        }
42535        self.drop_without_shutdown();
42536        _result
42537    }
42538
42539    /// Similar to "send" but does not shutdown the channel if an error occurs.
42540    pub fn send_no_shutdown_on_err(
42541        self,
42542        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
42543    ) -> Result<(), fidl::Error> {
42544        let _result = self.send_raw(result);
42545        self.drop_without_shutdown();
42546        _result
42547    }
42548
42549    fn send_raw(
42550        &self,
42551        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
42552    ) -> Result<(), fidl::Error> {
42553        self.control_handle.inner.send::<fidl::encoding::ResultType<
42554            BaseSocketGetAcceptConnResponse,
42555            fidl_fuchsia_posix::Errno,
42556        >>(
42557            result.map(|value| (value,)),
42558            self.tx_id,
42559            0x67ce6db6c2ec8966,
42560            fidl::encoding::DynamicFlags::empty(),
42561        )
42562    }
42563}
42564
42565#[must_use = "FIDL methods require a response to be sent"]
42566#[derive(Debug)]
42567pub struct DatagramSocketSetBindToDeviceResponder {
42568    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
42569    tx_id: u32,
42570}
42571
42572/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
42573/// if the responder is dropped without sending a response, so that the client
42574/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
42575impl std::ops::Drop for DatagramSocketSetBindToDeviceResponder {
42576    fn drop(&mut self) {
42577        self.control_handle.shutdown();
42578        // Safety: drops once, never accessed again
42579        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42580    }
42581}
42582
42583impl fidl::endpoints::Responder for DatagramSocketSetBindToDeviceResponder {
42584    type ControlHandle = DatagramSocketControlHandle;
42585
42586    fn control_handle(&self) -> &DatagramSocketControlHandle {
42587        &self.control_handle
42588    }
42589
42590    fn drop_without_shutdown(mut self) {
42591        // Safety: drops once, never accessed again due to mem::forget
42592        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42593        // Prevent Drop from running (which would shut down the channel)
42594        std::mem::forget(self);
42595    }
42596}
42597
42598impl DatagramSocketSetBindToDeviceResponder {
42599    /// Sends a response to the FIDL transaction.
42600    ///
42601    /// Sets the channel to shutdown if an error occurs.
42602    pub fn send(
42603        self,
42604        mut result: Result<(), fidl_fuchsia_posix::Errno>,
42605    ) -> Result<(), fidl::Error> {
42606        let _result = self.send_raw(result);
42607        if _result.is_err() {
42608            self.control_handle.shutdown();
42609        }
42610        self.drop_without_shutdown();
42611        _result
42612    }
42613
42614    /// Similar to "send" but does not shutdown the channel if an error occurs.
42615    pub fn send_no_shutdown_on_err(
42616        self,
42617        mut result: Result<(), fidl_fuchsia_posix::Errno>,
42618    ) -> Result<(), fidl::Error> {
42619        let _result = self.send_raw(result);
42620        self.drop_without_shutdown();
42621        _result
42622    }
42623
42624    fn send_raw(
42625        &self,
42626        mut result: Result<(), fidl_fuchsia_posix::Errno>,
42627    ) -> Result<(), fidl::Error> {
42628        self.control_handle.inner.send::<fidl::encoding::ResultType<
42629            fidl::encoding::EmptyStruct,
42630            fidl_fuchsia_posix::Errno,
42631        >>(
42632            result,
42633            self.tx_id,
42634            0x2118b483f28aafc4,
42635            fidl::encoding::DynamicFlags::empty(),
42636        )
42637    }
42638}
42639
42640#[must_use = "FIDL methods require a response to be sent"]
42641#[derive(Debug)]
42642pub struct DatagramSocketGetBindToDeviceResponder {
42643    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
42644    tx_id: u32,
42645}
42646
42647/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
42648/// if the responder is dropped without sending a response, so that the client
42649/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
42650impl std::ops::Drop for DatagramSocketGetBindToDeviceResponder {
42651    fn drop(&mut self) {
42652        self.control_handle.shutdown();
42653        // Safety: drops once, never accessed again
42654        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42655    }
42656}
42657
42658impl fidl::endpoints::Responder for DatagramSocketGetBindToDeviceResponder {
42659    type ControlHandle = DatagramSocketControlHandle;
42660
42661    fn control_handle(&self) -> &DatagramSocketControlHandle {
42662        &self.control_handle
42663    }
42664
42665    fn drop_without_shutdown(mut self) {
42666        // Safety: drops once, never accessed again due to mem::forget
42667        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42668        // Prevent Drop from running (which would shut down the channel)
42669        std::mem::forget(self);
42670    }
42671}
42672
42673impl DatagramSocketGetBindToDeviceResponder {
42674    /// Sends a response to the FIDL transaction.
42675    ///
42676    /// Sets the channel to shutdown if an error occurs.
42677    pub fn send(
42678        self,
42679        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
42680    ) -> Result<(), fidl::Error> {
42681        let _result = self.send_raw(result);
42682        if _result.is_err() {
42683            self.control_handle.shutdown();
42684        }
42685        self.drop_without_shutdown();
42686        _result
42687    }
42688
42689    /// Similar to "send" but does not shutdown the channel if an error occurs.
42690    pub fn send_no_shutdown_on_err(
42691        self,
42692        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
42693    ) -> Result<(), fidl::Error> {
42694        let _result = self.send_raw(result);
42695        self.drop_without_shutdown();
42696        _result
42697    }
42698
42699    fn send_raw(
42700        &self,
42701        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
42702    ) -> Result<(), fidl::Error> {
42703        self.control_handle.inner.send::<fidl::encoding::ResultType<
42704            BaseSocketGetBindToDeviceResponse,
42705            fidl_fuchsia_posix::Errno,
42706        >>(
42707            result.map(|value| (value,)),
42708            self.tx_id,
42709            0x1ab1fbf0ef7906c8,
42710            fidl::encoding::DynamicFlags::empty(),
42711        )
42712    }
42713}
42714
42715#[must_use = "FIDL methods require a response to be sent"]
42716#[derive(Debug)]
42717pub struct DatagramSocketSetBindToInterfaceIndexResponder {
42718    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
42719    tx_id: u32,
42720}
42721
42722/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
42723/// if the responder is dropped without sending a response, so that the client
42724/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
42725impl std::ops::Drop for DatagramSocketSetBindToInterfaceIndexResponder {
42726    fn drop(&mut self) {
42727        self.control_handle.shutdown();
42728        // Safety: drops once, never accessed again
42729        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42730    }
42731}
42732
42733impl fidl::endpoints::Responder for DatagramSocketSetBindToInterfaceIndexResponder {
42734    type ControlHandle = DatagramSocketControlHandle;
42735
42736    fn control_handle(&self) -> &DatagramSocketControlHandle {
42737        &self.control_handle
42738    }
42739
42740    fn drop_without_shutdown(mut self) {
42741        // Safety: drops once, never accessed again due to mem::forget
42742        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42743        // Prevent Drop from running (which would shut down the channel)
42744        std::mem::forget(self);
42745    }
42746}
42747
42748impl DatagramSocketSetBindToInterfaceIndexResponder {
42749    /// Sends a response to the FIDL transaction.
42750    ///
42751    /// Sets the channel to shutdown if an error occurs.
42752    pub fn send(
42753        self,
42754        mut result: Result<(), fidl_fuchsia_posix::Errno>,
42755    ) -> Result<(), fidl::Error> {
42756        let _result = self.send_raw(result);
42757        if _result.is_err() {
42758            self.control_handle.shutdown();
42759        }
42760        self.drop_without_shutdown();
42761        _result
42762    }
42763
42764    /// Similar to "send" but does not shutdown the channel if an error occurs.
42765    pub fn send_no_shutdown_on_err(
42766        self,
42767        mut result: Result<(), fidl_fuchsia_posix::Errno>,
42768    ) -> Result<(), fidl::Error> {
42769        let _result = self.send_raw(result);
42770        self.drop_without_shutdown();
42771        _result
42772    }
42773
42774    fn send_raw(
42775        &self,
42776        mut result: Result<(), fidl_fuchsia_posix::Errno>,
42777    ) -> Result<(), fidl::Error> {
42778        self.control_handle.inner.send::<fidl::encoding::ResultType<
42779            fidl::encoding::EmptyStruct,
42780            fidl_fuchsia_posix::Errno,
42781        >>(
42782            result,
42783            self.tx_id,
42784            0x6e387a0def00821,
42785            fidl::encoding::DynamicFlags::empty(),
42786        )
42787    }
42788}
42789
42790#[must_use = "FIDL methods require a response to be sent"]
42791#[derive(Debug)]
42792pub struct DatagramSocketGetBindToInterfaceIndexResponder {
42793    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
42794    tx_id: u32,
42795}
42796
42797/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
42798/// if the responder is dropped without sending a response, so that the client
42799/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
42800impl std::ops::Drop for DatagramSocketGetBindToInterfaceIndexResponder {
42801    fn drop(&mut self) {
42802        self.control_handle.shutdown();
42803        // Safety: drops once, never accessed again
42804        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42805    }
42806}
42807
42808impl fidl::endpoints::Responder for DatagramSocketGetBindToInterfaceIndexResponder {
42809    type ControlHandle = DatagramSocketControlHandle;
42810
42811    fn control_handle(&self) -> &DatagramSocketControlHandle {
42812        &self.control_handle
42813    }
42814
42815    fn drop_without_shutdown(mut self) {
42816        // Safety: drops once, never accessed again due to mem::forget
42817        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42818        // Prevent Drop from running (which would shut down the channel)
42819        std::mem::forget(self);
42820    }
42821}
42822
42823impl DatagramSocketGetBindToInterfaceIndexResponder {
42824    /// Sends a response to the FIDL transaction.
42825    ///
42826    /// Sets the channel to shutdown if an error occurs.
42827    pub fn send(
42828        self,
42829        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
42830    ) -> Result<(), fidl::Error> {
42831        let _result = self.send_raw(result);
42832        if _result.is_err() {
42833            self.control_handle.shutdown();
42834        }
42835        self.drop_without_shutdown();
42836        _result
42837    }
42838
42839    /// Similar to "send" but does not shutdown the channel if an error occurs.
42840    pub fn send_no_shutdown_on_err(
42841        self,
42842        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
42843    ) -> Result<(), fidl::Error> {
42844        let _result = self.send_raw(result);
42845        self.drop_without_shutdown();
42846        _result
42847    }
42848
42849    fn send_raw(
42850        &self,
42851        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
42852    ) -> Result<(), fidl::Error> {
42853        self.control_handle.inner.send::<fidl::encoding::ResultType<
42854            BaseSocketGetBindToInterfaceIndexResponse,
42855            fidl_fuchsia_posix::Errno,
42856        >>(
42857            result.map(|value| (value,)),
42858            self.tx_id,
42859            0x59c31dd3e3078295,
42860            fidl::encoding::DynamicFlags::empty(),
42861        )
42862    }
42863}
42864
42865#[must_use = "FIDL methods require a response to be sent"]
42866#[derive(Debug)]
42867pub struct DatagramSocketSetTimestampResponder {
42868    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
42869    tx_id: u32,
42870}
42871
42872/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
42873/// if the responder is dropped without sending a response, so that the client
42874/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
42875impl std::ops::Drop for DatagramSocketSetTimestampResponder {
42876    fn drop(&mut self) {
42877        self.control_handle.shutdown();
42878        // Safety: drops once, never accessed again
42879        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42880    }
42881}
42882
42883impl fidl::endpoints::Responder for DatagramSocketSetTimestampResponder {
42884    type ControlHandle = DatagramSocketControlHandle;
42885
42886    fn control_handle(&self) -> &DatagramSocketControlHandle {
42887        &self.control_handle
42888    }
42889
42890    fn drop_without_shutdown(mut self) {
42891        // Safety: drops once, never accessed again due to mem::forget
42892        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42893        // Prevent Drop from running (which would shut down the channel)
42894        std::mem::forget(self);
42895    }
42896}
42897
42898impl DatagramSocketSetTimestampResponder {
42899    /// Sends a response to the FIDL transaction.
42900    ///
42901    /// Sets the channel to shutdown if an error occurs.
42902    pub fn send(
42903        self,
42904        mut result: Result<(), fidl_fuchsia_posix::Errno>,
42905    ) -> Result<(), fidl::Error> {
42906        let _result = self.send_raw(result);
42907        if _result.is_err() {
42908            self.control_handle.shutdown();
42909        }
42910        self.drop_without_shutdown();
42911        _result
42912    }
42913
42914    /// Similar to "send" but does not shutdown the channel if an error occurs.
42915    pub fn send_no_shutdown_on_err(
42916        self,
42917        mut result: Result<(), fidl_fuchsia_posix::Errno>,
42918    ) -> Result<(), fidl::Error> {
42919        let _result = self.send_raw(result);
42920        self.drop_without_shutdown();
42921        _result
42922    }
42923
42924    fn send_raw(
42925        &self,
42926        mut result: Result<(), fidl_fuchsia_posix::Errno>,
42927    ) -> Result<(), fidl::Error> {
42928        self.control_handle.inner.send::<fidl::encoding::ResultType<
42929            fidl::encoding::EmptyStruct,
42930            fidl_fuchsia_posix::Errno,
42931        >>(
42932            result,
42933            self.tx_id,
42934            0x285d6516c263d839,
42935            fidl::encoding::DynamicFlags::empty(),
42936        )
42937    }
42938}
42939
42940#[must_use = "FIDL methods require a response to be sent"]
42941#[derive(Debug)]
42942pub struct DatagramSocketGetTimestampResponder {
42943    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
42944    tx_id: u32,
42945}
42946
42947/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
42948/// if the responder is dropped without sending a response, so that the client
42949/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
42950impl std::ops::Drop for DatagramSocketGetTimestampResponder {
42951    fn drop(&mut self) {
42952        self.control_handle.shutdown();
42953        // Safety: drops once, never accessed again
42954        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42955    }
42956}
42957
42958impl fidl::endpoints::Responder for DatagramSocketGetTimestampResponder {
42959    type ControlHandle = DatagramSocketControlHandle;
42960
42961    fn control_handle(&self) -> &DatagramSocketControlHandle {
42962        &self.control_handle
42963    }
42964
42965    fn drop_without_shutdown(mut self) {
42966        // Safety: drops once, never accessed again due to mem::forget
42967        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
42968        // Prevent Drop from running (which would shut down the channel)
42969        std::mem::forget(self);
42970    }
42971}
42972
42973impl DatagramSocketGetTimestampResponder {
42974    /// Sends a response to the FIDL transaction.
42975    ///
42976    /// Sets the channel to shutdown if an error occurs.
42977    pub fn send(
42978        self,
42979        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
42980    ) -> Result<(), fidl::Error> {
42981        let _result = self.send_raw(result);
42982        if _result.is_err() {
42983            self.control_handle.shutdown();
42984        }
42985        self.drop_without_shutdown();
42986        _result
42987    }
42988
42989    /// Similar to "send" but does not shutdown the channel if an error occurs.
42990    pub fn send_no_shutdown_on_err(
42991        self,
42992        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
42993    ) -> Result<(), fidl::Error> {
42994        let _result = self.send_raw(result);
42995        self.drop_without_shutdown();
42996        _result
42997    }
42998
42999    fn send_raw(
43000        &self,
43001        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
43002    ) -> Result<(), fidl::Error> {
43003        self.control_handle.inner.send::<fidl::encoding::ResultType<
43004            BaseSocketGetTimestampResponse,
43005            fidl_fuchsia_posix::Errno,
43006        >>(
43007            result.map(|value| (value,)),
43008            self.tx_id,
43009            0x49f2fffbbcc2bd27,
43010            fidl::encoding::DynamicFlags::empty(),
43011        )
43012    }
43013}
43014
43015#[must_use = "FIDL methods require a response to be sent"]
43016#[derive(Debug)]
43017pub struct DatagramSocketSetMarkResponder {
43018    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
43019    tx_id: u32,
43020}
43021
43022/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
43023/// if the responder is dropped without sending a response, so that the client
43024/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
43025impl std::ops::Drop for DatagramSocketSetMarkResponder {
43026    fn drop(&mut self) {
43027        self.control_handle.shutdown();
43028        // Safety: drops once, never accessed again
43029        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43030    }
43031}
43032
43033impl fidl::endpoints::Responder for DatagramSocketSetMarkResponder {
43034    type ControlHandle = DatagramSocketControlHandle;
43035
43036    fn control_handle(&self) -> &DatagramSocketControlHandle {
43037        &self.control_handle
43038    }
43039
43040    fn drop_without_shutdown(mut self) {
43041        // Safety: drops once, never accessed again due to mem::forget
43042        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43043        // Prevent Drop from running (which would shut down the channel)
43044        std::mem::forget(self);
43045    }
43046}
43047
43048impl DatagramSocketSetMarkResponder {
43049    /// Sends a response to the FIDL transaction.
43050    ///
43051    /// Sets the channel to shutdown if an error occurs.
43052    pub fn send(
43053        self,
43054        mut result: Result<(), fidl_fuchsia_posix::Errno>,
43055    ) -> Result<(), fidl::Error> {
43056        let _result = self.send_raw(result);
43057        if _result.is_err() {
43058            self.control_handle.shutdown();
43059        }
43060        self.drop_without_shutdown();
43061        _result
43062    }
43063
43064    /// Similar to "send" but does not shutdown the channel if an error occurs.
43065    pub fn send_no_shutdown_on_err(
43066        self,
43067        mut result: Result<(), fidl_fuchsia_posix::Errno>,
43068    ) -> Result<(), fidl::Error> {
43069        let _result = self.send_raw(result);
43070        self.drop_without_shutdown();
43071        _result
43072    }
43073
43074    fn send_raw(
43075        &self,
43076        mut result: Result<(), fidl_fuchsia_posix::Errno>,
43077    ) -> Result<(), fidl::Error> {
43078        self.control_handle.inner.send::<fidl::encoding::ResultType<
43079            fidl::encoding::EmptyStruct,
43080            fidl_fuchsia_posix::Errno,
43081        >>(
43082            result,
43083            self.tx_id,
43084            0x6ead6de09f653236,
43085            fidl::encoding::DynamicFlags::empty(),
43086        )
43087    }
43088}
43089
43090#[must_use = "FIDL methods require a response to be sent"]
43091#[derive(Debug)]
43092pub struct DatagramSocketGetMarkResponder {
43093    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
43094    tx_id: u32,
43095}
43096
43097/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
43098/// if the responder is dropped without sending a response, so that the client
43099/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
43100impl std::ops::Drop for DatagramSocketGetMarkResponder {
43101    fn drop(&mut self) {
43102        self.control_handle.shutdown();
43103        // Safety: drops once, never accessed again
43104        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43105    }
43106}
43107
43108impl fidl::endpoints::Responder for DatagramSocketGetMarkResponder {
43109    type ControlHandle = DatagramSocketControlHandle;
43110
43111    fn control_handle(&self) -> &DatagramSocketControlHandle {
43112        &self.control_handle
43113    }
43114
43115    fn drop_without_shutdown(mut self) {
43116        // Safety: drops once, never accessed again due to mem::forget
43117        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43118        // Prevent Drop from running (which would shut down the channel)
43119        std::mem::forget(self);
43120    }
43121}
43122
43123impl DatagramSocketGetMarkResponder {
43124    /// Sends a response to the FIDL transaction.
43125    ///
43126    /// Sets the channel to shutdown if an error occurs.
43127    pub fn send(
43128        self,
43129        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
43130    ) -> Result<(), fidl::Error> {
43131        let _result = self.send_raw(result);
43132        if _result.is_err() {
43133            self.control_handle.shutdown();
43134        }
43135        self.drop_without_shutdown();
43136        _result
43137    }
43138
43139    /// Similar to "send" but does not shutdown the channel if an error occurs.
43140    pub fn send_no_shutdown_on_err(
43141        self,
43142        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
43143    ) -> Result<(), fidl::Error> {
43144        let _result = self.send_raw(result);
43145        self.drop_without_shutdown();
43146        _result
43147    }
43148
43149    fn send_raw(
43150        &self,
43151        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
43152    ) -> Result<(), fidl::Error> {
43153        self.control_handle.inner.send::<fidl::encoding::ResultType<
43154            BaseSocketGetMarkResponse,
43155            fidl_fuchsia_posix::Errno,
43156        >>(
43157            result.map(|mark| (mark,)),
43158            self.tx_id,
43159            0x57a2752c61d93d47,
43160            fidl::encoding::DynamicFlags::empty(),
43161        )
43162    }
43163}
43164
43165#[must_use = "FIDL methods require a response to be sent"]
43166#[derive(Debug)]
43167pub struct DatagramSocketBindResponder {
43168    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
43169    tx_id: u32,
43170}
43171
43172/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
43173/// if the responder is dropped without sending a response, so that the client
43174/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
43175impl std::ops::Drop for DatagramSocketBindResponder {
43176    fn drop(&mut self) {
43177        self.control_handle.shutdown();
43178        // Safety: drops once, never accessed again
43179        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43180    }
43181}
43182
43183impl fidl::endpoints::Responder for DatagramSocketBindResponder {
43184    type ControlHandle = DatagramSocketControlHandle;
43185
43186    fn control_handle(&self) -> &DatagramSocketControlHandle {
43187        &self.control_handle
43188    }
43189
43190    fn drop_without_shutdown(mut self) {
43191        // Safety: drops once, never accessed again due to mem::forget
43192        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43193        // Prevent Drop from running (which would shut down the channel)
43194        std::mem::forget(self);
43195    }
43196}
43197
43198impl DatagramSocketBindResponder {
43199    /// Sends a response to the FIDL transaction.
43200    ///
43201    /// Sets the channel to shutdown if an error occurs.
43202    pub fn send(
43203        self,
43204        mut result: Result<(), fidl_fuchsia_posix::Errno>,
43205    ) -> Result<(), fidl::Error> {
43206        let _result = self.send_raw(result);
43207        if _result.is_err() {
43208            self.control_handle.shutdown();
43209        }
43210        self.drop_without_shutdown();
43211        _result
43212    }
43213
43214    /// Similar to "send" but does not shutdown the channel if an error occurs.
43215    pub fn send_no_shutdown_on_err(
43216        self,
43217        mut result: Result<(), fidl_fuchsia_posix::Errno>,
43218    ) -> Result<(), fidl::Error> {
43219        let _result = self.send_raw(result);
43220        self.drop_without_shutdown();
43221        _result
43222    }
43223
43224    fn send_raw(
43225        &self,
43226        mut result: Result<(), fidl_fuchsia_posix::Errno>,
43227    ) -> Result<(), fidl::Error> {
43228        self.control_handle.inner.send::<fidl::encoding::ResultType<
43229            fidl::encoding::EmptyStruct,
43230            fidl_fuchsia_posix::Errno,
43231        >>(
43232            result,
43233            self.tx_id,
43234            0x4bc6400ae92125d,
43235            fidl::encoding::DynamicFlags::empty(),
43236        )
43237    }
43238}
43239
43240#[must_use = "FIDL methods require a response to be sent"]
43241#[derive(Debug)]
43242pub struct DatagramSocketConnectResponder {
43243    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
43244    tx_id: u32,
43245}
43246
43247/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
43248/// if the responder is dropped without sending a response, so that the client
43249/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
43250impl std::ops::Drop for DatagramSocketConnectResponder {
43251    fn drop(&mut self) {
43252        self.control_handle.shutdown();
43253        // Safety: drops once, never accessed again
43254        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43255    }
43256}
43257
43258impl fidl::endpoints::Responder for DatagramSocketConnectResponder {
43259    type ControlHandle = DatagramSocketControlHandle;
43260
43261    fn control_handle(&self) -> &DatagramSocketControlHandle {
43262        &self.control_handle
43263    }
43264
43265    fn drop_without_shutdown(mut self) {
43266        // Safety: drops once, never accessed again due to mem::forget
43267        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43268        // Prevent Drop from running (which would shut down the channel)
43269        std::mem::forget(self);
43270    }
43271}
43272
43273impl DatagramSocketConnectResponder {
43274    /// Sends a response to the FIDL transaction.
43275    ///
43276    /// Sets the channel to shutdown if an error occurs.
43277    pub fn send(
43278        self,
43279        mut result: Result<(), fidl_fuchsia_posix::Errno>,
43280    ) -> Result<(), fidl::Error> {
43281        let _result = self.send_raw(result);
43282        if _result.is_err() {
43283            self.control_handle.shutdown();
43284        }
43285        self.drop_without_shutdown();
43286        _result
43287    }
43288
43289    /// Similar to "send" but does not shutdown the channel if an error occurs.
43290    pub fn send_no_shutdown_on_err(
43291        self,
43292        mut result: Result<(), fidl_fuchsia_posix::Errno>,
43293    ) -> Result<(), fidl::Error> {
43294        let _result = self.send_raw(result);
43295        self.drop_without_shutdown();
43296        _result
43297    }
43298
43299    fn send_raw(
43300        &self,
43301        mut result: Result<(), fidl_fuchsia_posix::Errno>,
43302    ) -> Result<(), fidl::Error> {
43303        self.control_handle.inner.send::<fidl::encoding::ResultType<
43304            fidl::encoding::EmptyStruct,
43305            fidl_fuchsia_posix::Errno,
43306        >>(
43307            result,
43308            self.tx_id,
43309            0x5f05f19bfdd38871,
43310            fidl::encoding::DynamicFlags::empty(),
43311        )
43312    }
43313}
43314
43315#[must_use = "FIDL methods require a response to be sent"]
43316#[derive(Debug)]
43317pub struct DatagramSocketDisconnectResponder {
43318    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
43319    tx_id: u32,
43320}
43321
43322/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
43323/// if the responder is dropped without sending a response, so that the client
43324/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
43325impl std::ops::Drop for DatagramSocketDisconnectResponder {
43326    fn drop(&mut self) {
43327        self.control_handle.shutdown();
43328        // Safety: drops once, never accessed again
43329        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43330    }
43331}
43332
43333impl fidl::endpoints::Responder for DatagramSocketDisconnectResponder {
43334    type ControlHandle = DatagramSocketControlHandle;
43335
43336    fn control_handle(&self) -> &DatagramSocketControlHandle {
43337        &self.control_handle
43338    }
43339
43340    fn drop_without_shutdown(mut self) {
43341        // Safety: drops once, never accessed again due to mem::forget
43342        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43343        // Prevent Drop from running (which would shut down the channel)
43344        std::mem::forget(self);
43345    }
43346}
43347
43348impl DatagramSocketDisconnectResponder {
43349    /// Sends a response to the FIDL transaction.
43350    ///
43351    /// Sets the channel to shutdown if an error occurs.
43352    pub fn send(
43353        self,
43354        mut result: Result<(), fidl_fuchsia_posix::Errno>,
43355    ) -> Result<(), fidl::Error> {
43356        let _result = self.send_raw(result);
43357        if _result.is_err() {
43358            self.control_handle.shutdown();
43359        }
43360        self.drop_without_shutdown();
43361        _result
43362    }
43363
43364    /// Similar to "send" but does not shutdown the channel if an error occurs.
43365    pub fn send_no_shutdown_on_err(
43366        self,
43367        mut result: Result<(), fidl_fuchsia_posix::Errno>,
43368    ) -> Result<(), fidl::Error> {
43369        let _result = self.send_raw(result);
43370        self.drop_without_shutdown();
43371        _result
43372    }
43373
43374    fn send_raw(
43375        &self,
43376        mut result: Result<(), fidl_fuchsia_posix::Errno>,
43377    ) -> Result<(), fidl::Error> {
43378        self.control_handle.inner.send::<fidl::encoding::ResultType<
43379            fidl::encoding::EmptyStruct,
43380            fidl_fuchsia_posix::Errno,
43381        >>(
43382            result,
43383            self.tx_id,
43384            0x74e63b91f7b29b2,
43385            fidl::encoding::DynamicFlags::empty(),
43386        )
43387    }
43388}
43389
43390#[must_use = "FIDL methods require a response to be sent"]
43391#[derive(Debug)]
43392pub struct DatagramSocketGetSockNameResponder {
43393    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
43394    tx_id: u32,
43395}
43396
43397/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
43398/// if the responder is dropped without sending a response, so that the client
43399/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
43400impl std::ops::Drop for DatagramSocketGetSockNameResponder {
43401    fn drop(&mut self) {
43402        self.control_handle.shutdown();
43403        // Safety: drops once, never accessed again
43404        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43405    }
43406}
43407
43408impl fidl::endpoints::Responder for DatagramSocketGetSockNameResponder {
43409    type ControlHandle = DatagramSocketControlHandle;
43410
43411    fn control_handle(&self) -> &DatagramSocketControlHandle {
43412        &self.control_handle
43413    }
43414
43415    fn drop_without_shutdown(mut self) {
43416        // Safety: drops once, never accessed again due to mem::forget
43417        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43418        // Prevent Drop from running (which would shut down the channel)
43419        std::mem::forget(self);
43420    }
43421}
43422
43423impl DatagramSocketGetSockNameResponder {
43424    /// Sends a response to the FIDL transaction.
43425    ///
43426    /// Sets the channel to shutdown if an error occurs.
43427    pub fn send(
43428        self,
43429        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
43430    ) -> Result<(), fidl::Error> {
43431        let _result = self.send_raw(result);
43432        if _result.is_err() {
43433            self.control_handle.shutdown();
43434        }
43435        self.drop_without_shutdown();
43436        _result
43437    }
43438
43439    /// Similar to "send" but does not shutdown the channel if an error occurs.
43440    pub fn send_no_shutdown_on_err(
43441        self,
43442        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
43443    ) -> Result<(), fidl::Error> {
43444        let _result = self.send_raw(result);
43445        self.drop_without_shutdown();
43446        _result
43447    }
43448
43449    fn send_raw(
43450        &self,
43451        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
43452    ) -> Result<(), fidl::Error> {
43453        self.control_handle.inner.send::<fidl::encoding::ResultType<
43454            BaseNetworkSocketGetSockNameResponse,
43455            fidl_fuchsia_posix::Errno,
43456        >>(
43457            result.map(|addr| (addr,)),
43458            self.tx_id,
43459            0x475f23f84a1a4f85,
43460            fidl::encoding::DynamicFlags::empty(),
43461        )
43462    }
43463}
43464
43465#[must_use = "FIDL methods require a response to be sent"]
43466#[derive(Debug)]
43467pub struct DatagramSocketGetPeerNameResponder {
43468    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
43469    tx_id: u32,
43470}
43471
43472/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
43473/// if the responder is dropped without sending a response, so that the client
43474/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
43475impl std::ops::Drop for DatagramSocketGetPeerNameResponder {
43476    fn drop(&mut self) {
43477        self.control_handle.shutdown();
43478        // Safety: drops once, never accessed again
43479        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43480    }
43481}
43482
43483impl fidl::endpoints::Responder for DatagramSocketGetPeerNameResponder {
43484    type ControlHandle = DatagramSocketControlHandle;
43485
43486    fn control_handle(&self) -> &DatagramSocketControlHandle {
43487        &self.control_handle
43488    }
43489
43490    fn drop_without_shutdown(mut self) {
43491        // Safety: drops once, never accessed again due to mem::forget
43492        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43493        // Prevent Drop from running (which would shut down the channel)
43494        std::mem::forget(self);
43495    }
43496}
43497
43498impl DatagramSocketGetPeerNameResponder {
43499    /// Sends a response to the FIDL transaction.
43500    ///
43501    /// Sets the channel to shutdown if an error occurs.
43502    pub fn send(
43503        self,
43504        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
43505    ) -> Result<(), fidl::Error> {
43506        let _result = self.send_raw(result);
43507        if _result.is_err() {
43508            self.control_handle.shutdown();
43509        }
43510        self.drop_without_shutdown();
43511        _result
43512    }
43513
43514    /// Similar to "send" but does not shutdown the channel if an error occurs.
43515    pub fn send_no_shutdown_on_err(
43516        self,
43517        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
43518    ) -> Result<(), fidl::Error> {
43519        let _result = self.send_raw(result);
43520        self.drop_without_shutdown();
43521        _result
43522    }
43523
43524    fn send_raw(
43525        &self,
43526        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
43527    ) -> Result<(), fidl::Error> {
43528        self.control_handle.inner.send::<fidl::encoding::ResultType<
43529            BaseNetworkSocketGetPeerNameResponse,
43530            fidl_fuchsia_posix::Errno,
43531        >>(
43532            result.map(|addr| (addr,)),
43533            self.tx_id,
43534            0x1ffecf4bd5b6432e,
43535            fidl::encoding::DynamicFlags::empty(),
43536        )
43537    }
43538}
43539
43540#[must_use = "FIDL methods require a response to be sent"]
43541#[derive(Debug)]
43542pub struct DatagramSocketShutdownResponder {
43543    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
43544    tx_id: u32,
43545}
43546
43547/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
43548/// if the responder is dropped without sending a response, so that the client
43549/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
43550impl std::ops::Drop for DatagramSocketShutdownResponder {
43551    fn drop(&mut self) {
43552        self.control_handle.shutdown();
43553        // Safety: drops once, never accessed again
43554        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43555    }
43556}
43557
43558impl fidl::endpoints::Responder for DatagramSocketShutdownResponder {
43559    type ControlHandle = DatagramSocketControlHandle;
43560
43561    fn control_handle(&self) -> &DatagramSocketControlHandle {
43562        &self.control_handle
43563    }
43564
43565    fn drop_without_shutdown(mut self) {
43566        // Safety: drops once, never accessed again due to mem::forget
43567        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43568        // Prevent Drop from running (which would shut down the channel)
43569        std::mem::forget(self);
43570    }
43571}
43572
43573impl DatagramSocketShutdownResponder {
43574    /// Sends a response to the FIDL transaction.
43575    ///
43576    /// Sets the channel to shutdown if an error occurs.
43577    pub fn send(
43578        self,
43579        mut result: Result<(), fidl_fuchsia_posix::Errno>,
43580    ) -> Result<(), fidl::Error> {
43581        let _result = self.send_raw(result);
43582        if _result.is_err() {
43583            self.control_handle.shutdown();
43584        }
43585        self.drop_without_shutdown();
43586        _result
43587    }
43588
43589    /// Similar to "send" but does not shutdown the channel if an error occurs.
43590    pub fn send_no_shutdown_on_err(
43591        self,
43592        mut result: Result<(), fidl_fuchsia_posix::Errno>,
43593    ) -> Result<(), fidl::Error> {
43594        let _result = self.send_raw(result);
43595        self.drop_without_shutdown();
43596        _result
43597    }
43598
43599    fn send_raw(
43600        &self,
43601        mut result: Result<(), fidl_fuchsia_posix::Errno>,
43602    ) -> Result<(), fidl::Error> {
43603        self.control_handle.inner.send::<fidl::encoding::ResultType<
43604            fidl::encoding::EmptyStruct,
43605            fidl_fuchsia_posix::Errno,
43606        >>(
43607            result,
43608            self.tx_id,
43609            0x247f38b6db68c336,
43610            fidl::encoding::DynamicFlags::empty(),
43611        )
43612    }
43613}
43614
43615#[must_use = "FIDL methods require a response to be sent"]
43616#[derive(Debug)]
43617pub struct DatagramSocketSetIpTypeOfServiceResponder {
43618    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
43619    tx_id: u32,
43620}
43621
43622/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
43623/// if the responder is dropped without sending a response, so that the client
43624/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
43625impl std::ops::Drop for DatagramSocketSetIpTypeOfServiceResponder {
43626    fn drop(&mut self) {
43627        self.control_handle.shutdown();
43628        // Safety: drops once, never accessed again
43629        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43630    }
43631}
43632
43633impl fidl::endpoints::Responder for DatagramSocketSetIpTypeOfServiceResponder {
43634    type ControlHandle = DatagramSocketControlHandle;
43635
43636    fn control_handle(&self) -> &DatagramSocketControlHandle {
43637        &self.control_handle
43638    }
43639
43640    fn drop_without_shutdown(mut self) {
43641        // Safety: drops once, never accessed again due to mem::forget
43642        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43643        // Prevent Drop from running (which would shut down the channel)
43644        std::mem::forget(self);
43645    }
43646}
43647
43648impl DatagramSocketSetIpTypeOfServiceResponder {
43649    /// Sends a response to the FIDL transaction.
43650    ///
43651    /// Sets the channel to shutdown if an error occurs.
43652    pub fn send(
43653        self,
43654        mut result: Result<(), fidl_fuchsia_posix::Errno>,
43655    ) -> Result<(), fidl::Error> {
43656        let _result = self.send_raw(result);
43657        if _result.is_err() {
43658            self.control_handle.shutdown();
43659        }
43660        self.drop_without_shutdown();
43661        _result
43662    }
43663
43664    /// Similar to "send" but does not shutdown the channel if an error occurs.
43665    pub fn send_no_shutdown_on_err(
43666        self,
43667        mut result: Result<(), fidl_fuchsia_posix::Errno>,
43668    ) -> Result<(), fidl::Error> {
43669        let _result = self.send_raw(result);
43670        self.drop_without_shutdown();
43671        _result
43672    }
43673
43674    fn send_raw(
43675        &self,
43676        mut result: Result<(), fidl_fuchsia_posix::Errno>,
43677    ) -> Result<(), fidl::Error> {
43678        self.control_handle.inner.send::<fidl::encoding::ResultType<
43679            fidl::encoding::EmptyStruct,
43680            fidl_fuchsia_posix::Errno,
43681        >>(
43682            result,
43683            self.tx_id,
43684            0x995c600475b6d46,
43685            fidl::encoding::DynamicFlags::empty(),
43686        )
43687    }
43688}
43689
43690#[must_use = "FIDL methods require a response to be sent"]
43691#[derive(Debug)]
43692pub struct DatagramSocketGetIpTypeOfServiceResponder {
43693    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
43694    tx_id: u32,
43695}
43696
43697/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
43698/// if the responder is dropped without sending a response, so that the client
43699/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
43700impl std::ops::Drop for DatagramSocketGetIpTypeOfServiceResponder {
43701    fn drop(&mut self) {
43702        self.control_handle.shutdown();
43703        // Safety: drops once, never accessed again
43704        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43705    }
43706}
43707
43708impl fidl::endpoints::Responder for DatagramSocketGetIpTypeOfServiceResponder {
43709    type ControlHandle = DatagramSocketControlHandle;
43710
43711    fn control_handle(&self) -> &DatagramSocketControlHandle {
43712        &self.control_handle
43713    }
43714
43715    fn drop_without_shutdown(mut self) {
43716        // Safety: drops once, never accessed again due to mem::forget
43717        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43718        // Prevent Drop from running (which would shut down the channel)
43719        std::mem::forget(self);
43720    }
43721}
43722
43723impl DatagramSocketGetIpTypeOfServiceResponder {
43724    /// Sends a response to the FIDL transaction.
43725    ///
43726    /// Sets the channel to shutdown if an error occurs.
43727    pub fn send(
43728        self,
43729        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
43730    ) -> Result<(), fidl::Error> {
43731        let _result = self.send_raw(result);
43732        if _result.is_err() {
43733            self.control_handle.shutdown();
43734        }
43735        self.drop_without_shutdown();
43736        _result
43737    }
43738
43739    /// Similar to "send" but does not shutdown the channel if an error occurs.
43740    pub fn send_no_shutdown_on_err(
43741        self,
43742        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
43743    ) -> Result<(), fidl::Error> {
43744        let _result = self.send_raw(result);
43745        self.drop_without_shutdown();
43746        _result
43747    }
43748
43749    fn send_raw(
43750        &self,
43751        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
43752    ) -> Result<(), fidl::Error> {
43753        self.control_handle.inner.send::<fidl::encoding::ResultType<
43754            BaseNetworkSocketGetIpTypeOfServiceResponse,
43755            fidl_fuchsia_posix::Errno,
43756        >>(
43757            result.map(|value| (value,)),
43758            self.tx_id,
43759            0x3814a04259f75fcb,
43760            fidl::encoding::DynamicFlags::empty(),
43761        )
43762    }
43763}
43764
43765#[must_use = "FIDL methods require a response to be sent"]
43766#[derive(Debug)]
43767pub struct DatagramSocketSetIpTtlResponder {
43768    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
43769    tx_id: u32,
43770}
43771
43772/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
43773/// if the responder is dropped without sending a response, so that the client
43774/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
43775impl std::ops::Drop for DatagramSocketSetIpTtlResponder {
43776    fn drop(&mut self) {
43777        self.control_handle.shutdown();
43778        // Safety: drops once, never accessed again
43779        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43780    }
43781}
43782
43783impl fidl::endpoints::Responder for DatagramSocketSetIpTtlResponder {
43784    type ControlHandle = DatagramSocketControlHandle;
43785
43786    fn control_handle(&self) -> &DatagramSocketControlHandle {
43787        &self.control_handle
43788    }
43789
43790    fn drop_without_shutdown(mut self) {
43791        // Safety: drops once, never accessed again due to mem::forget
43792        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43793        // Prevent Drop from running (which would shut down the channel)
43794        std::mem::forget(self);
43795    }
43796}
43797
43798impl DatagramSocketSetIpTtlResponder {
43799    /// Sends a response to the FIDL transaction.
43800    ///
43801    /// Sets the channel to shutdown if an error occurs.
43802    pub fn send(
43803        self,
43804        mut result: Result<(), fidl_fuchsia_posix::Errno>,
43805    ) -> Result<(), fidl::Error> {
43806        let _result = self.send_raw(result);
43807        if _result.is_err() {
43808            self.control_handle.shutdown();
43809        }
43810        self.drop_without_shutdown();
43811        _result
43812    }
43813
43814    /// Similar to "send" but does not shutdown the channel if an error occurs.
43815    pub fn send_no_shutdown_on_err(
43816        self,
43817        mut result: Result<(), fidl_fuchsia_posix::Errno>,
43818    ) -> Result<(), fidl::Error> {
43819        let _result = self.send_raw(result);
43820        self.drop_without_shutdown();
43821        _result
43822    }
43823
43824    fn send_raw(
43825        &self,
43826        mut result: Result<(), fidl_fuchsia_posix::Errno>,
43827    ) -> Result<(), fidl::Error> {
43828        self.control_handle.inner.send::<fidl::encoding::ResultType<
43829            fidl::encoding::EmptyStruct,
43830            fidl_fuchsia_posix::Errno,
43831        >>(
43832            result,
43833            self.tx_id,
43834            0x29e2424b433ae1ef,
43835            fidl::encoding::DynamicFlags::empty(),
43836        )
43837    }
43838}
43839
43840#[must_use = "FIDL methods require a response to be sent"]
43841#[derive(Debug)]
43842pub struct DatagramSocketGetIpTtlResponder {
43843    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
43844    tx_id: u32,
43845}
43846
43847/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
43848/// if the responder is dropped without sending a response, so that the client
43849/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
43850impl std::ops::Drop for DatagramSocketGetIpTtlResponder {
43851    fn drop(&mut self) {
43852        self.control_handle.shutdown();
43853        // Safety: drops once, never accessed again
43854        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43855    }
43856}
43857
43858impl fidl::endpoints::Responder for DatagramSocketGetIpTtlResponder {
43859    type ControlHandle = DatagramSocketControlHandle;
43860
43861    fn control_handle(&self) -> &DatagramSocketControlHandle {
43862        &self.control_handle
43863    }
43864
43865    fn drop_without_shutdown(mut self) {
43866        // Safety: drops once, never accessed again due to mem::forget
43867        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43868        // Prevent Drop from running (which would shut down the channel)
43869        std::mem::forget(self);
43870    }
43871}
43872
43873impl DatagramSocketGetIpTtlResponder {
43874    /// Sends a response to the FIDL transaction.
43875    ///
43876    /// Sets the channel to shutdown if an error occurs.
43877    pub fn send(
43878        self,
43879        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
43880    ) -> Result<(), fidl::Error> {
43881        let _result = self.send_raw(result);
43882        if _result.is_err() {
43883            self.control_handle.shutdown();
43884        }
43885        self.drop_without_shutdown();
43886        _result
43887    }
43888
43889    /// Similar to "send" but does not shutdown the channel if an error occurs.
43890    pub fn send_no_shutdown_on_err(
43891        self,
43892        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
43893    ) -> Result<(), fidl::Error> {
43894        let _result = self.send_raw(result);
43895        self.drop_without_shutdown();
43896        _result
43897    }
43898
43899    fn send_raw(
43900        &self,
43901        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
43902    ) -> Result<(), fidl::Error> {
43903        self.control_handle.inner.send::<fidl::encoding::ResultType<
43904            BaseNetworkSocketGetIpTtlResponse,
43905            fidl_fuchsia_posix::Errno,
43906        >>(
43907            result.map(|value| (value,)),
43908            self.tx_id,
43909            0x47e47fa1f24da471,
43910            fidl::encoding::DynamicFlags::empty(),
43911        )
43912    }
43913}
43914
43915#[must_use = "FIDL methods require a response to be sent"]
43916#[derive(Debug)]
43917pub struct DatagramSocketSetIpPacketInfoResponder {
43918    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
43919    tx_id: u32,
43920}
43921
43922/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
43923/// if the responder is dropped without sending a response, so that the client
43924/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
43925impl std::ops::Drop for DatagramSocketSetIpPacketInfoResponder {
43926    fn drop(&mut self) {
43927        self.control_handle.shutdown();
43928        // Safety: drops once, never accessed again
43929        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43930    }
43931}
43932
43933impl fidl::endpoints::Responder for DatagramSocketSetIpPacketInfoResponder {
43934    type ControlHandle = DatagramSocketControlHandle;
43935
43936    fn control_handle(&self) -> &DatagramSocketControlHandle {
43937        &self.control_handle
43938    }
43939
43940    fn drop_without_shutdown(mut self) {
43941        // Safety: drops once, never accessed again due to mem::forget
43942        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
43943        // Prevent Drop from running (which would shut down the channel)
43944        std::mem::forget(self);
43945    }
43946}
43947
43948impl DatagramSocketSetIpPacketInfoResponder {
43949    /// Sends a response to the FIDL transaction.
43950    ///
43951    /// Sets the channel to shutdown if an error occurs.
43952    pub fn send(
43953        self,
43954        mut result: Result<(), fidl_fuchsia_posix::Errno>,
43955    ) -> Result<(), fidl::Error> {
43956        let _result = self.send_raw(result);
43957        if _result.is_err() {
43958            self.control_handle.shutdown();
43959        }
43960        self.drop_without_shutdown();
43961        _result
43962    }
43963
43964    /// Similar to "send" but does not shutdown the channel if an error occurs.
43965    pub fn send_no_shutdown_on_err(
43966        self,
43967        mut result: Result<(), fidl_fuchsia_posix::Errno>,
43968    ) -> Result<(), fidl::Error> {
43969        let _result = self.send_raw(result);
43970        self.drop_without_shutdown();
43971        _result
43972    }
43973
43974    fn send_raw(
43975        &self,
43976        mut result: Result<(), fidl_fuchsia_posix::Errno>,
43977    ) -> Result<(), fidl::Error> {
43978        self.control_handle.inner.send::<fidl::encoding::ResultType<
43979            fidl::encoding::EmptyStruct,
43980            fidl_fuchsia_posix::Errno,
43981        >>(
43982            result,
43983            self.tx_id,
43984            0x392d16bee20c0e16,
43985            fidl::encoding::DynamicFlags::empty(),
43986        )
43987    }
43988}
43989
43990#[must_use = "FIDL methods require a response to be sent"]
43991#[derive(Debug)]
43992pub struct DatagramSocketGetIpPacketInfoResponder {
43993    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
43994    tx_id: u32,
43995}
43996
43997/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
43998/// if the responder is dropped without sending a response, so that the client
43999/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
44000impl std::ops::Drop for DatagramSocketGetIpPacketInfoResponder {
44001    fn drop(&mut self) {
44002        self.control_handle.shutdown();
44003        // Safety: drops once, never accessed again
44004        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44005    }
44006}
44007
44008impl fidl::endpoints::Responder for DatagramSocketGetIpPacketInfoResponder {
44009    type ControlHandle = DatagramSocketControlHandle;
44010
44011    fn control_handle(&self) -> &DatagramSocketControlHandle {
44012        &self.control_handle
44013    }
44014
44015    fn drop_without_shutdown(mut self) {
44016        // Safety: drops once, never accessed again due to mem::forget
44017        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44018        // Prevent Drop from running (which would shut down the channel)
44019        std::mem::forget(self);
44020    }
44021}
44022
44023impl DatagramSocketGetIpPacketInfoResponder {
44024    /// Sends a response to the FIDL transaction.
44025    ///
44026    /// Sets the channel to shutdown if an error occurs.
44027    pub fn send(
44028        self,
44029        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
44030    ) -> Result<(), fidl::Error> {
44031        let _result = self.send_raw(result);
44032        if _result.is_err() {
44033            self.control_handle.shutdown();
44034        }
44035        self.drop_without_shutdown();
44036        _result
44037    }
44038
44039    /// Similar to "send" but does not shutdown the channel if an error occurs.
44040    pub fn send_no_shutdown_on_err(
44041        self,
44042        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
44043    ) -> Result<(), fidl::Error> {
44044        let _result = self.send_raw(result);
44045        self.drop_without_shutdown();
44046        _result
44047    }
44048
44049    fn send_raw(
44050        &self,
44051        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
44052    ) -> Result<(), fidl::Error> {
44053        self.control_handle.inner.send::<fidl::encoding::ResultType<
44054            BaseNetworkSocketGetIpPacketInfoResponse,
44055            fidl_fuchsia_posix::Errno,
44056        >>(
44057            result.map(|value| (value,)),
44058            self.tx_id,
44059            0x54b505f242280740,
44060            fidl::encoding::DynamicFlags::empty(),
44061        )
44062    }
44063}
44064
44065#[must_use = "FIDL methods require a response to be sent"]
44066#[derive(Debug)]
44067pub struct DatagramSocketSetIpReceiveTypeOfServiceResponder {
44068    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
44069    tx_id: u32,
44070}
44071
44072/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
44073/// if the responder is dropped without sending a response, so that the client
44074/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
44075impl std::ops::Drop for DatagramSocketSetIpReceiveTypeOfServiceResponder {
44076    fn drop(&mut self) {
44077        self.control_handle.shutdown();
44078        // Safety: drops once, never accessed again
44079        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44080    }
44081}
44082
44083impl fidl::endpoints::Responder for DatagramSocketSetIpReceiveTypeOfServiceResponder {
44084    type ControlHandle = DatagramSocketControlHandle;
44085
44086    fn control_handle(&self) -> &DatagramSocketControlHandle {
44087        &self.control_handle
44088    }
44089
44090    fn drop_without_shutdown(mut self) {
44091        // Safety: drops once, never accessed again due to mem::forget
44092        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44093        // Prevent Drop from running (which would shut down the channel)
44094        std::mem::forget(self);
44095    }
44096}
44097
44098impl DatagramSocketSetIpReceiveTypeOfServiceResponder {
44099    /// Sends a response to the FIDL transaction.
44100    ///
44101    /// Sets the channel to shutdown if an error occurs.
44102    pub fn send(
44103        self,
44104        mut result: Result<(), fidl_fuchsia_posix::Errno>,
44105    ) -> Result<(), fidl::Error> {
44106        let _result = self.send_raw(result);
44107        if _result.is_err() {
44108            self.control_handle.shutdown();
44109        }
44110        self.drop_without_shutdown();
44111        _result
44112    }
44113
44114    /// Similar to "send" but does not shutdown the channel if an error occurs.
44115    pub fn send_no_shutdown_on_err(
44116        self,
44117        mut result: Result<(), fidl_fuchsia_posix::Errno>,
44118    ) -> Result<(), fidl::Error> {
44119        let _result = self.send_raw(result);
44120        self.drop_without_shutdown();
44121        _result
44122    }
44123
44124    fn send_raw(
44125        &self,
44126        mut result: Result<(), fidl_fuchsia_posix::Errno>,
44127    ) -> Result<(), fidl::Error> {
44128        self.control_handle.inner.send::<fidl::encoding::ResultType<
44129            fidl::encoding::EmptyStruct,
44130            fidl_fuchsia_posix::Errno,
44131        >>(
44132            result,
44133            self.tx_id,
44134            0x6c4f6714995f84ef,
44135            fidl::encoding::DynamicFlags::empty(),
44136        )
44137    }
44138}
44139
44140#[must_use = "FIDL methods require a response to be sent"]
44141#[derive(Debug)]
44142pub struct DatagramSocketGetIpReceiveTypeOfServiceResponder {
44143    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
44144    tx_id: u32,
44145}
44146
44147/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
44148/// if the responder is dropped without sending a response, so that the client
44149/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
44150impl std::ops::Drop for DatagramSocketGetIpReceiveTypeOfServiceResponder {
44151    fn drop(&mut self) {
44152        self.control_handle.shutdown();
44153        // Safety: drops once, never accessed again
44154        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44155    }
44156}
44157
44158impl fidl::endpoints::Responder for DatagramSocketGetIpReceiveTypeOfServiceResponder {
44159    type ControlHandle = DatagramSocketControlHandle;
44160
44161    fn control_handle(&self) -> &DatagramSocketControlHandle {
44162        &self.control_handle
44163    }
44164
44165    fn drop_without_shutdown(mut self) {
44166        // Safety: drops once, never accessed again due to mem::forget
44167        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44168        // Prevent Drop from running (which would shut down the channel)
44169        std::mem::forget(self);
44170    }
44171}
44172
44173impl DatagramSocketGetIpReceiveTypeOfServiceResponder {
44174    /// Sends a response to the FIDL transaction.
44175    ///
44176    /// Sets the channel to shutdown if an error occurs.
44177    pub fn send(
44178        self,
44179        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
44180    ) -> Result<(), fidl::Error> {
44181        let _result = self.send_raw(result);
44182        if _result.is_err() {
44183            self.control_handle.shutdown();
44184        }
44185        self.drop_without_shutdown();
44186        _result
44187    }
44188
44189    /// Similar to "send" but does not shutdown the channel if an error occurs.
44190    pub fn send_no_shutdown_on_err(
44191        self,
44192        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
44193    ) -> Result<(), fidl::Error> {
44194        let _result = self.send_raw(result);
44195        self.drop_without_shutdown();
44196        _result
44197    }
44198
44199    fn send_raw(
44200        &self,
44201        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
44202    ) -> Result<(), fidl::Error> {
44203        self.control_handle.inner.send::<fidl::encoding::ResultType<
44204            BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
44205            fidl_fuchsia_posix::Errno,
44206        >>(
44207            result.map(|value| (value,)),
44208            self.tx_id,
44209            0x4158ba7dc2795960,
44210            fidl::encoding::DynamicFlags::empty(),
44211        )
44212    }
44213}
44214
44215#[must_use = "FIDL methods require a response to be sent"]
44216#[derive(Debug)]
44217pub struct DatagramSocketSetIpReceiveTtlResponder {
44218    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
44219    tx_id: u32,
44220}
44221
44222/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
44223/// if the responder is dropped without sending a response, so that the client
44224/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
44225impl std::ops::Drop for DatagramSocketSetIpReceiveTtlResponder {
44226    fn drop(&mut self) {
44227        self.control_handle.shutdown();
44228        // Safety: drops once, never accessed again
44229        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44230    }
44231}
44232
44233impl fidl::endpoints::Responder for DatagramSocketSetIpReceiveTtlResponder {
44234    type ControlHandle = DatagramSocketControlHandle;
44235
44236    fn control_handle(&self) -> &DatagramSocketControlHandle {
44237        &self.control_handle
44238    }
44239
44240    fn drop_without_shutdown(mut self) {
44241        // Safety: drops once, never accessed again due to mem::forget
44242        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44243        // Prevent Drop from running (which would shut down the channel)
44244        std::mem::forget(self);
44245    }
44246}
44247
44248impl DatagramSocketSetIpReceiveTtlResponder {
44249    /// Sends a response to the FIDL transaction.
44250    ///
44251    /// Sets the channel to shutdown if an error occurs.
44252    pub fn send(
44253        self,
44254        mut result: Result<(), fidl_fuchsia_posix::Errno>,
44255    ) -> Result<(), fidl::Error> {
44256        let _result = self.send_raw(result);
44257        if _result.is_err() {
44258            self.control_handle.shutdown();
44259        }
44260        self.drop_without_shutdown();
44261        _result
44262    }
44263
44264    /// Similar to "send" but does not shutdown the channel if an error occurs.
44265    pub fn send_no_shutdown_on_err(
44266        self,
44267        mut result: Result<(), fidl_fuchsia_posix::Errno>,
44268    ) -> Result<(), fidl::Error> {
44269        let _result = self.send_raw(result);
44270        self.drop_without_shutdown();
44271        _result
44272    }
44273
44274    fn send_raw(
44275        &self,
44276        mut result: Result<(), fidl_fuchsia_posix::Errno>,
44277    ) -> Result<(), fidl::Error> {
44278        self.control_handle.inner.send::<fidl::encoding::ResultType<
44279            fidl::encoding::EmptyStruct,
44280            fidl_fuchsia_posix::Errno,
44281        >>(
44282            result,
44283            self.tx_id,
44284            0x46f15be0ce0ab82b,
44285            fidl::encoding::DynamicFlags::empty(),
44286        )
44287    }
44288}
44289
44290#[must_use = "FIDL methods require a response to be sent"]
44291#[derive(Debug)]
44292pub struct DatagramSocketGetIpReceiveTtlResponder {
44293    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
44294    tx_id: u32,
44295}
44296
44297/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
44298/// if the responder is dropped without sending a response, so that the client
44299/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
44300impl std::ops::Drop for DatagramSocketGetIpReceiveTtlResponder {
44301    fn drop(&mut self) {
44302        self.control_handle.shutdown();
44303        // Safety: drops once, never accessed again
44304        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44305    }
44306}
44307
44308impl fidl::endpoints::Responder for DatagramSocketGetIpReceiveTtlResponder {
44309    type ControlHandle = DatagramSocketControlHandle;
44310
44311    fn control_handle(&self) -> &DatagramSocketControlHandle {
44312        &self.control_handle
44313    }
44314
44315    fn drop_without_shutdown(mut self) {
44316        // Safety: drops once, never accessed again due to mem::forget
44317        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44318        // Prevent Drop from running (which would shut down the channel)
44319        std::mem::forget(self);
44320    }
44321}
44322
44323impl DatagramSocketGetIpReceiveTtlResponder {
44324    /// Sends a response to the FIDL transaction.
44325    ///
44326    /// Sets the channel to shutdown if an error occurs.
44327    pub fn send(
44328        self,
44329        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
44330    ) -> Result<(), fidl::Error> {
44331        let _result = self.send_raw(result);
44332        if _result.is_err() {
44333            self.control_handle.shutdown();
44334        }
44335        self.drop_without_shutdown();
44336        _result
44337    }
44338
44339    /// Similar to "send" but does not shutdown the channel if an error occurs.
44340    pub fn send_no_shutdown_on_err(
44341        self,
44342        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
44343    ) -> Result<(), fidl::Error> {
44344        let _result = self.send_raw(result);
44345        self.drop_without_shutdown();
44346        _result
44347    }
44348
44349    fn send_raw(
44350        &self,
44351        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
44352    ) -> Result<(), fidl::Error> {
44353        self.control_handle.inner.send::<fidl::encoding::ResultType<
44354            BaseNetworkSocketGetIpReceiveTtlResponse,
44355            fidl_fuchsia_posix::Errno,
44356        >>(
44357            result.map(|value| (value,)),
44358            self.tx_id,
44359            0x678ddd5a5dfa2eb5,
44360            fidl::encoding::DynamicFlags::empty(),
44361        )
44362    }
44363}
44364
44365#[must_use = "FIDL methods require a response to be sent"]
44366#[derive(Debug)]
44367pub struct DatagramSocketSetIpMulticastInterfaceResponder {
44368    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
44369    tx_id: u32,
44370}
44371
44372/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
44373/// if the responder is dropped without sending a response, so that the client
44374/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
44375impl std::ops::Drop for DatagramSocketSetIpMulticastInterfaceResponder {
44376    fn drop(&mut self) {
44377        self.control_handle.shutdown();
44378        // Safety: drops once, never accessed again
44379        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44380    }
44381}
44382
44383impl fidl::endpoints::Responder for DatagramSocketSetIpMulticastInterfaceResponder {
44384    type ControlHandle = DatagramSocketControlHandle;
44385
44386    fn control_handle(&self) -> &DatagramSocketControlHandle {
44387        &self.control_handle
44388    }
44389
44390    fn drop_without_shutdown(mut self) {
44391        // Safety: drops once, never accessed again due to mem::forget
44392        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44393        // Prevent Drop from running (which would shut down the channel)
44394        std::mem::forget(self);
44395    }
44396}
44397
44398impl DatagramSocketSetIpMulticastInterfaceResponder {
44399    /// Sends a response to the FIDL transaction.
44400    ///
44401    /// Sets the channel to shutdown if an error occurs.
44402    pub fn send(
44403        self,
44404        mut result: Result<(), fidl_fuchsia_posix::Errno>,
44405    ) -> Result<(), fidl::Error> {
44406        let _result = self.send_raw(result);
44407        if _result.is_err() {
44408            self.control_handle.shutdown();
44409        }
44410        self.drop_without_shutdown();
44411        _result
44412    }
44413
44414    /// Similar to "send" but does not shutdown the channel if an error occurs.
44415    pub fn send_no_shutdown_on_err(
44416        self,
44417        mut result: Result<(), fidl_fuchsia_posix::Errno>,
44418    ) -> Result<(), fidl::Error> {
44419        let _result = self.send_raw(result);
44420        self.drop_without_shutdown();
44421        _result
44422    }
44423
44424    fn send_raw(
44425        &self,
44426        mut result: Result<(), fidl_fuchsia_posix::Errno>,
44427    ) -> Result<(), fidl::Error> {
44428        self.control_handle.inner.send::<fidl::encoding::ResultType<
44429            fidl::encoding::EmptyStruct,
44430            fidl_fuchsia_posix::Errno,
44431        >>(
44432            result,
44433            self.tx_id,
44434            0x752fbfa9b12befe,
44435            fidl::encoding::DynamicFlags::empty(),
44436        )
44437    }
44438}
44439
44440#[must_use = "FIDL methods require a response to be sent"]
44441#[derive(Debug)]
44442pub struct DatagramSocketGetIpMulticastInterfaceResponder {
44443    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
44444    tx_id: u32,
44445}
44446
44447/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
44448/// if the responder is dropped without sending a response, so that the client
44449/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
44450impl std::ops::Drop for DatagramSocketGetIpMulticastInterfaceResponder {
44451    fn drop(&mut self) {
44452        self.control_handle.shutdown();
44453        // Safety: drops once, never accessed again
44454        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44455    }
44456}
44457
44458impl fidl::endpoints::Responder for DatagramSocketGetIpMulticastInterfaceResponder {
44459    type ControlHandle = DatagramSocketControlHandle;
44460
44461    fn control_handle(&self) -> &DatagramSocketControlHandle {
44462        &self.control_handle
44463    }
44464
44465    fn drop_without_shutdown(mut self) {
44466        // Safety: drops once, never accessed again due to mem::forget
44467        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44468        // Prevent Drop from running (which would shut down the channel)
44469        std::mem::forget(self);
44470    }
44471}
44472
44473impl DatagramSocketGetIpMulticastInterfaceResponder {
44474    /// Sends a response to the FIDL transaction.
44475    ///
44476    /// Sets the channel to shutdown if an error occurs.
44477    pub fn send(
44478        self,
44479        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
44480    ) -> Result<(), fidl::Error> {
44481        let _result = self.send_raw(result);
44482        if _result.is_err() {
44483            self.control_handle.shutdown();
44484        }
44485        self.drop_without_shutdown();
44486        _result
44487    }
44488
44489    /// Similar to "send" but does not shutdown the channel if an error occurs.
44490    pub fn send_no_shutdown_on_err(
44491        self,
44492        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
44493    ) -> Result<(), fidl::Error> {
44494        let _result = self.send_raw(result);
44495        self.drop_without_shutdown();
44496        _result
44497    }
44498
44499    fn send_raw(
44500        &self,
44501        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
44502    ) -> Result<(), fidl::Error> {
44503        self.control_handle.inner.send::<fidl::encoding::ResultType<
44504            BaseNetworkSocketGetIpMulticastInterfaceResponse,
44505            fidl_fuchsia_posix::Errno,
44506        >>(
44507            result.map(|value| (value,)),
44508            self.tx_id,
44509            0x320bd14c4df046c4,
44510            fidl::encoding::DynamicFlags::empty(),
44511        )
44512    }
44513}
44514
44515#[must_use = "FIDL methods require a response to be sent"]
44516#[derive(Debug)]
44517pub struct DatagramSocketSetIpMulticastTtlResponder {
44518    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
44519    tx_id: u32,
44520}
44521
44522/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
44523/// if the responder is dropped without sending a response, so that the client
44524/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
44525impl std::ops::Drop for DatagramSocketSetIpMulticastTtlResponder {
44526    fn drop(&mut self) {
44527        self.control_handle.shutdown();
44528        // Safety: drops once, never accessed again
44529        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44530    }
44531}
44532
44533impl fidl::endpoints::Responder for DatagramSocketSetIpMulticastTtlResponder {
44534    type ControlHandle = DatagramSocketControlHandle;
44535
44536    fn control_handle(&self) -> &DatagramSocketControlHandle {
44537        &self.control_handle
44538    }
44539
44540    fn drop_without_shutdown(mut self) {
44541        // Safety: drops once, never accessed again due to mem::forget
44542        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44543        // Prevent Drop from running (which would shut down the channel)
44544        std::mem::forget(self);
44545    }
44546}
44547
44548impl DatagramSocketSetIpMulticastTtlResponder {
44549    /// Sends a response to the FIDL transaction.
44550    ///
44551    /// Sets the channel to shutdown if an error occurs.
44552    pub fn send(
44553        self,
44554        mut result: Result<(), fidl_fuchsia_posix::Errno>,
44555    ) -> Result<(), fidl::Error> {
44556        let _result = self.send_raw(result);
44557        if _result.is_err() {
44558            self.control_handle.shutdown();
44559        }
44560        self.drop_without_shutdown();
44561        _result
44562    }
44563
44564    /// Similar to "send" but does not shutdown the channel if an error occurs.
44565    pub fn send_no_shutdown_on_err(
44566        self,
44567        mut result: Result<(), fidl_fuchsia_posix::Errno>,
44568    ) -> Result<(), fidl::Error> {
44569        let _result = self.send_raw(result);
44570        self.drop_without_shutdown();
44571        _result
44572    }
44573
44574    fn send_raw(
44575        &self,
44576        mut result: Result<(), fidl_fuchsia_posix::Errno>,
44577    ) -> Result<(), fidl::Error> {
44578        self.control_handle.inner.send::<fidl::encoding::ResultType<
44579            fidl::encoding::EmptyStruct,
44580            fidl_fuchsia_posix::Errno,
44581        >>(
44582            result,
44583            self.tx_id,
44584            0x63134d53772916a1,
44585            fidl::encoding::DynamicFlags::empty(),
44586        )
44587    }
44588}
44589
44590#[must_use = "FIDL methods require a response to be sent"]
44591#[derive(Debug)]
44592pub struct DatagramSocketGetIpMulticastTtlResponder {
44593    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
44594    tx_id: u32,
44595}
44596
44597/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
44598/// if the responder is dropped without sending a response, so that the client
44599/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
44600impl std::ops::Drop for DatagramSocketGetIpMulticastTtlResponder {
44601    fn drop(&mut self) {
44602        self.control_handle.shutdown();
44603        // Safety: drops once, never accessed again
44604        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44605    }
44606}
44607
44608impl fidl::endpoints::Responder for DatagramSocketGetIpMulticastTtlResponder {
44609    type ControlHandle = DatagramSocketControlHandle;
44610
44611    fn control_handle(&self) -> &DatagramSocketControlHandle {
44612        &self.control_handle
44613    }
44614
44615    fn drop_without_shutdown(mut self) {
44616        // Safety: drops once, never accessed again due to mem::forget
44617        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44618        // Prevent Drop from running (which would shut down the channel)
44619        std::mem::forget(self);
44620    }
44621}
44622
44623impl DatagramSocketGetIpMulticastTtlResponder {
44624    /// Sends a response to the FIDL transaction.
44625    ///
44626    /// Sets the channel to shutdown if an error occurs.
44627    pub fn send(
44628        self,
44629        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
44630    ) -> Result<(), fidl::Error> {
44631        let _result = self.send_raw(result);
44632        if _result.is_err() {
44633            self.control_handle.shutdown();
44634        }
44635        self.drop_without_shutdown();
44636        _result
44637    }
44638
44639    /// Similar to "send" but does not shutdown the channel if an error occurs.
44640    pub fn send_no_shutdown_on_err(
44641        self,
44642        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
44643    ) -> Result<(), fidl::Error> {
44644        let _result = self.send_raw(result);
44645        self.drop_without_shutdown();
44646        _result
44647    }
44648
44649    fn send_raw(
44650        &self,
44651        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
44652    ) -> Result<(), fidl::Error> {
44653        self.control_handle.inner.send::<fidl::encoding::ResultType<
44654            BaseNetworkSocketGetIpMulticastTtlResponse,
44655            fidl_fuchsia_posix::Errno,
44656        >>(
44657            result.map(|value| (value,)),
44658            self.tx_id,
44659            0x4665cd378f39e1a,
44660            fidl::encoding::DynamicFlags::empty(),
44661        )
44662    }
44663}
44664
44665#[must_use = "FIDL methods require a response to be sent"]
44666#[derive(Debug)]
44667pub struct DatagramSocketSetIpMulticastLoopbackResponder {
44668    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
44669    tx_id: u32,
44670}
44671
44672/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
44673/// if the responder is dropped without sending a response, so that the client
44674/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
44675impl std::ops::Drop for DatagramSocketSetIpMulticastLoopbackResponder {
44676    fn drop(&mut self) {
44677        self.control_handle.shutdown();
44678        // Safety: drops once, never accessed again
44679        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44680    }
44681}
44682
44683impl fidl::endpoints::Responder for DatagramSocketSetIpMulticastLoopbackResponder {
44684    type ControlHandle = DatagramSocketControlHandle;
44685
44686    fn control_handle(&self) -> &DatagramSocketControlHandle {
44687        &self.control_handle
44688    }
44689
44690    fn drop_without_shutdown(mut self) {
44691        // Safety: drops once, never accessed again due to mem::forget
44692        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44693        // Prevent Drop from running (which would shut down the channel)
44694        std::mem::forget(self);
44695    }
44696}
44697
44698impl DatagramSocketSetIpMulticastLoopbackResponder {
44699    /// Sends a response to the FIDL transaction.
44700    ///
44701    /// Sets the channel to shutdown if an error occurs.
44702    pub fn send(
44703        self,
44704        mut result: Result<(), fidl_fuchsia_posix::Errno>,
44705    ) -> Result<(), fidl::Error> {
44706        let _result = self.send_raw(result);
44707        if _result.is_err() {
44708            self.control_handle.shutdown();
44709        }
44710        self.drop_without_shutdown();
44711        _result
44712    }
44713
44714    /// Similar to "send" but does not shutdown the channel if an error occurs.
44715    pub fn send_no_shutdown_on_err(
44716        self,
44717        mut result: Result<(), fidl_fuchsia_posix::Errno>,
44718    ) -> Result<(), fidl::Error> {
44719        let _result = self.send_raw(result);
44720        self.drop_without_shutdown();
44721        _result
44722    }
44723
44724    fn send_raw(
44725        &self,
44726        mut result: Result<(), fidl_fuchsia_posix::Errno>,
44727    ) -> Result<(), fidl::Error> {
44728        self.control_handle.inner.send::<fidl::encoding::ResultType<
44729            fidl::encoding::EmptyStruct,
44730            fidl_fuchsia_posix::Errno,
44731        >>(
44732            result,
44733            self.tx_id,
44734            0x20c55c11f00943ea,
44735            fidl::encoding::DynamicFlags::empty(),
44736        )
44737    }
44738}
44739
44740#[must_use = "FIDL methods require a response to be sent"]
44741#[derive(Debug)]
44742pub struct DatagramSocketGetIpMulticastLoopbackResponder {
44743    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
44744    tx_id: u32,
44745}
44746
44747/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
44748/// if the responder is dropped without sending a response, so that the client
44749/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
44750impl std::ops::Drop for DatagramSocketGetIpMulticastLoopbackResponder {
44751    fn drop(&mut self) {
44752        self.control_handle.shutdown();
44753        // Safety: drops once, never accessed again
44754        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44755    }
44756}
44757
44758impl fidl::endpoints::Responder for DatagramSocketGetIpMulticastLoopbackResponder {
44759    type ControlHandle = DatagramSocketControlHandle;
44760
44761    fn control_handle(&self) -> &DatagramSocketControlHandle {
44762        &self.control_handle
44763    }
44764
44765    fn drop_without_shutdown(mut self) {
44766        // Safety: drops once, never accessed again due to mem::forget
44767        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44768        // Prevent Drop from running (which would shut down the channel)
44769        std::mem::forget(self);
44770    }
44771}
44772
44773impl DatagramSocketGetIpMulticastLoopbackResponder {
44774    /// Sends a response to the FIDL transaction.
44775    ///
44776    /// Sets the channel to shutdown if an error occurs.
44777    pub fn send(
44778        self,
44779        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
44780    ) -> Result<(), fidl::Error> {
44781        let _result = self.send_raw(result);
44782        if _result.is_err() {
44783            self.control_handle.shutdown();
44784        }
44785        self.drop_without_shutdown();
44786        _result
44787    }
44788
44789    /// Similar to "send" but does not shutdown the channel if an error occurs.
44790    pub fn send_no_shutdown_on_err(
44791        self,
44792        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
44793    ) -> Result<(), fidl::Error> {
44794        let _result = self.send_raw(result);
44795        self.drop_without_shutdown();
44796        _result
44797    }
44798
44799    fn send_raw(
44800        &self,
44801        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
44802    ) -> Result<(), fidl::Error> {
44803        self.control_handle.inner.send::<fidl::encoding::ResultType<
44804            BaseNetworkSocketGetIpMulticastLoopbackResponse,
44805            fidl_fuchsia_posix::Errno,
44806        >>(
44807            result.map(|value| (value,)),
44808            self.tx_id,
44809            0x3b6b26ff558298f2,
44810            fidl::encoding::DynamicFlags::empty(),
44811        )
44812    }
44813}
44814
44815#[must_use = "FIDL methods require a response to be sent"]
44816#[derive(Debug)]
44817pub struct DatagramSocketAddIpMembershipResponder {
44818    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
44819    tx_id: u32,
44820}
44821
44822/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
44823/// if the responder is dropped without sending a response, so that the client
44824/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
44825impl std::ops::Drop for DatagramSocketAddIpMembershipResponder {
44826    fn drop(&mut self) {
44827        self.control_handle.shutdown();
44828        // Safety: drops once, never accessed again
44829        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44830    }
44831}
44832
44833impl fidl::endpoints::Responder for DatagramSocketAddIpMembershipResponder {
44834    type ControlHandle = DatagramSocketControlHandle;
44835
44836    fn control_handle(&self) -> &DatagramSocketControlHandle {
44837        &self.control_handle
44838    }
44839
44840    fn drop_without_shutdown(mut self) {
44841        // Safety: drops once, never accessed again due to mem::forget
44842        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44843        // Prevent Drop from running (which would shut down the channel)
44844        std::mem::forget(self);
44845    }
44846}
44847
44848impl DatagramSocketAddIpMembershipResponder {
44849    /// Sends a response to the FIDL transaction.
44850    ///
44851    /// Sets the channel to shutdown if an error occurs.
44852    pub fn send(
44853        self,
44854        mut result: Result<(), fidl_fuchsia_posix::Errno>,
44855    ) -> Result<(), fidl::Error> {
44856        let _result = self.send_raw(result);
44857        if _result.is_err() {
44858            self.control_handle.shutdown();
44859        }
44860        self.drop_without_shutdown();
44861        _result
44862    }
44863
44864    /// Similar to "send" but does not shutdown the channel if an error occurs.
44865    pub fn send_no_shutdown_on_err(
44866        self,
44867        mut result: Result<(), fidl_fuchsia_posix::Errno>,
44868    ) -> Result<(), fidl::Error> {
44869        let _result = self.send_raw(result);
44870        self.drop_without_shutdown();
44871        _result
44872    }
44873
44874    fn send_raw(
44875        &self,
44876        mut result: Result<(), fidl_fuchsia_posix::Errno>,
44877    ) -> Result<(), fidl::Error> {
44878        self.control_handle.inner.send::<fidl::encoding::ResultType<
44879            fidl::encoding::EmptyStruct,
44880            fidl_fuchsia_posix::Errno,
44881        >>(
44882            result,
44883            self.tx_id,
44884            0x76bc7df115a3b4d0,
44885            fidl::encoding::DynamicFlags::empty(),
44886        )
44887    }
44888}
44889
44890#[must_use = "FIDL methods require a response to be sent"]
44891#[derive(Debug)]
44892pub struct DatagramSocketDropIpMembershipResponder {
44893    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
44894    tx_id: u32,
44895}
44896
44897/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
44898/// if the responder is dropped without sending a response, so that the client
44899/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
44900impl std::ops::Drop for DatagramSocketDropIpMembershipResponder {
44901    fn drop(&mut self) {
44902        self.control_handle.shutdown();
44903        // Safety: drops once, never accessed again
44904        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44905    }
44906}
44907
44908impl fidl::endpoints::Responder for DatagramSocketDropIpMembershipResponder {
44909    type ControlHandle = DatagramSocketControlHandle;
44910
44911    fn control_handle(&self) -> &DatagramSocketControlHandle {
44912        &self.control_handle
44913    }
44914
44915    fn drop_without_shutdown(mut self) {
44916        // Safety: drops once, never accessed again due to mem::forget
44917        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44918        // Prevent Drop from running (which would shut down the channel)
44919        std::mem::forget(self);
44920    }
44921}
44922
44923impl DatagramSocketDropIpMembershipResponder {
44924    /// Sends a response to the FIDL transaction.
44925    ///
44926    /// Sets the channel to shutdown if an error occurs.
44927    pub fn send(
44928        self,
44929        mut result: Result<(), fidl_fuchsia_posix::Errno>,
44930    ) -> Result<(), fidl::Error> {
44931        let _result = self.send_raw(result);
44932        if _result.is_err() {
44933            self.control_handle.shutdown();
44934        }
44935        self.drop_without_shutdown();
44936        _result
44937    }
44938
44939    /// Similar to "send" but does not shutdown the channel if an error occurs.
44940    pub fn send_no_shutdown_on_err(
44941        self,
44942        mut result: Result<(), fidl_fuchsia_posix::Errno>,
44943    ) -> Result<(), fidl::Error> {
44944        let _result = self.send_raw(result);
44945        self.drop_without_shutdown();
44946        _result
44947    }
44948
44949    fn send_raw(
44950        &self,
44951        mut result: Result<(), fidl_fuchsia_posix::Errno>,
44952    ) -> Result<(), fidl::Error> {
44953        self.control_handle.inner.send::<fidl::encoding::ResultType<
44954            fidl::encoding::EmptyStruct,
44955            fidl_fuchsia_posix::Errno,
44956        >>(
44957            result,
44958            self.tx_id,
44959            0x2888f3099188d03,
44960            fidl::encoding::DynamicFlags::empty(),
44961        )
44962    }
44963}
44964
44965#[must_use = "FIDL methods require a response to be sent"]
44966#[derive(Debug)]
44967pub struct DatagramSocketSetIpTransparentResponder {
44968    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
44969    tx_id: u32,
44970}
44971
44972/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
44973/// if the responder is dropped without sending a response, so that the client
44974/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
44975impl std::ops::Drop for DatagramSocketSetIpTransparentResponder {
44976    fn drop(&mut self) {
44977        self.control_handle.shutdown();
44978        // Safety: drops once, never accessed again
44979        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44980    }
44981}
44982
44983impl fidl::endpoints::Responder for DatagramSocketSetIpTransparentResponder {
44984    type ControlHandle = DatagramSocketControlHandle;
44985
44986    fn control_handle(&self) -> &DatagramSocketControlHandle {
44987        &self.control_handle
44988    }
44989
44990    fn drop_without_shutdown(mut self) {
44991        // Safety: drops once, never accessed again due to mem::forget
44992        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
44993        // Prevent Drop from running (which would shut down the channel)
44994        std::mem::forget(self);
44995    }
44996}
44997
44998impl DatagramSocketSetIpTransparentResponder {
44999    /// Sends a response to the FIDL transaction.
45000    ///
45001    /// Sets the channel to shutdown if an error occurs.
45002    pub fn send(
45003        self,
45004        mut result: Result<(), fidl_fuchsia_posix::Errno>,
45005    ) -> Result<(), fidl::Error> {
45006        let _result = self.send_raw(result);
45007        if _result.is_err() {
45008            self.control_handle.shutdown();
45009        }
45010        self.drop_without_shutdown();
45011        _result
45012    }
45013
45014    /// Similar to "send" but does not shutdown the channel if an error occurs.
45015    pub fn send_no_shutdown_on_err(
45016        self,
45017        mut result: Result<(), fidl_fuchsia_posix::Errno>,
45018    ) -> Result<(), fidl::Error> {
45019        let _result = self.send_raw(result);
45020        self.drop_without_shutdown();
45021        _result
45022    }
45023
45024    fn send_raw(
45025        &self,
45026        mut result: Result<(), fidl_fuchsia_posix::Errno>,
45027    ) -> Result<(), fidl::Error> {
45028        self.control_handle.inner.send::<fidl::encoding::ResultType<
45029            fidl::encoding::EmptyStruct,
45030            fidl_fuchsia_posix::Errno,
45031        >>(
45032            result,
45033            self.tx_id,
45034            0x1ae532b0c066e3a0,
45035            fidl::encoding::DynamicFlags::empty(),
45036        )
45037    }
45038}
45039
45040#[must_use = "FIDL methods require a response to be sent"]
45041#[derive(Debug)]
45042pub struct DatagramSocketGetIpTransparentResponder {
45043    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
45044    tx_id: u32,
45045}
45046
45047/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
45048/// if the responder is dropped without sending a response, so that the client
45049/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
45050impl std::ops::Drop for DatagramSocketGetIpTransparentResponder {
45051    fn drop(&mut self) {
45052        self.control_handle.shutdown();
45053        // Safety: drops once, never accessed again
45054        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45055    }
45056}
45057
45058impl fidl::endpoints::Responder for DatagramSocketGetIpTransparentResponder {
45059    type ControlHandle = DatagramSocketControlHandle;
45060
45061    fn control_handle(&self) -> &DatagramSocketControlHandle {
45062        &self.control_handle
45063    }
45064
45065    fn drop_without_shutdown(mut self) {
45066        // Safety: drops once, never accessed again due to mem::forget
45067        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45068        // Prevent Drop from running (which would shut down the channel)
45069        std::mem::forget(self);
45070    }
45071}
45072
45073impl DatagramSocketGetIpTransparentResponder {
45074    /// Sends a response to the FIDL transaction.
45075    ///
45076    /// Sets the channel to shutdown if an error occurs.
45077    pub fn send(
45078        self,
45079        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
45080    ) -> Result<(), fidl::Error> {
45081        let _result = self.send_raw(result);
45082        if _result.is_err() {
45083            self.control_handle.shutdown();
45084        }
45085        self.drop_without_shutdown();
45086        _result
45087    }
45088
45089    /// Similar to "send" but does not shutdown the channel if an error occurs.
45090    pub fn send_no_shutdown_on_err(
45091        self,
45092        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
45093    ) -> Result<(), fidl::Error> {
45094        let _result = self.send_raw(result);
45095        self.drop_without_shutdown();
45096        _result
45097    }
45098
45099    fn send_raw(
45100        &self,
45101        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
45102    ) -> Result<(), fidl::Error> {
45103        self.control_handle.inner.send::<fidl::encoding::ResultType<
45104            BaseNetworkSocketGetIpTransparentResponse,
45105            fidl_fuchsia_posix::Errno,
45106        >>(
45107            result.map(|value| (value,)),
45108            self.tx_id,
45109            0x51d43695962ebfb5,
45110            fidl::encoding::DynamicFlags::empty(),
45111        )
45112    }
45113}
45114
45115#[must_use = "FIDL methods require a response to be sent"]
45116#[derive(Debug)]
45117pub struct DatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
45118    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
45119    tx_id: u32,
45120}
45121
45122/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
45123/// if the responder is dropped without sending a response, so that the client
45124/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
45125impl std::ops::Drop for DatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
45126    fn drop(&mut self) {
45127        self.control_handle.shutdown();
45128        // Safety: drops once, never accessed again
45129        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45130    }
45131}
45132
45133impl fidl::endpoints::Responder for DatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
45134    type ControlHandle = DatagramSocketControlHandle;
45135
45136    fn control_handle(&self) -> &DatagramSocketControlHandle {
45137        &self.control_handle
45138    }
45139
45140    fn drop_without_shutdown(mut self) {
45141        // Safety: drops once, never accessed again due to mem::forget
45142        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45143        // Prevent Drop from running (which would shut down the channel)
45144        std::mem::forget(self);
45145    }
45146}
45147
45148impl DatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
45149    /// Sends a response to the FIDL transaction.
45150    ///
45151    /// Sets the channel to shutdown if an error occurs.
45152    pub fn send(
45153        self,
45154        mut result: Result<(), fidl_fuchsia_posix::Errno>,
45155    ) -> Result<(), fidl::Error> {
45156        let _result = self.send_raw(result);
45157        if _result.is_err() {
45158            self.control_handle.shutdown();
45159        }
45160        self.drop_without_shutdown();
45161        _result
45162    }
45163
45164    /// Similar to "send" but does not shutdown the channel if an error occurs.
45165    pub fn send_no_shutdown_on_err(
45166        self,
45167        mut result: Result<(), fidl_fuchsia_posix::Errno>,
45168    ) -> Result<(), fidl::Error> {
45169        let _result = self.send_raw(result);
45170        self.drop_without_shutdown();
45171        _result
45172    }
45173
45174    fn send_raw(
45175        &self,
45176        mut result: Result<(), fidl_fuchsia_posix::Errno>,
45177    ) -> Result<(), fidl::Error> {
45178        self.control_handle.inner.send::<fidl::encoding::ResultType<
45179            fidl::encoding::EmptyStruct,
45180            fidl_fuchsia_posix::Errno,
45181        >>(
45182            result,
45183            self.tx_id,
45184            0x4722b4ce52f7840,
45185            fidl::encoding::DynamicFlags::empty(),
45186        )
45187    }
45188}
45189
45190#[must_use = "FIDL methods require a response to be sent"]
45191#[derive(Debug)]
45192pub struct DatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
45193    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
45194    tx_id: u32,
45195}
45196
45197/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
45198/// if the responder is dropped without sending a response, so that the client
45199/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
45200impl std::ops::Drop for DatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
45201    fn drop(&mut self) {
45202        self.control_handle.shutdown();
45203        // Safety: drops once, never accessed again
45204        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45205    }
45206}
45207
45208impl fidl::endpoints::Responder for DatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
45209    type ControlHandle = DatagramSocketControlHandle;
45210
45211    fn control_handle(&self) -> &DatagramSocketControlHandle {
45212        &self.control_handle
45213    }
45214
45215    fn drop_without_shutdown(mut self) {
45216        // Safety: drops once, never accessed again due to mem::forget
45217        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45218        // Prevent Drop from running (which would shut down the channel)
45219        std::mem::forget(self);
45220    }
45221}
45222
45223impl DatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
45224    /// Sends a response to the FIDL transaction.
45225    ///
45226    /// Sets the channel to shutdown if an error occurs.
45227    pub fn send(
45228        self,
45229        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
45230    ) -> Result<(), fidl::Error> {
45231        let _result = self.send_raw(result);
45232        if _result.is_err() {
45233            self.control_handle.shutdown();
45234        }
45235        self.drop_without_shutdown();
45236        _result
45237    }
45238
45239    /// Similar to "send" but does not shutdown the channel if an error occurs.
45240    pub fn send_no_shutdown_on_err(
45241        self,
45242        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
45243    ) -> Result<(), fidl::Error> {
45244        let _result = self.send_raw(result);
45245        self.drop_without_shutdown();
45246        _result
45247    }
45248
45249    fn send_raw(
45250        &self,
45251        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
45252    ) -> Result<(), fidl::Error> {
45253        self.control_handle.inner.send::<fidl::encoding::ResultType<
45254            BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
45255            fidl_fuchsia_posix::Errno,
45256        >>(
45257            result.map(|value| (value,)),
45258            self.tx_id,
45259            0x2a0e7dc5d6bfdfe9,
45260            fidl::encoding::DynamicFlags::empty(),
45261        )
45262    }
45263}
45264
45265#[must_use = "FIDL methods require a response to be sent"]
45266#[derive(Debug)]
45267pub struct DatagramSocketAddIpv6MembershipResponder {
45268    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
45269    tx_id: u32,
45270}
45271
45272/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
45273/// if the responder is dropped without sending a response, so that the client
45274/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
45275impl std::ops::Drop for DatagramSocketAddIpv6MembershipResponder {
45276    fn drop(&mut self) {
45277        self.control_handle.shutdown();
45278        // Safety: drops once, never accessed again
45279        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45280    }
45281}
45282
45283impl fidl::endpoints::Responder for DatagramSocketAddIpv6MembershipResponder {
45284    type ControlHandle = DatagramSocketControlHandle;
45285
45286    fn control_handle(&self) -> &DatagramSocketControlHandle {
45287        &self.control_handle
45288    }
45289
45290    fn drop_without_shutdown(mut self) {
45291        // Safety: drops once, never accessed again due to mem::forget
45292        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45293        // Prevent Drop from running (which would shut down the channel)
45294        std::mem::forget(self);
45295    }
45296}
45297
45298impl DatagramSocketAddIpv6MembershipResponder {
45299    /// Sends a response to the FIDL transaction.
45300    ///
45301    /// Sets the channel to shutdown if an error occurs.
45302    pub fn send(
45303        self,
45304        mut result: Result<(), fidl_fuchsia_posix::Errno>,
45305    ) -> Result<(), fidl::Error> {
45306        let _result = self.send_raw(result);
45307        if _result.is_err() {
45308            self.control_handle.shutdown();
45309        }
45310        self.drop_without_shutdown();
45311        _result
45312    }
45313
45314    /// Similar to "send" but does not shutdown the channel if an error occurs.
45315    pub fn send_no_shutdown_on_err(
45316        self,
45317        mut result: Result<(), fidl_fuchsia_posix::Errno>,
45318    ) -> Result<(), fidl::Error> {
45319        let _result = self.send_raw(result);
45320        self.drop_without_shutdown();
45321        _result
45322    }
45323
45324    fn send_raw(
45325        &self,
45326        mut result: Result<(), fidl_fuchsia_posix::Errno>,
45327    ) -> Result<(), fidl::Error> {
45328        self.control_handle.inner.send::<fidl::encoding::ResultType<
45329            fidl::encoding::EmptyStruct,
45330            fidl_fuchsia_posix::Errno,
45331        >>(
45332            result,
45333            self.tx_id,
45334            0x7c94727acb4ea4b3,
45335            fidl::encoding::DynamicFlags::empty(),
45336        )
45337    }
45338}
45339
45340#[must_use = "FIDL methods require a response to be sent"]
45341#[derive(Debug)]
45342pub struct DatagramSocketDropIpv6MembershipResponder {
45343    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
45344    tx_id: u32,
45345}
45346
45347/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
45348/// if the responder is dropped without sending a response, so that the client
45349/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
45350impl std::ops::Drop for DatagramSocketDropIpv6MembershipResponder {
45351    fn drop(&mut self) {
45352        self.control_handle.shutdown();
45353        // Safety: drops once, never accessed again
45354        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45355    }
45356}
45357
45358impl fidl::endpoints::Responder for DatagramSocketDropIpv6MembershipResponder {
45359    type ControlHandle = DatagramSocketControlHandle;
45360
45361    fn control_handle(&self) -> &DatagramSocketControlHandle {
45362        &self.control_handle
45363    }
45364
45365    fn drop_without_shutdown(mut self) {
45366        // Safety: drops once, never accessed again due to mem::forget
45367        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45368        // Prevent Drop from running (which would shut down the channel)
45369        std::mem::forget(self);
45370    }
45371}
45372
45373impl DatagramSocketDropIpv6MembershipResponder {
45374    /// Sends a response to the FIDL transaction.
45375    ///
45376    /// Sets the channel to shutdown if an error occurs.
45377    pub fn send(
45378        self,
45379        mut result: Result<(), fidl_fuchsia_posix::Errno>,
45380    ) -> Result<(), fidl::Error> {
45381        let _result = self.send_raw(result);
45382        if _result.is_err() {
45383            self.control_handle.shutdown();
45384        }
45385        self.drop_without_shutdown();
45386        _result
45387    }
45388
45389    /// Similar to "send" but does not shutdown the channel if an error occurs.
45390    pub fn send_no_shutdown_on_err(
45391        self,
45392        mut result: Result<(), fidl_fuchsia_posix::Errno>,
45393    ) -> Result<(), fidl::Error> {
45394        let _result = self.send_raw(result);
45395        self.drop_without_shutdown();
45396        _result
45397    }
45398
45399    fn send_raw(
45400        &self,
45401        mut result: Result<(), fidl_fuchsia_posix::Errno>,
45402    ) -> Result<(), fidl::Error> {
45403        self.control_handle.inner.send::<fidl::encoding::ResultType<
45404            fidl::encoding::EmptyStruct,
45405            fidl_fuchsia_posix::Errno,
45406        >>(
45407            result,
45408            self.tx_id,
45409            0x42104c70ccaba304,
45410            fidl::encoding::DynamicFlags::empty(),
45411        )
45412    }
45413}
45414
45415#[must_use = "FIDL methods require a response to be sent"]
45416#[derive(Debug)]
45417pub struct DatagramSocketSetIpv6MulticastInterfaceResponder {
45418    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
45419    tx_id: u32,
45420}
45421
45422/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
45423/// if the responder is dropped without sending a response, so that the client
45424/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
45425impl std::ops::Drop for DatagramSocketSetIpv6MulticastInterfaceResponder {
45426    fn drop(&mut self) {
45427        self.control_handle.shutdown();
45428        // Safety: drops once, never accessed again
45429        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45430    }
45431}
45432
45433impl fidl::endpoints::Responder for DatagramSocketSetIpv6MulticastInterfaceResponder {
45434    type ControlHandle = DatagramSocketControlHandle;
45435
45436    fn control_handle(&self) -> &DatagramSocketControlHandle {
45437        &self.control_handle
45438    }
45439
45440    fn drop_without_shutdown(mut self) {
45441        // Safety: drops once, never accessed again due to mem::forget
45442        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45443        // Prevent Drop from running (which would shut down the channel)
45444        std::mem::forget(self);
45445    }
45446}
45447
45448impl DatagramSocketSetIpv6MulticastInterfaceResponder {
45449    /// Sends a response to the FIDL transaction.
45450    ///
45451    /// Sets the channel to shutdown if an error occurs.
45452    pub fn send(
45453        self,
45454        mut result: Result<(), fidl_fuchsia_posix::Errno>,
45455    ) -> Result<(), fidl::Error> {
45456        let _result = self.send_raw(result);
45457        if _result.is_err() {
45458            self.control_handle.shutdown();
45459        }
45460        self.drop_without_shutdown();
45461        _result
45462    }
45463
45464    /// Similar to "send" but does not shutdown the channel if an error occurs.
45465    pub fn send_no_shutdown_on_err(
45466        self,
45467        mut result: Result<(), fidl_fuchsia_posix::Errno>,
45468    ) -> Result<(), fidl::Error> {
45469        let _result = self.send_raw(result);
45470        self.drop_without_shutdown();
45471        _result
45472    }
45473
45474    fn send_raw(
45475        &self,
45476        mut result: Result<(), fidl_fuchsia_posix::Errno>,
45477    ) -> Result<(), fidl::Error> {
45478        self.control_handle.inner.send::<fidl::encoding::ResultType<
45479            fidl::encoding::EmptyStruct,
45480            fidl_fuchsia_posix::Errno,
45481        >>(
45482            result,
45483            self.tx_id,
45484            0x135f76db3774ab3b,
45485            fidl::encoding::DynamicFlags::empty(),
45486        )
45487    }
45488}
45489
45490#[must_use = "FIDL methods require a response to be sent"]
45491#[derive(Debug)]
45492pub struct DatagramSocketGetIpv6MulticastInterfaceResponder {
45493    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
45494    tx_id: u32,
45495}
45496
45497/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
45498/// if the responder is dropped without sending a response, so that the client
45499/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
45500impl std::ops::Drop for DatagramSocketGetIpv6MulticastInterfaceResponder {
45501    fn drop(&mut self) {
45502        self.control_handle.shutdown();
45503        // Safety: drops once, never accessed again
45504        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45505    }
45506}
45507
45508impl fidl::endpoints::Responder for DatagramSocketGetIpv6MulticastInterfaceResponder {
45509    type ControlHandle = DatagramSocketControlHandle;
45510
45511    fn control_handle(&self) -> &DatagramSocketControlHandle {
45512        &self.control_handle
45513    }
45514
45515    fn drop_without_shutdown(mut self) {
45516        // Safety: drops once, never accessed again due to mem::forget
45517        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45518        // Prevent Drop from running (which would shut down the channel)
45519        std::mem::forget(self);
45520    }
45521}
45522
45523impl DatagramSocketGetIpv6MulticastInterfaceResponder {
45524    /// Sends a response to the FIDL transaction.
45525    ///
45526    /// Sets the channel to shutdown if an error occurs.
45527    pub fn send(
45528        self,
45529        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
45530    ) -> Result<(), fidl::Error> {
45531        let _result = self.send_raw(result);
45532        if _result.is_err() {
45533            self.control_handle.shutdown();
45534        }
45535        self.drop_without_shutdown();
45536        _result
45537    }
45538
45539    /// Similar to "send" but does not shutdown the channel if an error occurs.
45540    pub fn send_no_shutdown_on_err(
45541        self,
45542        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
45543    ) -> Result<(), fidl::Error> {
45544        let _result = self.send_raw(result);
45545        self.drop_without_shutdown();
45546        _result
45547    }
45548
45549    fn send_raw(
45550        &self,
45551        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
45552    ) -> Result<(), fidl::Error> {
45553        self.control_handle.inner.send::<fidl::encoding::ResultType<
45554            BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
45555            fidl_fuchsia_posix::Errno,
45556        >>(
45557            result.map(|value| (value,)),
45558            self.tx_id,
45559            0x1f26fcdd348f1882,
45560            fidl::encoding::DynamicFlags::empty(),
45561        )
45562    }
45563}
45564
45565#[must_use = "FIDL methods require a response to be sent"]
45566#[derive(Debug)]
45567pub struct DatagramSocketSetIpv6UnicastHopsResponder {
45568    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
45569    tx_id: u32,
45570}
45571
45572/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
45573/// if the responder is dropped without sending a response, so that the client
45574/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
45575impl std::ops::Drop for DatagramSocketSetIpv6UnicastHopsResponder {
45576    fn drop(&mut self) {
45577        self.control_handle.shutdown();
45578        // Safety: drops once, never accessed again
45579        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45580    }
45581}
45582
45583impl fidl::endpoints::Responder for DatagramSocketSetIpv6UnicastHopsResponder {
45584    type ControlHandle = DatagramSocketControlHandle;
45585
45586    fn control_handle(&self) -> &DatagramSocketControlHandle {
45587        &self.control_handle
45588    }
45589
45590    fn drop_without_shutdown(mut self) {
45591        // Safety: drops once, never accessed again due to mem::forget
45592        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45593        // Prevent Drop from running (which would shut down the channel)
45594        std::mem::forget(self);
45595    }
45596}
45597
45598impl DatagramSocketSetIpv6UnicastHopsResponder {
45599    /// Sends a response to the FIDL transaction.
45600    ///
45601    /// Sets the channel to shutdown if an error occurs.
45602    pub fn send(
45603        self,
45604        mut result: Result<(), fidl_fuchsia_posix::Errno>,
45605    ) -> Result<(), fidl::Error> {
45606        let _result = self.send_raw(result);
45607        if _result.is_err() {
45608            self.control_handle.shutdown();
45609        }
45610        self.drop_without_shutdown();
45611        _result
45612    }
45613
45614    /// Similar to "send" but does not shutdown the channel if an error occurs.
45615    pub fn send_no_shutdown_on_err(
45616        self,
45617        mut result: Result<(), fidl_fuchsia_posix::Errno>,
45618    ) -> Result<(), fidl::Error> {
45619        let _result = self.send_raw(result);
45620        self.drop_without_shutdown();
45621        _result
45622    }
45623
45624    fn send_raw(
45625        &self,
45626        mut result: Result<(), fidl_fuchsia_posix::Errno>,
45627    ) -> Result<(), fidl::Error> {
45628        self.control_handle.inner.send::<fidl::encoding::ResultType<
45629            fidl::encoding::EmptyStruct,
45630            fidl_fuchsia_posix::Errno,
45631        >>(
45632            result,
45633            self.tx_id,
45634            0x157d51e98f462859,
45635            fidl::encoding::DynamicFlags::empty(),
45636        )
45637    }
45638}
45639
45640#[must_use = "FIDL methods require a response to be sent"]
45641#[derive(Debug)]
45642pub struct DatagramSocketGetIpv6UnicastHopsResponder {
45643    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
45644    tx_id: u32,
45645}
45646
45647/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
45648/// if the responder is dropped without sending a response, so that the client
45649/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
45650impl std::ops::Drop for DatagramSocketGetIpv6UnicastHopsResponder {
45651    fn drop(&mut self) {
45652        self.control_handle.shutdown();
45653        // Safety: drops once, never accessed again
45654        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45655    }
45656}
45657
45658impl fidl::endpoints::Responder for DatagramSocketGetIpv6UnicastHopsResponder {
45659    type ControlHandle = DatagramSocketControlHandle;
45660
45661    fn control_handle(&self) -> &DatagramSocketControlHandle {
45662        &self.control_handle
45663    }
45664
45665    fn drop_without_shutdown(mut self) {
45666        // Safety: drops once, never accessed again due to mem::forget
45667        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45668        // Prevent Drop from running (which would shut down the channel)
45669        std::mem::forget(self);
45670    }
45671}
45672
45673impl DatagramSocketGetIpv6UnicastHopsResponder {
45674    /// Sends a response to the FIDL transaction.
45675    ///
45676    /// Sets the channel to shutdown if an error occurs.
45677    pub fn send(
45678        self,
45679        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
45680    ) -> Result<(), fidl::Error> {
45681        let _result = self.send_raw(result);
45682        if _result.is_err() {
45683            self.control_handle.shutdown();
45684        }
45685        self.drop_without_shutdown();
45686        _result
45687    }
45688
45689    /// Similar to "send" but does not shutdown the channel if an error occurs.
45690    pub fn send_no_shutdown_on_err(
45691        self,
45692        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
45693    ) -> Result<(), fidl::Error> {
45694        let _result = self.send_raw(result);
45695        self.drop_without_shutdown();
45696        _result
45697    }
45698
45699    fn send_raw(
45700        &self,
45701        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
45702    ) -> Result<(), fidl::Error> {
45703        self.control_handle.inner.send::<fidl::encoding::ResultType<
45704            BaseNetworkSocketGetIpv6UnicastHopsResponse,
45705            fidl_fuchsia_posix::Errno,
45706        >>(
45707            result.map(|value| (value,)),
45708            self.tx_id,
45709            0x21f4641cad8bd8d2,
45710            fidl::encoding::DynamicFlags::empty(),
45711        )
45712    }
45713}
45714
45715#[must_use = "FIDL methods require a response to be sent"]
45716#[derive(Debug)]
45717pub struct DatagramSocketSetIpv6ReceiveHopLimitResponder {
45718    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
45719    tx_id: u32,
45720}
45721
45722/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
45723/// if the responder is dropped without sending a response, so that the client
45724/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
45725impl std::ops::Drop for DatagramSocketSetIpv6ReceiveHopLimitResponder {
45726    fn drop(&mut self) {
45727        self.control_handle.shutdown();
45728        // Safety: drops once, never accessed again
45729        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45730    }
45731}
45732
45733impl fidl::endpoints::Responder for DatagramSocketSetIpv6ReceiveHopLimitResponder {
45734    type ControlHandle = DatagramSocketControlHandle;
45735
45736    fn control_handle(&self) -> &DatagramSocketControlHandle {
45737        &self.control_handle
45738    }
45739
45740    fn drop_without_shutdown(mut self) {
45741        // Safety: drops once, never accessed again due to mem::forget
45742        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45743        // Prevent Drop from running (which would shut down the channel)
45744        std::mem::forget(self);
45745    }
45746}
45747
45748impl DatagramSocketSetIpv6ReceiveHopLimitResponder {
45749    /// Sends a response to the FIDL transaction.
45750    ///
45751    /// Sets the channel to shutdown if an error occurs.
45752    pub fn send(
45753        self,
45754        mut result: Result<(), fidl_fuchsia_posix::Errno>,
45755    ) -> Result<(), fidl::Error> {
45756        let _result = self.send_raw(result);
45757        if _result.is_err() {
45758            self.control_handle.shutdown();
45759        }
45760        self.drop_without_shutdown();
45761        _result
45762    }
45763
45764    /// Similar to "send" but does not shutdown the channel if an error occurs.
45765    pub fn send_no_shutdown_on_err(
45766        self,
45767        mut result: Result<(), fidl_fuchsia_posix::Errno>,
45768    ) -> Result<(), fidl::Error> {
45769        let _result = self.send_raw(result);
45770        self.drop_without_shutdown();
45771        _result
45772    }
45773
45774    fn send_raw(
45775        &self,
45776        mut result: Result<(), fidl_fuchsia_posix::Errno>,
45777    ) -> Result<(), fidl::Error> {
45778        self.control_handle.inner.send::<fidl::encoding::ResultType<
45779            fidl::encoding::EmptyStruct,
45780            fidl_fuchsia_posix::Errno,
45781        >>(
45782            result,
45783            self.tx_id,
45784            0x5c24808ed2e84a1e,
45785            fidl::encoding::DynamicFlags::empty(),
45786        )
45787    }
45788}
45789
45790#[must_use = "FIDL methods require a response to be sent"]
45791#[derive(Debug)]
45792pub struct DatagramSocketGetIpv6ReceiveHopLimitResponder {
45793    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
45794    tx_id: u32,
45795}
45796
45797/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
45798/// if the responder is dropped without sending a response, so that the client
45799/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
45800impl std::ops::Drop for DatagramSocketGetIpv6ReceiveHopLimitResponder {
45801    fn drop(&mut self) {
45802        self.control_handle.shutdown();
45803        // Safety: drops once, never accessed again
45804        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45805    }
45806}
45807
45808impl fidl::endpoints::Responder for DatagramSocketGetIpv6ReceiveHopLimitResponder {
45809    type ControlHandle = DatagramSocketControlHandle;
45810
45811    fn control_handle(&self) -> &DatagramSocketControlHandle {
45812        &self.control_handle
45813    }
45814
45815    fn drop_without_shutdown(mut self) {
45816        // Safety: drops once, never accessed again due to mem::forget
45817        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45818        // Prevent Drop from running (which would shut down the channel)
45819        std::mem::forget(self);
45820    }
45821}
45822
45823impl DatagramSocketGetIpv6ReceiveHopLimitResponder {
45824    /// Sends a response to the FIDL transaction.
45825    ///
45826    /// Sets the channel to shutdown if an error occurs.
45827    pub fn send(
45828        self,
45829        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
45830    ) -> Result<(), fidl::Error> {
45831        let _result = self.send_raw(result);
45832        if _result.is_err() {
45833            self.control_handle.shutdown();
45834        }
45835        self.drop_without_shutdown();
45836        _result
45837    }
45838
45839    /// Similar to "send" but does not shutdown the channel if an error occurs.
45840    pub fn send_no_shutdown_on_err(
45841        self,
45842        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
45843    ) -> Result<(), fidl::Error> {
45844        let _result = self.send_raw(result);
45845        self.drop_without_shutdown();
45846        _result
45847    }
45848
45849    fn send_raw(
45850        &self,
45851        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
45852    ) -> Result<(), fidl::Error> {
45853        self.control_handle.inner.send::<fidl::encoding::ResultType<
45854            BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
45855            fidl_fuchsia_posix::Errno,
45856        >>(
45857            result.map(|value| (value,)),
45858            self.tx_id,
45859            0x341e06689885b4c0,
45860            fidl::encoding::DynamicFlags::empty(),
45861        )
45862    }
45863}
45864
45865#[must_use = "FIDL methods require a response to be sent"]
45866#[derive(Debug)]
45867pub struct DatagramSocketSetIpv6MulticastHopsResponder {
45868    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
45869    tx_id: u32,
45870}
45871
45872/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
45873/// if the responder is dropped without sending a response, so that the client
45874/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
45875impl std::ops::Drop for DatagramSocketSetIpv6MulticastHopsResponder {
45876    fn drop(&mut self) {
45877        self.control_handle.shutdown();
45878        // Safety: drops once, never accessed again
45879        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45880    }
45881}
45882
45883impl fidl::endpoints::Responder for DatagramSocketSetIpv6MulticastHopsResponder {
45884    type ControlHandle = DatagramSocketControlHandle;
45885
45886    fn control_handle(&self) -> &DatagramSocketControlHandle {
45887        &self.control_handle
45888    }
45889
45890    fn drop_without_shutdown(mut self) {
45891        // Safety: drops once, never accessed again due to mem::forget
45892        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45893        // Prevent Drop from running (which would shut down the channel)
45894        std::mem::forget(self);
45895    }
45896}
45897
45898impl DatagramSocketSetIpv6MulticastHopsResponder {
45899    /// Sends a response to the FIDL transaction.
45900    ///
45901    /// Sets the channel to shutdown if an error occurs.
45902    pub fn send(
45903        self,
45904        mut result: Result<(), fidl_fuchsia_posix::Errno>,
45905    ) -> Result<(), fidl::Error> {
45906        let _result = self.send_raw(result);
45907        if _result.is_err() {
45908            self.control_handle.shutdown();
45909        }
45910        self.drop_without_shutdown();
45911        _result
45912    }
45913
45914    /// Similar to "send" but does not shutdown the channel if an error occurs.
45915    pub fn send_no_shutdown_on_err(
45916        self,
45917        mut result: Result<(), fidl_fuchsia_posix::Errno>,
45918    ) -> Result<(), fidl::Error> {
45919        let _result = self.send_raw(result);
45920        self.drop_without_shutdown();
45921        _result
45922    }
45923
45924    fn send_raw(
45925        &self,
45926        mut result: Result<(), fidl_fuchsia_posix::Errno>,
45927    ) -> Result<(), fidl::Error> {
45928        self.control_handle.inner.send::<fidl::encoding::ResultType<
45929            fidl::encoding::EmptyStruct,
45930            fidl_fuchsia_posix::Errno,
45931        >>(
45932            result,
45933            self.tx_id,
45934            0x25b9cd4d181f82c1,
45935            fidl::encoding::DynamicFlags::empty(),
45936        )
45937    }
45938}
45939
45940#[must_use = "FIDL methods require a response to be sent"]
45941#[derive(Debug)]
45942pub struct DatagramSocketGetIpv6MulticastHopsResponder {
45943    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
45944    tx_id: u32,
45945}
45946
45947/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
45948/// if the responder is dropped without sending a response, so that the client
45949/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
45950impl std::ops::Drop for DatagramSocketGetIpv6MulticastHopsResponder {
45951    fn drop(&mut self) {
45952        self.control_handle.shutdown();
45953        // Safety: drops once, never accessed again
45954        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45955    }
45956}
45957
45958impl fidl::endpoints::Responder for DatagramSocketGetIpv6MulticastHopsResponder {
45959    type ControlHandle = DatagramSocketControlHandle;
45960
45961    fn control_handle(&self) -> &DatagramSocketControlHandle {
45962        &self.control_handle
45963    }
45964
45965    fn drop_without_shutdown(mut self) {
45966        // Safety: drops once, never accessed again due to mem::forget
45967        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
45968        // Prevent Drop from running (which would shut down the channel)
45969        std::mem::forget(self);
45970    }
45971}
45972
45973impl DatagramSocketGetIpv6MulticastHopsResponder {
45974    /// Sends a response to the FIDL transaction.
45975    ///
45976    /// Sets the channel to shutdown if an error occurs.
45977    pub fn send(
45978        self,
45979        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
45980    ) -> Result<(), fidl::Error> {
45981        let _result = self.send_raw(result);
45982        if _result.is_err() {
45983            self.control_handle.shutdown();
45984        }
45985        self.drop_without_shutdown();
45986        _result
45987    }
45988
45989    /// Similar to "send" but does not shutdown the channel if an error occurs.
45990    pub fn send_no_shutdown_on_err(
45991        self,
45992        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
45993    ) -> Result<(), fidl::Error> {
45994        let _result = self.send_raw(result);
45995        self.drop_without_shutdown();
45996        _result
45997    }
45998
45999    fn send_raw(
46000        &self,
46001        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
46002    ) -> Result<(), fidl::Error> {
46003        self.control_handle.inner.send::<fidl::encoding::ResultType<
46004            BaseNetworkSocketGetIpv6MulticastHopsResponse,
46005            fidl_fuchsia_posix::Errno,
46006        >>(
46007            result.map(|value| (value,)),
46008            self.tx_id,
46009            0x52916948a365012a,
46010            fidl::encoding::DynamicFlags::empty(),
46011        )
46012    }
46013}
46014
46015#[must_use = "FIDL methods require a response to be sent"]
46016#[derive(Debug)]
46017pub struct DatagramSocketSetIpv6MulticastLoopbackResponder {
46018    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
46019    tx_id: u32,
46020}
46021
46022/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
46023/// if the responder is dropped without sending a response, so that the client
46024/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
46025impl std::ops::Drop for DatagramSocketSetIpv6MulticastLoopbackResponder {
46026    fn drop(&mut self) {
46027        self.control_handle.shutdown();
46028        // Safety: drops once, never accessed again
46029        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46030    }
46031}
46032
46033impl fidl::endpoints::Responder for DatagramSocketSetIpv6MulticastLoopbackResponder {
46034    type ControlHandle = DatagramSocketControlHandle;
46035
46036    fn control_handle(&self) -> &DatagramSocketControlHandle {
46037        &self.control_handle
46038    }
46039
46040    fn drop_without_shutdown(mut self) {
46041        // Safety: drops once, never accessed again due to mem::forget
46042        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46043        // Prevent Drop from running (which would shut down the channel)
46044        std::mem::forget(self);
46045    }
46046}
46047
46048impl DatagramSocketSetIpv6MulticastLoopbackResponder {
46049    /// Sends a response to the FIDL transaction.
46050    ///
46051    /// Sets the channel to shutdown if an error occurs.
46052    pub fn send(
46053        self,
46054        mut result: Result<(), fidl_fuchsia_posix::Errno>,
46055    ) -> Result<(), fidl::Error> {
46056        let _result = self.send_raw(result);
46057        if _result.is_err() {
46058            self.control_handle.shutdown();
46059        }
46060        self.drop_without_shutdown();
46061        _result
46062    }
46063
46064    /// Similar to "send" but does not shutdown the channel if an error occurs.
46065    pub fn send_no_shutdown_on_err(
46066        self,
46067        mut result: Result<(), fidl_fuchsia_posix::Errno>,
46068    ) -> Result<(), fidl::Error> {
46069        let _result = self.send_raw(result);
46070        self.drop_without_shutdown();
46071        _result
46072    }
46073
46074    fn send_raw(
46075        &self,
46076        mut result: Result<(), fidl_fuchsia_posix::Errno>,
46077    ) -> Result<(), fidl::Error> {
46078        self.control_handle.inner.send::<fidl::encoding::ResultType<
46079            fidl::encoding::EmptyStruct,
46080            fidl_fuchsia_posix::Errno,
46081        >>(
46082            result,
46083            self.tx_id,
46084            0x55701c409ff41b40,
46085            fidl::encoding::DynamicFlags::empty(),
46086        )
46087    }
46088}
46089
46090#[must_use = "FIDL methods require a response to be sent"]
46091#[derive(Debug)]
46092pub struct DatagramSocketGetIpv6MulticastLoopbackResponder {
46093    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
46094    tx_id: u32,
46095}
46096
46097/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
46098/// if the responder is dropped without sending a response, so that the client
46099/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
46100impl std::ops::Drop for DatagramSocketGetIpv6MulticastLoopbackResponder {
46101    fn drop(&mut self) {
46102        self.control_handle.shutdown();
46103        // Safety: drops once, never accessed again
46104        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46105    }
46106}
46107
46108impl fidl::endpoints::Responder for DatagramSocketGetIpv6MulticastLoopbackResponder {
46109    type ControlHandle = DatagramSocketControlHandle;
46110
46111    fn control_handle(&self) -> &DatagramSocketControlHandle {
46112        &self.control_handle
46113    }
46114
46115    fn drop_without_shutdown(mut self) {
46116        // Safety: drops once, never accessed again due to mem::forget
46117        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46118        // Prevent Drop from running (which would shut down the channel)
46119        std::mem::forget(self);
46120    }
46121}
46122
46123impl DatagramSocketGetIpv6MulticastLoopbackResponder {
46124    /// Sends a response to the FIDL transaction.
46125    ///
46126    /// Sets the channel to shutdown if an error occurs.
46127    pub fn send(
46128        self,
46129        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
46130    ) -> Result<(), fidl::Error> {
46131        let _result = self.send_raw(result);
46132        if _result.is_err() {
46133            self.control_handle.shutdown();
46134        }
46135        self.drop_without_shutdown();
46136        _result
46137    }
46138
46139    /// Similar to "send" but does not shutdown the channel if an error occurs.
46140    pub fn send_no_shutdown_on_err(
46141        self,
46142        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
46143    ) -> Result<(), fidl::Error> {
46144        let _result = self.send_raw(result);
46145        self.drop_without_shutdown();
46146        _result
46147    }
46148
46149    fn send_raw(
46150        &self,
46151        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
46152    ) -> Result<(), fidl::Error> {
46153        self.control_handle.inner.send::<fidl::encoding::ResultType<
46154            BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
46155            fidl_fuchsia_posix::Errno,
46156        >>(
46157            result.map(|value| (value,)),
46158            self.tx_id,
46159            0x4415b701fde319c3,
46160            fidl::encoding::DynamicFlags::empty(),
46161        )
46162    }
46163}
46164
46165#[must_use = "FIDL methods require a response to be sent"]
46166#[derive(Debug)]
46167pub struct DatagramSocketSetIpv6OnlyResponder {
46168    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
46169    tx_id: u32,
46170}
46171
46172/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
46173/// if the responder is dropped without sending a response, so that the client
46174/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
46175impl std::ops::Drop for DatagramSocketSetIpv6OnlyResponder {
46176    fn drop(&mut self) {
46177        self.control_handle.shutdown();
46178        // Safety: drops once, never accessed again
46179        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46180    }
46181}
46182
46183impl fidl::endpoints::Responder for DatagramSocketSetIpv6OnlyResponder {
46184    type ControlHandle = DatagramSocketControlHandle;
46185
46186    fn control_handle(&self) -> &DatagramSocketControlHandle {
46187        &self.control_handle
46188    }
46189
46190    fn drop_without_shutdown(mut self) {
46191        // Safety: drops once, never accessed again due to mem::forget
46192        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46193        // Prevent Drop from running (which would shut down the channel)
46194        std::mem::forget(self);
46195    }
46196}
46197
46198impl DatagramSocketSetIpv6OnlyResponder {
46199    /// Sends a response to the FIDL transaction.
46200    ///
46201    /// Sets the channel to shutdown if an error occurs.
46202    pub fn send(
46203        self,
46204        mut result: Result<(), fidl_fuchsia_posix::Errno>,
46205    ) -> Result<(), fidl::Error> {
46206        let _result = self.send_raw(result);
46207        if _result.is_err() {
46208            self.control_handle.shutdown();
46209        }
46210        self.drop_without_shutdown();
46211        _result
46212    }
46213
46214    /// Similar to "send" but does not shutdown the channel if an error occurs.
46215    pub fn send_no_shutdown_on_err(
46216        self,
46217        mut result: Result<(), fidl_fuchsia_posix::Errno>,
46218    ) -> Result<(), fidl::Error> {
46219        let _result = self.send_raw(result);
46220        self.drop_without_shutdown();
46221        _result
46222    }
46223
46224    fn send_raw(
46225        &self,
46226        mut result: Result<(), fidl_fuchsia_posix::Errno>,
46227    ) -> Result<(), fidl::Error> {
46228        self.control_handle.inner.send::<fidl::encoding::ResultType<
46229            fidl::encoding::EmptyStruct,
46230            fidl_fuchsia_posix::Errno,
46231        >>(
46232            result,
46233            self.tx_id,
46234            0x4873f1364758cbba,
46235            fidl::encoding::DynamicFlags::empty(),
46236        )
46237    }
46238}
46239
46240#[must_use = "FIDL methods require a response to be sent"]
46241#[derive(Debug)]
46242pub struct DatagramSocketGetIpv6OnlyResponder {
46243    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
46244    tx_id: u32,
46245}
46246
46247/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
46248/// if the responder is dropped without sending a response, so that the client
46249/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
46250impl std::ops::Drop for DatagramSocketGetIpv6OnlyResponder {
46251    fn drop(&mut self) {
46252        self.control_handle.shutdown();
46253        // Safety: drops once, never accessed again
46254        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46255    }
46256}
46257
46258impl fidl::endpoints::Responder for DatagramSocketGetIpv6OnlyResponder {
46259    type ControlHandle = DatagramSocketControlHandle;
46260
46261    fn control_handle(&self) -> &DatagramSocketControlHandle {
46262        &self.control_handle
46263    }
46264
46265    fn drop_without_shutdown(mut self) {
46266        // Safety: drops once, never accessed again due to mem::forget
46267        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46268        // Prevent Drop from running (which would shut down the channel)
46269        std::mem::forget(self);
46270    }
46271}
46272
46273impl DatagramSocketGetIpv6OnlyResponder {
46274    /// Sends a response to the FIDL transaction.
46275    ///
46276    /// Sets the channel to shutdown if an error occurs.
46277    pub fn send(
46278        self,
46279        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
46280    ) -> Result<(), fidl::Error> {
46281        let _result = self.send_raw(result);
46282        if _result.is_err() {
46283            self.control_handle.shutdown();
46284        }
46285        self.drop_without_shutdown();
46286        _result
46287    }
46288
46289    /// Similar to "send" but does not shutdown the channel if an error occurs.
46290    pub fn send_no_shutdown_on_err(
46291        self,
46292        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
46293    ) -> Result<(), fidl::Error> {
46294        let _result = self.send_raw(result);
46295        self.drop_without_shutdown();
46296        _result
46297    }
46298
46299    fn send_raw(
46300        &self,
46301        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
46302    ) -> Result<(), fidl::Error> {
46303        self.control_handle.inner.send::<fidl::encoding::ResultType<
46304            BaseNetworkSocketGetIpv6OnlyResponse,
46305            fidl_fuchsia_posix::Errno,
46306        >>(
46307            result.map(|value| (value,)),
46308            self.tx_id,
46309            0x4aa3340a1a26b89c,
46310            fidl::encoding::DynamicFlags::empty(),
46311        )
46312    }
46313}
46314
46315#[must_use = "FIDL methods require a response to be sent"]
46316#[derive(Debug)]
46317pub struct DatagramSocketSetIpv6ReceiveTrafficClassResponder {
46318    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
46319    tx_id: u32,
46320}
46321
46322/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
46323/// if the responder is dropped without sending a response, so that the client
46324/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
46325impl std::ops::Drop for DatagramSocketSetIpv6ReceiveTrafficClassResponder {
46326    fn drop(&mut self) {
46327        self.control_handle.shutdown();
46328        // Safety: drops once, never accessed again
46329        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46330    }
46331}
46332
46333impl fidl::endpoints::Responder for DatagramSocketSetIpv6ReceiveTrafficClassResponder {
46334    type ControlHandle = DatagramSocketControlHandle;
46335
46336    fn control_handle(&self) -> &DatagramSocketControlHandle {
46337        &self.control_handle
46338    }
46339
46340    fn drop_without_shutdown(mut self) {
46341        // Safety: drops once, never accessed again due to mem::forget
46342        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46343        // Prevent Drop from running (which would shut down the channel)
46344        std::mem::forget(self);
46345    }
46346}
46347
46348impl DatagramSocketSetIpv6ReceiveTrafficClassResponder {
46349    /// Sends a response to the FIDL transaction.
46350    ///
46351    /// Sets the channel to shutdown if an error occurs.
46352    pub fn send(
46353        self,
46354        mut result: Result<(), fidl_fuchsia_posix::Errno>,
46355    ) -> Result<(), fidl::Error> {
46356        let _result = self.send_raw(result);
46357        if _result.is_err() {
46358            self.control_handle.shutdown();
46359        }
46360        self.drop_without_shutdown();
46361        _result
46362    }
46363
46364    /// Similar to "send" but does not shutdown the channel if an error occurs.
46365    pub fn send_no_shutdown_on_err(
46366        self,
46367        mut result: Result<(), fidl_fuchsia_posix::Errno>,
46368    ) -> Result<(), fidl::Error> {
46369        let _result = self.send_raw(result);
46370        self.drop_without_shutdown();
46371        _result
46372    }
46373
46374    fn send_raw(
46375        &self,
46376        mut result: Result<(), fidl_fuchsia_posix::Errno>,
46377    ) -> Result<(), fidl::Error> {
46378        self.control_handle.inner.send::<fidl::encoding::ResultType<
46379            fidl::encoding::EmptyStruct,
46380            fidl_fuchsia_posix::Errno,
46381        >>(
46382            result,
46383            self.tx_id,
46384            0x58f07c8788d099a0,
46385            fidl::encoding::DynamicFlags::empty(),
46386        )
46387    }
46388}
46389
46390#[must_use = "FIDL methods require a response to be sent"]
46391#[derive(Debug)]
46392pub struct DatagramSocketGetIpv6ReceiveTrafficClassResponder {
46393    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
46394    tx_id: u32,
46395}
46396
46397/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
46398/// if the responder is dropped without sending a response, so that the client
46399/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
46400impl std::ops::Drop for DatagramSocketGetIpv6ReceiveTrafficClassResponder {
46401    fn drop(&mut self) {
46402        self.control_handle.shutdown();
46403        // Safety: drops once, never accessed again
46404        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46405    }
46406}
46407
46408impl fidl::endpoints::Responder for DatagramSocketGetIpv6ReceiveTrafficClassResponder {
46409    type ControlHandle = DatagramSocketControlHandle;
46410
46411    fn control_handle(&self) -> &DatagramSocketControlHandle {
46412        &self.control_handle
46413    }
46414
46415    fn drop_without_shutdown(mut self) {
46416        // Safety: drops once, never accessed again due to mem::forget
46417        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46418        // Prevent Drop from running (which would shut down the channel)
46419        std::mem::forget(self);
46420    }
46421}
46422
46423impl DatagramSocketGetIpv6ReceiveTrafficClassResponder {
46424    /// Sends a response to the FIDL transaction.
46425    ///
46426    /// Sets the channel to shutdown if an error occurs.
46427    pub fn send(
46428        self,
46429        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
46430    ) -> Result<(), fidl::Error> {
46431        let _result = self.send_raw(result);
46432        if _result.is_err() {
46433            self.control_handle.shutdown();
46434        }
46435        self.drop_without_shutdown();
46436        _result
46437    }
46438
46439    /// Similar to "send" but does not shutdown the channel if an error occurs.
46440    pub fn send_no_shutdown_on_err(
46441        self,
46442        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
46443    ) -> Result<(), fidl::Error> {
46444        let _result = self.send_raw(result);
46445        self.drop_without_shutdown();
46446        _result
46447    }
46448
46449    fn send_raw(
46450        &self,
46451        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
46452    ) -> Result<(), fidl::Error> {
46453        self.control_handle.inner.send::<fidl::encoding::ResultType<
46454            BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
46455            fidl_fuchsia_posix::Errno,
46456        >>(
46457            result.map(|value| (value,)),
46458            self.tx_id,
46459            0x2e334df1da553ffa,
46460            fidl::encoding::DynamicFlags::empty(),
46461        )
46462    }
46463}
46464
46465#[must_use = "FIDL methods require a response to be sent"]
46466#[derive(Debug)]
46467pub struct DatagramSocketSetIpv6TrafficClassResponder {
46468    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
46469    tx_id: u32,
46470}
46471
46472/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
46473/// if the responder is dropped without sending a response, so that the client
46474/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
46475impl std::ops::Drop for DatagramSocketSetIpv6TrafficClassResponder {
46476    fn drop(&mut self) {
46477        self.control_handle.shutdown();
46478        // Safety: drops once, never accessed again
46479        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46480    }
46481}
46482
46483impl fidl::endpoints::Responder for DatagramSocketSetIpv6TrafficClassResponder {
46484    type ControlHandle = DatagramSocketControlHandle;
46485
46486    fn control_handle(&self) -> &DatagramSocketControlHandle {
46487        &self.control_handle
46488    }
46489
46490    fn drop_without_shutdown(mut self) {
46491        // Safety: drops once, never accessed again due to mem::forget
46492        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46493        // Prevent Drop from running (which would shut down the channel)
46494        std::mem::forget(self);
46495    }
46496}
46497
46498impl DatagramSocketSetIpv6TrafficClassResponder {
46499    /// Sends a response to the FIDL transaction.
46500    ///
46501    /// Sets the channel to shutdown if an error occurs.
46502    pub fn send(
46503        self,
46504        mut result: Result<(), fidl_fuchsia_posix::Errno>,
46505    ) -> Result<(), fidl::Error> {
46506        let _result = self.send_raw(result);
46507        if _result.is_err() {
46508            self.control_handle.shutdown();
46509        }
46510        self.drop_without_shutdown();
46511        _result
46512    }
46513
46514    /// Similar to "send" but does not shutdown the channel if an error occurs.
46515    pub fn send_no_shutdown_on_err(
46516        self,
46517        mut result: Result<(), fidl_fuchsia_posix::Errno>,
46518    ) -> Result<(), fidl::Error> {
46519        let _result = self.send_raw(result);
46520        self.drop_without_shutdown();
46521        _result
46522    }
46523
46524    fn send_raw(
46525        &self,
46526        mut result: Result<(), fidl_fuchsia_posix::Errno>,
46527    ) -> Result<(), fidl::Error> {
46528        self.control_handle.inner.send::<fidl::encoding::ResultType<
46529            fidl::encoding::EmptyStruct,
46530            fidl_fuchsia_posix::Errno,
46531        >>(
46532            result,
46533            self.tx_id,
46534            0x6af077800c5a0b4f,
46535            fidl::encoding::DynamicFlags::empty(),
46536        )
46537    }
46538}
46539
46540#[must_use = "FIDL methods require a response to be sent"]
46541#[derive(Debug)]
46542pub struct DatagramSocketGetIpv6TrafficClassResponder {
46543    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
46544    tx_id: u32,
46545}
46546
46547/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
46548/// if the responder is dropped without sending a response, so that the client
46549/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
46550impl std::ops::Drop for DatagramSocketGetIpv6TrafficClassResponder {
46551    fn drop(&mut self) {
46552        self.control_handle.shutdown();
46553        // Safety: drops once, never accessed again
46554        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46555    }
46556}
46557
46558impl fidl::endpoints::Responder for DatagramSocketGetIpv6TrafficClassResponder {
46559    type ControlHandle = DatagramSocketControlHandle;
46560
46561    fn control_handle(&self) -> &DatagramSocketControlHandle {
46562        &self.control_handle
46563    }
46564
46565    fn drop_without_shutdown(mut self) {
46566        // Safety: drops once, never accessed again due to mem::forget
46567        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46568        // Prevent Drop from running (which would shut down the channel)
46569        std::mem::forget(self);
46570    }
46571}
46572
46573impl DatagramSocketGetIpv6TrafficClassResponder {
46574    /// Sends a response to the FIDL transaction.
46575    ///
46576    /// Sets the channel to shutdown if an error occurs.
46577    pub fn send(
46578        self,
46579        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
46580    ) -> Result<(), fidl::Error> {
46581        let _result = self.send_raw(result);
46582        if _result.is_err() {
46583            self.control_handle.shutdown();
46584        }
46585        self.drop_without_shutdown();
46586        _result
46587    }
46588
46589    /// Similar to "send" but does not shutdown the channel if an error occurs.
46590    pub fn send_no_shutdown_on_err(
46591        self,
46592        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
46593    ) -> Result<(), fidl::Error> {
46594        let _result = self.send_raw(result);
46595        self.drop_without_shutdown();
46596        _result
46597    }
46598
46599    fn send_raw(
46600        &self,
46601        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
46602    ) -> Result<(), fidl::Error> {
46603        self.control_handle.inner.send::<fidl::encoding::ResultType<
46604            BaseNetworkSocketGetIpv6TrafficClassResponse,
46605            fidl_fuchsia_posix::Errno,
46606        >>(
46607            result.map(|value| (value,)),
46608            self.tx_id,
46609            0x6baf6eed8fc2f04,
46610            fidl::encoding::DynamicFlags::empty(),
46611        )
46612    }
46613}
46614
46615#[must_use = "FIDL methods require a response to be sent"]
46616#[derive(Debug)]
46617pub struct DatagramSocketSetIpv6ReceivePacketInfoResponder {
46618    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
46619    tx_id: u32,
46620}
46621
46622/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
46623/// if the responder is dropped without sending a response, so that the client
46624/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
46625impl std::ops::Drop for DatagramSocketSetIpv6ReceivePacketInfoResponder {
46626    fn drop(&mut self) {
46627        self.control_handle.shutdown();
46628        // Safety: drops once, never accessed again
46629        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46630    }
46631}
46632
46633impl fidl::endpoints::Responder for DatagramSocketSetIpv6ReceivePacketInfoResponder {
46634    type ControlHandle = DatagramSocketControlHandle;
46635
46636    fn control_handle(&self) -> &DatagramSocketControlHandle {
46637        &self.control_handle
46638    }
46639
46640    fn drop_without_shutdown(mut self) {
46641        // Safety: drops once, never accessed again due to mem::forget
46642        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46643        // Prevent Drop from running (which would shut down the channel)
46644        std::mem::forget(self);
46645    }
46646}
46647
46648impl DatagramSocketSetIpv6ReceivePacketInfoResponder {
46649    /// Sends a response to the FIDL transaction.
46650    ///
46651    /// Sets the channel to shutdown if an error occurs.
46652    pub fn send(
46653        self,
46654        mut result: Result<(), fidl_fuchsia_posix::Errno>,
46655    ) -> Result<(), fidl::Error> {
46656        let _result = self.send_raw(result);
46657        if _result.is_err() {
46658            self.control_handle.shutdown();
46659        }
46660        self.drop_without_shutdown();
46661        _result
46662    }
46663
46664    /// Similar to "send" but does not shutdown the channel if an error occurs.
46665    pub fn send_no_shutdown_on_err(
46666        self,
46667        mut result: Result<(), fidl_fuchsia_posix::Errno>,
46668    ) -> Result<(), fidl::Error> {
46669        let _result = self.send_raw(result);
46670        self.drop_without_shutdown();
46671        _result
46672    }
46673
46674    fn send_raw(
46675        &self,
46676        mut result: Result<(), fidl_fuchsia_posix::Errno>,
46677    ) -> Result<(), fidl::Error> {
46678        self.control_handle.inner.send::<fidl::encoding::ResultType<
46679            fidl::encoding::EmptyStruct,
46680            fidl_fuchsia_posix::Errno,
46681        >>(
46682            result,
46683            self.tx_id,
46684            0x19259775b1a92768,
46685            fidl::encoding::DynamicFlags::empty(),
46686        )
46687    }
46688}
46689
46690#[must_use = "FIDL methods require a response to be sent"]
46691#[derive(Debug)]
46692pub struct DatagramSocketGetIpv6ReceivePacketInfoResponder {
46693    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
46694    tx_id: u32,
46695}
46696
46697/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
46698/// if the responder is dropped without sending a response, so that the client
46699/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
46700impl std::ops::Drop for DatagramSocketGetIpv6ReceivePacketInfoResponder {
46701    fn drop(&mut self) {
46702        self.control_handle.shutdown();
46703        // Safety: drops once, never accessed again
46704        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46705    }
46706}
46707
46708impl fidl::endpoints::Responder for DatagramSocketGetIpv6ReceivePacketInfoResponder {
46709    type ControlHandle = DatagramSocketControlHandle;
46710
46711    fn control_handle(&self) -> &DatagramSocketControlHandle {
46712        &self.control_handle
46713    }
46714
46715    fn drop_without_shutdown(mut self) {
46716        // Safety: drops once, never accessed again due to mem::forget
46717        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46718        // Prevent Drop from running (which would shut down the channel)
46719        std::mem::forget(self);
46720    }
46721}
46722
46723impl DatagramSocketGetIpv6ReceivePacketInfoResponder {
46724    /// Sends a response to the FIDL transaction.
46725    ///
46726    /// Sets the channel to shutdown if an error occurs.
46727    pub fn send(
46728        self,
46729        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
46730    ) -> Result<(), fidl::Error> {
46731        let _result = self.send_raw(result);
46732        if _result.is_err() {
46733            self.control_handle.shutdown();
46734        }
46735        self.drop_without_shutdown();
46736        _result
46737    }
46738
46739    /// Similar to "send" but does not shutdown the channel if an error occurs.
46740    pub fn send_no_shutdown_on_err(
46741        self,
46742        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
46743    ) -> Result<(), fidl::Error> {
46744        let _result = self.send_raw(result);
46745        self.drop_without_shutdown();
46746        _result
46747    }
46748
46749    fn send_raw(
46750        &self,
46751        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
46752    ) -> Result<(), fidl::Error> {
46753        self.control_handle.inner.send::<fidl::encoding::ResultType<
46754            BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
46755            fidl_fuchsia_posix::Errno,
46756        >>(
46757            result.map(|value| (value,)),
46758            self.tx_id,
46759            0x7acd4a2775baec75,
46760            fidl::encoding::DynamicFlags::empty(),
46761        )
46762    }
46763}
46764
46765#[must_use = "FIDL methods require a response to be sent"]
46766#[derive(Debug)]
46767pub struct DatagramSocketGetOriginalDestinationResponder {
46768    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
46769    tx_id: u32,
46770}
46771
46772/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
46773/// if the responder is dropped without sending a response, so that the client
46774/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
46775impl std::ops::Drop for DatagramSocketGetOriginalDestinationResponder {
46776    fn drop(&mut self) {
46777        self.control_handle.shutdown();
46778        // Safety: drops once, never accessed again
46779        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46780    }
46781}
46782
46783impl fidl::endpoints::Responder for DatagramSocketGetOriginalDestinationResponder {
46784    type ControlHandle = DatagramSocketControlHandle;
46785
46786    fn control_handle(&self) -> &DatagramSocketControlHandle {
46787        &self.control_handle
46788    }
46789
46790    fn drop_without_shutdown(mut self) {
46791        // Safety: drops once, never accessed again due to mem::forget
46792        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46793        // Prevent Drop from running (which would shut down the channel)
46794        std::mem::forget(self);
46795    }
46796}
46797
46798impl DatagramSocketGetOriginalDestinationResponder {
46799    /// Sends a response to the FIDL transaction.
46800    ///
46801    /// Sets the channel to shutdown if an error occurs.
46802    pub fn send(
46803        self,
46804        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
46805    ) -> Result<(), fidl::Error> {
46806        let _result = self.send_raw(result);
46807        if _result.is_err() {
46808            self.control_handle.shutdown();
46809        }
46810        self.drop_without_shutdown();
46811        _result
46812    }
46813
46814    /// Similar to "send" but does not shutdown the channel if an error occurs.
46815    pub fn send_no_shutdown_on_err(
46816        self,
46817        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
46818    ) -> Result<(), fidl::Error> {
46819        let _result = self.send_raw(result);
46820        self.drop_without_shutdown();
46821        _result
46822    }
46823
46824    fn send_raw(
46825        &self,
46826        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
46827    ) -> Result<(), fidl::Error> {
46828        self.control_handle.inner.send::<fidl::encoding::ResultType<
46829            BaseNetworkSocketGetOriginalDestinationResponse,
46830            fidl_fuchsia_posix::Errno,
46831        >>(
46832            result.map(|value| (value,)),
46833            self.tx_id,
46834            0x38bf28f0dafdbac0,
46835            fidl::encoding::DynamicFlags::empty(),
46836        )
46837    }
46838}
46839
46840#[must_use = "FIDL methods require a response to be sent"]
46841#[derive(Debug)]
46842pub struct DatagramSocketGetInfoResponder {
46843    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
46844    tx_id: u32,
46845}
46846
46847/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
46848/// if the responder is dropped without sending a response, so that the client
46849/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
46850impl std::ops::Drop for DatagramSocketGetInfoResponder {
46851    fn drop(&mut self) {
46852        self.control_handle.shutdown();
46853        // Safety: drops once, never accessed again
46854        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46855    }
46856}
46857
46858impl fidl::endpoints::Responder for DatagramSocketGetInfoResponder {
46859    type ControlHandle = DatagramSocketControlHandle;
46860
46861    fn control_handle(&self) -> &DatagramSocketControlHandle {
46862        &self.control_handle
46863    }
46864
46865    fn drop_without_shutdown(mut self) {
46866        // Safety: drops once, never accessed again due to mem::forget
46867        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46868        // Prevent Drop from running (which would shut down the channel)
46869        std::mem::forget(self);
46870    }
46871}
46872
46873impl DatagramSocketGetInfoResponder {
46874    /// Sends a response to the FIDL transaction.
46875    ///
46876    /// Sets the channel to shutdown if an error occurs.
46877    pub fn send(
46878        self,
46879        mut result: Result<(Domain, DatagramSocketProtocol), fidl_fuchsia_posix::Errno>,
46880    ) -> Result<(), fidl::Error> {
46881        let _result = self.send_raw(result);
46882        if _result.is_err() {
46883            self.control_handle.shutdown();
46884        }
46885        self.drop_without_shutdown();
46886        _result
46887    }
46888
46889    /// Similar to "send" but does not shutdown the channel if an error occurs.
46890    pub fn send_no_shutdown_on_err(
46891        self,
46892        mut result: Result<(Domain, DatagramSocketProtocol), fidl_fuchsia_posix::Errno>,
46893    ) -> Result<(), fidl::Error> {
46894        let _result = self.send_raw(result);
46895        self.drop_without_shutdown();
46896        _result
46897    }
46898
46899    fn send_raw(
46900        &self,
46901        mut result: Result<(Domain, DatagramSocketProtocol), fidl_fuchsia_posix::Errno>,
46902    ) -> Result<(), fidl::Error> {
46903        self.control_handle.inner.send::<fidl::encoding::ResultType<
46904            BaseDatagramSocketGetInfoResponse,
46905            fidl_fuchsia_posix::Errno,
46906        >>(
46907            result,
46908            self.tx_id,
46909            0x48aa0a1f6a32d2ed,
46910            fidl::encoding::DynamicFlags::empty(),
46911        )
46912    }
46913}
46914
46915#[must_use = "FIDL methods require a response to be sent"]
46916#[derive(Debug)]
46917pub struct DatagramSocketDescribeResponder {
46918    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
46919    tx_id: u32,
46920}
46921
46922/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
46923/// if the responder is dropped without sending a response, so that the client
46924/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
46925impl std::ops::Drop for DatagramSocketDescribeResponder {
46926    fn drop(&mut self) {
46927        self.control_handle.shutdown();
46928        // Safety: drops once, never accessed again
46929        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46930    }
46931}
46932
46933impl fidl::endpoints::Responder for DatagramSocketDescribeResponder {
46934    type ControlHandle = DatagramSocketControlHandle;
46935
46936    fn control_handle(&self) -> &DatagramSocketControlHandle {
46937        &self.control_handle
46938    }
46939
46940    fn drop_without_shutdown(mut self) {
46941        // Safety: drops once, never accessed again due to mem::forget
46942        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46943        // Prevent Drop from running (which would shut down the channel)
46944        std::mem::forget(self);
46945    }
46946}
46947
46948impl DatagramSocketDescribeResponder {
46949    /// Sends a response to the FIDL transaction.
46950    ///
46951    /// Sets the channel to shutdown if an error occurs.
46952    pub fn send(self, mut payload: DatagramSocketDescribeResponse) -> Result<(), fidl::Error> {
46953        let _result = self.send_raw(payload);
46954        if _result.is_err() {
46955            self.control_handle.shutdown();
46956        }
46957        self.drop_without_shutdown();
46958        _result
46959    }
46960
46961    /// Similar to "send" but does not shutdown the channel if an error occurs.
46962    pub fn send_no_shutdown_on_err(
46963        self,
46964        mut payload: DatagramSocketDescribeResponse,
46965    ) -> Result<(), fidl::Error> {
46966        let _result = self.send_raw(payload);
46967        self.drop_without_shutdown();
46968        _result
46969    }
46970
46971    fn send_raw(&self, mut payload: DatagramSocketDescribeResponse) -> Result<(), fidl::Error> {
46972        self.control_handle.inner.send::<DatagramSocketDescribeResponse>(
46973            &mut payload,
46974            self.tx_id,
46975            0xbf1e2f0a86601f3,
46976            fidl::encoding::DynamicFlags::empty(),
46977        )
46978    }
46979}
46980
46981#[must_use = "FIDL methods require a response to be sent"]
46982#[derive(Debug)]
46983pub struct DatagramSocketSendMsgPreflightResponder {
46984    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
46985    tx_id: u32,
46986}
46987
46988/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
46989/// if the responder is dropped without sending a response, so that the client
46990/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
46991impl std::ops::Drop for DatagramSocketSendMsgPreflightResponder {
46992    fn drop(&mut self) {
46993        self.control_handle.shutdown();
46994        // Safety: drops once, never accessed again
46995        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
46996    }
46997}
46998
46999impl fidl::endpoints::Responder for DatagramSocketSendMsgPreflightResponder {
47000    type ControlHandle = DatagramSocketControlHandle;
47001
47002    fn control_handle(&self) -> &DatagramSocketControlHandle {
47003        &self.control_handle
47004    }
47005
47006    fn drop_without_shutdown(mut self) {
47007        // Safety: drops once, never accessed again due to mem::forget
47008        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
47009        // Prevent Drop from running (which would shut down the channel)
47010        std::mem::forget(self);
47011    }
47012}
47013
47014impl DatagramSocketSendMsgPreflightResponder {
47015    /// Sends a response to the FIDL transaction.
47016    ///
47017    /// Sets the channel to shutdown if an error occurs.
47018    pub fn send(
47019        self,
47020        mut result: Result<DatagramSocketSendMsgPreflightResponse, fidl_fuchsia_posix::Errno>,
47021    ) -> Result<(), fidl::Error> {
47022        let _result = self.send_raw(result);
47023        if _result.is_err() {
47024            self.control_handle.shutdown();
47025        }
47026        self.drop_without_shutdown();
47027        _result
47028    }
47029
47030    /// Similar to "send" but does not shutdown the channel if an error occurs.
47031    pub fn send_no_shutdown_on_err(
47032        self,
47033        mut result: Result<DatagramSocketSendMsgPreflightResponse, fidl_fuchsia_posix::Errno>,
47034    ) -> Result<(), fidl::Error> {
47035        let _result = self.send_raw(result);
47036        self.drop_without_shutdown();
47037        _result
47038    }
47039
47040    fn send_raw(
47041        &self,
47042        mut result: Result<DatagramSocketSendMsgPreflightResponse, fidl_fuchsia_posix::Errno>,
47043    ) -> Result<(), fidl::Error> {
47044        self.control_handle.inner.send::<fidl::encoding::ResultType<
47045            DatagramSocketSendMsgPreflightResponse,
47046            fidl_fuchsia_posix::Errno,
47047        >>(
47048            result.as_mut().map_err(|e| *e),
47049            self.tx_id,
47050            0x5362e668e777248a,
47051            fidl::encoding::DynamicFlags::empty(),
47052        )
47053    }
47054}
47055
47056#[must_use = "FIDL methods require a response to be sent"]
47057#[derive(Debug)]
47058pub struct DatagramSocketRecvMsgPostflightResponder {
47059    control_handle: std::mem::ManuallyDrop<DatagramSocketControlHandle>,
47060    tx_id: u32,
47061}
47062
47063/// Set the the channel to be shutdown (see [`DatagramSocketControlHandle::shutdown`])
47064/// if the responder is dropped without sending a response, so that the client
47065/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
47066impl std::ops::Drop for DatagramSocketRecvMsgPostflightResponder {
47067    fn drop(&mut self) {
47068        self.control_handle.shutdown();
47069        // Safety: drops once, never accessed again
47070        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
47071    }
47072}
47073
47074impl fidl::endpoints::Responder for DatagramSocketRecvMsgPostflightResponder {
47075    type ControlHandle = DatagramSocketControlHandle;
47076
47077    fn control_handle(&self) -> &DatagramSocketControlHandle {
47078        &self.control_handle
47079    }
47080
47081    fn drop_without_shutdown(mut self) {
47082        // Safety: drops once, never accessed again due to mem::forget
47083        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
47084        // Prevent Drop from running (which would shut down the channel)
47085        std::mem::forget(self);
47086    }
47087}
47088
47089impl DatagramSocketRecvMsgPostflightResponder {
47090    /// Sends a response to the FIDL transaction.
47091    ///
47092    /// Sets the channel to shutdown if an error occurs.
47093    pub fn send(
47094        self,
47095        mut result: Result<DatagramSocketRecvMsgPostflightResponse, fidl_fuchsia_posix::Errno>,
47096    ) -> Result<(), fidl::Error> {
47097        let _result = self.send_raw(result);
47098        if _result.is_err() {
47099            self.control_handle.shutdown();
47100        }
47101        self.drop_without_shutdown();
47102        _result
47103    }
47104
47105    /// Similar to "send" but does not shutdown the channel if an error occurs.
47106    pub fn send_no_shutdown_on_err(
47107        self,
47108        mut result: Result<DatagramSocketRecvMsgPostflightResponse, fidl_fuchsia_posix::Errno>,
47109    ) -> Result<(), fidl::Error> {
47110        let _result = self.send_raw(result);
47111        self.drop_without_shutdown();
47112        _result
47113    }
47114
47115    fn send_raw(
47116        &self,
47117        mut result: Result<DatagramSocketRecvMsgPostflightResponse, fidl_fuchsia_posix::Errno>,
47118    ) -> Result<(), fidl::Error> {
47119        self.control_handle.inner.send::<fidl::encoding::ResultType<
47120            DatagramSocketRecvMsgPostflightResponse,
47121            fidl_fuchsia_posix::Errno,
47122        >>(
47123            result.as_mut().map_err(|e| *e),
47124            self.tx_id,
47125            0x1a7cdeca5f3eb8e2,
47126            fidl::encoding::DynamicFlags::empty(),
47127        )
47128    }
47129}
47130
47131#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
47132pub struct ProviderMarker;
47133
47134impl fidl::endpoints::ProtocolMarker for ProviderMarker {
47135    type Proxy = ProviderProxy;
47136    type RequestStream = ProviderRequestStream;
47137    #[cfg(target_os = "fuchsia")]
47138    type SynchronousProxy = ProviderSynchronousProxy;
47139
47140    const DEBUG_NAME: &'static str = "fuchsia.posix.socket.Provider";
47141}
47142impl fidl::endpoints::DiscoverableProtocolMarker for ProviderMarker {}
47143pub type ProviderStreamSocketWithOptionsResult =
47144    Result<fidl::endpoints::ClientEnd<StreamSocketMarker>, fidl_fuchsia_posix::Errno>;
47145pub type ProviderStreamSocketResult =
47146    Result<fidl::endpoints::ClientEnd<StreamSocketMarker>, fidl_fuchsia_posix::Errno>;
47147pub type ProviderDatagramSocketDeprecatedResult =
47148    Result<fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>, fidl_fuchsia_posix::Errno>;
47149pub type ProviderDatagramSocketResult =
47150    Result<ProviderDatagramSocketResponse, fidl_fuchsia_posix::Errno>;
47151pub type ProviderDatagramSocketWithOptionsResult =
47152    Result<ProviderDatagramSocketWithOptionsResponse, fidl_fuchsia_posix::Errno>;
47153pub type ProviderInterfaceIndexToNameResult = Result<String, i32>;
47154pub type ProviderInterfaceNameToIndexResult = Result<u64, i32>;
47155pub type ProviderInterfaceNameToFlagsResult = Result<InterfaceFlags, i32>;
47156
47157pub trait ProviderProxyInterface: Send + Sync {
47158    type StreamSocketWithOptionsResponseFut: std::future::Future<Output = Result<ProviderStreamSocketWithOptionsResult, fidl::Error>>
47159        + Send;
47160    fn r#stream_socket_with_options(
47161        &self,
47162        domain: Domain,
47163        proto: StreamSocketProtocol,
47164        opts: &SocketCreationOptions,
47165    ) -> Self::StreamSocketWithOptionsResponseFut;
47166    type StreamSocketResponseFut: std::future::Future<Output = Result<ProviderStreamSocketResult, fidl::Error>>
47167        + Send;
47168    fn r#stream_socket(
47169        &self,
47170        domain: Domain,
47171        proto: StreamSocketProtocol,
47172    ) -> Self::StreamSocketResponseFut;
47173    type DatagramSocketDeprecatedResponseFut: std::future::Future<Output = Result<ProviderDatagramSocketDeprecatedResult, fidl::Error>>
47174        + Send;
47175    fn r#datagram_socket_deprecated(
47176        &self,
47177        domain: Domain,
47178        proto: DatagramSocketProtocol,
47179    ) -> Self::DatagramSocketDeprecatedResponseFut;
47180    type DatagramSocketResponseFut: std::future::Future<Output = Result<ProviderDatagramSocketResult, fidl::Error>>
47181        + Send;
47182    fn r#datagram_socket(
47183        &self,
47184        domain: Domain,
47185        proto: DatagramSocketProtocol,
47186    ) -> Self::DatagramSocketResponseFut;
47187    type DatagramSocketWithOptionsResponseFut: std::future::Future<Output = Result<ProviderDatagramSocketWithOptionsResult, fidl::Error>>
47188        + Send;
47189    fn r#datagram_socket_with_options(
47190        &self,
47191        domain: Domain,
47192        proto: DatagramSocketProtocol,
47193        opts: &SocketCreationOptions,
47194    ) -> Self::DatagramSocketWithOptionsResponseFut;
47195    type InterfaceIndexToNameResponseFut: std::future::Future<Output = Result<ProviderInterfaceIndexToNameResult, fidl::Error>>
47196        + Send;
47197    fn r#interface_index_to_name(&self, index: u64) -> Self::InterfaceIndexToNameResponseFut;
47198    type InterfaceNameToIndexResponseFut: std::future::Future<Output = Result<ProviderInterfaceNameToIndexResult, fidl::Error>>
47199        + Send;
47200    fn r#interface_name_to_index(&self, name: &str) -> Self::InterfaceNameToIndexResponseFut;
47201    type InterfaceNameToFlagsResponseFut: std::future::Future<Output = Result<ProviderInterfaceNameToFlagsResult, fidl::Error>>
47202        + Send;
47203    fn r#interface_name_to_flags(&self, name: &str) -> Self::InterfaceNameToFlagsResponseFut;
47204    type GetInterfaceAddressesResponseFut: std::future::Future<Output = Result<Vec<InterfaceAddresses>, fidl::Error>>
47205        + Send;
47206    fn r#get_interface_addresses(&self) -> Self::GetInterfaceAddressesResponseFut;
47207}
47208#[derive(Debug)]
47209#[cfg(target_os = "fuchsia")]
47210pub struct ProviderSynchronousProxy {
47211    client: fidl::client::sync::Client,
47212}
47213
47214#[cfg(target_os = "fuchsia")]
47215impl fidl::endpoints::SynchronousProxy for ProviderSynchronousProxy {
47216    type Proxy = ProviderProxy;
47217    type Protocol = ProviderMarker;
47218
47219    fn from_channel(inner: fidl::Channel) -> Self {
47220        Self::new(inner)
47221    }
47222
47223    fn into_channel(self) -> fidl::Channel {
47224        self.client.into_channel()
47225    }
47226
47227    fn as_channel(&self) -> &fidl::Channel {
47228        self.client.as_channel()
47229    }
47230}
47231
47232#[cfg(target_os = "fuchsia")]
47233impl ProviderSynchronousProxy {
47234    pub fn new(channel: fidl::Channel) -> Self {
47235        let protocol_name = <ProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
47236        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
47237    }
47238
47239    pub fn into_channel(self) -> fidl::Channel {
47240        self.client.into_channel()
47241    }
47242
47243    /// Waits until an event arrives and returns it. It is safe for other
47244    /// threads to make concurrent requests while waiting for an event.
47245    pub fn wait_for_event(
47246        &self,
47247        deadline: zx::MonotonicInstant,
47248    ) -> Result<ProviderEvent, fidl::Error> {
47249        ProviderEvent::decode(self.client.wait_for_event(deadline)?)
47250    }
47251
47252    /// Requests a stream socket with the specifed parameters and the creation
47253    /// options.
47254    pub fn r#stream_socket_with_options(
47255        &self,
47256        mut domain: Domain,
47257        mut proto: StreamSocketProtocol,
47258        mut opts: &SocketCreationOptions,
47259        ___deadline: zx::MonotonicInstant,
47260    ) -> Result<ProviderStreamSocketWithOptionsResult, fidl::Error> {
47261        let _response = self
47262            .client
47263            .send_query::<ProviderStreamSocketWithOptionsRequest, fidl::encoding::ResultType<
47264                ProviderStreamSocketWithOptionsResponse,
47265                fidl_fuchsia_posix::Errno,
47266            >>(
47267                (domain, proto, opts),
47268                0x3969bf7eb78386e0,
47269                fidl::encoding::DynamicFlags::empty(),
47270                ___deadline,
47271            )?;
47272        Ok(_response.map(|x| x.s))
47273    }
47274
47275    /// Requests a stream socket with the specified parameters.
47276    pub fn r#stream_socket(
47277        &self,
47278        mut domain: Domain,
47279        mut proto: StreamSocketProtocol,
47280        ___deadline: zx::MonotonicInstant,
47281    ) -> Result<ProviderStreamSocketResult, fidl::Error> {
47282        let _response =
47283            self.client.send_query::<ProviderStreamSocketRequest, fidl::encoding::ResultType<
47284                ProviderStreamSocketResponse,
47285                fidl_fuchsia_posix::Errno,
47286            >>(
47287                (domain, proto),
47288                0x27c3581da2155545,
47289                fidl::encoding::DynamicFlags::empty(),
47290                ___deadline,
47291            )?;
47292        Ok(_response.map(|x| x.s))
47293    }
47294
47295    /// Requests a datagram socket with the specified parameters.
47296    /// TODO(https://fxbug.dev/42165881): Remove this method once no more callers rely on it.
47297    pub fn r#datagram_socket_deprecated(
47298        &self,
47299        mut domain: Domain,
47300        mut proto: DatagramSocketProtocol,
47301        ___deadline: zx::MonotonicInstant,
47302    ) -> Result<ProviderDatagramSocketDeprecatedResult, fidl::Error> {
47303        let _response = self
47304            .client
47305            .send_query::<ProviderDatagramSocketDeprecatedRequest, fidl::encoding::ResultType<
47306                ProviderDatagramSocketDeprecatedResponse,
47307                fidl_fuchsia_posix::Errno,
47308            >>(
47309                (domain, proto),
47310                0x38876c87cf031cb1,
47311                fidl::encoding::DynamicFlags::empty(),
47312                ___deadline,
47313            )?;
47314        Ok(_response.map(|x| x.s))
47315    }
47316
47317    /// Requests a datagram socket with the specified parameters.
47318    pub fn r#datagram_socket(
47319        &self,
47320        mut domain: Domain,
47321        mut proto: DatagramSocketProtocol,
47322        ___deadline: zx::MonotonicInstant,
47323    ) -> Result<ProviderDatagramSocketResult, fidl::Error> {
47324        let _response =
47325            self.client.send_query::<ProviderDatagramSocketRequest, fidl::encoding::ResultType<
47326                ProviderDatagramSocketResponse,
47327                fidl_fuchsia_posix::Errno,
47328            >>(
47329                (domain, proto),
47330                0x4021b4fa1b6452f2,
47331                fidl::encoding::DynamicFlags::empty(),
47332                ___deadline,
47333            )?;
47334        Ok(_response.map(|x| x))
47335    }
47336
47337    /// Requests a datagram socket with the specifed parameters and the creation
47338    /// options.
47339    pub fn r#datagram_socket_with_options(
47340        &self,
47341        mut domain: Domain,
47342        mut proto: DatagramSocketProtocol,
47343        mut opts: &SocketCreationOptions,
47344        ___deadline: zx::MonotonicInstant,
47345    ) -> Result<ProviderDatagramSocketWithOptionsResult, fidl::Error> {
47346        let _response = self
47347            .client
47348            .send_query::<ProviderDatagramSocketWithOptionsRequest, fidl::encoding::ResultType<
47349                ProviderDatagramSocketWithOptionsResponse,
47350                fidl_fuchsia_posix::Errno,
47351            >>(
47352                (domain, proto, opts),
47353                0x4cd0cffbffa39eb1,
47354                fidl::encoding::DynamicFlags::empty(),
47355                ___deadline,
47356            )?;
47357        Ok(_response.map(|x| x))
47358    }
47359
47360    /// Looks up an interface by its index and returns its name. Returns
47361    /// `ZX_ERR_NOT_FOUND` if the specified index doesn't exist.
47362    pub fn r#interface_index_to_name(
47363        &self,
47364        mut index: u64,
47365        ___deadline: zx::MonotonicInstant,
47366    ) -> Result<ProviderInterfaceIndexToNameResult, fidl::Error> {
47367        let _response = self.client.send_query::<
47368            ProviderInterfaceIndexToNameRequest,
47369            fidl::encoding::ResultType<ProviderInterfaceIndexToNameResponse, i32>,
47370        >(
47371            (index,),
47372            0x4d59a64fce98272f,
47373            fidl::encoding::DynamicFlags::empty(),
47374            ___deadline,
47375        )?;
47376        Ok(_response.map(|x| x.name))
47377    }
47378
47379    /// Looks up an interface by its name and returns its index. Returns
47380    /// `ZX_ERR_NOT_FOUND` if the specified name doesn't exist.
47381    pub fn r#interface_name_to_index(
47382        &self,
47383        mut name: &str,
47384        ___deadline: zx::MonotonicInstant,
47385    ) -> Result<ProviderInterfaceNameToIndexResult, fidl::Error> {
47386        let _response = self.client.send_query::<
47387            ProviderInterfaceNameToIndexRequest,
47388            fidl::encoding::ResultType<ProviderInterfaceNameToIndexResponse, i32>,
47389        >(
47390            (name,),
47391            0x690cd8d2f2d650f8,
47392            fidl::encoding::DynamicFlags::empty(),
47393            ___deadline,
47394        )?;
47395        Ok(_response.map(|x| x.index))
47396    }
47397
47398    /// Looks up an interface by its name and returns its flags. Returns
47399    /// `ZX_ERR_NOT_FOUND` if the specified name doesn't exist.
47400    pub fn r#interface_name_to_flags(
47401        &self,
47402        mut name: &str,
47403        ___deadline: zx::MonotonicInstant,
47404    ) -> Result<ProviderInterfaceNameToFlagsResult, fidl::Error> {
47405        let _response = self.client.send_query::<
47406            ProviderInterfaceNameToFlagsRequest,
47407            fidl::encoding::ResultType<ProviderInterfaceNameToFlagsResponse, i32>,
47408        >(
47409            (name,),
47410            0x25d0efcdb6671a0b,
47411            fidl::encoding::DynamicFlags::empty(),
47412            ___deadline,
47413        )?;
47414        Ok(_response.map(|x| x.flags))
47415    }
47416
47417    /// Requests a list of [`fuchsia.posix.socket.InterfaceAddresses`]
47418    /// describing the network interfaces on the system.
47419    pub fn r#get_interface_addresses(
47420        &self,
47421        ___deadline: zx::MonotonicInstant,
47422    ) -> Result<Vec<InterfaceAddresses>, fidl::Error> {
47423        let _response = self
47424            .client
47425            .send_query::<fidl::encoding::EmptyPayload, ProviderGetInterfaceAddressesResponse>(
47426                (),
47427                0x2e7b9aaf327c870,
47428                fidl::encoding::DynamicFlags::empty(),
47429                ___deadline,
47430            )?;
47431        Ok(_response.interfaces)
47432    }
47433}
47434
47435#[cfg(target_os = "fuchsia")]
47436impl From<ProviderSynchronousProxy> for zx::Handle {
47437    fn from(value: ProviderSynchronousProxy) -> Self {
47438        value.into_channel().into()
47439    }
47440}
47441
47442#[cfg(target_os = "fuchsia")]
47443impl From<fidl::Channel> for ProviderSynchronousProxy {
47444    fn from(value: fidl::Channel) -> Self {
47445        Self::new(value)
47446    }
47447}
47448
47449#[derive(Debug, Clone)]
47450pub struct ProviderProxy {
47451    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
47452}
47453
47454impl fidl::endpoints::Proxy for ProviderProxy {
47455    type Protocol = ProviderMarker;
47456
47457    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
47458        Self::new(inner)
47459    }
47460
47461    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
47462        self.client.into_channel().map_err(|client| Self { client })
47463    }
47464
47465    fn as_channel(&self) -> &::fidl::AsyncChannel {
47466        self.client.as_channel()
47467    }
47468}
47469
47470impl ProviderProxy {
47471    /// Create a new Proxy for fuchsia.posix.socket/Provider.
47472    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
47473        let protocol_name = <ProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
47474        Self { client: fidl::client::Client::new(channel, protocol_name) }
47475    }
47476
47477    /// Get a Stream of events from the remote end of the protocol.
47478    ///
47479    /// # Panics
47480    ///
47481    /// Panics if the event stream was already taken.
47482    pub fn take_event_stream(&self) -> ProviderEventStream {
47483        ProviderEventStream { event_receiver: self.client.take_event_receiver() }
47484    }
47485
47486    /// Requests a stream socket with the specifed parameters and the creation
47487    /// options.
47488    pub fn r#stream_socket_with_options(
47489        &self,
47490        mut domain: Domain,
47491        mut proto: StreamSocketProtocol,
47492        mut opts: &SocketCreationOptions,
47493    ) -> fidl::client::QueryResponseFut<
47494        ProviderStreamSocketWithOptionsResult,
47495        fidl::encoding::DefaultFuchsiaResourceDialect,
47496    > {
47497        ProviderProxyInterface::r#stream_socket_with_options(self, domain, proto, opts)
47498    }
47499
47500    /// Requests a stream socket with the specified parameters.
47501    pub fn r#stream_socket(
47502        &self,
47503        mut domain: Domain,
47504        mut proto: StreamSocketProtocol,
47505    ) -> fidl::client::QueryResponseFut<
47506        ProviderStreamSocketResult,
47507        fidl::encoding::DefaultFuchsiaResourceDialect,
47508    > {
47509        ProviderProxyInterface::r#stream_socket(self, domain, proto)
47510    }
47511
47512    /// Requests a datagram socket with the specified parameters.
47513    /// TODO(https://fxbug.dev/42165881): Remove this method once no more callers rely on it.
47514    pub fn r#datagram_socket_deprecated(
47515        &self,
47516        mut domain: Domain,
47517        mut proto: DatagramSocketProtocol,
47518    ) -> fidl::client::QueryResponseFut<
47519        ProviderDatagramSocketDeprecatedResult,
47520        fidl::encoding::DefaultFuchsiaResourceDialect,
47521    > {
47522        ProviderProxyInterface::r#datagram_socket_deprecated(self, domain, proto)
47523    }
47524
47525    /// Requests a datagram socket with the specified parameters.
47526    pub fn r#datagram_socket(
47527        &self,
47528        mut domain: Domain,
47529        mut proto: DatagramSocketProtocol,
47530    ) -> fidl::client::QueryResponseFut<
47531        ProviderDatagramSocketResult,
47532        fidl::encoding::DefaultFuchsiaResourceDialect,
47533    > {
47534        ProviderProxyInterface::r#datagram_socket(self, domain, proto)
47535    }
47536
47537    /// Requests a datagram socket with the specifed parameters and the creation
47538    /// options.
47539    pub fn r#datagram_socket_with_options(
47540        &self,
47541        mut domain: Domain,
47542        mut proto: DatagramSocketProtocol,
47543        mut opts: &SocketCreationOptions,
47544    ) -> fidl::client::QueryResponseFut<
47545        ProviderDatagramSocketWithOptionsResult,
47546        fidl::encoding::DefaultFuchsiaResourceDialect,
47547    > {
47548        ProviderProxyInterface::r#datagram_socket_with_options(self, domain, proto, opts)
47549    }
47550
47551    /// Looks up an interface by its index and returns its name. Returns
47552    /// `ZX_ERR_NOT_FOUND` if the specified index doesn't exist.
47553    pub fn r#interface_index_to_name(
47554        &self,
47555        mut index: u64,
47556    ) -> fidl::client::QueryResponseFut<
47557        ProviderInterfaceIndexToNameResult,
47558        fidl::encoding::DefaultFuchsiaResourceDialect,
47559    > {
47560        ProviderProxyInterface::r#interface_index_to_name(self, index)
47561    }
47562
47563    /// Looks up an interface by its name and returns its index. Returns
47564    /// `ZX_ERR_NOT_FOUND` if the specified name doesn't exist.
47565    pub fn r#interface_name_to_index(
47566        &self,
47567        mut name: &str,
47568    ) -> fidl::client::QueryResponseFut<
47569        ProviderInterfaceNameToIndexResult,
47570        fidl::encoding::DefaultFuchsiaResourceDialect,
47571    > {
47572        ProviderProxyInterface::r#interface_name_to_index(self, name)
47573    }
47574
47575    /// Looks up an interface by its name and returns its flags. Returns
47576    /// `ZX_ERR_NOT_FOUND` if the specified name doesn't exist.
47577    pub fn r#interface_name_to_flags(
47578        &self,
47579        mut name: &str,
47580    ) -> fidl::client::QueryResponseFut<
47581        ProviderInterfaceNameToFlagsResult,
47582        fidl::encoding::DefaultFuchsiaResourceDialect,
47583    > {
47584        ProviderProxyInterface::r#interface_name_to_flags(self, name)
47585    }
47586
47587    /// Requests a list of [`fuchsia.posix.socket.InterfaceAddresses`]
47588    /// describing the network interfaces on the system.
47589    pub fn r#get_interface_addresses(
47590        &self,
47591    ) -> fidl::client::QueryResponseFut<
47592        Vec<InterfaceAddresses>,
47593        fidl::encoding::DefaultFuchsiaResourceDialect,
47594    > {
47595        ProviderProxyInterface::r#get_interface_addresses(self)
47596    }
47597}
47598
47599impl ProviderProxyInterface for ProviderProxy {
47600    type StreamSocketWithOptionsResponseFut = fidl::client::QueryResponseFut<
47601        ProviderStreamSocketWithOptionsResult,
47602        fidl::encoding::DefaultFuchsiaResourceDialect,
47603    >;
47604    fn r#stream_socket_with_options(
47605        &self,
47606        mut domain: Domain,
47607        mut proto: StreamSocketProtocol,
47608        mut opts: &SocketCreationOptions,
47609    ) -> Self::StreamSocketWithOptionsResponseFut {
47610        fn _decode(
47611            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
47612        ) -> Result<ProviderStreamSocketWithOptionsResult, fidl::Error> {
47613            let _response = fidl::client::decode_transaction_body::<
47614                fidl::encoding::ResultType<
47615                    ProviderStreamSocketWithOptionsResponse,
47616                    fidl_fuchsia_posix::Errno,
47617                >,
47618                fidl::encoding::DefaultFuchsiaResourceDialect,
47619                0x3969bf7eb78386e0,
47620            >(_buf?)?;
47621            Ok(_response.map(|x| x.s))
47622        }
47623        self.client.send_query_and_decode::<
47624            ProviderStreamSocketWithOptionsRequest,
47625            ProviderStreamSocketWithOptionsResult,
47626        >(
47627            (domain, proto, opts,),
47628            0x3969bf7eb78386e0,
47629            fidl::encoding::DynamicFlags::empty(),
47630            _decode,
47631        )
47632    }
47633
47634    type StreamSocketResponseFut = fidl::client::QueryResponseFut<
47635        ProviderStreamSocketResult,
47636        fidl::encoding::DefaultFuchsiaResourceDialect,
47637    >;
47638    fn r#stream_socket(
47639        &self,
47640        mut domain: Domain,
47641        mut proto: StreamSocketProtocol,
47642    ) -> Self::StreamSocketResponseFut {
47643        fn _decode(
47644            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
47645        ) -> Result<ProviderStreamSocketResult, fidl::Error> {
47646            let _response = fidl::client::decode_transaction_body::<
47647                fidl::encoding::ResultType<ProviderStreamSocketResponse, fidl_fuchsia_posix::Errno>,
47648                fidl::encoding::DefaultFuchsiaResourceDialect,
47649                0x27c3581da2155545,
47650            >(_buf?)?;
47651            Ok(_response.map(|x| x.s))
47652        }
47653        self.client
47654            .send_query_and_decode::<ProviderStreamSocketRequest, ProviderStreamSocketResult>(
47655                (domain, proto),
47656                0x27c3581da2155545,
47657                fidl::encoding::DynamicFlags::empty(),
47658                _decode,
47659            )
47660    }
47661
47662    type DatagramSocketDeprecatedResponseFut = fidl::client::QueryResponseFut<
47663        ProviderDatagramSocketDeprecatedResult,
47664        fidl::encoding::DefaultFuchsiaResourceDialect,
47665    >;
47666    fn r#datagram_socket_deprecated(
47667        &self,
47668        mut domain: Domain,
47669        mut proto: DatagramSocketProtocol,
47670    ) -> Self::DatagramSocketDeprecatedResponseFut {
47671        fn _decode(
47672            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
47673        ) -> Result<ProviderDatagramSocketDeprecatedResult, fidl::Error> {
47674            let _response = fidl::client::decode_transaction_body::<
47675                fidl::encoding::ResultType<
47676                    ProviderDatagramSocketDeprecatedResponse,
47677                    fidl_fuchsia_posix::Errno,
47678                >,
47679                fidl::encoding::DefaultFuchsiaResourceDialect,
47680                0x38876c87cf031cb1,
47681            >(_buf?)?;
47682            Ok(_response.map(|x| x.s))
47683        }
47684        self.client.send_query_and_decode::<
47685            ProviderDatagramSocketDeprecatedRequest,
47686            ProviderDatagramSocketDeprecatedResult,
47687        >(
47688            (domain, proto,),
47689            0x38876c87cf031cb1,
47690            fidl::encoding::DynamicFlags::empty(),
47691            _decode,
47692        )
47693    }
47694
47695    type DatagramSocketResponseFut = fidl::client::QueryResponseFut<
47696        ProviderDatagramSocketResult,
47697        fidl::encoding::DefaultFuchsiaResourceDialect,
47698    >;
47699    fn r#datagram_socket(
47700        &self,
47701        mut domain: Domain,
47702        mut proto: DatagramSocketProtocol,
47703    ) -> Self::DatagramSocketResponseFut {
47704        fn _decode(
47705            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
47706        ) -> Result<ProviderDatagramSocketResult, fidl::Error> {
47707            let _response = fidl::client::decode_transaction_body::<
47708                fidl::encoding::ResultType<
47709                    ProviderDatagramSocketResponse,
47710                    fidl_fuchsia_posix::Errno,
47711                >,
47712                fidl::encoding::DefaultFuchsiaResourceDialect,
47713                0x4021b4fa1b6452f2,
47714            >(_buf?)?;
47715            Ok(_response.map(|x| x))
47716        }
47717        self.client
47718            .send_query_and_decode::<ProviderDatagramSocketRequest, ProviderDatagramSocketResult>(
47719                (domain, proto),
47720                0x4021b4fa1b6452f2,
47721                fidl::encoding::DynamicFlags::empty(),
47722                _decode,
47723            )
47724    }
47725
47726    type DatagramSocketWithOptionsResponseFut = fidl::client::QueryResponseFut<
47727        ProviderDatagramSocketWithOptionsResult,
47728        fidl::encoding::DefaultFuchsiaResourceDialect,
47729    >;
47730    fn r#datagram_socket_with_options(
47731        &self,
47732        mut domain: Domain,
47733        mut proto: DatagramSocketProtocol,
47734        mut opts: &SocketCreationOptions,
47735    ) -> Self::DatagramSocketWithOptionsResponseFut {
47736        fn _decode(
47737            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
47738        ) -> Result<ProviderDatagramSocketWithOptionsResult, fidl::Error> {
47739            let _response = fidl::client::decode_transaction_body::<
47740                fidl::encoding::ResultType<
47741                    ProviderDatagramSocketWithOptionsResponse,
47742                    fidl_fuchsia_posix::Errno,
47743                >,
47744                fidl::encoding::DefaultFuchsiaResourceDialect,
47745                0x4cd0cffbffa39eb1,
47746            >(_buf?)?;
47747            Ok(_response.map(|x| x))
47748        }
47749        self.client.send_query_and_decode::<
47750            ProviderDatagramSocketWithOptionsRequest,
47751            ProviderDatagramSocketWithOptionsResult,
47752        >(
47753            (domain, proto, opts,),
47754            0x4cd0cffbffa39eb1,
47755            fidl::encoding::DynamicFlags::empty(),
47756            _decode,
47757        )
47758    }
47759
47760    type InterfaceIndexToNameResponseFut = fidl::client::QueryResponseFut<
47761        ProviderInterfaceIndexToNameResult,
47762        fidl::encoding::DefaultFuchsiaResourceDialect,
47763    >;
47764    fn r#interface_index_to_name(&self, mut index: u64) -> Self::InterfaceIndexToNameResponseFut {
47765        fn _decode(
47766            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
47767        ) -> Result<ProviderInterfaceIndexToNameResult, fidl::Error> {
47768            let _response = fidl::client::decode_transaction_body::<
47769                fidl::encoding::ResultType<ProviderInterfaceIndexToNameResponse, i32>,
47770                fidl::encoding::DefaultFuchsiaResourceDialect,
47771                0x4d59a64fce98272f,
47772            >(_buf?)?;
47773            Ok(_response.map(|x| x.name))
47774        }
47775        self.client.send_query_and_decode::<
47776            ProviderInterfaceIndexToNameRequest,
47777            ProviderInterfaceIndexToNameResult,
47778        >(
47779            (index,),
47780            0x4d59a64fce98272f,
47781            fidl::encoding::DynamicFlags::empty(),
47782            _decode,
47783        )
47784    }
47785
47786    type InterfaceNameToIndexResponseFut = fidl::client::QueryResponseFut<
47787        ProviderInterfaceNameToIndexResult,
47788        fidl::encoding::DefaultFuchsiaResourceDialect,
47789    >;
47790    fn r#interface_name_to_index(&self, mut name: &str) -> Self::InterfaceNameToIndexResponseFut {
47791        fn _decode(
47792            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
47793        ) -> Result<ProviderInterfaceNameToIndexResult, fidl::Error> {
47794            let _response = fidl::client::decode_transaction_body::<
47795                fidl::encoding::ResultType<ProviderInterfaceNameToIndexResponse, i32>,
47796                fidl::encoding::DefaultFuchsiaResourceDialect,
47797                0x690cd8d2f2d650f8,
47798            >(_buf?)?;
47799            Ok(_response.map(|x| x.index))
47800        }
47801        self.client.send_query_and_decode::<
47802            ProviderInterfaceNameToIndexRequest,
47803            ProviderInterfaceNameToIndexResult,
47804        >(
47805            (name,),
47806            0x690cd8d2f2d650f8,
47807            fidl::encoding::DynamicFlags::empty(),
47808            _decode,
47809        )
47810    }
47811
47812    type InterfaceNameToFlagsResponseFut = fidl::client::QueryResponseFut<
47813        ProviderInterfaceNameToFlagsResult,
47814        fidl::encoding::DefaultFuchsiaResourceDialect,
47815    >;
47816    fn r#interface_name_to_flags(&self, mut name: &str) -> Self::InterfaceNameToFlagsResponseFut {
47817        fn _decode(
47818            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
47819        ) -> Result<ProviderInterfaceNameToFlagsResult, fidl::Error> {
47820            let _response = fidl::client::decode_transaction_body::<
47821                fidl::encoding::ResultType<ProviderInterfaceNameToFlagsResponse, i32>,
47822                fidl::encoding::DefaultFuchsiaResourceDialect,
47823                0x25d0efcdb6671a0b,
47824            >(_buf?)?;
47825            Ok(_response.map(|x| x.flags))
47826        }
47827        self.client.send_query_and_decode::<
47828            ProviderInterfaceNameToFlagsRequest,
47829            ProviderInterfaceNameToFlagsResult,
47830        >(
47831            (name,),
47832            0x25d0efcdb6671a0b,
47833            fidl::encoding::DynamicFlags::empty(),
47834            _decode,
47835        )
47836    }
47837
47838    type GetInterfaceAddressesResponseFut = fidl::client::QueryResponseFut<
47839        Vec<InterfaceAddresses>,
47840        fidl::encoding::DefaultFuchsiaResourceDialect,
47841    >;
47842    fn r#get_interface_addresses(&self) -> Self::GetInterfaceAddressesResponseFut {
47843        fn _decode(
47844            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
47845        ) -> Result<Vec<InterfaceAddresses>, fidl::Error> {
47846            let _response = fidl::client::decode_transaction_body::<
47847                ProviderGetInterfaceAddressesResponse,
47848                fidl::encoding::DefaultFuchsiaResourceDialect,
47849                0x2e7b9aaf327c870,
47850            >(_buf?)?;
47851            Ok(_response.interfaces)
47852        }
47853        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<InterfaceAddresses>>(
47854            (),
47855            0x2e7b9aaf327c870,
47856            fidl::encoding::DynamicFlags::empty(),
47857            _decode,
47858        )
47859    }
47860}
47861
47862pub struct ProviderEventStream {
47863    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
47864}
47865
47866impl std::marker::Unpin for ProviderEventStream {}
47867
47868impl futures::stream::FusedStream for ProviderEventStream {
47869    fn is_terminated(&self) -> bool {
47870        self.event_receiver.is_terminated()
47871    }
47872}
47873
47874impl futures::Stream for ProviderEventStream {
47875    type Item = Result<ProviderEvent, fidl::Error>;
47876
47877    fn poll_next(
47878        mut self: std::pin::Pin<&mut Self>,
47879        cx: &mut std::task::Context<'_>,
47880    ) -> std::task::Poll<Option<Self::Item>> {
47881        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
47882            &mut self.event_receiver,
47883            cx
47884        )?) {
47885            Some(buf) => std::task::Poll::Ready(Some(ProviderEvent::decode(buf))),
47886            None => std::task::Poll::Ready(None),
47887        }
47888    }
47889}
47890
47891#[derive(Debug)]
47892pub enum ProviderEvent {}
47893
47894impl ProviderEvent {
47895    /// Decodes a message buffer as a [`ProviderEvent`].
47896    fn decode(
47897        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
47898    ) -> Result<ProviderEvent, fidl::Error> {
47899        let (bytes, _handles) = buf.split_mut();
47900        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
47901        debug_assert_eq!(tx_header.tx_id, 0);
47902        match tx_header.ordinal {
47903            _ => Err(fidl::Error::UnknownOrdinal {
47904                ordinal: tx_header.ordinal,
47905                protocol_name: <ProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
47906            }),
47907        }
47908    }
47909}
47910
47911/// A Stream of incoming requests for fuchsia.posix.socket/Provider.
47912pub struct ProviderRequestStream {
47913    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
47914    is_terminated: bool,
47915}
47916
47917impl std::marker::Unpin for ProviderRequestStream {}
47918
47919impl futures::stream::FusedStream for ProviderRequestStream {
47920    fn is_terminated(&self) -> bool {
47921        self.is_terminated
47922    }
47923}
47924
47925impl fidl::endpoints::RequestStream for ProviderRequestStream {
47926    type Protocol = ProviderMarker;
47927    type ControlHandle = ProviderControlHandle;
47928
47929    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
47930        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
47931    }
47932
47933    fn control_handle(&self) -> Self::ControlHandle {
47934        ProviderControlHandle { inner: self.inner.clone() }
47935    }
47936
47937    fn into_inner(
47938        self,
47939    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
47940    {
47941        (self.inner, self.is_terminated)
47942    }
47943
47944    fn from_inner(
47945        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
47946        is_terminated: bool,
47947    ) -> Self {
47948        Self { inner, is_terminated }
47949    }
47950}
47951
47952impl futures::Stream for ProviderRequestStream {
47953    type Item = Result<ProviderRequest, fidl::Error>;
47954
47955    fn poll_next(
47956        mut self: std::pin::Pin<&mut Self>,
47957        cx: &mut std::task::Context<'_>,
47958    ) -> std::task::Poll<Option<Self::Item>> {
47959        let this = &mut *self;
47960        if this.inner.check_shutdown(cx) {
47961            this.is_terminated = true;
47962            return std::task::Poll::Ready(None);
47963        }
47964        if this.is_terminated {
47965            panic!("polled ProviderRequestStream after completion");
47966        }
47967        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
47968            |bytes, handles| {
47969                match this.inner.channel().read_etc(cx, bytes, handles) {
47970                    std::task::Poll::Ready(Ok(())) => {}
47971                    std::task::Poll::Pending => return std::task::Poll::Pending,
47972                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
47973                        this.is_terminated = true;
47974                        return std::task::Poll::Ready(None);
47975                    }
47976                    std::task::Poll::Ready(Err(e)) => {
47977                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
47978                            e.into(),
47979                        ))))
47980                    }
47981                }
47982
47983                // A message has been received from the channel
47984                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
47985
47986                std::task::Poll::Ready(Some(match header.ordinal {
47987                    0x3969bf7eb78386e0 => {
47988                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
47989                        let mut req = fidl::new_empty!(
47990                            ProviderStreamSocketWithOptionsRequest,
47991                            fidl::encoding::DefaultFuchsiaResourceDialect
47992                        );
47993                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProviderStreamSocketWithOptionsRequest>(&header, _body_bytes, handles, &mut req)?;
47994                        let control_handle = ProviderControlHandle { inner: this.inner.clone() };
47995                        Ok(ProviderRequest::StreamSocketWithOptions {
47996                            domain: req.domain,
47997                            proto: req.proto,
47998                            opts: req.opts,
47999
48000                            responder: ProviderStreamSocketWithOptionsResponder {
48001                                control_handle: std::mem::ManuallyDrop::new(control_handle),
48002                                tx_id: header.tx_id,
48003                            },
48004                        })
48005                    }
48006                    0x27c3581da2155545 => {
48007                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
48008                        let mut req = fidl::new_empty!(
48009                            ProviderStreamSocketRequest,
48010                            fidl::encoding::DefaultFuchsiaResourceDialect
48011                        );
48012                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProviderStreamSocketRequest>(&header, _body_bytes, handles, &mut req)?;
48013                        let control_handle = ProviderControlHandle { inner: this.inner.clone() };
48014                        Ok(ProviderRequest::StreamSocket {
48015                            domain: req.domain,
48016                            proto: req.proto,
48017
48018                            responder: ProviderStreamSocketResponder {
48019                                control_handle: std::mem::ManuallyDrop::new(control_handle),
48020                                tx_id: header.tx_id,
48021                            },
48022                        })
48023                    }
48024                    0x38876c87cf031cb1 => {
48025                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
48026                        let mut req = fidl::new_empty!(
48027                            ProviderDatagramSocketDeprecatedRequest,
48028                            fidl::encoding::DefaultFuchsiaResourceDialect
48029                        );
48030                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProviderDatagramSocketDeprecatedRequest>(&header, _body_bytes, handles, &mut req)?;
48031                        let control_handle = ProviderControlHandle { inner: this.inner.clone() };
48032                        Ok(ProviderRequest::DatagramSocketDeprecated {
48033                            domain: req.domain,
48034                            proto: req.proto,
48035
48036                            responder: ProviderDatagramSocketDeprecatedResponder {
48037                                control_handle: std::mem::ManuallyDrop::new(control_handle),
48038                                tx_id: header.tx_id,
48039                            },
48040                        })
48041                    }
48042                    0x4021b4fa1b6452f2 => {
48043                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
48044                        let mut req = fidl::new_empty!(
48045                            ProviderDatagramSocketRequest,
48046                            fidl::encoding::DefaultFuchsiaResourceDialect
48047                        );
48048                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProviderDatagramSocketRequest>(&header, _body_bytes, handles, &mut req)?;
48049                        let control_handle = ProviderControlHandle { inner: this.inner.clone() };
48050                        Ok(ProviderRequest::DatagramSocket {
48051                            domain: req.domain,
48052                            proto: req.proto,
48053
48054                            responder: ProviderDatagramSocketResponder {
48055                                control_handle: std::mem::ManuallyDrop::new(control_handle),
48056                                tx_id: header.tx_id,
48057                            },
48058                        })
48059                    }
48060                    0x4cd0cffbffa39eb1 => {
48061                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
48062                        let mut req = fidl::new_empty!(
48063                            ProviderDatagramSocketWithOptionsRequest,
48064                            fidl::encoding::DefaultFuchsiaResourceDialect
48065                        );
48066                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProviderDatagramSocketWithOptionsRequest>(&header, _body_bytes, handles, &mut req)?;
48067                        let control_handle = ProviderControlHandle { inner: this.inner.clone() };
48068                        Ok(ProviderRequest::DatagramSocketWithOptions {
48069                            domain: req.domain,
48070                            proto: req.proto,
48071                            opts: req.opts,
48072
48073                            responder: ProviderDatagramSocketWithOptionsResponder {
48074                                control_handle: std::mem::ManuallyDrop::new(control_handle),
48075                                tx_id: header.tx_id,
48076                            },
48077                        })
48078                    }
48079                    0x4d59a64fce98272f => {
48080                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
48081                        let mut req = fidl::new_empty!(
48082                            ProviderInterfaceIndexToNameRequest,
48083                            fidl::encoding::DefaultFuchsiaResourceDialect
48084                        );
48085                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProviderInterfaceIndexToNameRequest>(&header, _body_bytes, handles, &mut req)?;
48086                        let control_handle = ProviderControlHandle { inner: this.inner.clone() };
48087                        Ok(ProviderRequest::InterfaceIndexToName {
48088                            index: req.index,
48089
48090                            responder: ProviderInterfaceIndexToNameResponder {
48091                                control_handle: std::mem::ManuallyDrop::new(control_handle),
48092                                tx_id: header.tx_id,
48093                            },
48094                        })
48095                    }
48096                    0x690cd8d2f2d650f8 => {
48097                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
48098                        let mut req = fidl::new_empty!(
48099                            ProviderInterfaceNameToIndexRequest,
48100                            fidl::encoding::DefaultFuchsiaResourceDialect
48101                        );
48102                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProviderInterfaceNameToIndexRequest>(&header, _body_bytes, handles, &mut req)?;
48103                        let control_handle = ProviderControlHandle { inner: this.inner.clone() };
48104                        Ok(ProviderRequest::InterfaceNameToIndex {
48105                            name: req.name,
48106
48107                            responder: ProviderInterfaceNameToIndexResponder {
48108                                control_handle: std::mem::ManuallyDrop::new(control_handle),
48109                                tx_id: header.tx_id,
48110                            },
48111                        })
48112                    }
48113                    0x25d0efcdb6671a0b => {
48114                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
48115                        let mut req = fidl::new_empty!(
48116                            ProviderInterfaceNameToFlagsRequest,
48117                            fidl::encoding::DefaultFuchsiaResourceDialect
48118                        );
48119                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ProviderInterfaceNameToFlagsRequest>(&header, _body_bytes, handles, &mut req)?;
48120                        let control_handle = ProviderControlHandle { inner: this.inner.clone() };
48121                        Ok(ProviderRequest::InterfaceNameToFlags {
48122                            name: req.name,
48123
48124                            responder: ProviderInterfaceNameToFlagsResponder {
48125                                control_handle: std::mem::ManuallyDrop::new(control_handle),
48126                                tx_id: header.tx_id,
48127                            },
48128                        })
48129                    }
48130                    0x2e7b9aaf327c870 => {
48131                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
48132                        let mut req = fidl::new_empty!(
48133                            fidl::encoding::EmptyPayload,
48134                            fidl::encoding::DefaultFuchsiaResourceDialect
48135                        );
48136                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
48137                        let control_handle = ProviderControlHandle { inner: this.inner.clone() };
48138                        Ok(ProviderRequest::GetInterfaceAddresses {
48139                            responder: ProviderGetInterfaceAddressesResponder {
48140                                control_handle: std::mem::ManuallyDrop::new(control_handle),
48141                                tx_id: header.tx_id,
48142                            },
48143                        })
48144                    }
48145                    _ => Err(fidl::Error::UnknownOrdinal {
48146                        ordinal: header.ordinal,
48147                        protocol_name:
48148                            <ProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
48149                    }),
48150                }))
48151            },
48152        )
48153    }
48154}
48155
48156/// Provider implements the POSIX sockets API.
48157///
48158/// *Warning:* This protocol is not yet ready for direct use by clients.
48159/// Instead, clients should use the BSD sockets API to interact with sockets.
48160/// We plan to change this protocol substantially and clients that couple
48161/// directly to this protocol will make those changes more difficult.
48162#[derive(Debug)]
48163pub enum ProviderRequest {
48164    /// Requests a stream socket with the specifed parameters and the creation
48165    /// options.
48166    StreamSocketWithOptions {
48167        domain: Domain,
48168        proto: StreamSocketProtocol,
48169        opts: SocketCreationOptions,
48170        responder: ProviderStreamSocketWithOptionsResponder,
48171    },
48172    /// Requests a stream socket with the specified parameters.
48173    StreamSocket {
48174        domain: Domain,
48175        proto: StreamSocketProtocol,
48176        responder: ProviderStreamSocketResponder,
48177    },
48178    /// Requests a datagram socket with the specified parameters.
48179    /// TODO(https://fxbug.dev/42165881): Remove this method once no more callers rely on it.
48180    DatagramSocketDeprecated {
48181        domain: Domain,
48182        proto: DatagramSocketProtocol,
48183        responder: ProviderDatagramSocketDeprecatedResponder,
48184    },
48185    /// Requests a datagram socket with the specified parameters.
48186    DatagramSocket {
48187        domain: Domain,
48188        proto: DatagramSocketProtocol,
48189        responder: ProviderDatagramSocketResponder,
48190    },
48191    /// Requests a datagram socket with the specifed parameters and the creation
48192    /// options.
48193    DatagramSocketWithOptions {
48194        domain: Domain,
48195        proto: DatagramSocketProtocol,
48196        opts: SocketCreationOptions,
48197        responder: ProviderDatagramSocketWithOptionsResponder,
48198    },
48199    /// Looks up an interface by its index and returns its name. Returns
48200    /// `ZX_ERR_NOT_FOUND` if the specified index doesn't exist.
48201    InterfaceIndexToName { index: u64, responder: ProviderInterfaceIndexToNameResponder },
48202    /// Looks up an interface by its name and returns its index. Returns
48203    /// `ZX_ERR_NOT_FOUND` if the specified name doesn't exist.
48204    InterfaceNameToIndex { name: String, responder: ProviderInterfaceNameToIndexResponder },
48205    /// Looks up an interface by its name and returns its flags. Returns
48206    /// `ZX_ERR_NOT_FOUND` if the specified name doesn't exist.
48207    InterfaceNameToFlags { name: String, responder: ProviderInterfaceNameToFlagsResponder },
48208    /// Requests a list of [`fuchsia.posix.socket.InterfaceAddresses`]
48209    /// describing the network interfaces on the system.
48210    GetInterfaceAddresses { responder: ProviderGetInterfaceAddressesResponder },
48211}
48212
48213impl ProviderRequest {
48214    #[allow(irrefutable_let_patterns)]
48215    pub fn into_stream_socket_with_options(
48216        self,
48217    ) -> Option<(
48218        Domain,
48219        StreamSocketProtocol,
48220        SocketCreationOptions,
48221        ProviderStreamSocketWithOptionsResponder,
48222    )> {
48223        if let ProviderRequest::StreamSocketWithOptions { domain, proto, opts, responder } = self {
48224            Some((domain, proto, opts, responder))
48225        } else {
48226            None
48227        }
48228    }
48229
48230    #[allow(irrefutable_let_patterns)]
48231    pub fn into_stream_socket(
48232        self,
48233    ) -> Option<(Domain, StreamSocketProtocol, ProviderStreamSocketResponder)> {
48234        if let ProviderRequest::StreamSocket { domain, proto, responder } = self {
48235            Some((domain, proto, responder))
48236        } else {
48237            None
48238        }
48239    }
48240
48241    #[allow(irrefutable_let_patterns)]
48242    pub fn into_datagram_socket_deprecated(
48243        self,
48244    ) -> Option<(Domain, DatagramSocketProtocol, ProviderDatagramSocketDeprecatedResponder)> {
48245        if let ProviderRequest::DatagramSocketDeprecated { domain, proto, responder } = self {
48246            Some((domain, proto, responder))
48247        } else {
48248            None
48249        }
48250    }
48251
48252    #[allow(irrefutable_let_patterns)]
48253    pub fn into_datagram_socket(
48254        self,
48255    ) -> Option<(Domain, DatagramSocketProtocol, ProviderDatagramSocketResponder)> {
48256        if let ProviderRequest::DatagramSocket { domain, proto, responder } = self {
48257            Some((domain, proto, responder))
48258        } else {
48259            None
48260        }
48261    }
48262
48263    #[allow(irrefutable_let_patterns)]
48264    pub fn into_datagram_socket_with_options(
48265        self,
48266    ) -> Option<(
48267        Domain,
48268        DatagramSocketProtocol,
48269        SocketCreationOptions,
48270        ProviderDatagramSocketWithOptionsResponder,
48271    )> {
48272        if let ProviderRequest::DatagramSocketWithOptions { domain, proto, opts, responder } = self
48273        {
48274            Some((domain, proto, opts, responder))
48275        } else {
48276            None
48277        }
48278    }
48279
48280    #[allow(irrefutable_let_patterns)]
48281    pub fn into_interface_index_to_name(
48282        self,
48283    ) -> Option<(u64, ProviderInterfaceIndexToNameResponder)> {
48284        if let ProviderRequest::InterfaceIndexToName { index, responder } = self {
48285            Some((index, responder))
48286        } else {
48287            None
48288        }
48289    }
48290
48291    #[allow(irrefutable_let_patterns)]
48292    pub fn into_interface_name_to_index(
48293        self,
48294    ) -> Option<(String, ProviderInterfaceNameToIndexResponder)> {
48295        if let ProviderRequest::InterfaceNameToIndex { name, responder } = self {
48296            Some((name, responder))
48297        } else {
48298            None
48299        }
48300    }
48301
48302    #[allow(irrefutable_let_patterns)]
48303    pub fn into_interface_name_to_flags(
48304        self,
48305    ) -> Option<(String, ProviderInterfaceNameToFlagsResponder)> {
48306        if let ProviderRequest::InterfaceNameToFlags { name, responder } = self {
48307            Some((name, responder))
48308        } else {
48309            None
48310        }
48311    }
48312
48313    #[allow(irrefutable_let_patterns)]
48314    pub fn into_get_interface_addresses(self) -> Option<(ProviderGetInterfaceAddressesResponder)> {
48315        if let ProviderRequest::GetInterfaceAddresses { responder } = self {
48316            Some((responder))
48317        } else {
48318            None
48319        }
48320    }
48321
48322    /// Name of the method defined in FIDL
48323    pub fn method_name(&self) -> &'static str {
48324        match *self {
48325            ProviderRequest::StreamSocketWithOptions { .. } => "stream_socket_with_options",
48326            ProviderRequest::StreamSocket { .. } => "stream_socket",
48327            ProviderRequest::DatagramSocketDeprecated { .. } => "datagram_socket_deprecated",
48328            ProviderRequest::DatagramSocket { .. } => "datagram_socket",
48329            ProviderRequest::DatagramSocketWithOptions { .. } => "datagram_socket_with_options",
48330            ProviderRequest::InterfaceIndexToName { .. } => "interface_index_to_name",
48331            ProviderRequest::InterfaceNameToIndex { .. } => "interface_name_to_index",
48332            ProviderRequest::InterfaceNameToFlags { .. } => "interface_name_to_flags",
48333            ProviderRequest::GetInterfaceAddresses { .. } => "get_interface_addresses",
48334        }
48335    }
48336}
48337
48338#[derive(Debug, Clone)]
48339pub struct ProviderControlHandle {
48340    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
48341}
48342
48343impl fidl::endpoints::ControlHandle for ProviderControlHandle {
48344    fn shutdown(&self) {
48345        self.inner.shutdown()
48346    }
48347    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
48348        self.inner.shutdown_with_epitaph(status)
48349    }
48350
48351    fn is_closed(&self) -> bool {
48352        self.inner.channel().is_closed()
48353    }
48354    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
48355        self.inner.channel().on_closed()
48356    }
48357
48358    #[cfg(target_os = "fuchsia")]
48359    fn signal_peer(
48360        &self,
48361        clear_mask: zx::Signals,
48362        set_mask: zx::Signals,
48363    ) -> Result<(), zx_status::Status> {
48364        use fidl::Peered;
48365        self.inner.channel().signal_peer(clear_mask, set_mask)
48366    }
48367}
48368
48369impl ProviderControlHandle {}
48370
48371#[must_use = "FIDL methods require a response to be sent"]
48372#[derive(Debug)]
48373pub struct ProviderStreamSocketWithOptionsResponder {
48374    control_handle: std::mem::ManuallyDrop<ProviderControlHandle>,
48375    tx_id: u32,
48376}
48377
48378/// Set the the channel to be shutdown (see [`ProviderControlHandle::shutdown`])
48379/// if the responder is dropped without sending a response, so that the client
48380/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
48381impl std::ops::Drop for ProviderStreamSocketWithOptionsResponder {
48382    fn drop(&mut self) {
48383        self.control_handle.shutdown();
48384        // Safety: drops once, never accessed again
48385        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48386    }
48387}
48388
48389impl fidl::endpoints::Responder for ProviderStreamSocketWithOptionsResponder {
48390    type ControlHandle = ProviderControlHandle;
48391
48392    fn control_handle(&self) -> &ProviderControlHandle {
48393        &self.control_handle
48394    }
48395
48396    fn drop_without_shutdown(mut self) {
48397        // Safety: drops once, never accessed again due to mem::forget
48398        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48399        // Prevent Drop from running (which would shut down the channel)
48400        std::mem::forget(self);
48401    }
48402}
48403
48404impl ProviderStreamSocketWithOptionsResponder {
48405    /// Sends a response to the FIDL transaction.
48406    ///
48407    /// Sets the channel to shutdown if an error occurs.
48408    pub fn send(
48409        self,
48410        mut result: Result<
48411            fidl::endpoints::ClientEnd<StreamSocketMarker>,
48412            fidl_fuchsia_posix::Errno,
48413        >,
48414    ) -> Result<(), fidl::Error> {
48415        let _result = self.send_raw(result);
48416        if _result.is_err() {
48417            self.control_handle.shutdown();
48418        }
48419        self.drop_without_shutdown();
48420        _result
48421    }
48422
48423    /// Similar to "send" but does not shutdown the channel if an error occurs.
48424    pub fn send_no_shutdown_on_err(
48425        self,
48426        mut result: Result<
48427            fidl::endpoints::ClientEnd<StreamSocketMarker>,
48428            fidl_fuchsia_posix::Errno,
48429        >,
48430    ) -> Result<(), fidl::Error> {
48431        let _result = self.send_raw(result);
48432        self.drop_without_shutdown();
48433        _result
48434    }
48435
48436    fn send_raw(
48437        &self,
48438        mut result: Result<
48439            fidl::endpoints::ClientEnd<StreamSocketMarker>,
48440            fidl_fuchsia_posix::Errno,
48441        >,
48442    ) -> Result<(), fidl::Error> {
48443        self.control_handle.inner.send::<fidl::encoding::ResultType<
48444            ProviderStreamSocketWithOptionsResponse,
48445            fidl_fuchsia_posix::Errno,
48446        >>(
48447            result.map(|s| (s,)),
48448            self.tx_id,
48449            0x3969bf7eb78386e0,
48450            fidl::encoding::DynamicFlags::empty(),
48451        )
48452    }
48453}
48454
48455#[must_use = "FIDL methods require a response to be sent"]
48456#[derive(Debug)]
48457pub struct ProviderStreamSocketResponder {
48458    control_handle: std::mem::ManuallyDrop<ProviderControlHandle>,
48459    tx_id: u32,
48460}
48461
48462/// Set the the channel to be shutdown (see [`ProviderControlHandle::shutdown`])
48463/// if the responder is dropped without sending a response, so that the client
48464/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
48465impl std::ops::Drop for ProviderStreamSocketResponder {
48466    fn drop(&mut self) {
48467        self.control_handle.shutdown();
48468        // Safety: drops once, never accessed again
48469        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48470    }
48471}
48472
48473impl fidl::endpoints::Responder for ProviderStreamSocketResponder {
48474    type ControlHandle = ProviderControlHandle;
48475
48476    fn control_handle(&self) -> &ProviderControlHandle {
48477        &self.control_handle
48478    }
48479
48480    fn drop_without_shutdown(mut self) {
48481        // Safety: drops once, never accessed again due to mem::forget
48482        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48483        // Prevent Drop from running (which would shut down the channel)
48484        std::mem::forget(self);
48485    }
48486}
48487
48488impl ProviderStreamSocketResponder {
48489    /// Sends a response to the FIDL transaction.
48490    ///
48491    /// Sets the channel to shutdown if an error occurs.
48492    pub fn send(
48493        self,
48494        mut result: Result<
48495            fidl::endpoints::ClientEnd<StreamSocketMarker>,
48496            fidl_fuchsia_posix::Errno,
48497        >,
48498    ) -> Result<(), fidl::Error> {
48499        let _result = self.send_raw(result);
48500        if _result.is_err() {
48501            self.control_handle.shutdown();
48502        }
48503        self.drop_without_shutdown();
48504        _result
48505    }
48506
48507    /// Similar to "send" but does not shutdown the channel if an error occurs.
48508    pub fn send_no_shutdown_on_err(
48509        self,
48510        mut result: Result<
48511            fidl::endpoints::ClientEnd<StreamSocketMarker>,
48512            fidl_fuchsia_posix::Errno,
48513        >,
48514    ) -> Result<(), fidl::Error> {
48515        let _result = self.send_raw(result);
48516        self.drop_without_shutdown();
48517        _result
48518    }
48519
48520    fn send_raw(
48521        &self,
48522        mut result: Result<
48523            fidl::endpoints::ClientEnd<StreamSocketMarker>,
48524            fidl_fuchsia_posix::Errno,
48525        >,
48526    ) -> Result<(), fidl::Error> {
48527        self.control_handle.inner.send::<fidl::encoding::ResultType<
48528            ProviderStreamSocketResponse,
48529            fidl_fuchsia_posix::Errno,
48530        >>(
48531            result.map(|s| (s,)),
48532            self.tx_id,
48533            0x27c3581da2155545,
48534            fidl::encoding::DynamicFlags::empty(),
48535        )
48536    }
48537}
48538
48539#[must_use = "FIDL methods require a response to be sent"]
48540#[derive(Debug)]
48541pub struct ProviderDatagramSocketDeprecatedResponder {
48542    control_handle: std::mem::ManuallyDrop<ProviderControlHandle>,
48543    tx_id: u32,
48544}
48545
48546/// Set the the channel to be shutdown (see [`ProviderControlHandle::shutdown`])
48547/// if the responder is dropped without sending a response, so that the client
48548/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
48549impl std::ops::Drop for ProviderDatagramSocketDeprecatedResponder {
48550    fn drop(&mut self) {
48551        self.control_handle.shutdown();
48552        // Safety: drops once, never accessed again
48553        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48554    }
48555}
48556
48557impl fidl::endpoints::Responder for ProviderDatagramSocketDeprecatedResponder {
48558    type ControlHandle = ProviderControlHandle;
48559
48560    fn control_handle(&self) -> &ProviderControlHandle {
48561        &self.control_handle
48562    }
48563
48564    fn drop_without_shutdown(mut self) {
48565        // Safety: drops once, never accessed again due to mem::forget
48566        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48567        // Prevent Drop from running (which would shut down the channel)
48568        std::mem::forget(self);
48569    }
48570}
48571
48572impl ProviderDatagramSocketDeprecatedResponder {
48573    /// Sends a response to the FIDL transaction.
48574    ///
48575    /// Sets the channel to shutdown if an error occurs.
48576    pub fn send(
48577        self,
48578        mut result: Result<
48579            fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
48580            fidl_fuchsia_posix::Errno,
48581        >,
48582    ) -> Result<(), fidl::Error> {
48583        let _result = self.send_raw(result);
48584        if _result.is_err() {
48585            self.control_handle.shutdown();
48586        }
48587        self.drop_without_shutdown();
48588        _result
48589    }
48590
48591    /// Similar to "send" but does not shutdown the channel if an error occurs.
48592    pub fn send_no_shutdown_on_err(
48593        self,
48594        mut result: Result<
48595            fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
48596            fidl_fuchsia_posix::Errno,
48597        >,
48598    ) -> Result<(), fidl::Error> {
48599        let _result = self.send_raw(result);
48600        self.drop_without_shutdown();
48601        _result
48602    }
48603
48604    fn send_raw(
48605        &self,
48606        mut result: Result<
48607            fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
48608            fidl_fuchsia_posix::Errno,
48609        >,
48610    ) -> Result<(), fidl::Error> {
48611        self.control_handle.inner.send::<fidl::encoding::ResultType<
48612            ProviderDatagramSocketDeprecatedResponse,
48613            fidl_fuchsia_posix::Errno,
48614        >>(
48615            result.map(|s| (s,)),
48616            self.tx_id,
48617            0x38876c87cf031cb1,
48618            fidl::encoding::DynamicFlags::empty(),
48619        )
48620    }
48621}
48622
48623#[must_use = "FIDL methods require a response to be sent"]
48624#[derive(Debug)]
48625pub struct ProviderDatagramSocketResponder {
48626    control_handle: std::mem::ManuallyDrop<ProviderControlHandle>,
48627    tx_id: u32,
48628}
48629
48630/// Set the the channel to be shutdown (see [`ProviderControlHandle::shutdown`])
48631/// if the responder is dropped without sending a response, so that the client
48632/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
48633impl std::ops::Drop for ProviderDatagramSocketResponder {
48634    fn drop(&mut self) {
48635        self.control_handle.shutdown();
48636        // Safety: drops once, never accessed again
48637        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48638    }
48639}
48640
48641impl fidl::endpoints::Responder for ProviderDatagramSocketResponder {
48642    type ControlHandle = ProviderControlHandle;
48643
48644    fn control_handle(&self) -> &ProviderControlHandle {
48645        &self.control_handle
48646    }
48647
48648    fn drop_without_shutdown(mut self) {
48649        // Safety: drops once, never accessed again due to mem::forget
48650        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48651        // Prevent Drop from running (which would shut down the channel)
48652        std::mem::forget(self);
48653    }
48654}
48655
48656impl ProviderDatagramSocketResponder {
48657    /// Sends a response to the FIDL transaction.
48658    ///
48659    /// Sets the channel to shutdown if an error occurs.
48660    pub fn send(
48661        self,
48662        mut result: Result<ProviderDatagramSocketResponse, fidl_fuchsia_posix::Errno>,
48663    ) -> Result<(), fidl::Error> {
48664        let _result = self.send_raw(result);
48665        if _result.is_err() {
48666            self.control_handle.shutdown();
48667        }
48668        self.drop_without_shutdown();
48669        _result
48670    }
48671
48672    /// Similar to "send" but does not shutdown the channel if an error occurs.
48673    pub fn send_no_shutdown_on_err(
48674        self,
48675        mut result: Result<ProviderDatagramSocketResponse, fidl_fuchsia_posix::Errno>,
48676    ) -> Result<(), fidl::Error> {
48677        let _result = self.send_raw(result);
48678        self.drop_without_shutdown();
48679        _result
48680    }
48681
48682    fn send_raw(
48683        &self,
48684        mut result: Result<ProviderDatagramSocketResponse, fidl_fuchsia_posix::Errno>,
48685    ) -> Result<(), fidl::Error> {
48686        self.control_handle.inner.send::<fidl::encoding::ResultType<
48687            ProviderDatagramSocketResponse,
48688            fidl_fuchsia_posix::Errno,
48689        >>(
48690            result.as_mut().map_err(|e| *e),
48691            self.tx_id,
48692            0x4021b4fa1b6452f2,
48693            fidl::encoding::DynamicFlags::empty(),
48694        )
48695    }
48696}
48697
48698#[must_use = "FIDL methods require a response to be sent"]
48699#[derive(Debug)]
48700pub struct ProviderDatagramSocketWithOptionsResponder {
48701    control_handle: std::mem::ManuallyDrop<ProviderControlHandle>,
48702    tx_id: u32,
48703}
48704
48705/// Set the the channel to be shutdown (see [`ProviderControlHandle::shutdown`])
48706/// if the responder is dropped without sending a response, so that the client
48707/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
48708impl std::ops::Drop for ProviderDatagramSocketWithOptionsResponder {
48709    fn drop(&mut self) {
48710        self.control_handle.shutdown();
48711        // Safety: drops once, never accessed again
48712        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48713    }
48714}
48715
48716impl fidl::endpoints::Responder for ProviderDatagramSocketWithOptionsResponder {
48717    type ControlHandle = ProviderControlHandle;
48718
48719    fn control_handle(&self) -> &ProviderControlHandle {
48720        &self.control_handle
48721    }
48722
48723    fn drop_without_shutdown(mut self) {
48724        // Safety: drops once, never accessed again due to mem::forget
48725        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48726        // Prevent Drop from running (which would shut down the channel)
48727        std::mem::forget(self);
48728    }
48729}
48730
48731impl ProviderDatagramSocketWithOptionsResponder {
48732    /// Sends a response to the FIDL transaction.
48733    ///
48734    /// Sets the channel to shutdown if an error occurs.
48735    pub fn send(
48736        self,
48737        mut result: Result<ProviderDatagramSocketWithOptionsResponse, fidl_fuchsia_posix::Errno>,
48738    ) -> Result<(), fidl::Error> {
48739        let _result = self.send_raw(result);
48740        if _result.is_err() {
48741            self.control_handle.shutdown();
48742        }
48743        self.drop_without_shutdown();
48744        _result
48745    }
48746
48747    /// Similar to "send" but does not shutdown the channel if an error occurs.
48748    pub fn send_no_shutdown_on_err(
48749        self,
48750        mut result: Result<ProviderDatagramSocketWithOptionsResponse, fidl_fuchsia_posix::Errno>,
48751    ) -> Result<(), fidl::Error> {
48752        let _result = self.send_raw(result);
48753        self.drop_without_shutdown();
48754        _result
48755    }
48756
48757    fn send_raw(
48758        &self,
48759        mut result: Result<ProviderDatagramSocketWithOptionsResponse, fidl_fuchsia_posix::Errno>,
48760    ) -> Result<(), fidl::Error> {
48761        self.control_handle.inner.send::<fidl::encoding::ResultType<
48762            ProviderDatagramSocketWithOptionsResponse,
48763            fidl_fuchsia_posix::Errno,
48764        >>(
48765            result.as_mut().map_err(|e| *e),
48766            self.tx_id,
48767            0x4cd0cffbffa39eb1,
48768            fidl::encoding::DynamicFlags::empty(),
48769        )
48770    }
48771}
48772
48773#[must_use = "FIDL methods require a response to be sent"]
48774#[derive(Debug)]
48775pub struct ProviderInterfaceIndexToNameResponder {
48776    control_handle: std::mem::ManuallyDrop<ProviderControlHandle>,
48777    tx_id: u32,
48778}
48779
48780/// Set the the channel to be shutdown (see [`ProviderControlHandle::shutdown`])
48781/// if the responder is dropped without sending a response, so that the client
48782/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
48783impl std::ops::Drop for ProviderInterfaceIndexToNameResponder {
48784    fn drop(&mut self) {
48785        self.control_handle.shutdown();
48786        // Safety: drops once, never accessed again
48787        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48788    }
48789}
48790
48791impl fidl::endpoints::Responder for ProviderInterfaceIndexToNameResponder {
48792    type ControlHandle = ProviderControlHandle;
48793
48794    fn control_handle(&self) -> &ProviderControlHandle {
48795        &self.control_handle
48796    }
48797
48798    fn drop_without_shutdown(mut self) {
48799        // Safety: drops once, never accessed again due to mem::forget
48800        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48801        // Prevent Drop from running (which would shut down the channel)
48802        std::mem::forget(self);
48803    }
48804}
48805
48806impl ProviderInterfaceIndexToNameResponder {
48807    /// Sends a response to the FIDL transaction.
48808    ///
48809    /// Sets the channel to shutdown if an error occurs.
48810    pub fn send(self, mut result: Result<&str, i32>) -> Result<(), fidl::Error> {
48811        let _result = self.send_raw(result);
48812        if _result.is_err() {
48813            self.control_handle.shutdown();
48814        }
48815        self.drop_without_shutdown();
48816        _result
48817    }
48818
48819    /// Similar to "send" but does not shutdown the channel if an error occurs.
48820    pub fn send_no_shutdown_on_err(self, mut result: Result<&str, i32>) -> Result<(), fidl::Error> {
48821        let _result = self.send_raw(result);
48822        self.drop_without_shutdown();
48823        _result
48824    }
48825
48826    fn send_raw(&self, mut result: Result<&str, i32>) -> Result<(), fidl::Error> {
48827        self.control_handle.inner.send::<fidl::encoding::ResultType<
48828            ProviderInterfaceIndexToNameResponse,
48829            i32,
48830        >>(
48831            result.map(|name| (name,)),
48832            self.tx_id,
48833            0x4d59a64fce98272f,
48834            fidl::encoding::DynamicFlags::empty(),
48835        )
48836    }
48837}
48838
48839#[must_use = "FIDL methods require a response to be sent"]
48840#[derive(Debug)]
48841pub struct ProviderInterfaceNameToIndexResponder {
48842    control_handle: std::mem::ManuallyDrop<ProviderControlHandle>,
48843    tx_id: u32,
48844}
48845
48846/// Set the the channel to be shutdown (see [`ProviderControlHandle::shutdown`])
48847/// if the responder is dropped without sending a response, so that the client
48848/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
48849impl std::ops::Drop for ProviderInterfaceNameToIndexResponder {
48850    fn drop(&mut self) {
48851        self.control_handle.shutdown();
48852        // Safety: drops once, never accessed again
48853        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48854    }
48855}
48856
48857impl fidl::endpoints::Responder for ProviderInterfaceNameToIndexResponder {
48858    type ControlHandle = ProviderControlHandle;
48859
48860    fn control_handle(&self) -> &ProviderControlHandle {
48861        &self.control_handle
48862    }
48863
48864    fn drop_without_shutdown(mut self) {
48865        // Safety: drops once, never accessed again due to mem::forget
48866        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48867        // Prevent Drop from running (which would shut down the channel)
48868        std::mem::forget(self);
48869    }
48870}
48871
48872impl ProviderInterfaceNameToIndexResponder {
48873    /// Sends a response to the FIDL transaction.
48874    ///
48875    /// Sets the channel to shutdown if an error occurs.
48876    pub fn send(self, mut result: Result<u64, i32>) -> Result<(), fidl::Error> {
48877        let _result = self.send_raw(result);
48878        if _result.is_err() {
48879            self.control_handle.shutdown();
48880        }
48881        self.drop_without_shutdown();
48882        _result
48883    }
48884
48885    /// Similar to "send" but does not shutdown the channel if an error occurs.
48886    pub fn send_no_shutdown_on_err(self, mut result: Result<u64, i32>) -> Result<(), fidl::Error> {
48887        let _result = self.send_raw(result);
48888        self.drop_without_shutdown();
48889        _result
48890    }
48891
48892    fn send_raw(&self, mut result: Result<u64, i32>) -> Result<(), fidl::Error> {
48893        self.control_handle.inner.send::<fidl::encoding::ResultType<
48894            ProviderInterfaceNameToIndexResponse,
48895            i32,
48896        >>(
48897            result.map(|index| (index,)),
48898            self.tx_id,
48899            0x690cd8d2f2d650f8,
48900            fidl::encoding::DynamicFlags::empty(),
48901        )
48902    }
48903}
48904
48905#[must_use = "FIDL methods require a response to be sent"]
48906#[derive(Debug)]
48907pub struct ProviderInterfaceNameToFlagsResponder {
48908    control_handle: std::mem::ManuallyDrop<ProviderControlHandle>,
48909    tx_id: u32,
48910}
48911
48912/// Set the the channel to be shutdown (see [`ProviderControlHandle::shutdown`])
48913/// if the responder is dropped without sending a response, so that the client
48914/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
48915impl std::ops::Drop for ProviderInterfaceNameToFlagsResponder {
48916    fn drop(&mut self) {
48917        self.control_handle.shutdown();
48918        // Safety: drops once, never accessed again
48919        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48920    }
48921}
48922
48923impl fidl::endpoints::Responder for ProviderInterfaceNameToFlagsResponder {
48924    type ControlHandle = ProviderControlHandle;
48925
48926    fn control_handle(&self) -> &ProviderControlHandle {
48927        &self.control_handle
48928    }
48929
48930    fn drop_without_shutdown(mut self) {
48931        // Safety: drops once, never accessed again due to mem::forget
48932        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48933        // Prevent Drop from running (which would shut down the channel)
48934        std::mem::forget(self);
48935    }
48936}
48937
48938impl ProviderInterfaceNameToFlagsResponder {
48939    /// Sends a response to the FIDL transaction.
48940    ///
48941    /// Sets the channel to shutdown if an error occurs.
48942    pub fn send(self, mut result: Result<InterfaceFlags, i32>) -> Result<(), fidl::Error> {
48943        let _result = self.send_raw(result);
48944        if _result.is_err() {
48945            self.control_handle.shutdown();
48946        }
48947        self.drop_without_shutdown();
48948        _result
48949    }
48950
48951    /// Similar to "send" but does not shutdown the channel if an error occurs.
48952    pub fn send_no_shutdown_on_err(
48953        self,
48954        mut result: Result<InterfaceFlags, i32>,
48955    ) -> Result<(), fidl::Error> {
48956        let _result = self.send_raw(result);
48957        self.drop_without_shutdown();
48958        _result
48959    }
48960
48961    fn send_raw(&self, mut result: Result<InterfaceFlags, i32>) -> Result<(), fidl::Error> {
48962        self.control_handle.inner.send::<fidl::encoding::ResultType<
48963            ProviderInterfaceNameToFlagsResponse,
48964            i32,
48965        >>(
48966            result.map(|flags| (flags,)),
48967            self.tx_id,
48968            0x25d0efcdb6671a0b,
48969            fidl::encoding::DynamicFlags::empty(),
48970        )
48971    }
48972}
48973
48974#[must_use = "FIDL methods require a response to be sent"]
48975#[derive(Debug)]
48976pub struct ProviderGetInterfaceAddressesResponder {
48977    control_handle: std::mem::ManuallyDrop<ProviderControlHandle>,
48978    tx_id: u32,
48979}
48980
48981/// Set the the channel to be shutdown (see [`ProviderControlHandle::shutdown`])
48982/// if the responder is dropped without sending a response, so that the client
48983/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
48984impl std::ops::Drop for ProviderGetInterfaceAddressesResponder {
48985    fn drop(&mut self) {
48986        self.control_handle.shutdown();
48987        // Safety: drops once, never accessed again
48988        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
48989    }
48990}
48991
48992impl fidl::endpoints::Responder for ProviderGetInterfaceAddressesResponder {
48993    type ControlHandle = ProviderControlHandle;
48994
48995    fn control_handle(&self) -> &ProviderControlHandle {
48996        &self.control_handle
48997    }
48998
48999    fn drop_without_shutdown(mut self) {
49000        // Safety: drops once, never accessed again due to mem::forget
49001        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
49002        // Prevent Drop from running (which would shut down the channel)
49003        std::mem::forget(self);
49004    }
49005}
49006
49007impl ProviderGetInterfaceAddressesResponder {
49008    /// Sends a response to the FIDL transaction.
49009    ///
49010    /// Sets the channel to shutdown if an error occurs.
49011    pub fn send(self, mut interfaces: &[InterfaceAddresses]) -> Result<(), fidl::Error> {
49012        let _result = self.send_raw(interfaces);
49013        if _result.is_err() {
49014            self.control_handle.shutdown();
49015        }
49016        self.drop_without_shutdown();
49017        _result
49018    }
49019
49020    /// Similar to "send" but does not shutdown the channel if an error occurs.
49021    pub fn send_no_shutdown_on_err(
49022        self,
49023        mut interfaces: &[InterfaceAddresses],
49024    ) -> Result<(), fidl::Error> {
49025        let _result = self.send_raw(interfaces);
49026        self.drop_without_shutdown();
49027        _result
49028    }
49029
49030    fn send_raw(&self, mut interfaces: &[InterfaceAddresses]) -> Result<(), fidl::Error> {
49031        self.control_handle.inner.send::<ProviderGetInterfaceAddressesResponse>(
49032            (interfaces,),
49033            self.tx_id,
49034            0x2e7b9aaf327c870,
49035            fidl::encoding::DynamicFlags::empty(),
49036        )
49037    }
49038}
49039
49040#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
49041pub struct StreamSocketMarker;
49042
49043impl fidl::endpoints::ProtocolMarker for StreamSocketMarker {
49044    type Proxy = StreamSocketProxy;
49045    type RequestStream = StreamSocketRequestStream;
49046    #[cfg(target_os = "fuchsia")]
49047    type SynchronousProxy = StreamSocketSynchronousProxy;
49048
49049    const DEBUG_NAME: &'static str = "fuchsia.posix.socket.StreamSocket";
49050}
49051impl fidl::endpoints::DiscoverableProtocolMarker for StreamSocketMarker {}
49052pub type StreamSocketListenResult = Result<(), fidl_fuchsia_posix::Errno>;
49053pub type StreamSocketAcceptResult = Result<
49054    (Option<Box<fidl_fuchsia_net::SocketAddress>>, fidl::endpoints::ClientEnd<StreamSocketMarker>),
49055    fidl_fuchsia_posix::Errno,
49056>;
49057pub type StreamSocketGetInfoResult =
49058    Result<(Domain, StreamSocketProtocol), fidl_fuchsia_posix::Errno>;
49059pub type StreamSocketSetTcpNoDelayResult = Result<(), fidl_fuchsia_posix::Errno>;
49060pub type StreamSocketGetTcpNoDelayResult = Result<bool, fidl_fuchsia_posix::Errno>;
49061pub type StreamSocketSetTcpMaxSegmentResult = Result<(), fidl_fuchsia_posix::Errno>;
49062pub type StreamSocketGetTcpMaxSegmentResult = Result<u32, fidl_fuchsia_posix::Errno>;
49063pub type StreamSocketSetTcpCorkResult = Result<(), fidl_fuchsia_posix::Errno>;
49064pub type StreamSocketGetTcpCorkResult = Result<bool, fidl_fuchsia_posix::Errno>;
49065pub type StreamSocketSetTcpKeepAliveIdleResult = Result<(), fidl_fuchsia_posix::Errno>;
49066pub type StreamSocketGetTcpKeepAliveIdleResult = Result<u32, fidl_fuchsia_posix::Errno>;
49067pub type StreamSocketSetTcpKeepAliveIntervalResult = Result<(), fidl_fuchsia_posix::Errno>;
49068pub type StreamSocketGetTcpKeepAliveIntervalResult = Result<u32, fidl_fuchsia_posix::Errno>;
49069pub type StreamSocketSetTcpKeepAliveCountResult = Result<(), fidl_fuchsia_posix::Errno>;
49070pub type StreamSocketGetTcpKeepAliveCountResult = Result<u32, fidl_fuchsia_posix::Errno>;
49071pub type StreamSocketSetTcpSynCountResult = Result<(), fidl_fuchsia_posix::Errno>;
49072pub type StreamSocketGetTcpSynCountResult = Result<u32, fidl_fuchsia_posix::Errno>;
49073pub type StreamSocketSetTcpLingerResult = Result<(), fidl_fuchsia_posix::Errno>;
49074pub type StreamSocketGetTcpLingerResult = Result<OptionalUint32, fidl_fuchsia_posix::Errno>;
49075pub type StreamSocketSetTcpDeferAcceptResult = Result<(), fidl_fuchsia_posix::Errno>;
49076pub type StreamSocketGetTcpDeferAcceptResult = Result<u32, fidl_fuchsia_posix::Errno>;
49077pub type StreamSocketSetTcpWindowClampResult = Result<(), fidl_fuchsia_posix::Errno>;
49078pub type StreamSocketGetTcpWindowClampResult = Result<u32, fidl_fuchsia_posix::Errno>;
49079pub type StreamSocketGetTcpInfoResult = Result<TcpInfo, fidl_fuchsia_posix::Errno>;
49080pub type StreamSocketSetTcpQuickAckResult = Result<(), fidl_fuchsia_posix::Errno>;
49081pub type StreamSocketGetTcpQuickAckResult = Result<bool, fidl_fuchsia_posix::Errno>;
49082pub type StreamSocketSetTcpCongestionResult = Result<(), fidl_fuchsia_posix::Errno>;
49083pub type StreamSocketGetTcpCongestionResult =
49084    Result<TcpCongestionControl, fidl_fuchsia_posix::Errno>;
49085pub type StreamSocketSetTcpUserTimeoutResult = Result<(), fidl_fuchsia_posix::Errno>;
49086pub type StreamSocketGetTcpUserTimeoutResult = Result<u32, fidl_fuchsia_posix::Errno>;
49087
49088pub trait StreamSocketProxyInterface: Send + Sync {
49089    fn r#clone(
49090        &self,
49091        request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
49092    ) -> Result<(), fidl::Error>;
49093    type CloseResponseFut: std::future::Future<
49094            Output = Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error>,
49095        > + Send;
49096    fn r#close(&self) -> Self::CloseResponseFut;
49097    type QueryResponseFut: std::future::Future<Output = Result<Vec<u8>, fidl::Error>> + Send;
49098    fn r#query(&self) -> Self::QueryResponseFut;
49099    type SetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketSetReuseAddressResult, fidl::Error>>
49100        + Send;
49101    fn r#set_reuse_address(&self, value: bool) -> Self::SetReuseAddressResponseFut;
49102    type GetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketGetReuseAddressResult, fidl::Error>>
49103        + Send;
49104    fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut;
49105    type GetErrorResponseFut: std::future::Future<Output = Result<BaseSocketGetErrorResult, fidl::Error>>
49106        + Send;
49107    fn r#get_error(&self) -> Self::GetErrorResponseFut;
49108    type SetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketSetBroadcastResult, fidl::Error>>
49109        + Send;
49110    fn r#set_broadcast(&self, value: bool) -> Self::SetBroadcastResponseFut;
49111    type GetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketGetBroadcastResult, fidl::Error>>
49112        + Send;
49113    fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut;
49114    type SetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetSendBufferResult, fidl::Error>>
49115        + Send;
49116    fn r#set_send_buffer(&self, value_bytes: u64) -> Self::SetSendBufferResponseFut;
49117    type GetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetSendBufferResult, fidl::Error>>
49118        + Send;
49119    fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut;
49120    type SetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetReceiveBufferResult, fidl::Error>>
49121        + Send;
49122    fn r#set_receive_buffer(&self, value_bytes: u64) -> Self::SetReceiveBufferResponseFut;
49123    type GetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetReceiveBufferResult, fidl::Error>>
49124        + Send;
49125    fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut;
49126    type SetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketSetKeepAliveResult, fidl::Error>>
49127        + Send;
49128    fn r#set_keep_alive(&self, value: bool) -> Self::SetKeepAliveResponseFut;
49129    type GetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketGetKeepAliveResult, fidl::Error>>
49130        + Send;
49131    fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut;
49132    type SetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketSetOutOfBandInlineResult, fidl::Error>>
49133        + Send;
49134    fn r#set_out_of_band_inline(&self, value: bool) -> Self::SetOutOfBandInlineResponseFut;
49135    type GetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketGetOutOfBandInlineResult, fidl::Error>>
49136        + Send;
49137    fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut;
49138    type SetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketSetNoCheckResult, fidl::Error>>
49139        + Send;
49140    fn r#set_no_check(&self, value: bool) -> Self::SetNoCheckResponseFut;
49141    type GetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketGetNoCheckResult, fidl::Error>>
49142        + Send;
49143    fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut;
49144    type SetLingerResponseFut: std::future::Future<Output = Result<BaseSocketSetLingerResult, fidl::Error>>
49145        + Send;
49146    fn r#set_linger(&self, linger: bool, length_secs: u32) -> Self::SetLingerResponseFut;
49147    type GetLingerResponseFut: std::future::Future<Output = Result<BaseSocketGetLingerResult, fidl::Error>>
49148        + Send;
49149    fn r#get_linger(&self) -> Self::GetLingerResponseFut;
49150    type SetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketSetReusePortResult, fidl::Error>>
49151        + Send;
49152    fn r#set_reuse_port(&self, value: bool) -> Self::SetReusePortResponseFut;
49153    type GetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketGetReusePortResult, fidl::Error>>
49154        + Send;
49155    fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut;
49156    type GetAcceptConnResponseFut: std::future::Future<Output = Result<BaseSocketGetAcceptConnResult, fidl::Error>>
49157        + Send;
49158    fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut;
49159    type SetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToDeviceResult, fidl::Error>>
49160        + Send;
49161    fn r#set_bind_to_device(&self, value: &str) -> Self::SetBindToDeviceResponseFut;
49162    type GetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToDeviceResult, fidl::Error>>
49163        + Send;
49164    fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut;
49165    type SetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error>>
49166        + Send;
49167    fn r#set_bind_to_interface_index(&self, value: u64)
49168        -> Self::SetBindToInterfaceIndexResponseFut;
49169    type GetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error>>
49170        + Send;
49171    fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut;
49172    type SetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketSetTimestampResult, fidl::Error>>
49173        + Send;
49174    fn r#set_timestamp(&self, value: TimestampOption) -> Self::SetTimestampResponseFut;
49175    type GetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketGetTimestampResult, fidl::Error>>
49176        + Send;
49177    fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut;
49178    type SetMarkResponseFut: std::future::Future<Output = Result<BaseSocketSetMarkResult, fidl::Error>>
49179        + Send;
49180    fn r#set_mark(
49181        &self,
49182        domain: fidl_fuchsia_net::MarkDomain,
49183        mark: &OptionalUint32,
49184    ) -> Self::SetMarkResponseFut;
49185    type GetMarkResponseFut: std::future::Future<Output = Result<BaseSocketGetMarkResult, fidl::Error>>
49186        + Send;
49187    fn r#get_mark(&self, domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut;
49188    type BindResponseFut: std::future::Future<Output = Result<BaseNetworkSocketBindResult, fidl::Error>>
49189        + Send;
49190    fn r#bind(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut;
49191    type ConnectResponseFut: std::future::Future<Output = Result<BaseNetworkSocketConnectResult, fidl::Error>>
49192        + Send;
49193    fn r#connect(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut;
49194    type DisconnectResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDisconnectResult, fidl::Error>>
49195        + Send;
49196    fn r#disconnect(&self) -> Self::DisconnectResponseFut;
49197    type GetSockNameResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetSockNameResult, fidl::Error>>
49198        + Send;
49199    fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut;
49200    type GetPeerNameResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetPeerNameResult, fidl::Error>>
49201        + Send;
49202    fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut;
49203    type ShutdownResponseFut: std::future::Future<Output = Result<BaseNetworkSocketShutdownResult, fidl::Error>>
49204        + Send;
49205    fn r#shutdown(&self, mode: ShutdownMode) -> Self::ShutdownResponseFut;
49206    type SetIpTypeOfServiceResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error>>
49207        + Send;
49208    fn r#set_ip_type_of_service(&self, value: u8) -> Self::SetIpTypeOfServiceResponseFut;
49209    type GetIpTypeOfServiceResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error>>
49210        + Send;
49211    fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut;
49212    type SetIpTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTtlResult, fidl::Error>>
49213        + Send;
49214    fn r#set_ip_ttl(&self, value: &OptionalUint8) -> Self::SetIpTtlResponseFut;
49215    type GetIpTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTtlResult, fidl::Error>>
49216        + Send;
49217    fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut;
49218    type SetIpPacketInfoResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error>>
49219        + Send;
49220    fn r#set_ip_packet_info(&self, value: bool) -> Self::SetIpPacketInfoResponseFut;
49221    type GetIpPacketInfoResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error>>
49222        + Send;
49223    fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut;
49224    type SetIpReceiveTypeOfServiceResponseFut: std::future::Future<
49225            Output = Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error>,
49226        > + Send;
49227    fn r#set_ip_receive_type_of_service(
49228        &self,
49229        value: bool,
49230    ) -> Self::SetIpReceiveTypeOfServiceResponseFut;
49231    type GetIpReceiveTypeOfServiceResponseFut: std::future::Future<
49232            Output = Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error>,
49233        > + Send;
49234    fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut;
49235    type SetIpReceiveTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error>>
49236        + Send;
49237    fn r#set_ip_receive_ttl(&self, value: bool) -> Self::SetIpReceiveTtlResponseFut;
49238    type GetIpReceiveTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error>>
49239        + Send;
49240    fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut;
49241    type SetIpMulticastInterfaceResponseFut: std::future::Future<
49242            Output = Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error>,
49243        > + Send;
49244    fn r#set_ip_multicast_interface(
49245        &self,
49246        iface: u64,
49247        address: &fidl_fuchsia_net::Ipv4Address,
49248    ) -> Self::SetIpMulticastInterfaceResponseFut;
49249    type GetIpMulticastInterfaceResponseFut: std::future::Future<
49250            Output = Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error>,
49251        > + Send;
49252    fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut;
49253    type SetIpMulticastTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error>>
49254        + Send;
49255    fn r#set_ip_multicast_ttl(&self, value: &OptionalUint8) -> Self::SetIpMulticastTtlResponseFut;
49256    type GetIpMulticastTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error>>
49257        + Send;
49258    fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut;
49259    type SetIpMulticastLoopbackResponseFut: std::future::Future<
49260            Output = Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error>,
49261        > + Send;
49262    fn r#set_ip_multicast_loopback(&self, value: bool) -> Self::SetIpMulticastLoopbackResponseFut;
49263    type GetIpMulticastLoopbackResponseFut: std::future::Future<
49264            Output = Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error>,
49265        > + Send;
49266    fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut;
49267    type AddIpMembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error>>
49268        + Send;
49269    fn r#add_ip_membership(
49270        &self,
49271        membership: &IpMulticastMembership,
49272    ) -> Self::AddIpMembershipResponseFut;
49273    type DropIpMembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error>>
49274        + Send;
49275    fn r#drop_ip_membership(
49276        &self,
49277        membership: &IpMulticastMembership,
49278    ) -> Self::DropIpMembershipResponseFut;
49279    type SetIpTransparentResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error>>
49280        + Send;
49281    fn r#set_ip_transparent(&self, value: bool) -> Self::SetIpTransparentResponseFut;
49282    type GetIpTransparentResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error>>
49283        + Send;
49284    fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut;
49285    type SetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<
49286            Output = Result<
49287                BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
49288                fidl::Error,
49289            >,
49290        > + Send;
49291    fn r#set_ip_receive_original_destination_address(
49292        &self,
49293        value: bool,
49294    ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut;
49295    type GetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<
49296            Output = Result<
49297                BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
49298                fidl::Error,
49299            >,
49300        > + Send;
49301    fn r#get_ip_receive_original_destination_address(
49302        &self,
49303    ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut;
49304    type AddIpv6MembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error>>
49305        + Send;
49306    fn r#add_ipv6_membership(
49307        &self,
49308        membership: &Ipv6MulticastMembership,
49309    ) -> Self::AddIpv6MembershipResponseFut;
49310    type DropIpv6MembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error>>
49311        + Send;
49312    fn r#drop_ipv6_membership(
49313        &self,
49314        membership: &Ipv6MulticastMembership,
49315    ) -> Self::DropIpv6MembershipResponseFut;
49316    type SetIpv6MulticastInterfaceResponseFut: std::future::Future<
49317            Output = Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error>,
49318        > + Send;
49319    fn r#set_ipv6_multicast_interface(
49320        &self,
49321        value: u64,
49322    ) -> Self::SetIpv6MulticastInterfaceResponseFut;
49323    type GetIpv6MulticastInterfaceResponseFut: std::future::Future<
49324            Output = Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error>,
49325        > + Send;
49326    fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut;
49327    type SetIpv6UnicastHopsResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error>>
49328        + Send;
49329    fn r#set_ipv6_unicast_hops(&self, value: &OptionalUint8)
49330        -> Self::SetIpv6UnicastHopsResponseFut;
49331    type GetIpv6UnicastHopsResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error>>
49332        + Send;
49333    fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut;
49334    type SetIpv6ReceiveHopLimitResponseFut: std::future::Future<
49335            Output = Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error>,
49336        > + Send;
49337    fn r#set_ipv6_receive_hop_limit(&self, value: bool) -> Self::SetIpv6ReceiveHopLimitResponseFut;
49338    type GetIpv6ReceiveHopLimitResponseFut: std::future::Future<
49339            Output = Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error>,
49340        > + Send;
49341    fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut;
49342    type SetIpv6MulticastHopsResponseFut: std::future::Future<
49343            Output = Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error>,
49344        > + Send;
49345    fn r#set_ipv6_multicast_hops(
49346        &self,
49347        value: &OptionalUint8,
49348    ) -> Self::SetIpv6MulticastHopsResponseFut;
49349    type GetIpv6MulticastHopsResponseFut: std::future::Future<
49350            Output = Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error>,
49351        > + Send;
49352    fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut;
49353    type SetIpv6MulticastLoopbackResponseFut: std::future::Future<
49354            Output = Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error>,
49355        > + Send;
49356    fn r#set_ipv6_multicast_loopback(
49357        &self,
49358        value: bool,
49359    ) -> Self::SetIpv6MulticastLoopbackResponseFut;
49360    type GetIpv6MulticastLoopbackResponseFut: std::future::Future<
49361            Output = Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error>,
49362        > + Send;
49363    fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut;
49364    type SetIpv6OnlyResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error>>
49365        + Send;
49366    fn r#set_ipv6_only(&self, value: bool) -> Self::SetIpv6OnlyResponseFut;
49367    type GetIpv6OnlyResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error>>
49368        + Send;
49369    fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut;
49370    type SetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
49371            Output = Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error>,
49372        > + Send;
49373    fn r#set_ipv6_receive_traffic_class(
49374        &self,
49375        value: bool,
49376    ) -> Self::SetIpv6ReceiveTrafficClassResponseFut;
49377    type GetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
49378            Output = Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error>,
49379        > + Send;
49380    fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut;
49381    type SetIpv6TrafficClassResponseFut: std::future::Future<
49382            Output = Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error>,
49383        > + Send;
49384    fn r#set_ipv6_traffic_class(
49385        &self,
49386        value: &OptionalUint8,
49387    ) -> Self::SetIpv6TrafficClassResponseFut;
49388    type GetIpv6TrafficClassResponseFut: std::future::Future<
49389            Output = Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error>,
49390        > + Send;
49391    fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut;
49392    type SetIpv6ReceivePacketInfoResponseFut: std::future::Future<
49393            Output = Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error>,
49394        > + Send;
49395    fn r#set_ipv6_receive_packet_info(
49396        &self,
49397        value: bool,
49398    ) -> Self::SetIpv6ReceivePacketInfoResponseFut;
49399    type GetIpv6ReceivePacketInfoResponseFut: std::future::Future<
49400            Output = Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error>,
49401        > + Send;
49402    fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut;
49403    type GetOriginalDestinationResponseFut: std::future::Future<
49404            Output = Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error>,
49405        > + Send;
49406    fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut;
49407    type DescribeResponseFut: std::future::Future<Output = Result<StreamSocketDescribeResponse, fidl::Error>>
49408        + Send;
49409    fn r#describe(&self) -> Self::DescribeResponseFut;
49410    type ListenResponseFut: std::future::Future<Output = Result<StreamSocketListenResult, fidl::Error>>
49411        + Send;
49412    fn r#listen(&self, backlog: i16) -> Self::ListenResponseFut;
49413    type AcceptResponseFut: std::future::Future<Output = Result<StreamSocketAcceptResult, fidl::Error>>
49414        + Send;
49415    fn r#accept(&self, want_addr: bool) -> Self::AcceptResponseFut;
49416    type GetInfoResponseFut: std::future::Future<Output = Result<StreamSocketGetInfoResult, fidl::Error>>
49417        + Send;
49418    fn r#get_info(&self) -> Self::GetInfoResponseFut;
49419    type SetTcpNoDelayResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpNoDelayResult, fidl::Error>>
49420        + Send;
49421    fn r#set_tcp_no_delay(&self, value: bool) -> Self::SetTcpNoDelayResponseFut;
49422    type GetTcpNoDelayResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpNoDelayResult, fidl::Error>>
49423        + Send;
49424    fn r#get_tcp_no_delay(&self) -> Self::GetTcpNoDelayResponseFut;
49425    type SetTcpMaxSegmentResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpMaxSegmentResult, fidl::Error>>
49426        + Send;
49427    fn r#set_tcp_max_segment(&self, value_bytes: u32) -> Self::SetTcpMaxSegmentResponseFut;
49428    type GetTcpMaxSegmentResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpMaxSegmentResult, fidl::Error>>
49429        + Send;
49430    fn r#get_tcp_max_segment(&self) -> Self::GetTcpMaxSegmentResponseFut;
49431    type SetTcpCorkResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpCorkResult, fidl::Error>>
49432        + Send;
49433    fn r#set_tcp_cork(&self, value: bool) -> Self::SetTcpCorkResponseFut;
49434    type GetTcpCorkResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpCorkResult, fidl::Error>>
49435        + Send;
49436    fn r#get_tcp_cork(&self) -> Self::GetTcpCorkResponseFut;
49437    type SetTcpKeepAliveIdleResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpKeepAliveIdleResult, fidl::Error>>
49438        + Send;
49439    fn r#set_tcp_keep_alive_idle(&self, value_secs: u32) -> Self::SetTcpKeepAliveIdleResponseFut;
49440    type GetTcpKeepAliveIdleResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpKeepAliveIdleResult, fidl::Error>>
49441        + Send;
49442    fn r#get_tcp_keep_alive_idle(&self) -> Self::GetTcpKeepAliveIdleResponseFut;
49443    type SetTcpKeepAliveIntervalResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpKeepAliveIntervalResult, fidl::Error>>
49444        + Send;
49445    fn r#set_tcp_keep_alive_interval(
49446        &self,
49447        value_secs: u32,
49448    ) -> Self::SetTcpKeepAliveIntervalResponseFut;
49449    type GetTcpKeepAliveIntervalResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpKeepAliveIntervalResult, fidl::Error>>
49450        + Send;
49451    fn r#get_tcp_keep_alive_interval(&self) -> Self::GetTcpKeepAliveIntervalResponseFut;
49452    type SetTcpKeepAliveCountResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpKeepAliveCountResult, fidl::Error>>
49453        + Send;
49454    fn r#set_tcp_keep_alive_count(&self, value: u32) -> Self::SetTcpKeepAliveCountResponseFut;
49455    type GetTcpKeepAliveCountResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpKeepAliveCountResult, fidl::Error>>
49456        + Send;
49457    fn r#get_tcp_keep_alive_count(&self) -> Self::GetTcpKeepAliveCountResponseFut;
49458    type SetTcpSynCountResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpSynCountResult, fidl::Error>>
49459        + Send;
49460    fn r#set_tcp_syn_count(&self, value: u32) -> Self::SetTcpSynCountResponseFut;
49461    type GetTcpSynCountResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpSynCountResult, fidl::Error>>
49462        + Send;
49463    fn r#get_tcp_syn_count(&self) -> Self::GetTcpSynCountResponseFut;
49464    type SetTcpLingerResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpLingerResult, fidl::Error>>
49465        + Send;
49466    fn r#set_tcp_linger(&self, value_secs: &OptionalUint32) -> Self::SetTcpLingerResponseFut;
49467    type GetTcpLingerResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpLingerResult, fidl::Error>>
49468        + Send;
49469    fn r#get_tcp_linger(&self) -> Self::GetTcpLingerResponseFut;
49470    type SetTcpDeferAcceptResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpDeferAcceptResult, fidl::Error>>
49471        + Send;
49472    fn r#set_tcp_defer_accept(&self, value_secs: u32) -> Self::SetTcpDeferAcceptResponseFut;
49473    type GetTcpDeferAcceptResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpDeferAcceptResult, fidl::Error>>
49474        + Send;
49475    fn r#get_tcp_defer_accept(&self) -> Self::GetTcpDeferAcceptResponseFut;
49476    type SetTcpWindowClampResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpWindowClampResult, fidl::Error>>
49477        + Send;
49478    fn r#set_tcp_window_clamp(&self, value: u32) -> Self::SetTcpWindowClampResponseFut;
49479    type GetTcpWindowClampResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpWindowClampResult, fidl::Error>>
49480        + Send;
49481    fn r#get_tcp_window_clamp(&self) -> Self::GetTcpWindowClampResponseFut;
49482    type GetTcpInfoResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpInfoResult, fidl::Error>>
49483        + Send;
49484    fn r#get_tcp_info(&self) -> Self::GetTcpInfoResponseFut;
49485    type SetTcpQuickAckResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpQuickAckResult, fidl::Error>>
49486        + Send;
49487    fn r#set_tcp_quick_ack(&self, value: bool) -> Self::SetTcpQuickAckResponseFut;
49488    type GetTcpQuickAckResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpQuickAckResult, fidl::Error>>
49489        + Send;
49490    fn r#get_tcp_quick_ack(&self) -> Self::GetTcpQuickAckResponseFut;
49491    type SetTcpCongestionResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpCongestionResult, fidl::Error>>
49492        + Send;
49493    fn r#set_tcp_congestion(
49494        &self,
49495        value: TcpCongestionControl,
49496    ) -> Self::SetTcpCongestionResponseFut;
49497    type GetTcpCongestionResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpCongestionResult, fidl::Error>>
49498        + Send;
49499    fn r#get_tcp_congestion(&self) -> Self::GetTcpCongestionResponseFut;
49500    type SetTcpUserTimeoutResponseFut: std::future::Future<Output = Result<StreamSocketSetTcpUserTimeoutResult, fidl::Error>>
49501        + Send;
49502    fn r#set_tcp_user_timeout(&self, value_millis: u32) -> Self::SetTcpUserTimeoutResponseFut;
49503    type GetTcpUserTimeoutResponseFut: std::future::Future<Output = Result<StreamSocketGetTcpUserTimeoutResult, fidl::Error>>
49504        + Send;
49505    fn r#get_tcp_user_timeout(&self) -> Self::GetTcpUserTimeoutResponseFut;
49506}
49507#[derive(Debug)]
49508#[cfg(target_os = "fuchsia")]
49509pub struct StreamSocketSynchronousProxy {
49510    client: fidl::client::sync::Client,
49511}
49512
49513#[cfg(target_os = "fuchsia")]
49514impl fidl::endpoints::SynchronousProxy for StreamSocketSynchronousProxy {
49515    type Proxy = StreamSocketProxy;
49516    type Protocol = StreamSocketMarker;
49517
49518    fn from_channel(inner: fidl::Channel) -> Self {
49519        Self::new(inner)
49520    }
49521
49522    fn into_channel(self) -> fidl::Channel {
49523        self.client.into_channel()
49524    }
49525
49526    fn as_channel(&self) -> &fidl::Channel {
49527        self.client.as_channel()
49528    }
49529}
49530
49531#[cfg(target_os = "fuchsia")]
49532impl StreamSocketSynchronousProxy {
49533    pub fn new(channel: fidl::Channel) -> Self {
49534        let protocol_name = <StreamSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
49535        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
49536    }
49537
49538    pub fn into_channel(self) -> fidl::Channel {
49539        self.client.into_channel()
49540    }
49541
49542    /// Waits until an event arrives and returns it. It is safe for other
49543    /// threads to make concurrent requests while waiting for an event.
49544    pub fn wait_for_event(
49545        &self,
49546        deadline: zx::MonotonicInstant,
49547    ) -> Result<StreamSocketEvent, fidl::Error> {
49548        StreamSocketEvent::decode(self.client.wait_for_event(deadline)?)
49549    }
49550
49551    pub fn r#clone(
49552        &self,
49553        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
49554    ) -> Result<(), fidl::Error> {
49555        self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
49556            (request,),
49557            0x20d8a7aba2168a79,
49558            fidl::encoding::DynamicFlags::empty(),
49559        )
49560    }
49561
49562    /// Terminates the connection.
49563    ///
49564    /// After calling `Close`, the client must not send any other requests.
49565    ///
49566    /// Servers, after sending the status response, should close the connection
49567    /// regardless of status and without sending an epitaph.
49568    ///
49569    /// Closing the client end of the channel should be semantically equivalent
49570    /// to calling `Close` without knowing when the close has completed or its
49571    /// status.
49572    pub fn r#close(
49573        &self,
49574        ___deadline: zx::MonotonicInstant,
49575    ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
49576        let _response = self.client.send_query::<
49577            fidl::encoding::EmptyPayload,
49578            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
49579        >(
49580            (),
49581            0x5ac5d459ad7f657e,
49582            fidl::encoding::DynamicFlags::empty(),
49583            ___deadline,
49584        )?;
49585        Ok(_response.map(|x| x))
49586    }
49587
49588    pub fn r#query(&self, ___deadline: zx::MonotonicInstant) -> Result<Vec<u8>, fidl::Error> {
49589        let _response = self.client.send_query::<
49590            fidl::encoding::EmptyPayload,
49591            fidl_fuchsia_unknown::QueryableQueryResponse,
49592        >(
49593            (),
49594            0x2658edee9decfc06,
49595            fidl::encoding::DynamicFlags::empty(),
49596            ___deadline,
49597        )?;
49598        Ok(_response.protocol)
49599    }
49600
49601    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
49602    pub fn r#set_reuse_address(
49603        &self,
49604        mut value: bool,
49605        ___deadline: zx::MonotonicInstant,
49606    ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
49607        let _response =
49608            self.client.send_query::<BaseSocketSetReuseAddressRequest, fidl::encoding::ResultType<
49609                fidl::encoding::EmptyStruct,
49610                fidl_fuchsia_posix::Errno,
49611            >>(
49612                (value,),
49613                0x1fd74ee8b9a4a876,
49614                fidl::encoding::DynamicFlags::empty(),
49615                ___deadline,
49616            )?;
49617        Ok(_response.map(|x| x))
49618    }
49619
49620    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
49621    pub fn r#get_reuse_address(
49622        &self,
49623        ___deadline: zx::MonotonicInstant,
49624    ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
49625        let _response = self
49626            .client
49627            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
49628                BaseSocketGetReuseAddressResponse,
49629                fidl_fuchsia_posix::Errno,
49630            >>(
49631                (), 0x67b7206b8d1bc0a5, fidl::encoding::DynamicFlags::empty(), ___deadline
49632            )?;
49633        Ok(_response.map(|x| x.value))
49634    }
49635
49636    /// Get `SOL_SOCKET` -> `SO_ERROR`.
49637    /// Returns the last error if there is an error set on the socket.
49638    pub fn r#get_error(
49639        &self,
49640        ___deadline: zx::MonotonicInstant,
49641    ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
49642        let _response =
49643            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
49644                fidl::encoding::EmptyStruct,
49645                fidl_fuchsia_posix::Errno,
49646            >>(
49647                (),
49648                0x5aad39b33e5f6ebb,
49649                fidl::encoding::DynamicFlags::empty(),
49650                ___deadline,
49651            )?;
49652        Ok(_response.map(|x| x))
49653    }
49654
49655    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
49656    pub fn r#set_broadcast(
49657        &self,
49658        mut value: bool,
49659        ___deadline: zx::MonotonicInstant,
49660    ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
49661        let _response =
49662            self.client.send_query::<BaseSocketSetBroadcastRequest, fidl::encoding::ResultType<
49663                fidl::encoding::EmptyStruct,
49664                fidl_fuchsia_posix::Errno,
49665            >>(
49666                (value,),
49667                0x6023e081ce3cd947,
49668                fidl::encoding::DynamicFlags::empty(),
49669                ___deadline,
49670            )?;
49671        Ok(_response.map(|x| x))
49672    }
49673
49674    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
49675    pub fn r#get_broadcast(
49676        &self,
49677        ___deadline: zx::MonotonicInstant,
49678    ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
49679        let _response =
49680            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
49681                BaseSocketGetBroadcastResponse,
49682                fidl_fuchsia_posix::Errno,
49683            >>(
49684                (),
49685                0x68796fc556f9780d,
49686                fidl::encoding::DynamicFlags::empty(),
49687                ___deadline,
49688            )?;
49689        Ok(_response.map(|x| x.value))
49690    }
49691
49692    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
49693    pub fn r#set_send_buffer(
49694        &self,
49695        mut value_bytes: u64,
49696        ___deadline: zx::MonotonicInstant,
49697    ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
49698        let _response =
49699            self.client.send_query::<BaseSocketSetSendBufferRequest, fidl::encoding::ResultType<
49700                fidl::encoding::EmptyStruct,
49701                fidl_fuchsia_posix::Errno,
49702            >>(
49703                (value_bytes,),
49704                0x756eac32d73a7a70,
49705                fidl::encoding::DynamicFlags::empty(),
49706                ___deadline,
49707            )?;
49708        Ok(_response.map(|x| x))
49709    }
49710
49711    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
49712    pub fn r#get_send_buffer(
49713        &self,
49714        ___deadline: zx::MonotonicInstant,
49715    ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
49716        let _response = self
49717            .client
49718            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
49719                BaseSocketGetSendBufferResponse,
49720                fidl_fuchsia_posix::Errno,
49721            >>(
49722                (), 0x78a52fd9c7b2410b, fidl::encoding::DynamicFlags::empty(), ___deadline
49723            )?;
49724        Ok(_response.map(|x| x.value_bytes))
49725    }
49726
49727    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
49728    pub fn r#set_receive_buffer(
49729        &self,
49730        mut value_bytes: u64,
49731        ___deadline: zx::MonotonicInstant,
49732    ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
49733        let _response =
49734            self.client
49735                .send_query::<BaseSocketSetReceiveBufferRequest, fidl::encoding::ResultType<
49736                    fidl::encoding::EmptyStruct,
49737                    fidl_fuchsia_posix::Errno,
49738                >>(
49739                    (value_bytes,),
49740                    0x6b0cf2f1919c7001,
49741                    fidl::encoding::DynamicFlags::empty(),
49742                    ___deadline,
49743                )?;
49744        Ok(_response.map(|x| x))
49745    }
49746
49747    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
49748    pub fn r#get_receive_buffer(
49749        &self,
49750        ___deadline: zx::MonotonicInstant,
49751    ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
49752        let _response = self
49753            .client
49754            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
49755                BaseSocketGetReceiveBufferResponse,
49756                fidl_fuchsia_posix::Errno,
49757            >>(
49758                (), 0x14c1a4b64f709e5c, fidl::encoding::DynamicFlags::empty(), ___deadline
49759            )?;
49760        Ok(_response.map(|x| x.value_bytes))
49761    }
49762
49763    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
49764    pub fn r#set_keep_alive(
49765        &self,
49766        mut value: bool,
49767        ___deadline: zx::MonotonicInstant,
49768    ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
49769        let _response =
49770            self.client.send_query::<BaseSocketSetKeepAliveRequest, fidl::encoding::ResultType<
49771                fidl::encoding::EmptyStruct,
49772                fidl_fuchsia_posix::Errno,
49773            >>(
49774                (value,),
49775                0x572df8f0b920d2c7,
49776                fidl::encoding::DynamicFlags::empty(),
49777                ___deadline,
49778            )?;
49779        Ok(_response.map(|x| x))
49780    }
49781
49782    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
49783    pub fn r#get_keep_alive(
49784        &self,
49785        ___deadline: zx::MonotonicInstant,
49786    ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
49787        let _response =
49788            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
49789                BaseSocketGetKeepAliveResponse,
49790                fidl_fuchsia_posix::Errno,
49791            >>(
49792                (),
49793                0x2dd29d3215f2c9d2,
49794                fidl::encoding::DynamicFlags::empty(),
49795                ___deadline,
49796            )?;
49797        Ok(_response.map(|x| x.value))
49798    }
49799
49800    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
49801    pub fn r#set_out_of_band_inline(
49802        &self,
49803        mut value: bool,
49804        ___deadline: zx::MonotonicInstant,
49805    ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
49806        let _response =
49807            self.client
49808                .send_query::<BaseSocketSetOutOfBandInlineRequest, fidl::encoding::ResultType<
49809                    fidl::encoding::EmptyStruct,
49810                    fidl_fuchsia_posix::Errno,
49811                >>(
49812                    (value,),
49813                    0x3ecb49968bee439,
49814                    fidl::encoding::DynamicFlags::empty(),
49815                    ___deadline,
49816                )?;
49817        Ok(_response.map(|x| x))
49818    }
49819
49820    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
49821    pub fn r#get_out_of_band_inline(
49822        &self,
49823        ___deadline: zx::MonotonicInstant,
49824    ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
49825        let _response = self
49826            .client
49827            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
49828                BaseSocketGetOutOfBandInlineResponse,
49829                fidl_fuchsia_posix::Errno,
49830            >>(
49831                (), 0x348c1ab3aeca1745, fidl::encoding::DynamicFlags::empty(), ___deadline
49832            )?;
49833        Ok(_response.map(|x| x.value))
49834    }
49835
49836    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
49837    pub fn r#set_no_check(
49838        &self,
49839        mut value: bool,
49840        ___deadline: zx::MonotonicInstant,
49841    ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
49842        let _response =
49843            self.client.send_query::<BaseSocketSetNoCheckRequest, fidl::encoding::ResultType<
49844                fidl::encoding::EmptyStruct,
49845                fidl_fuchsia_posix::Errno,
49846            >>(
49847                (value,),
49848                0x6bbf00c53a4c78c2,
49849                fidl::encoding::DynamicFlags::empty(),
49850                ___deadline,
49851            )?;
49852        Ok(_response.map(|x| x))
49853    }
49854
49855    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
49856    pub fn r#get_no_check(
49857        &self,
49858        ___deadline: zx::MonotonicInstant,
49859    ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
49860        let _response =
49861            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
49862                BaseSocketGetNoCheckResponse,
49863                fidl_fuchsia_posix::Errno,
49864            >>(
49865                (),
49866                0x2cd4249286417694,
49867                fidl::encoding::DynamicFlags::empty(),
49868                ___deadline,
49869            )?;
49870        Ok(_response.map(|x| x.value))
49871    }
49872
49873    /// Set `SOL_SOCKET` -> `SO_LINGER`.
49874    pub fn r#set_linger(
49875        &self,
49876        mut linger: bool,
49877        mut length_secs: u32,
49878        ___deadline: zx::MonotonicInstant,
49879    ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
49880        let _response =
49881            self.client.send_query::<BaseSocketSetLingerRequest, fidl::encoding::ResultType<
49882                fidl::encoding::EmptyStruct,
49883                fidl_fuchsia_posix::Errno,
49884            >>(
49885                (linger, length_secs),
49886                0x45386351246e998e,
49887                fidl::encoding::DynamicFlags::empty(),
49888                ___deadline,
49889            )?;
49890        Ok(_response.map(|x| x))
49891    }
49892
49893    /// Get `SOL_SOCKET` -> `SO_LINGER`.
49894    pub fn r#get_linger(
49895        &self,
49896        ___deadline: zx::MonotonicInstant,
49897    ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
49898        let _response =
49899            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
49900                BaseSocketGetLingerResponse,
49901                fidl_fuchsia_posix::Errno,
49902            >>(
49903                (),
49904                0x48eb20fc5ccb0e45,
49905                fidl::encoding::DynamicFlags::empty(),
49906                ___deadline,
49907            )?;
49908        Ok(_response.map(|x| (x.linger, x.length_secs)))
49909    }
49910
49911    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
49912    pub fn r#set_reuse_port(
49913        &self,
49914        mut value: bool,
49915        ___deadline: zx::MonotonicInstant,
49916    ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
49917        let _response =
49918            self.client.send_query::<BaseSocketSetReusePortRequest, fidl::encoding::ResultType<
49919                fidl::encoding::EmptyStruct,
49920                fidl_fuchsia_posix::Errno,
49921            >>(
49922                (value,),
49923                0x24dd3e5cb36d9ccb,
49924                fidl::encoding::DynamicFlags::empty(),
49925                ___deadline,
49926            )?;
49927        Ok(_response.map(|x| x))
49928    }
49929
49930    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
49931    pub fn r#get_reuse_port(
49932        &self,
49933        ___deadline: zx::MonotonicInstant,
49934    ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
49935        let _response =
49936            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
49937                BaseSocketGetReusePortResponse,
49938                fidl_fuchsia_posix::Errno,
49939            >>(
49940                (),
49941                0x7a112c1ab54ff828,
49942                fidl::encoding::DynamicFlags::empty(),
49943                ___deadline,
49944            )?;
49945        Ok(_response.map(|x| x.value))
49946    }
49947
49948    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
49949    pub fn r#get_accept_conn(
49950        &self,
49951        ___deadline: zx::MonotonicInstant,
49952    ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
49953        let _response = self
49954            .client
49955            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
49956                BaseSocketGetAcceptConnResponse,
49957                fidl_fuchsia_posix::Errno,
49958            >>(
49959                (), 0x67ce6db6c2ec8966, fidl::encoding::DynamicFlags::empty(), ___deadline
49960            )?;
49961        Ok(_response.map(|x| x.value))
49962    }
49963
49964    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
49965    pub fn r#set_bind_to_device(
49966        &self,
49967        mut value: &str,
49968        ___deadline: zx::MonotonicInstant,
49969    ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
49970        let _response =
49971            self.client.send_query::<BaseSocketSetBindToDeviceRequest, fidl::encoding::ResultType<
49972                fidl::encoding::EmptyStruct,
49973                fidl_fuchsia_posix::Errno,
49974            >>(
49975                (value,),
49976                0x2118b483f28aafc4,
49977                fidl::encoding::DynamicFlags::empty(),
49978                ___deadline,
49979            )?;
49980        Ok(_response.map(|x| x))
49981    }
49982
49983    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
49984    pub fn r#get_bind_to_device(
49985        &self,
49986        ___deadline: zx::MonotonicInstant,
49987    ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
49988        let _response = self
49989            .client
49990            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
49991                BaseSocketGetBindToDeviceResponse,
49992                fidl_fuchsia_posix::Errno,
49993            >>(
49994                (), 0x1ab1fbf0ef7906c8, fidl::encoding::DynamicFlags::empty(), ___deadline
49995            )?;
49996        Ok(_response.map(|x| x.value))
49997    }
49998
49999    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
50000    /// If `value` is 0, this clears the bound interface.
50001    pub fn r#set_bind_to_interface_index(
50002        &self,
50003        mut value: u64,
50004        ___deadline: zx::MonotonicInstant,
50005    ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
50006        let _response =
50007            self.client
50008                .send_query::<BaseSocketSetBindToInterfaceIndexRequest, fidl::encoding::ResultType<
50009                    fidl::encoding::EmptyStruct,
50010                    fidl_fuchsia_posix::Errno,
50011                >>(
50012                    (value,),
50013                    0x6e387a0def00821,
50014                    fidl::encoding::DynamicFlags::empty(),
50015                    ___deadline,
50016                )?;
50017        Ok(_response.map(|x| x))
50018    }
50019
50020    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
50021    pub fn r#get_bind_to_interface_index(
50022        &self,
50023        ___deadline: zx::MonotonicInstant,
50024    ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
50025        let _response = self
50026            .client
50027            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50028                BaseSocketGetBindToInterfaceIndexResponse,
50029                fidl_fuchsia_posix::Errno,
50030            >>(
50031                (), 0x59c31dd3e3078295, fidl::encoding::DynamicFlags::empty(), ___deadline
50032            )?;
50033        Ok(_response.map(|x| x.value))
50034    }
50035
50036    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
50037    pub fn r#set_timestamp(
50038        &self,
50039        mut value: TimestampOption,
50040        ___deadline: zx::MonotonicInstant,
50041    ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
50042        let _response =
50043            self.client.send_query::<BaseSocketSetTimestampRequest, fidl::encoding::ResultType<
50044                fidl::encoding::EmptyStruct,
50045                fidl_fuchsia_posix::Errno,
50046            >>(
50047                (value,),
50048                0x285d6516c263d839,
50049                fidl::encoding::DynamicFlags::empty(),
50050                ___deadline,
50051            )?;
50052        Ok(_response.map(|x| x))
50053    }
50054
50055    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
50056    pub fn r#get_timestamp(
50057        &self,
50058        ___deadline: zx::MonotonicInstant,
50059    ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
50060        let _response =
50061            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50062                BaseSocketGetTimestampResponse,
50063                fidl_fuchsia_posix::Errno,
50064            >>(
50065                (),
50066                0x49f2fffbbcc2bd27,
50067                fidl::encoding::DynamicFlags::empty(),
50068                ___deadline,
50069            )?;
50070        Ok(_response.map(|x| x.value))
50071    }
50072
50073    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
50074    /// unlike the standard SO_MARK, this API has multiple mark domains and each
50075    /// mark can be set independently in each domain.
50076    pub fn r#set_mark(
50077        &self,
50078        mut domain: fidl_fuchsia_net::MarkDomain,
50079        mut mark: &OptionalUint32,
50080        ___deadline: zx::MonotonicInstant,
50081    ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
50082        let _response =
50083            self.client.send_query::<BaseSocketSetMarkRequest, fidl::encoding::ResultType<
50084                fidl::encoding::EmptyStruct,
50085                fidl_fuchsia_posix::Errno,
50086            >>(
50087                (domain, mark),
50088                0x6ead6de09f653236,
50089                fidl::encoding::DynamicFlags::empty(),
50090                ___deadline,
50091            )?;
50092        Ok(_response.map(|x| x))
50093    }
50094
50095    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
50096    /// unlike the standard SO_MARK, this API has multiple mark domains and each
50097    /// mark can be retrieved independently in each domain.
50098    pub fn r#get_mark(
50099        &self,
50100        mut domain: fidl_fuchsia_net::MarkDomain,
50101        ___deadline: zx::MonotonicInstant,
50102    ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
50103        let _response =
50104            self.client.send_query::<BaseSocketGetMarkRequest, fidl::encoding::ResultType<
50105                BaseSocketGetMarkResponse,
50106                fidl_fuchsia_posix::Errno,
50107            >>(
50108                (domain,),
50109                0x57a2752c61d93d47,
50110                fidl::encoding::DynamicFlags::empty(),
50111                ___deadline,
50112            )?;
50113        Ok(_response.map(|x| x.mark))
50114    }
50115
50116    /// Sets the local address used for the socket.
50117    pub fn r#bind(
50118        &self,
50119        mut addr: &fidl_fuchsia_net::SocketAddress,
50120        ___deadline: zx::MonotonicInstant,
50121    ) -> Result<BaseNetworkSocketBindResult, fidl::Error> {
50122        let _response =
50123            self.client.send_query::<BaseNetworkSocketBindRequest, fidl::encoding::ResultType<
50124                fidl::encoding::EmptyStruct,
50125                fidl_fuchsia_posix::Errno,
50126            >>(
50127                (addr,),
50128                0x4bc6400ae92125d,
50129                fidl::encoding::DynamicFlags::empty(),
50130                ___deadline,
50131            )?;
50132        Ok(_response.map(|x| x))
50133    }
50134
50135    /// Initiates a connection to a remote address.
50136    pub fn r#connect(
50137        &self,
50138        mut addr: &fidl_fuchsia_net::SocketAddress,
50139        ___deadline: zx::MonotonicInstant,
50140    ) -> Result<BaseNetworkSocketConnectResult, fidl::Error> {
50141        let _response =
50142            self.client.send_query::<BaseNetworkSocketConnectRequest, fidl::encoding::ResultType<
50143                fidl::encoding::EmptyStruct,
50144                fidl_fuchsia_posix::Errno,
50145            >>(
50146                (addr,),
50147                0x5f05f19bfdd38871,
50148                fidl::encoding::DynamicFlags::empty(),
50149                ___deadline,
50150            )?;
50151        Ok(_response.map(|x| x))
50152    }
50153
50154    /// Clears connection information from this socket.
50155    pub fn r#disconnect(
50156        &self,
50157        ___deadline: zx::MonotonicInstant,
50158    ) -> Result<BaseNetworkSocketDisconnectResult, fidl::Error> {
50159        let _response =
50160            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50161                fidl::encoding::EmptyStruct,
50162                fidl_fuchsia_posix::Errno,
50163            >>(
50164                (),
50165                0x74e63b91f7b29b2,
50166                fidl::encoding::DynamicFlags::empty(),
50167                ___deadline,
50168            )?;
50169        Ok(_response.map(|x| x))
50170    }
50171
50172    /// Retrieves the local socket address.
50173    pub fn r#get_sock_name(
50174        &self,
50175        ___deadline: zx::MonotonicInstant,
50176    ) -> Result<BaseNetworkSocketGetSockNameResult, fidl::Error> {
50177        let _response = self
50178            .client
50179            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50180                BaseNetworkSocketGetSockNameResponse,
50181                fidl_fuchsia_posix::Errno,
50182            >>(
50183                (), 0x475f23f84a1a4f85, fidl::encoding::DynamicFlags::empty(), ___deadline
50184            )?;
50185        Ok(_response.map(|x| x.addr))
50186    }
50187
50188    /// Retrieves the remote socket address.
50189    pub fn r#get_peer_name(
50190        &self,
50191        ___deadline: zx::MonotonicInstant,
50192    ) -> Result<BaseNetworkSocketGetPeerNameResult, fidl::Error> {
50193        let _response = self
50194            .client
50195            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50196                BaseNetworkSocketGetPeerNameResponse,
50197                fidl_fuchsia_posix::Errno,
50198            >>(
50199                (), 0x1ffecf4bd5b6432e, fidl::encoding::DynamicFlags::empty(), ___deadline
50200            )?;
50201        Ok(_response.map(|x| x.addr))
50202    }
50203
50204    /// Shuts down part of the socket.
50205    pub fn r#shutdown(
50206        &self,
50207        mut mode: ShutdownMode,
50208        ___deadline: zx::MonotonicInstant,
50209    ) -> Result<BaseNetworkSocketShutdownResult, fidl::Error> {
50210        let _response =
50211            self.client.send_query::<BaseNetworkSocketShutdownRequest, fidl::encoding::ResultType<
50212                fidl::encoding::EmptyStruct,
50213                fidl_fuchsia_posix::Errno,
50214            >>(
50215                (mode,),
50216                0x247f38b6db68c336,
50217                fidl::encoding::DynamicFlags::empty(),
50218                ___deadline,
50219            )?;
50220        Ok(_response.map(|x| x))
50221    }
50222
50223    /// Set `SOL_IP` -> `IP_TOS`.
50224    pub fn r#set_ip_type_of_service(
50225        &self,
50226        mut value: u8,
50227        ___deadline: zx::MonotonicInstant,
50228    ) -> Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error> {
50229        let _response = self.client.send_query::<
50230            BaseNetworkSocketSetIpTypeOfServiceRequest,
50231            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
50232        >(
50233            (value,),
50234            0x995c600475b6d46,
50235            fidl::encoding::DynamicFlags::empty(),
50236            ___deadline,
50237        )?;
50238        Ok(_response.map(|x| x))
50239    }
50240
50241    /// Get `SOL_IP` -> `IP_TOS`.
50242    pub fn r#get_ip_type_of_service(
50243        &self,
50244        ___deadline: zx::MonotonicInstant,
50245    ) -> Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error> {
50246        let _response = self
50247            .client
50248            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50249                BaseNetworkSocketGetIpTypeOfServiceResponse,
50250                fidl_fuchsia_posix::Errno,
50251            >>(
50252                (), 0x3814a04259f75fcb, fidl::encoding::DynamicFlags::empty(), ___deadline
50253            )?;
50254        Ok(_response.map(|x| x.value))
50255    }
50256
50257    /// Set `SOL_IP` -> `IP_TTL`.
50258    pub fn r#set_ip_ttl(
50259        &self,
50260        mut value: &OptionalUint8,
50261        ___deadline: zx::MonotonicInstant,
50262    ) -> Result<BaseNetworkSocketSetIpTtlResult, fidl::Error> {
50263        let _response =
50264            self.client.send_query::<BaseNetworkSocketSetIpTtlRequest, fidl::encoding::ResultType<
50265                fidl::encoding::EmptyStruct,
50266                fidl_fuchsia_posix::Errno,
50267            >>(
50268                (value,),
50269                0x29e2424b433ae1ef,
50270                fidl::encoding::DynamicFlags::empty(),
50271                ___deadline,
50272            )?;
50273        Ok(_response.map(|x| x))
50274    }
50275
50276    /// Get `SOL_IP` -> `IP_TTL`.
50277    pub fn r#get_ip_ttl(
50278        &self,
50279        ___deadline: zx::MonotonicInstant,
50280    ) -> Result<BaseNetworkSocketGetIpTtlResult, fidl::Error> {
50281        let _response = self
50282            .client
50283            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50284                BaseNetworkSocketGetIpTtlResponse,
50285                fidl_fuchsia_posix::Errno,
50286            >>(
50287                (), 0x47e47fa1f24da471, fidl::encoding::DynamicFlags::empty(), ___deadline
50288            )?;
50289        Ok(_response.map(|x| x.value))
50290    }
50291
50292    /// Set `SOL_IP` -> `IP_PKTINFO`.
50293    pub fn r#set_ip_packet_info(
50294        &self,
50295        mut value: bool,
50296        ___deadline: zx::MonotonicInstant,
50297    ) -> Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error> {
50298        let _response =
50299            self.client
50300                .send_query::<BaseNetworkSocketSetIpPacketInfoRequest, fidl::encoding::ResultType<
50301                    fidl::encoding::EmptyStruct,
50302                    fidl_fuchsia_posix::Errno,
50303                >>(
50304                    (value,),
50305                    0x392d16bee20c0e16,
50306                    fidl::encoding::DynamicFlags::empty(),
50307                    ___deadline,
50308                )?;
50309        Ok(_response.map(|x| x))
50310    }
50311
50312    /// Get `SOL_IP` -> `IP_PKTINFO`.
50313    pub fn r#get_ip_packet_info(
50314        &self,
50315        ___deadline: zx::MonotonicInstant,
50316    ) -> Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error> {
50317        let _response = self
50318            .client
50319            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50320                BaseNetworkSocketGetIpPacketInfoResponse,
50321                fidl_fuchsia_posix::Errno,
50322            >>(
50323                (), 0x54b505f242280740, fidl::encoding::DynamicFlags::empty(), ___deadline
50324            )?;
50325        Ok(_response.map(|x| x.value))
50326    }
50327
50328    /// Set `SOL_IP` -> `IP_RECVTOS`.
50329    pub fn r#set_ip_receive_type_of_service(
50330        &self,
50331        mut value: bool,
50332        ___deadline: zx::MonotonicInstant,
50333    ) -> Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error> {
50334        let _response = self.client.send_query::<
50335            BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
50336            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
50337        >(
50338            (value,),
50339            0x6c4f6714995f84ef,
50340            fidl::encoding::DynamicFlags::empty(),
50341            ___deadline,
50342        )?;
50343        Ok(_response.map(|x| x))
50344    }
50345
50346    /// Get `SOL_IP` -> `IP_RECVTOS`.
50347    pub fn r#get_ip_receive_type_of_service(
50348        &self,
50349        ___deadline: zx::MonotonicInstant,
50350    ) -> Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error> {
50351        let _response = self
50352            .client
50353            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50354                BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
50355                fidl_fuchsia_posix::Errno,
50356            >>(
50357                (), 0x4158ba7dc2795960, fidl::encoding::DynamicFlags::empty(), ___deadline
50358            )?;
50359        Ok(_response.map(|x| x.value))
50360    }
50361
50362    /// Set `SOL_IP` -> `IP_RECVTTL`.
50363    pub fn r#set_ip_receive_ttl(
50364        &self,
50365        mut value: bool,
50366        ___deadline: zx::MonotonicInstant,
50367    ) -> Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error> {
50368        let _response =
50369            self.client
50370                .send_query::<BaseNetworkSocketSetIpReceiveTtlRequest, fidl::encoding::ResultType<
50371                    fidl::encoding::EmptyStruct,
50372                    fidl_fuchsia_posix::Errno,
50373                >>(
50374                    (value,),
50375                    0x46f15be0ce0ab82b,
50376                    fidl::encoding::DynamicFlags::empty(),
50377                    ___deadline,
50378                )?;
50379        Ok(_response.map(|x| x))
50380    }
50381
50382    /// Get `SOL_IP` -> `IP_RECVTTL`.
50383    pub fn r#get_ip_receive_ttl(
50384        &self,
50385        ___deadline: zx::MonotonicInstant,
50386    ) -> Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error> {
50387        let _response = self
50388            .client
50389            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50390                BaseNetworkSocketGetIpReceiveTtlResponse,
50391                fidl_fuchsia_posix::Errno,
50392            >>(
50393                (), 0x678ddd5a5dfa2eb5, fidl::encoding::DynamicFlags::empty(), ___deadline
50394            )?;
50395        Ok(_response.map(|x| x.value))
50396    }
50397
50398    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
50399    pub fn r#set_ip_multicast_interface(
50400        &self,
50401        mut iface: u64,
50402        mut address: &fidl_fuchsia_net::Ipv4Address,
50403        ___deadline: zx::MonotonicInstant,
50404    ) -> Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error> {
50405        let _response = self.client.send_query::<
50406            BaseNetworkSocketSetIpMulticastInterfaceRequest,
50407            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
50408        >(
50409            (iface, address,),
50410            0x752fbfa9b12befe,
50411            fidl::encoding::DynamicFlags::empty(),
50412            ___deadline,
50413        )?;
50414        Ok(_response.map(|x| x))
50415    }
50416
50417    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
50418    pub fn r#get_ip_multicast_interface(
50419        &self,
50420        ___deadline: zx::MonotonicInstant,
50421    ) -> Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error> {
50422        let _response = self
50423            .client
50424            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50425                BaseNetworkSocketGetIpMulticastInterfaceResponse,
50426                fidl_fuchsia_posix::Errno,
50427            >>(
50428                (), 0x320bd14c4df046c4, fidl::encoding::DynamicFlags::empty(), ___deadline
50429            )?;
50430        Ok(_response.map(|x| x.value))
50431    }
50432
50433    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
50434    pub fn r#set_ip_multicast_ttl(
50435        &self,
50436        mut value: &OptionalUint8,
50437        ___deadline: zx::MonotonicInstant,
50438    ) -> Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error> {
50439        let _response =
50440            self.client
50441                .send_query::<BaseNetworkSocketSetIpMulticastTtlRequest, fidl::encoding::ResultType<
50442                    fidl::encoding::EmptyStruct,
50443                    fidl_fuchsia_posix::Errno,
50444                >>(
50445                    (value,),
50446                    0x63134d53772916a1,
50447                    fidl::encoding::DynamicFlags::empty(),
50448                    ___deadline,
50449                )?;
50450        Ok(_response.map(|x| x))
50451    }
50452
50453    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
50454    pub fn r#get_ip_multicast_ttl(
50455        &self,
50456        ___deadline: zx::MonotonicInstant,
50457    ) -> Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error> {
50458        let _response = self
50459            .client
50460            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50461                BaseNetworkSocketGetIpMulticastTtlResponse,
50462                fidl_fuchsia_posix::Errno,
50463            >>(
50464                (), 0x4665cd378f39e1a, fidl::encoding::DynamicFlags::empty(), ___deadline
50465            )?;
50466        Ok(_response.map(|x| x.value))
50467    }
50468
50469    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
50470    pub fn r#set_ip_multicast_loopback(
50471        &self,
50472        mut value: bool,
50473        ___deadline: zx::MonotonicInstant,
50474    ) -> Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error> {
50475        let _response = self.client.send_query::<
50476            BaseNetworkSocketSetIpMulticastLoopbackRequest,
50477            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
50478        >(
50479            (value,),
50480            0x20c55c11f00943ea,
50481            fidl::encoding::DynamicFlags::empty(),
50482            ___deadline,
50483        )?;
50484        Ok(_response.map(|x| x))
50485    }
50486
50487    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
50488    pub fn r#get_ip_multicast_loopback(
50489        &self,
50490        ___deadline: zx::MonotonicInstant,
50491    ) -> Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error> {
50492        let _response = self
50493            .client
50494            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50495                BaseNetworkSocketGetIpMulticastLoopbackResponse,
50496                fidl_fuchsia_posix::Errno,
50497            >>(
50498                (), 0x3b6b26ff558298f2, fidl::encoding::DynamicFlags::empty(), ___deadline
50499            )?;
50500        Ok(_response.map(|x| x.value))
50501    }
50502
50503    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
50504    pub fn r#add_ip_membership(
50505        &self,
50506        mut membership: &IpMulticastMembership,
50507        ___deadline: zx::MonotonicInstant,
50508    ) -> Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error> {
50509        let _response =
50510            self.client
50511                .send_query::<BaseNetworkSocketAddIpMembershipRequest, fidl::encoding::ResultType<
50512                    fidl::encoding::EmptyStruct,
50513                    fidl_fuchsia_posix::Errno,
50514                >>(
50515                    (membership,),
50516                    0x76bc7df115a3b4d0,
50517                    fidl::encoding::DynamicFlags::empty(),
50518                    ___deadline,
50519                )?;
50520        Ok(_response.map(|x| x))
50521    }
50522
50523    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
50524    pub fn r#drop_ip_membership(
50525        &self,
50526        mut membership: &IpMulticastMembership,
50527        ___deadline: zx::MonotonicInstant,
50528    ) -> Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error> {
50529        let _response =
50530            self.client
50531                .send_query::<BaseNetworkSocketDropIpMembershipRequest, fidl::encoding::ResultType<
50532                    fidl::encoding::EmptyStruct,
50533                    fidl_fuchsia_posix::Errno,
50534                >>(
50535                    (membership,),
50536                    0x2888f3099188d03,
50537                    fidl::encoding::DynamicFlags::empty(),
50538                    ___deadline,
50539                )?;
50540        Ok(_response.map(|x| x))
50541    }
50542
50543    /// Set `SOL_IP` -> `IP_TRANSPARENT`
50544    pub fn r#set_ip_transparent(
50545        &self,
50546        mut value: bool,
50547        ___deadline: zx::MonotonicInstant,
50548    ) -> Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error> {
50549        let _response =
50550            self.client
50551                .send_query::<BaseNetworkSocketSetIpTransparentRequest, fidl::encoding::ResultType<
50552                    fidl::encoding::EmptyStruct,
50553                    fidl_fuchsia_posix::Errno,
50554                >>(
50555                    (value,),
50556                    0x1ae532b0c066e3a0,
50557                    fidl::encoding::DynamicFlags::empty(),
50558                    ___deadline,
50559                )?;
50560        Ok(_response.map(|x| x))
50561    }
50562
50563    /// Get `SOL_IP` -> `IP_TRANSPARENT`
50564    pub fn r#get_ip_transparent(
50565        &self,
50566        ___deadline: zx::MonotonicInstant,
50567    ) -> Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error> {
50568        let _response = self
50569            .client
50570            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50571                BaseNetworkSocketGetIpTransparentResponse,
50572                fidl_fuchsia_posix::Errno,
50573            >>(
50574                (), 0x51d43695962ebfb5, fidl::encoding::DynamicFlags::empty(), ___deadline
50575            )?;
50576        Ok(_response.map(|x| x.value))
50577    }
50578
50579    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
50580    pub fn r#set_ip_receive_original_destination_address(
50581        &self,
50582        mut value: bool,
50583        ___deadline: zx::MonotonicInstant,
50584    ) -> Result<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error> {
50585        let _response = self.client.send_query::<
50586            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
50587            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
50588        >(
50589            (value,),
50590            0x4722b4ce52f7840,
50591            fidl::encoding::DynamicFlags::empty(),
50592            ___deadline,
50593        )?;
50594        Ok(_response.map(|x| x))
50595    }
50596
50597    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
50598    pub fn r#get_ip_receive_original_destination_address(
50599        &self,
50600        ___deadline: zx::MonotonicInstant,
50601    ) -> Result<BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error> {
50602        let _response = self
50603            .client
50604            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50605                BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
50606                fidl_fuchsia_posix::Errno,
50607            >>(
50608                (), 0x2a0e7dc5d6bfdfe9, fidl::encoding::DynamicFlags::empty(), ___deadline
50609            )?;
50610        Ok(_response.map(|x| x.value))
50611    }
50612
50613    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
50614    pub fn r#add_ipv6_membership(
50615        &self,
50616        mut membership: &Ipv6MulticastMembership,
50617        ___deadline: zx::MonotonicInstant,
50618    ) -> Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error> {
50619        let _response =
50620            self.client
50621                .send_query::<BaseNetworkSocketAddIpv6MembershipRequest, fidl::encoding::ResultType<
50622                    fidl::encoding::EmptyStruct,
50623                    fidl_fuchsia_posix::Errno,
50624                >>(
50625                    (membership,),
50626                    0x7c94727acb4ea4b3,
50627                    fidl::encoding::DynamicFlags::empty(),
50628                    ___deadline,
50629                )?;
50630        Ok(_response.map(|x| x))
50631    }
50632
50633    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
50634    pub fn r#drop_ipv6_membership(
50635        &self,
50636        mut membership: &Ipv6MulticastMembership,
50637        ___deadline: zx::MonotonicInstant,
50638    ) -> Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error> {
50639        let _response = self.client.send_query::<
50640            BaseNetworkSocketDropIpv6MembershipRequest,
50641            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
50642        >(
50643            (membership,),
50644            0x42104c70ccaba304,
50645            fidl::encoding::DynamicFlags::empty(),
50646            ___deadline,
50647        )?;
50648        Ok(_response.map(|x| x))
50649    }
50650
50651    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
50652    pub fn r#set_ipv6_multicast_interface(
50653        &self,
50654        mut value: u64,
50655        ___deadline: zx::MonotonicInstant,
50656    ) -> Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error> {
50657        let _response = self.client.send_query::<
50658            BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
50659            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
50660        >(
50661            (value,),
50662            0x135f76db3774ab3b,
50663            fidl::encoding::DynamicFlags::empty(),
50664            ___deadline,
50665        )?;
50666        Ok(_response.map(|x| x))
50667    }
50668
50669    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
50670    pub fn r#get_ipv6_multicast_interface(
50671        &self,
50672        ___deadline: zx::MonotonicInstant,
50673    ) -> Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error> {
50674        let _response = self
50675            .client
50676            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50677                BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
50678                fidl_fuchsia_posix::Errno,
50679            >>(
50680                (), 0x1f26fcdd348f1882, fidl::encoding::DynamicFlags::empty(), ___deadline
50681            )?;
50682        Ok(_response.map(|x| x.value))
50683    }
50684
50685    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
50686    pub fn r#set_ipv6_unicast_hops(
50687        &self,
50688        mut value: &OptionalUint8,
50689        ___deadline: zx::MonotonicInstant,
50690    ) -> Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error> {
50691        let _response = self.client.send_query::<
50692            BaseNetworkSocketSetIpv6UnicastHopsRequest,
50693            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
50694        >(
50695            (value,),
50696            0x157d51e98f462859,
50697            fidl::encoding::DynamicFlags::empty(),
50698            ___deadline,
50699        )?;
50700        Ok(_response.map(|x| x))
50701    }
50702
50703    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
50704    pub fn r#get_ipv6_unicast_hops(
50705        &self,
50706        ___deadline: zx::MonotonicInstant,
50707    ) -> Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error> {
50708        let _response = self
50709            .client
50710            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50711                BaseNetworkSocketGetIpv6UnicastHopsResponse,
50712                fidl_fuchsia_posix::Errno,
50713            >>(
50714                (), 0x21f4641cad8bd8d2, fidl::encoding::DynamicFlags::empty(), ___deadline
50715            )?;
50716        Ok(_response.map(|x| x.value))
50717    }
50718
50719    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
50720    pub fn r#set_ipv6_receive_hop_limit(
50721        &self,
50722        mut value: bool,
50723        ___deadline: zx::MonotonicInstant,
50724    ) -> Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error> {
50725        let _response = self.client.send_query::<
50726            BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
50727            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
50728        >(
50729            (value,),
50730            0x5c24808ed2e84a1e,
50731            fidl::encoding::DynamicFlags::empty(),
50732            ___deadline,
50733        )?;
50734        Ok(_response.map(|x| x))
50735    }
50736
50737    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
50738    pub fn r#get_ipv6_receive_hop_limit(
50739        &self,
50740        ___deadline: zx::MonotonicInstant,
50741    ) -> Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error> {
50742        let _response = self
50743            .client
50744            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50745                BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
50746                fidl_fuchsia_posix::Errno,
50747            >>(
50748                (), 0x341e06689885b4c0, fidl::encoding::DynamicFlags::empty(), ___deadline
50749            )?;
50750        Ok(_response.map(|x| x.value))
50751    }
50752
50753    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
50754    pub fn r#set_ipv6_multicast_hops(
50755        &self,
50756        mut value: &OptionalUint8,
50757        ___deadline: zx::MonotonicInstant,
50758    ) -> Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error> {
50759        let _response = self.client.send_query::<
50760            BaseNetworkSocketSetIpv6MulticastHopsRequest,
50761            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
50762        >(
50763            (value,),
50764            0x25b9cd4d181f82c1,
50765            fidl::encoding::DynamicFlags::empty(),
50766            ___deadline,
50767        )?;
50768        Ok(_response.map(|x| x))
50769    }
50770
50771    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
50772    pub fn r#get_ipv6_multicast_hops(
50773        &self,
50774        ___deadline: zx::MonotonicInstant,
50775    ) -> Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error> {
50776        let _response = self
50777            .client
50778            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50779                BaseNetworkSocketGetIpv6MulticastHopsResponse,
50780                fidl_fuchsia_posix::Errno,
50781            >>(
50782                (), 0x52916948a365012a, fidl::encoding::DynamicFlags::empty(), ___deadline
50783            )?;
50784        Ok(_response.map(|x| x.value))
50785    }
50786
50787    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
50788    pub fn r#set_ipv6_multicast_loopback(
50789        &self,
50790        mut value: bool,
50791        ___deadline: zx::MonotonicInstant,
50792    ) -> Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error> {
50793        let _response = self.client.send_query::<
50794            BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
50795            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
50796        >(
50797            (value,),
50798            0x55701c409ff41b40,
50799            fidl::encoding::DynamicFlags::empty(),
50800            ___deadline,
50801        )?;
50802        Ok(_response.map(|x| x))
50803    }
50804
50805    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
50806    pub fn r#get_ipv6_multicast_loopback(
50807        &self,
50808        ___deadline: zx::MonotonicInstant,
50809    ) -> Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error> {
50810        let _response = self
50811            .client
50812            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50813                BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
50814                fidl_fuchsia_posix::Errno,
50815            >>(
50816                (), 0x4415b701fde319c3, fidl::encoding::DynamicFlags::empty(), ___deadline
50817            )?;
50818        Ok(_response.map(|x| x.value))
50819    }
50820
50821    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
50822    pub fn r#set_ipv6_only(
50823        &self,
50824        mut value: bool,
50825        ___deadline: zx::MonotonicInstant,
50826    ) -> Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
50827        let _response =
50828            self.client
50829                .send_query::<BaseNetworkSocketSetIpv6OnlyRequest, fidl::encoding::ResultType<
50830                    fidl::encoding::EmptyStruct,
50831                    fidl_fuchsia_posix::Errno,
50832                >>(
50833                    (value,),
50834                    0x4873f1364758cbba,
50835                    fidl::encoding::DynamicFlags::empty(),
50836                    ___deadline,
50837                )?;
50838        Ok(_response.map(|x| x))
50839    }
50840
50841    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
50842    pub fn r#get_ipv6_only(
50843        &self,
50844        ___deadline: zx::MonotonicInstant,
50845    ) -> Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
50846        let _response = self
50847            .client
50848            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50849                BaseNetworkSocketGetIpv6OnlyResponse,
50850                fidl_fuchsia_posix::Errno,
50851            >>(
50852                (), 0x4aa3340a1a26b89c, fidl::encoding::DynamicFlags::empty(), ___deadline
50853            )?;
50854        Ok(_response.map(|x| x.value))
50855    }
50856
50857    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
50858    pub fn r#set_ipv6_receive_traffic_class(
50859        &self,
50860        mut value: bool,
50861        ___deadline: zx::MonotonicInstant,
50862    ) -> Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error> {
50863        let _response = self.client.send_query::<
50864            BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
50865            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
50866        >(
50867            (value,),
50868            0x58f07c8788d099a0,
50869            fidl::encoding::DynamicFlags::empty(),
50870            ___deadline,
50871        )?;
50872        Ok(_response.map(|x| x))
50873    }
50874
50875    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
50876    pub fn r#get_ipv6_receive_traffic_class(
50877        &self,
50878        ___deadline: zx::MonotonicInstant,
50879    ) -> Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error> {
50880        let _response = self
50881            .client
50882            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50883                BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
50884                fidl_fuchsia_posix::Errno,
50885            >>(
50886                (), 0x2e334df1da553ffa, fidl::encoding::DynamicFlags::empty(), ___deadline
50887            )?;
50888        Ok(_response.map(|x| x.value))
50889    }
50890
50891    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
50892    pub fn r#set_ipv6_traffic_class(
50893        &self,
50894        mut value: &OptionalUint8,
50895        ___deadline: zx::MonotonicInstant,
50896    ) -> Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error> {
50897        let _response = self.client.send_query::<
50898            BaseNetworkSocketSetIpv6TrafficClassRequest,
50899            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
50900        >(
50901            (value,),
50902            0x6af077800c5a0b4f,
50903            fidl::encoding::DynamicFlags::empty(),
50904            ___deadline,
50905        )?;
50906        Ok(_response.map(|x| x))
50907    }
50908
50909    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
50910    pub fn r#get_ipv6_traffic_class(
50911        &self,
50912        ___deadline: zx::MonotonicInstant,
50913    ) -> Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error> {
50914        let _response = self
50915            .client
50916            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50917                BaseNetworkSocketGetIpv6TrafficClassResponse,
50918                fidl_fuchsia_posix::Errno,
50919            >>(
50920                (), 0x6baf6eed8fc2f04, fidl::encoding::DynamicFlags::empty(), ___deadline
50921            )?;
50922        Ok(_response.map(|x| x.value))
50923    }
50924
50925    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
50926    pub fn r#set_ipv6_receive_packet_info(
50927        &self,
50928        mut value: bool,
50929        ___deadline: zx::MonotonicInstant,
50930    ) -> Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error> {
50931        let _response = self.client.send_query::<
50932            BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
50933            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
50934        >(
50935            (value,),
50936            0x19259775b1a92768,
50937            fidl::encoding::DynamicFlags::empty(),
50938            ___deadline,
50939        )?;
50940        Ok(_response.map(|x| x))
50941    }
50942
50943    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
50944    pub fn r#get_ipv6_receive_packet_info(
50945        &self,
50946        ___deadline: zx::MonotonicInstant,
50947    ) -> Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error> {
50948        let _response = self
50949            .client
50950            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50951                BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
50952                fidl_fuchsia_posix::Errno,
50953            >>(
50954                (), 0x7acd4a2775baec75, fidl::encoding::DynamicFlags::empty(), ___deadline
50955            )?;
50956        Ok(_response.map(|x| x.value))
50957    }
50958
50959    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
50960    pub fn r#get_original_destination(
50961        &self,
50962        ___deadline: zx::MonotonicInstant,
50963    ) -> Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error> {
50964        let _response = self
50965            .client
50966            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
50967                BaseNetworkSocketGetOriginalDestinationResponse,
50968                fidl_fuchsia_posix::Errno,
50969            >>(
50970                (), 0x38bf28f0dafdbac0, fidl::encoding::DynamicFlags::empty(), ___deadline
50971            )?;
50972        Ok(_response.map(|x| x.value))
50973    }
50974
50975    pub fn r#describe(
50976        &self,
50977        ___deadline: zx::MonotonicInstant,
50978    ) -> Result<StreamSocketDescribeResponse, fidl::Error> {
50979        let _response =
50980            self.client.send_query::<fidl::encoding::EmptyPayload, StreamSocketDescribeResponse>(
50981                (),
50982                0x29e22969a7dadc32,
50983                fidl::encoding::DynamicFlags::empty(),
50984                ___deadline,
50985            )?;
50986        Ok(_response)
50987    }
50988
50989    /// Begins listening for new incoming connections. At most `backlog`
50990    /// connections will be buffered.
50991    pub fn r#listen(
50992        &self,
50993        mut backlog: i16,
50994        ___deadline: zx::MonotonicInstant,
50995    ) -> Result<StreamSocketListenResult, fidl::Error> {
50996        let _response =
50997            self.client.send_query::<StreamSocketListenRequest, fidl::encoding::ResultType<
50998                fidl::encoding::EmptyStruct,
50999                fidl_fuchsia_posix::Errno,
51000            >>(
51001                (backlog,),
51002                0x3d0a65ced3d10108,
51003                fidl::encoding::DynamicFlags::empty(),
51004                ___deadline,
51005            )?;
51006        Ok(_response.map(|x| x))
51007    }
51008
51009    /// Accepts a buffered incoming connection.
51010    pub fn r#accept(
51011        &self,
51012        mut want_addr: bool,
51013        ___deadline: zx::MonotonicInstant,
51014    ) -> Result<StreamSocketAcceptResult, fidl::Error> {
51015        let _response =
51016            self.client.send_query::<StreamSocketAcceptRequest, fidl::encoding::ResultType<
51017                StreamSocketAcceptResponse,
51018                fidl_fuchsia_posix::Errno,
51019            >>(
51020                (want_addr,),
51021                0x5ab7ad620424c163,
51022                fidl::encoding::DynamicFlags::empty(),
51023                ___deadline,
51024            )?;
51025        Ok(_response.map(|x| (x.addr, x.s)))
51026    }
51027
51028    /// Retrieves creation information from the socket.
51029    pub fn r#get_info(
51030        &self,
51031        ___deadline: zx::MonotonicInstant,
51032    ) -> Result<StreamSocketGetInfoResult, fidl::Error> {
51033        let _response =
51034            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
51035                StreamSocketGetInfoResponse,
51036                fidl_fuchsia_posix::Errno,
51037            >>(
51038                (),
51039                0x87cfa55d19f878f,
51040                fidl::encoding::DynamicFlags::empty(),
51041                ___deadline,
51042            )?;
51043        Ok(_response.map(|x| (x.domain, x.proto)))
51044    }
51045
51046    /// Set `SOL_TCP` -> `TCP_NODELAY`.
51047    pub fn r#set_tcp_no_delay(
51048        &self,
51049        mut value: bool,
51050        ___deadline: zx::MonotonicInstant,
51051    ) -> Result<StreamSocketSetTcpNoDelayResult, fidl::Error> {
51052        let _response =
51053            self.client.send_query::<StreamSocketSetTcpNoDelayRequest, fidl::encoding::ResultType<
51054                fidl::encoding::EmptyStruct,
51055                fidl_fuchsia_posix::Errno,
51056            >>(
51057                (value,),
51058                0x5a59b778f7333ada,
51059                fidl::encoding::DynamicFlags::empty(),
51060                ___deadline,
51061            )?;
51062        Ok(_response.map(|x| x))
51063    }
51064
51065    /// Get `SOL_TCP` -> `TCP_NODELAY`.
51066    pub fn r#get_tcp_no_delay(
51067        &self,
51068        ___deadline: zx::MonotonicInstant,
51069    ) -> Result<StreamSocketGetTcpNoDelayResult, fidl::Error> {
51070        let _response = self
51071            .client
51072            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
51073                StreamSocketGetTcpNoDelayResponse,
51074                fidl_fuchsia_posix::Errno,
51075            >>(
51076                (), 0xac219a3218b0799, fidl::encoding::DynamicFlags::empty(), ___deadline
51077            )?;
51078        Ok(_response.map(|x| x.value))
51079    }
51080
51081    /// Set `SOL_TCP` -> `TCP_MAXSEG`.
51082    pub fn r#set_tcp_max_segment(
51083        &self,
51084        mut value_bytes: u32,
51085        ___deadline: zx::MonotonicInstant,
51086    ) -> Result<StreamSocketSetTcpMaxSegmentResult, fidl::Error> {
51087        let _response =
51088            self.client
51089                .send_query::<StreamSocketSetTcpMaxSegmentRequest, fidl::encoding::ResultType<
51090                    fidl::encoding::EmptyStruct,
51091                    fidl_fuchsia_posix::Errno,
51092                >>(
51093                    (value_bytes,),
51094                    0xb3d30c498266d18,
51095                    fidl::encoding::DynamicFlags::empty(),
51096                    ___deadline,
51097                )?;
51098        Ok(_response.map(|x| x))
51099    }
51100
51101    /// Get `SOL_TCP` -> `TCP_MAXSEG`.
51102    pub fn r#get_tcp_max_segment(
51103        &self,
51104        ___deadline: zx::MonotonicInstant,
51105    ) -> Result<StreamSocketGetTcpMaxSegmentResult, fidl::Error> {
51106        let _response = self
51107            .client
51108            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
51109                StreamSocketGetTcpMaxSegmentResponse,
51110                fidl_fuchsia_posix::Errno,
51111            >>(
51112                (), 0x637404d1b4b9982c, fidl::encoding::DynamicFlags::empty(), ___deadline
51113            )?;
51114        Ok(_response.map(|x| x.value_bytes))
51115    }
51116
51117    /// Set `SOL_TCP` -> `TCP_CORK`.
51118    pub fn r#set_tcp_cork(
51119        &self,
51120        mut value: bool,
51121        ___deadline: zx::MonotonicInstant,
51122    ) -> Result<StreamSocketSetTcpCorkResult, fidl::Error> {
51123        let _response =
51124            self.client.send_query::<StreamSocketSetTcpCorkRequest, fidl::encoding::ResultType<
51125                fidl::encoding::EmptyStruct,
51126                fidl_fuchsia_posix::Errno,
51127            >>(
51128                (value,),
51129                0x62e26891541143a0,
51130                fidl::encoding::DynamicFlags::empty(),
51131                ___deadline,
51132            )?;
51133        Ok(_response.map(|x| x))
51134    }
51135
51136    /// Get `SOL_TCP` -> `TCP_CORK`.
51137    pub fn r#get_tcp_cork(
51138        &self,
51139        ___deadline: zx::MonotonicInstant,
51140    ) -> Result<StreamSocketGetTcpCorkResult, fidl::Error> {
51141        let _response =
51142            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
51143                StreamSocketGetTcpCorkResponse,
51144                fidl_fuchsia_posix::Errno,
51145            >>(
51146                (),
51147                0x435bb232e0e74f32,
51148                fidl::encoding::DynamicFlags::empty(),
51149                ___deadline,
51150            )?;
51151        Ok(_response.map(|x| x.value))
51152    }
51153
51154    /// Set `SOL_TCP` -> `TCP_KEEPIDLE`.
51155    pub fn r#set_tcp_keep_alive_idle(
51156        &self,
51157        mut value_secs: u32,
51158        ___deadline: zx::MonotonicInstant,
51159    ) -> Result<StreamSocketSetTcpKeepAliveIdleResult, fidl::Error> {
51160        let _response =
51161            self.client
51162                .send_query::<StreamSocketSetTcpKeepAliveIdleRequest, fidl::encoding::ResultType<
51163                    fidl::encoding::EmptyStruct,
51164                    fidl_fuchsia_posix::Errno,
51165                >>(
51166                    (value_secs,),
51167                    0x196d053d8363c42,
51168                    fidl::encoding::DynamicFlags::empty(),
51169                    ___deadline,
51170                )?;
51171        Ok(_response.map(|x| x))
51172    }
51173
51174    /// Get `SOL_TCP` -> `TCP_KEEPIDLE`.
51175    pub fn r#get_tcp_keep_alive_idle(
51176        &self,
51177        ___deadline: zx::MonotonicInstant,
51178    ) -> Result<StreamSocketGetTcpKeepAliveIdleResult, fidl::Error> {
51179        let _response = self
51180            .client
51181            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
51182                StreamSocketGetTcpKeepAliveIdleResponse,
51183                fidl_fuchsia_posix::Errno,
51184            >>(
51185                (), 0x35ec58564879dac, fidl::encoding::DynamicFlags::empty(), ___deadline
51186            )?;
51187        Ok(_response.map(|x| x.value_secs))
51188    }
51189
51190    /// Set `SOL_TCP` -> `TCP_KEEPINTVL`.
51191    pub fn r#set_tcp_keep_alive_interval(
51192        &self,
51193        mut value_secs: u32,
51194        ___deadline: zx::MonotonicInstant,
51195    ) -> Result<StreamSocketSetTcpKeepAliveIntervalResult, fidl::Error> {
51196        let _response = self.client.send_query::<
51197            StreamSocketSetTcpKeepAliveIntervalRequest,
51198            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
51199        >(
51200            (value_secs,),
51201            0x485ffbc2da1243f2,
51202            fidl::encoding::DynamicFlags::empty(),
51203            ___deadline,
51204        )?;
51205        Ok(_response.map(|x| x))
51206    }
51207
51208    /// Get `SOL_TCP` -> `TCP_KEEPINTVL`.
51209    pub fn r#get_tcp_keep_alive_interval(
51210        &self,
51211        ___deadline: zx::MonotonicInstant,
51212    ) -> Result<StreamSocketGetTcpKeepAliveIntervalResult, fidl::Error> {
51213        let _response = self
51214            .client
51215            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
51216                StreamSocketGetTcpKeepAliveIntervalResponse,
51217                fidl_fuchsia_posix::Errno,
51218            >>(
51219                (), 0x264eaf46306b284, fidl::encoding::DynamicFlags::empty(), ___deadline
51220            )?;
51221        Ok(_response.map(|x| x.value_secs))
51222    }
51223
51224    /// Set `SOL_TCP` -> `TCP_KEEPCNT`.
51225    pub fn r#set_tcp_keep_alive_count(
51226        &self,
51227        mut value: u32,
51228        ___deadline: zx::MonotonicInstant,
51229    ) -> Result<StreamSocketSetTcpKeepAliveCountResult, fidl::Error> {
51230        let _response =
51231            self.client
51232                .send_query::<StreamSocketSetTcpKeepAliveCountRequest, fidl::encoding::ResultType<
51233                    fidl::encoding::EmptyStruct,
51234                    fidl_fuchsia_posix::Errno,
51235                >>(
51236                    (value,),
51237                    0x2ab2e8c111708421,
51238                    fidl::encoding::DynamicFlags::empty(),
51239                    ___deadline,
51240                )?;
51241        Ok(_response.map(|x| x))
51242    }
51243
51244    /// Get `SOL_TCP` -> `TCP_KEEPCNT`.
51245    pub fn r#get_tcp_keep_alive_count(
51246        &self,
51247        ___deadline: zx::MonotonicInstant,
51248    ) -> Result<StreamSocketGetTcpKeepAliveCountResult, fidl::Error> {
51249        let _response = self
51250            .client
51251            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
51252                StreamSocketGetTcpKeepAliveCountResponse,
51253                fidl_fuchsia_posix::Errno,
51254            >>(
51255                (), 0x2f176ae271fe7a09, fidl::encoding::DynamicFlags::empty(), ___deadline
51256            )?;
51257        Ok(_response.map(|x| x.value))
51258    }
51259
51260    /// Set `SOL_TCP` -> `TCP_SYNCNT`.
51261    pub fn r#set_tcp_syn_count(
51262        &self,
51263        mut value: u32,
51264        ___deadline: zx::MonotonicInstant,
51265    ) -> Result<StreamSocketSetTcpSynCountResult, fidl::Error> {
51266        let _response =
51267            self.client
51268                .send_query::<StreamSocketSetTcpSynCountRequest, fidl::encoding::ResultType<
51269                    fidl::encoding::EmptyStruct,
51270                    fidl_fuchsia_posix::Errno,
51271                >>(
51272                    (value,),
51273                    0x4dcd6ab5573c1eb3,
51274                    fidl::encoding::DynamicFlags::empty(),
51275                    ___deadline,
51276                )?;
51277        Ok(_response.map(|x| x))
51278    }
51279
51280    /// Get `SOL_TCP` -> `TCP_SYNCNT`.
51281    pub fn r#get_tcp_syn_count(
51282        &self,
51283        ___deadline: zx::MonotonicInstant,
51284    ) -> Result<StreamSocketGetTcpSynCountResult, fidl::Error> {
51285        let _response = self
51286            .client
51287            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
51288                StreamSocketGetTcpSynCountResponse,
51289                fidl_fuchsia_posix::Errno,
51290            >>(
51291                (), 0x7d457cba8f5f3ee6, fidl::encoding::DynamicFlags::empty(), ___deadline
51292            )?;
51293        Ok(_response.map(|x| x.value))
51294    }
51295
51296    /// Set `SOL_TCP` -> `TCP_LINGER2`.
51297    pub fn r#set_tcp_linger(
51298        &self,
51299        mut value_secs: &OptionalUint32,
51300        ___deadline: zx::MonotonicInstant,
51301    ) -> Result<StreamSocketSetTcpLingerResult, fidl::Error> {
51302        let _response =
51303            self.client.send_query::<StreamSocketSetTcpLingerRequest, fidl::encoding::ResultType<
51304                fidl::encoding::EmptyStruct,
51305                fidl_fuchsia_posix::Errno,
51306            >>(
51307                (value_secs,),
51308                0xd5cc1e8654d36e4,
51309                fidl::encoding::DynamicFlags::empty(),
51310                ___deadline,
51311            )?;
51312        Ok(_response.map(|x| x))
51313    }
51314
51315    /// Get `SOL_TCP` -> `TCP_LINGER2`.
51316    pub fn r#get_tcp_linger(
51317        &self,
51318        ___deadline: zx::MonotonicInstant,
51319    ) -> Result<StreamSocketGetTcpLingerResult, fidl::Error> {
51320        let _response = self
51321            .client
51322            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
51323                StreamSocketGetTcpLingerResponse,
51324                fidl_fuchsia_posix::Errno,
51325            >>(
51326                (), 0xad870d311cf30eb, fidl::encoding::DynamicFlags::empty(), ___deadline
51327            )?;
51328        Ok(_response.map(|x| x.value_secs))
51329    }
51330
51331    /// Set `SOL_TCP` -> `TCP_DEFER_ACCEPT`.
51332    pub fn r#set_tcp_defer_accept(
51333        &self,
51334        mut value_secs: u32,
51335        ___deadline: zx::MonotonicInstant,
51336    ) -> Result<StreamSocketSetTcpDeferAcceptResult, fidl::Error> {
51337        let _response =
51338            self.client
51339                .send_query::<StreamSocketSetTcpDeferAcceptRequest, fidl::encoding::ResultType<
51340                    fidl::encoding::EmptyStruct,
51341                    fidl_fuchsia_posix::Errno,
51342                >>(
51343                    (value_secs,),
51344                    0x15092f181e57c404,
51345                    fidl::encoding::DynamicFlags::empty(),
51346                    ___deadline,
51347                )?;
51348        Ok(_response.map(|x| x))
51349    }
51350
51351    /// Get `SOL_TCP` -> `TCP_DEFER_ACCEPT`.
51352    pub fn r#get_tcp_defer_accept(
51353        &self,
51354        ___deadline: zx::MonotonicInstant,
51355    ) -> Result<StreamSocketGetTcpDeferAcceptResult, fidl::Error> {
51356        let _response = self
51357            .client
51358            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
51359                StreamSocketGetTcpDeferAcceptResponse,
51360                fidl_fuchsia_posix::Errno,
51361            >>(
51362                (), 0x64589790842cb7c6, fidl::encoding::DynamicFlags::empty(), ___deadline
51363            )?;
51364        Ok(_response.map(|x| x.value_secs))
51365    }
51366
51367    /// Set `SOL_TCP` -> `TCP_WINDOW_CLAMP`.
51368    pub fn r#set_tcp_window_clamp(
51369        &self,
51370        mut value: u32,
51371        ___deadline: zx::MonotonicInstant,
51372    ) -> Result<StreamSocketSetTcpWindowClampResult, fidl::Error> {
51373        let _response =
51374            self.client
51375                .send_query::<StreamSocketSetTcpWindowClampRequest, fidl::encoding::ResultType<
51376                    fidl::encoding::EmptyStruct,
51377                    fidl_fuchsia_posix::Errno,
51378                >>(
51379                    (value,),
51380                    0x4a26ce07d847f1c6,
51381                    fidl::encoding::DynamicFlags::empty(),
51382                    ___deadline,
51383                )?;
51384        Ok(_response.map(|x| x))
51385    }
51386
51387    /// Get `SOL_TCP` -> `TCP_WINDOW_CLAMP`.
51388    pub fn r#get_tcp_window_clamp(
51389        &self,
51390        ___deadline: zx::MonotonicInstant,
51391    ) -> Result<StreamSocketGetTcpWindowClampResult, fidl::Error> {
51392        let _response = self
51393            .client
51394            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
51395                StreamSocketGetTcpWindowClampResponse,
51396                fidl_fuchsia_posix::Errno,
51397            >>(
51398                (), 0x2df6b636bf0a6a4e, fidl::encoding::DynamicFlags::empty(), ___deadline
51399            )?;
51400        Ok(_response.map(|x| x.value))
51401    }
51402
51403    /// Get `SOL_TCP` -> `TCP_INFO`.
51404    pub fn r#get_tcp_info(
51405        &self,
51406        ___deadline: zx::MonotonicInstant,
51407    ) -> Result<StreamSocketGetTcpInfoResult, fidl::Error> {
51408        let _response =
51409            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
51410                StreamSocketGetTcpInfoResponse,
51411                fidl_fuchsia_posix::Errno,
51412            >>(
51413                (),
51414                0x1ffb123d9f03ead2,
51415                fidl::encoding::DynamicFlags::empty(),
51416                ___deadline,
51417            )?;
51418        Ok(_response.map(|x| x.info))
51419    }
51420
51421    /// Set `SOL_TCP` -> `TCP_QUICKACK`.
51422    pub fn r#set_tcp_quick_ack(
51423        &self,
51424        mut value: bool,
51425        ___deadline: zx::MonotonicInstant,
51426    ) -> Result<StreamSocketSetTcpQuickAckResult, fidl::Error> {
51427        let _response =
51428            self.client
51429                .send_query::<StreamSocketSetTcpQuickAckRequest, fidl::encoding::ResultType<
51430                    fidl::encoding::EmptyStruct,
51431                    fidl_fuchsia_posix::Errno,
51432                >>(
51433                    (value,),
51434                    0x6fa811be8fde7457,
51435                    fidl::encoding::DynamicFlags::empty(),
51436                    ___deadline,
51437                )?;
51438        Ok(_response.map(|x| x))
51439    }
51440
51441    /// Get `SOL_TCP` -> `TCP_QUICKACK`.
51442    pub fn r#get_tcp_quick_ack(
51443        &self,
51444        ___deadline: zx::MonotonicInstant,
51445    ) -> Result<StreamSocketGetTcpQuickAckResult, fidl::Error> {
51446        let _response = self
51447            .client
51448            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
51449                StreamSocketGetTcpQuickAckResponse,
51450                fidl_fuchsia_posix::Errno,
51451            >>(
51452                (), 0x7356a949bef2df32, fidl::encoding::DynamicFlags::empty(), ___deadline
51453            )?;
51454        Ok(_response.map(|x| x.value))
51455    }
51456
51457    /// Set `SOL_TCP` -> `TCP_CONGESTION`.
51458    pub fn r#set_tcp_congestion(
51459        &self,
51460        mut value: TcpCongestionControl,
51461        ___deadline: zx::MonotonicInstant,
51462    ) -> Result<StreamSocketSetTcpCongestionResult, fidl::Error> {
51463        let _response =
51464            self.client
51465                .send_query::<StreamSocketSetTcpCongestionRequest, fidl::encoding::ResultType<
51466                    fidl::encoding::EmptyStruct,
51467                    fidl_fuchsia_posix::Errno,
51468                >>(
51469                    (value,),
51470                    0x7924c6eabde7819e,
51471                    fidl::encoding::DynamicFlags::empty(),
51472                    ___deadline,
51473                )?;
51474        Ok(_response.map(|x| x))
51475    }
51476
51477    /// Get `SOL_TCP` -> `TCP_CONGESTION`.
51478    pub fn r#get_tcp_congestion(
51479        &self,
51480        ___deadline: zx::MonotonicInstant,
51481    ) -> Result<StreamSocketGetTcpCongestionResult, fidl::Error> {
51482        let _response = self
51483            .client
51484            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
51485                StreamSocketGetTcpCongestionResponse,
51486                fidl_fuchsia_posix::Errno,
51487            >>(
51488                (), 0x11e16397e1b72a47, fidl::encoding::DynamicFlags::empty(), ___deadline
51489            )?;
51490        Ok(_response.map(|x| x.value))
51491    }
51492
51493    /// Set `SOL_TCP` -> `TCP_USER_TIMEOUT`.
51494    pub fn r#set_tcp_user_timeout(
51495        &self,
51496        mut value_millis: u32,
51497        ___deadline: zx::MonotonicInstant,
51498    ) -> Result<StreamSocketSetTcpUserTimeoutResult, fidl::Error> {
51499        let _response =
51500            self.client
51501                .send_query::<StreamSocketSetTcpUserTimeoutRequest, fidl::encoding::ResultType<
51502                    fidl::encoding::EmptyStruct,
51503                    fidl_fuchsia_posix::Errno,
51504                >>(
51505                    (value_millis,),
51506                    0x6b459e81c3741a60,
51507                    fidl::encoding::DynamicFlags::empty(),
51508                    ___deadline,
51509                )?;
51510        Ok(_response.map(|x| x))
51511    }
51512
51513    /// Get `SOL_TCP` -> `TCP_USER_TIMEOUT`.
51514    pub fn r#get_tcp_user_timeout(
51515        &self,
51516        ___deadline: zx::MonotonicInstant,
51517    ) -> Result<StreamSocketGetTcpUserTimeoutResult, fidl::Error> {
51518        let _response = self
51519            .client
51520            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
51521                StreamSocketGetTcpUserTimeoutResponse,
51522                fidl_fuchsia_posix::Errno,
51523            >>(
51524                (), 0x24bbd5858ad8c380, fidl::encoding::DynamicFlags::empty(), ___deadline
51525            )?;
51526        Ok(_response.map(|x| x.value_millis))
51527    }
51528}
51529
51530#[cfg(target_os = "fuchsia")]
51531impl From<StreamSocketSynchronousProxy> for zx::Handle {
51532    fn from(value: StreamSocketSynchronousProxy) -> Self {
51533        value.into_channel().into()
51534    }
51535}
51536
51537#[cfg(target_os = "fuchsia")]
51538impl From<fidl::Channel> for StreamSocketSynchronousProxy {
51539    fn from(value: fidl::Channel) -> Self {
51540        Self::new(value)
51541    }
51542}
51543
51544#[derive(Debug, Clone)]
51545pub struct StreamSocketProxy {
51546    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
51547}
51548
51549impl fidl::endpoints::Proxy for StreamSocketProxy {
51550    type Protocol = StreamSocketMarker;
51551
51552    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
51553        Self::new(inner)
51554    }
51555
51556    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
51557        self.client.into_channel().map_err(|client| Self { client })
51558    }
51559
51560    fn as_channel(&self) -> &::fidl::AsyncChannel {
51561        self.client.as_channel()
51562    }
51563}
51564
51565impl StreamSocketProxy {
51566    /// Create a new Proxy for fuchsia.posix.socket/StreamSocket.
51567    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
51568        let protocol_name = <StreamSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
51569        Self { client: fidl::client::Client::new(channel, protocol_name) }
51570    }
51571
51572    /// Get a Stream of events from the remote end of the protocol.
51573    ///
51574    /// # Panics
51575    ///
51576    /// Panics if the event stream was already taken.
51577    pub fn take_event_stream(&self) -> StreamSocketEventStream {
51578        StreamSocketEventStream { event_receiver: self.client.take_event_receiver() }
51579    }
51580
51581    pub fn r#clone(
51582        &self,
51583        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
51584    ) -> Result<(), fidl::Error> {
51585        StreamSocketProxyInterface::r#clone(self, request)
51586    }
51587
51588    /// Terminates the connection.
51589    ///
51590    /// After calling `Close`, the client must not send any other requests.
51591    ///
51592    /// Servers, after sending the status response, should close the connection
51593    /// regardless of status and without sending an epitaph.
51594    ///
51595    /// Closing the client end of the channel should be semantically equivalent
51596    /// to calling `Close` without knowing when the close has completed or its
51597    /// status.
51598    pub fn r#close(
51599        &self,
51600    ) -> fidl::client::QueryResponseFut<
51601        fidl_fuchsia_unknown::CloseableCloseResult,
51602        fidl::encoding::DefaultFuchsiaResourceDialect,
51603    > {
51604        StreamSocketProxyInterface::r#close(self)
51605    }
51606
51607    pub fn r#query(
51608        &self,
51609    ) -> fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>
51610    {
51611        StreamSocketProxyInterface::r#query(self)
51612    }
51613
51614    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
51615    pub fn r#set_reuse_address(
51616        &self,
51617        mut value: bool,
51618    ) -> fidl::client::QueryResponseFut<
51619        BaseSocketSetReuseAddressResult,
51620        fidl::encoding::DefaultFuchsiaResourceDialect,
51621    > {
51622        StreamSocketProxyInterface::r#set_reuse_address(self, value)
51623    }
51624
51625    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
51626    pub fn r#get_reuse_address(
51627        &self,
51628    ) -> fidl::client::QueryResponseFut<
51629        BaseSocketGetReuseAddressResult,
51630        fidl::encoding::DefaultFuchsiaResourceDialect,
51631    > {
51632        StreamSocketProxyInterface::r#get_reuse_address(self)
51633    }
51634
51635    /// Get `SOL_SOCKET` -> `SO_ERROR`.
51636    /// Returns the last error if there is an error set on the socket.
51637    pub fn r#get_error(
51638        &self,
51639    ) -> fidl::client::QueryResponseFut<
51640        BaseSocketGetErrorResult,
51641        fidl::encoding::DefaultFuchsiaResourceDialect,
51642    > {
51643        StreamSocketProxyInterface::r#get_error(self)
51644    }
51645
51646    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
51647    pub fn r#set_broadcast(
51648        &self,
51649        mut value: bool,
51650    ) -> fidl::client::QueryResponseFut<
51651        BaseSocketSetBroadcastResult,
51652        fidl::encoding::DefaultFuchsiaResourceDialect,
51653    > {
51654        StreamSocketProxyInterface::r#set_broadcast(self, value)
51655    }
51656
51657    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
51658    pub fn r#get_broadcast(
51659        &self,
51660    ) -> fidl::client::QueryResponseFut<
51661        BaseSocketGetBroadcastResult,
51662        fidl::encoding::DefaultFuchsiaResourceDialect,
51663    > {
51664        StreamSocketProxyInterface::r#get_broadcast(self)
51665    }
51666
51667    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
51668    pub fn r#set_send_buffer(
51669        &self,
51670        mut value_bytes: u64,
51671    ) -> fidl::client::QueryResponseFut<
51672        BaseSocketSetSendBufferResult,
51673        fidl::encoding::DefaultFuchsiaResourceDialect,
51674    > {
51675        StreamSocketProxyInterface::r#set_send_buffer(self, value_bytes)
51676    }
51677
51678    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
51679    pub fn r#get_send_buffer(
51680        &self,
51681    ) -> fidl::client::QueryResponseFut<
51682        BaseSocketGetSendBufferResult,
51683        fidl::encoding::DefaultFuchsiaResourceDialect,
51684    > {
51685        StreamSocketProxyInterface::r#get_send_buffer(self)
51686    }
51687
51688    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
51689    pub fn r#set_receive_buffer(
51690        &self,
51691        mut value_bytes: u64,
51692    ) -> fidl::client::QueryResponseFut<
51693        BaseSocketSetReceiveBufferResult,
51694        fidl::encoding::DefaultFuchsiaResourceDialect,
51695    > {
51696        StreamSocketProxyInterface::r#set_receive_buffer(self, value_bytes)
51697    }
51698
51699    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
51700    pub fn r#get_receive_buffer(
51701        &self,
51702    ) -> fidl::client::QueryResponseFut<
51703        BaseSocketGetReceiveBufferResult,
51704        fidl::encoding::DefaultFuchsiaResourceDialect,
51705    > {
51706        StreamSocketProxyInterface::r#get_receive_buffer(self)
51707    }
51708
51709    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
51710    pub fn r#set_keep_alive(
51711        &self,
51712        mut value: bool,
51713    ) -> fidl::client::QueryResponseFut<
51714        BaseSocketSetKeepAliveResult,
51715        fidl::encoding::DefaultFuchsiaResourceDialect,
51716    > {
51717        StreamSocketProxyInterface::r#set_keep_alive(self, value)
51718    }
51719
51720    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
51721    pub fn r#get_keep_alive(
51722        &self,
51723    ) -> fidl::client::QueryResponseFut<
51724        BaseSocketGetKeepAliveResult,
51725        fidl::encoding::DefaultFuchsiaResourceDialect,
51726    > {
51727        StreamSocketProxyInterface::r#get_keep_alive(self)
51728    }
51729
51730    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
51731    pub fn r#set_out_of_band_inline(
51732        &self,
51733        mut value: bool,
51734    ) -> fidl::client::QueryResponseFut<
51735        BaseSocketSetOutOfBandInlineResult,
51736        fidl::encoding::DefaultFuchsiaResourceDialect,
51737    > {
51738        StreamSocketProxyInterface::r#set_out_of_band_inline(self, value)
51739    }
51740
51741    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
51742    pub fn r#get_out_of_band_inline(
51743        &self,
51744    ) -> fidl::client::QueryResponseFut<
51745        BaseSocketGetOutOfBandInlineResult,
51746        fidl::encoding::DefaultFuchsiaResourceDialect,
51747    > {
51748        StreamSocketProxyInterface::r#get_out_of_band_inline(self)
51749    }
51750
51751    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
51752    pub fn r#set_no_check(
51753        &self,
51754        mut value: bool,
51755    ) -> fidl::client::QueryResponseFut<
51756        BaseSocketSetNoCheckResult,
51757        fidl::encoding::DefaultFuchsiaResourceDialect,
51758    > {
51759        StreamSocketProxyInterface::r#set_no_check(self, value)
51760    }
51761
51762    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
51763    pub fn r#get_no_check(
51764        &self,
51765    ) -> fidl::client::QueryResponseFut<
51766        BaseSocketGetNoCheckResult,
51767        fidl::encoding::DefaultFuchsiaResourceDialect,
51768    > {
51769        StreamSocketProxyInterface::r#get_no_check(self)
51770    }
51771
51772    /// Set `SOL_SOCKET` -> `SO_LINGER`.
51773    pub fn r#set_linger(
51774        &self,
51775        mut linger: bool,
51776        mut length_secs: u32,
51777    ) -> fidl::client::QueryResponseFut<
51778        BaseSocketSetLingerResult,
51779        fidl::encoding::DefaultFuchsiaResourceDialect,
51780    > {
51781        StreamSocketProxyInterface::r#set_linger(self, linger, length_secs)
51782    }
51783
51784    /// Get `SOL_SOCKET` -> `SO_LINGER`.
51785    pub fn r#get_linger(
51786        &self,
51787    ) -> fidl::client::QueryResponseFut<
51788        BaseSocketGetLingerResult,
51789        fidl::encoding::DefaultFuchsiaResourceDialect,
51790    > {
51791        StreamSocketProxyInterface::r#get_linger(self)
51792    }
51793
51794    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
51795    pub fn r#set_reuse_port(
51796        &self,
51797        mut value: bool,
51798    ) -> fidl::client::QueryResponseFut<
51799        BaseSocketSetReusePortResult,
51800        fidl::encoding::DefaultFuchsiaResourceDialect,
51801    > {
51802        StreamSocketProxyInterface::r#set_reuse_port(self, value)
51803    }
51804
51805    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
51806    pub fn r#get_reuse_port(
51807        &self,
51808    ) -> fidl::client::QueryResponseFut<
51809        BaseSocketGetReusePortResult,
51810        fidl::encoding::DefaultFuchsiaResourceDialect,
51811    > {
51812        StreamSocketProxyInterface::r#get_reuse_port(self)
51813    }
51814
51815    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
51816    pub fn r#get_accept_conn(
51817        &self,
51818    ) -> fidl::client::QueryResponseFut<
51819        BaseSocketGetAcceptConnResult,
51820        fidl::encoding::DefaultFuchsiaResourceDialect,
51821    > {
51822        StreamSocketProxyInterface::r#get_accept_conn(self)
51823    }
51824
51825    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
51826    pub fn r#set_bind_to_device(
51827        &self,
51828        mut value: &str,
51829    ) -> fidl::client::QueryResponseFut<
51830        BaseSocketSetBindToDeviceResult,
51831        fidl::encoding::DefaultFuchsiaResourceDialect,
51832    > {
51833        StreamSocketProxyInterface::r#set_bind_to_device(self, value)
51834    }
51835
51836    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
51837    pub fn r#get_bind_to_device(
51838        &self,
51839    ) -> fidl::client::QueryResponseFut<
51840        BaseSocketGetBindToDeviceResult,
51841        fidl::encoding::DefaultFuchsiaResourceDialect,
51842    > {
51843        StreamSocketProxyInterface::r#get_bind_to_device(self)
51844    }
51845
51846    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
51847    /// If `value` is 0, this clears the bound interface.
51848    pub fn r#set_bind_to_interface_index(
51849        &self,
51850        mut value: u64,
51851    ) -> fidl::client::QueryResponseFut<
51852        BaseSocketSetBindToInterfaceIndexResult,
51853        fidl::encoding::DefaultFuchsiaResourceDialect,
51854    > {
51855        StreamSocketProxyInterface::r#set_bind_to_interface_index(self, value)
51856    }
51857
51858    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
51859    pub fn r#get_bind_to_interface_index(
51860        &self,
51861    ) -> fidl::client::QueryResponseFut<
51862        BaseSocketGetBindToInterfaceIndexResult,
51863        fidl::encoding::DefaultFuchsiaResourceDialect,
51864    > {
51865        StreamSocketProxyInterface::r#get_bind_to_interface_index(self)
51866    }
51867
51868    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
51869    pub fn r#set_timestamp(
51870        &self,
51871        mut value: TimestampOption,
51872    ) -> fidl::client::QueryResponseFut<
51873        BaseSocketSetTimestampResult,
51874        fidl::encoding::DefaultFuchsiaResourceDialect,
51875    > {
51876        StreamSocketProxyInterface::r#set_timestamp(self, value)
51877    }
51878
51879    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
51880    pub fn r#get_timestamp(
51881        &self,
51882    ) -> fidl::client::QueryResponseFut<
51883        BaseSocketGetTimestampResult,
51884        fidl::encoding::DefaultFuchsiaResourceDialect,
51885    > {
51886        StreamSocketProxyInterface::r#get_timestamp(self)
51887    }
51888
51889    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
51890    /// unlike the standard SO_MARK, this API has multiple mark domains and each
51891    /// mark can be set independently in each domain.
51892    pub fn r#set_mark(
51893        &self,
51894        mut domain: fidl_fuchsia_net::MarkDomain,
51895        mut mark: &OptionalUint32,
51896    ) -> fidl::client::QueryResponseFut<
51897        BaseSocketSetMarkResult,
51898        fidl::encoding::DefaultFuchsiaResourceDialect,
51899    > {
51900        StreamSocketProxyInterface::r#set_mark(self, domain, mark)
51901    }
51902
51903    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
51904    /// unlike the standard SO_MARK, this API has multiple mark domains and each
51905    /// mark can be retrieved independently in each domain.
51906    pub fn r#get_mark(
51907        &self,
51908        mut domain: fidl_fuchsia_net::MarkDomain,
51909    ) -> fidl::client::QueryResponseFut<
51910        BaseSocketGetMarkResult,
51911        fidl::encoding::DefaultFuchsiaResourceDialect,
51912    > {
51913        StreamSocketProxyInterface::r#get_mark(self, domain)
51914    }
51915
51916    /// Sets the local address used for the socket.
51917    pub fn r#bind(
51918        &self,
51919        mut addr: &fidl_fuchsia_net::SocketAddress,
51920    ) -> fidl::client::QueryResponseFut<
51921        BaseNetworkSocketBindResult,
51922        fidl::encoding::DefaultFuchsiaResourceDialect,
51923    > {
51924        StreamSocketProxyInterface::r#bind(self, addr)
51925    }
51926
51927    /// Initiates a connection to a remote address.
51928    pub fn r#connect(
51929        &self,
51930        mut addr: &fidl_fuchsia_net::SocketAddress,
51931    ) -> fidl::client::QueryResponseFut<
51932        BaseNetworkSocketConnectResult,
51933        fidl::encoding::DefaultFuchsiaResourceDialect,
51934    > {
51935        StreamSocketProxyInterface::r#connect(self, addr)
51936    }
51937
51938    /// Clears connection information from this socket.
51939    pub fn r#disconnect(
51940        &self,
51941    ) -> fidl::client::QueryResponseFut<
51942        BaseNetworkSocketDisconnectResult,
51943        fidl::encoding::DefaultFuchsiaResourceDialect,
51944    > {
51945        StreamSocketProxyInterface::r#disconnect(self)
51946    }
51947
51948    /// Retrieves the local socket address.
51949    pub fn r#get_sock_name(
51950        &self,
51951    ) -> fidl::client::QueryResponseFut<
51952        BaseNetworkSocketGetSockNameResult,
51953        fidl::encoding::DefaultFuchsiaResourceDialect,
51954    > {
51955        StreamSocketProxyInterface::r#get_sock_name(self)
51956    }
51957
51958    /// Retrieves the remote socket address.
51959    pub fn r#get_peer_name(
51960        &self,
51961    ) -> fidl::client::QueryResponseFut<
51962        BaseNetworkSocketGetPeerNameResult,
51963        fidl::encoding::DefaultFuchsiaResourceDialect,
51964    > {
51965        StreamSocketProxyInterface::r#get_peer_name(self)
51966    }
51967
51968    /// Shuts down part of the socket.
51969    pub fn r#shutdown(
51970        &self,
51971        mut mode: ShutdownMode,
51972    ) -> fidl::client::QueryResponseFut<
51973        BaseNetworkSocketShutdownResult,
51974        fidl::encoding::DefaultFuchsiaResourceDialect,
51975    > {
51976        StreamSocketProxyInterface::r#shutdown(self, mode)
51977    }
51978
51979    /// Set `SOL_IP` -> `IP_TOS`.
51980    pub fn r#set_ip_type_of_service(
51981        &self,
51982        mut value: u8,
51983    ) -> fidl::client::QueryResponseFut<
51984        BaseNetworkSocketSetIpTypeOfServiceResult,
51985        fidl::encoding::DefaultFuchsiaResourceDialect,
51986    > {
51987        StreamSocketProxyInterface::r#set_ip_type_of_service(self, value)
51988    }
51989
51990    /// Get `SOL_IP` -> `IP_TOS`.
51991    pub fn r#get_ip_type_of_service(
51992        &self,
51993    ) -> fidl::client::QueryResponseFut<
51994        BaseNetworkSocketGetIpTypeOfServiceResult,
51995        fidl::encoding::DefaultFuchsiaResourceDialect,
51996    > {
51997        StreamSocketProxyInterface::r#get_ip_type_of_service(self)
51998    }
51999
52000    /// Set `SOL_IP` -> `IP_TTL`.
52001    pub fn r#set_ip_ttl(
52002        &self,
52003        mut value: &OptionalUint8,
52004    ) -> fidl::client::QueryResponseFut<
52005        BaseNetworkSocketSetIpTtlResult,
52006        fidl::encoding::DefaultFuchsiaResourceDialect,
52007    > {
52008        StreamSocketProxyInterface::r#set_ip_ttl(self, value)
52009    }
52010
52011    /// Get `SOL_IP` -> `IP_TTL`.
52012    pub fn r#get_ip_ttl(
52013        &self,
52014    ) -> fidl::client::QueryResponseFut<
52015        BaseNetworkSocketGetIpTtlResult,
52016        fidl::encoding::DefaultFuchsiaResourceDialect,
52017    > {
52018        StreamSocketProxyInterface::r#get_ip_ttl(self)
52019    }
52020
52021    /// Set `SOL_IP` -> `IP_PKTINFO`.
52022    pub fn r#set_ip_packet_info(
52023        &self,
52024        mut value: bool,
52025    ) -> fidl::client::QueryResponseFut<
52026        BaseNetworkSocketSetIpPacketInfoResult,
52027        fidl::encoding::DefaultFuchsiaResourceDialect,
52028    > {
52029        StreamSocketProxyInterface::r#set_ip_packet_info(self, value)
52030    }
52031
52032    /// Get `SOL_IP` -> `IP_PKTINFO`.
52033    pub fn r#get_ip_packet_info(
52034        &self,
52035    ) -> fidl::client::QueryResponseFut<
52036        BaseNetworkSocketGetIpPacketInfoResult,
52037        fidl::encoding::DefaultFuchsiaResourceDialect,
52038    > {
52039        StreamSocketProxyInterface::r#get_ip_packet_info(self)
52040    }
52041
52042    /// Set `SOL_IP` -> `IP_RECVTOS`.
52043    pub fn r#set_ip_receive_type_of_service(
52044        &self,
52045        mut value: bool,
52046    ) -> fidl::client::QueryResponseFut<
52047        BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
52048        fidl::encoding::DefaultFuchsiaResourceDialect,
52049    > {
52050        StreamSocketProxyInterface::r#set_ip_receive_type_of_service(self, value)
52051    }
52052
52053    /// Get `SOL_IP` -> `IP_RECVTOS`.
52054    pub fn r#get_ip_receive_type_of_service(
52055        &self,
52056    ) -> fidl::client::QueryResponseFut<
52057        BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
52058        fidl::encoding::DefaultFuchsiaResourceDialect,
52059    > {
52060        StreamSocketProxyInterface::r#get_ip_receive_type_of_service(self)
52061    }
52062
52063    /// Set `SOL_IP` -> `IP_RECVTTL`.
52064    pub fn r#set_ip_receive_ttl(
52065        &self,
52066        mut value: bool,
52067    ) -> fidl::client::QueryResponseFut<
52068        BaseNetworkSocketSetIpReceiveTtlResult,
52069        fidl::encoding::DefaultFuchsiaResourceDialect,
52070    > {
52071        StreamSocketProxyInterface::r#set_ip_receive_ttl(self, value)
52072    }
52073
52074    /// Get `SOL_IP` -> `IP_RECVTTL`.
52075    pub fn r#get_ip_receive_ttl(
52076        &self,
52077    ) -> fidl::client::QueryResponseFut<
52078        BaseNetworkSocketGetIpReceiveTtlResult,
52079        fidl::encoding::DefaultFuchsiaResourceDialect,
52080    > {
52081        StreamSocketProxyInterface::r#get_ip_receive_ttl(self)
52082    }
52083
52084    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
52085    pub fn r#set_ip_multicast_interface(
52086        &self,
52087        mut iface: u64,
52088        mut address: &fidl_fuchsia_net::Ipv4Address,
52089    ) -> fidl::client::QueryResponseFut<
52090        BaseNetworkSocketSetIpMulticastInterfaceResult,
52091        fidl::encoding::DefaultFuchsiaResourceDialect,
52092    > {
52093        StreamSocketProxyInterface::r#set_ip_multicast_interface(self, iface, address)
52094    }
52095
52096    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
52097    pub fn r#get_ip_multicast_interface(
52098        &self,
52099    ) -> fidl::client::QueryResponseFut<
52100        BaseNetworkSocketGetIpMulticastInterfaceResult,
52101        fidl::encoding::DefaultFuchsiaResourceDialect,
52102    > {
52103        StreamSocketProxyInterface::r#get_ip_multicast_interface(self)
52104    }
52105
52106    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
52107    pub fn r#set_ip_multicast_ttl(
52108        &self,
52109        mut value: &OptionalUint8,
52110    ) -> fidl::client::QueryResponseFut<
52111        BaseNetworkSocketSetIpMulticastTtlResult,
52112        fidl::encoding::DefaultFuchsiaResourceDialect,
52113    > {
52114        StreamSocketProxyInterface::r#set_ip_multicast_ttl(self, value)
52115    }
52116
52117    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
52118    pub fn r#get_ip_multicast_ttl(
52119        &self,
52120    ) -> fidl::client::QueryResponseFut<
52121        BaseNetworkSocketGetIpMulticastTtlResult,
52122        fidl::encoding::DefaultFuchsiaResourceDialect,
52123    > {
52124        StreamSocketProxyInterface::r#get_ip_multicast_ttl(self)
52125    }
52126
52127    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
52128    pub fn r#set_ip_multicast_loopback(
52129        &self,
52130        mut value: bool,
52131    ) -> fidl::client::QueryResponseFut<
52132        BaseNetworkSocketSetIpMulticastLoopbackResult,
52133        fidl::encoding::DefaultFuchsiaResourceDialect,
52134    > {
52135        StreamSocketProxyInterface::r#set_ip_multicast_loopback(self, value)
52136    }
52137
52138    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
52139    pub fn r#get_ip_multicast_loopback(
52140        &self,
52141    ) -> fidl::client::QueryResponseFut<
52142        BaseNetworkSocketGetIpMulticastLoopbackResult,
52143        fidl::encoding::DefaultFuchsiaResourceDialect,
52144    > {
52145        StreamSocketProxyInterface::r#get_ip_multicast_loopback(self)
52146    }
52147
52148    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
52149    pub fn r#add_ip_membership(
52150        &self,
52151        mut membership: &IpMulticastMembership,
52152    ) -> fidl::client::QueryResponseFut<
52153        BaseNetworkSocketAddIpMembershipResult,
52154        fidl::encoding::DefaultFuchsiaResourceDialect,
52155    > {
52156        StreamSocketProxyInterface::r#add_ip_membership(self, membership)
52157    }
52158
52159    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
52160    pub fn r#drop_ip_membership(
52161        &self,
52162        mut membership: &IpMulticastMembership,
52163    ) -> fidl::client::QueryResponseFut<
52164        BaseNetworkSocketDropIpMembershipResult,
52165        fidl::encoding::DefaultFuchsiaResourceDialect,
52166    > {
52167        StreamSocketProxyInterface::r#drop_ip_membership(self, membership)
52168    }
52169
52170    /// Set `SOL_IP` -> `IP_TRANSPARENT`
52171    pub fn r#set_ip_transparent(
52172        &self,
52173        mut value: bool,
52174    ) -> fidl::client::QueryResponseFut<
52175        BaseNetworkSocketSetIpTransparentResult,
52176        fidl::encoding::DefaultFuchsiaResourceDialect,
52177    > {
52178        StreamSocketProxyInterface::r#set_ip_transparent(self, value)
52179    }
52180
52181    /// Get `SOL_IP` -> `IP_TRANSPARENT`
52182    pub fn r#get_ip_transparent(
52183        &self,
52184    ) -> fidl::client::QueryResponseFut<
52185        BaseNetworkSocketGetIpTransparentResult,
52186        fidl::encoding::DefaultFuchsiaResourceDialect,
52187    > {
52188        StreamSocketProxyInterface::r#get_ip_transparent(self)
52189    }
52190
52191    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
52192    pub fn r#set_ip_receive_original_destination_address(
52193        &self,
52194        mut value: bool,
52195    ) -> fidl::client::QueryResponseFut<
52196        BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
52197        fidl::encoding::DefaultFuchsiaResourceDialect,
52198    > {
52199        StreamSocketProxyInterface::r#set_ip_receive_original_destination_address(self, value)
52200    }
52201
52202    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
52203    pub fn r#get_ip_receive_original_destination_address(
52204        &self,
52205    ) -> fidl::client::QueryResponseFut<
52206        BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
52207        fidl::encoding::DefaultFuchsiaResourceDialect,
52208    > {
52209        StreamSocketProxyInterface::r#get_ip_receive_original_destination_address(self)
52210    }
52211
52212    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
52213    pub fn r#add_ipv6_membership(
52214        &self,
52215        mut membership: &Ipv6MulticastMembership,
52216    ) -> fidl::client::QueryResponseFut<
52217        BaseNetworkSocketAddIpv6MembershipResult,
52218        fidl::encoding::DefaultFuchsiaResourceDialect,
52219    > {
52220        StreamSocketProxyInterface::r#add_ipv6_membership(self, membership)
52221    }
52222
52223    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
52224    pub fn r#drop_ipv6_membership(
52225        &self,
52226        mut membership: &Ipv6MulticastMembership,
52227    ) -> fidl::client::QueryResponseFut<
52228        BaseNetworkSocketDropIpv6MembershipResult,
52229        fidl::encoding::DefaultFuchsiaResourceDialect,
52230    > {
52231        StreamSocketProxyInterface::r#drop_ipv6_membership(self, membership)
52232    }
52233
52234    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
52235    pub fn r#set_ipv6_multicast_interface(
52236        &self,
52237        mut value: u64,
52238    ) -> fidl::client::QueryResponseFut<
52239        BaseNetworkSocketSetIpv6MulticastInterfaceResult,
52240        fidl::encoding::DefaultFuchsiaResourceDialect,
52241    > {
52242        StreamSocketProxyInterface::r#set_ipv6_multicast_interface(self, value)
52243    }
52244
52245    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
52246    pub fn r#get_ipv6_multicast_interface(
52247        &self,
52248    ) -> fidl::client::QueryResponseFut<
52249        BaseNetworkSocketGetIpv6MulticastInterfaceResult,
52250        fidl::encoding::DefaultFuchsiaResourceDialect,
52251    > {
52252        StreamSocketProxyInterface::r#get_ipv6_multicast_interface(self)
52253    }
52254
52255    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
52256    pub fn r#set_ipv6_unicast_hops(
52257        &self,
52258        mut value: &OptionalUint8,
52259    ) -> fidl::client::QueryResponseFut<
52260        BaseNetworkSocketSetIpv6UnicastHopsResult,
52261        fidl::encoding::DefaultFuchsiaResourceDialect,
52262    > {
52263        StreamSocketProxyInterface::r#set_ipv6_unicast_hops(self, value)
52264    }
52265
52266    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
52267    pub fn r#get_ipv6_unicast_hops(
52268        &self,
52269    ) -> fidl::client::QueryResponseFut<
52270        BaseNetworkSocketGetIpv6UnicastHopsResult,
52271        fidl::encoding::DefaultFuchsiaResourceDialect,
52272    > {
52273        StreamSocketProxyInterface::r#get_ipv6_unicast_hops(self)
52274    }
52275
52276    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
52277    pub fn r#set_ipv6_receive_hop_limit(
52278        &self,
52279        mut value: bool,
52280    ) -> fidl::client::QueryResponseFut<
52281        BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
52282        fidl::encoding::DefaultFuchsiaResourceDialect,
52283    > {
52284        StreamSocketProxyInterface::r#set_ipv6_receive_hop_limit(self, value)
52285    }
52286
52287    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
52288    pub fn r#get_ipv6_receive_hop_limit(
52289        &self,
52290    ) -> fidl::client::QueryResponseFut<
52291        BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
52292        fidl::encoding::DefaultFuchsiaResourceDialect,
52293    > {
52294        StreamSocketProxyInterface::r#get_ipv6_receive_hop_limit(self)
52295    }
52296
52297    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
52298    pub fn r#set_ipv6_multicast_hops(
52299        &self,
52300        mut value: &OptionalUint8,
52301    ) -> fidl::client::QueryResponseFut<
52302        BaseNetworkSocketSetIpv6MulticastHopsResult,
52303        fidl::encoding::DefaultFuchsiaResourceDialect,
52304    > {
52305        StreamSocketProxyInterface::r#set_ipv6_multicast_hops(self, value)
52306    }
52307
52308    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
52309    pub fn r#get_ipv6_multicast_hops(
52310        &self,
52311    ) -> fidl::client::QueryResponseFut<
52312        BaseNetworkSocketGetIpv6MulticastHopsResult,
52313        fidl::encoding::DefaultFuchsiaResourceDialect,
52314    > {
52315        StreamSocketProxyInterface::r#get_ipv6_multicast_hops(self)
52316    }
52317
52318    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
52319    pub fn r#set_ipv6_multicast_loopback(
52320        &self,
52321        mut value: bool,
52322    ) -> fidl::client::QueryResponseFut<
52323        BaseNetworkSocketSetIpv6MulticastLoopbackResult,
52324        fidl::encoding::DefaultFuchsiaResourceDialect,
52325    > {
52326        StreamSocketProxyInterface::r#set_ipv6_multicast_loopback(self, value)
52327    }
52328
52329    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
52330    pub fn r#get_ipv6_multicast_loopback(
52331        &self,
52332    ) -> fidl::client::QueryResponseFut<
52333        BaseNetworkSocketGetIpv6MulticastLoopbackResult,
52334        fidl::encoding::DefaultFuchsiaResourceDialect,
52335    > {
52336        StreamSocketProxyInterface::r#get_ipv6_multicast_loopback(self)
52337    }
52338
52339    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
52340    pub fn r#set_ipv6_only(
52341        &self,
52342        mut value: bool,
52343    ) -> fidl::client::QueryResponseFut<
52344        BaseNetworkSocketSetIpv6OnlyResult,
52345        fidl::encoding::DefaultFuchsiaResourceDialect,
52346    > {
52347        StreamSocketProxyInterface::r#set_ipv6_only(self, value)
52348    }
52349
52350    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
52351    pub fn r#get_ipv6_only(
52352        &self,
52353    ) -> fidl::client::QueryResponseFut<
52354        BaseNetworkSocketGetIpv6OnlyResult,
52355        fidl::encoding::DefaultFuchsiaResourceDialect,
52356    > {
52357        StreamSocketProxyInterface::r#get_ipv6_only(self)
52358    }
52359
52360    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
52361    pub fn r#set_ipv6_receive_traffic_class(
52362        &self,
52363        mut value: bool,
52364    ) -> fidl::client::QueryResponseFut<
52365        BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
52366        fidl::encoding::DefaultFuchsiaResourceDialect,
52367    > {
52368        StreamSocketProxyInterface::r#set_ipv6_receive_traffic_class(self, value)
52369    }
52370
52371    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
52372    pub fn r#get_ipv6_receive_traffic_class(
52373        &self,
52374    ) -> fidl::client::QueryResponseFut<
52375        BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
52376        fidl::encoding::DefaultFuchsiaResourceDialect,
52377    > {
52378        StreamSocketProxyInterface::r#get_ipv6_receive_traffic_class(self)
52379    }
52380
52381    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
52382    pub fn r#set_ipv6_traffic_class(
52383        &self,
52384        mut value: &OptionalUint8,
52385    ) -> fidl::client::QueryResponseFut<
52386        BaseNetworkSocketSetIpv6TrafficClassResult,
52387        fidl::encoding::DefaultFuchsiaResourceDialect,
52388    > {
52389        StreamSocketProxyInterface::r#set_ipv6_traffic_class(self, value)
52390    }
52391
52392    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
52393    pub fn r#get_ipv6_traffic_class(
52394        &self,
52395    ) -> fidl::client::QueryResponseFut<
52396        BaseNetworkSocketGetIpv6TrafficClassResult,
52397        fidl::encoding::DefaultFuchsiaResourceDialect,
52398    > {
52399        StreamSocketProxyInterface::r#get_ipv6_traffic_class(self)
52400    }
52401
52402    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
52403    pub fn r#set_ipv6_receive_packet_info(
52404        &self,
52405        mut value: bool,
52406    ) -> fidl::client::QueryResponseFut<
52407        BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
52408        fidl::encoding::DefaultFuchsiaResourceDialect,
52409    > {
52410        StreamSocketProxyInterface::r#set_ipv6_receive_packet_info(self, value)
52411    }
52412
52413    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
52414    pub fn r#get_ipv6_receive_packet_info(
52415        &self,
52416    ) -> fidl::client::QueryResponseFut<
52417        BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
52418        fidl::encoding::DefaultFuchsiaResourceDialect,
52419    > {
52420        StreamSocketProxyInterface::r#get_ipv6_receive_packet_info(self)
52421    }
52422
52423    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
52424    pub fn r#get_original_destination(
52425        &self,
52426    ) -> fidl::client::QueryResponseFut<
52427        BaseNetworkSocketGetOriginalDestinationResult,
52428        fidl::encoding::DefaultFuchsiaResourceDialect,
52429    > {
52430        StreamSocketProxyInterface::r#get_original_destination(self)
52431    }
52432
52433    pub fn r#describe(
52434        &self,
52435    ) -> fidl::client::QueryResponseFut<
52436        StreamSocketDescribeResponse,
52437        fidl::encoding::DefaultFuchsiaResourceDialect,
52438    > {
52439        StreamSocketProxyInterface::r#describe(self)
52440    }
52441
52442    /// Begins listening for new incoming connections. At most `backlog`
52443    /// connections will be buffered.
52444    pub fn r#listen(
52445        &self,
52446        mut backlog: i16,
52447    ) -> fidl::client::QueryResponseFut<
52448        StreamSocketListenResult,
52449        fidl::encoding::DefaultFuchsiaResourceDialect,
52450    > {
52451        StreamSocketProxyInterface::r#listen(self, backlog)
52452    }
52453
52454    /// Accepts a buffered incoming connection.
52455    pub fn r#accept(
52456        &self,
52457        mut want_addr: bool,
52458    ) -> fidl::client::QueryResponseFut<
52459        StreamSocketAcceptResult,
52460        fidl::encoding::DefaultFuchsiaResourceDialect,
52461    > {
52462        StreamSocketProxyInterface::r#accept(self, want_addr)
52463    }
52464
52465    /// Retrieves creation information from the socket.
52466    pub fn r#get_info(
52467        &self,
52468    ) -> fidl::client::QueryResponseFut<
52469        StreamSocketGetInfoResult,
52470        fidl::encoding::DefaultFuchsiaResourceDialect,
52471    > {
52472        StreamSocketProxyInterface::r#get_info(self)
52473    }
52474
52475    /// Set `SOL_TCP` -> `TCP_NODELAY`.
52476    pub fn r#set_tcp_no_delay(
52477        &self,
52478        mut value: bool,
52479    ) -> fidl::client::QueryResponseFut<
52480        StreamSocketSetTcpNoDelayResult,
52481        fidl::encoding::DefaultFuchsiaResourceDialect,
52482    > {
52483        StreamSocketProxyInterface::r#set_tcp_no_delay(self, value)
52484    }
52485
52486    /// Get `SOL_TCP` -> `TCP_NODELAY`.
52487    pub fn r#get_tcp_no_delay(
52488        &self,
52489    ) -> fidl::client::QueryResponseFut<
52490        StreamSocketGetTcpNoDelayResult,
52491        fidl::encoding::DefaultFuchsiaResourceDialect,
52492    > {
52493        StreamSocketProxyInterface::r#get_tcp_no_delay(self)
52494    }
52495
52496    /// Set `SOL_TCP` -> `TCP_MAXSEG`.
52497    pub fn r#set_tcp_max_segment(
52498        &self,
52499        mut value_bytes: u32,
52500    ) -> fidl::client::QueryResponseFut<
52501        StreamSocketSetTcpMaxSegmentResult,
52502        fidl::encoding::DefaultFuchsiaResourceDialect,
52503    > {
52504        StreamSocketProxyInterface::r#set_tcp_max_segment(self, value_bytes)
52505    }
52506
52507    /// Get `SOL_TCP` -> `TCP_MAXSEG`.
52508    pub fn r#get_tcp_max_segment(
52509        &self,
52510    ) -> fidl::client::QueryResponseFut<
52511        StreamSocketGetTcpMaxSegmentResult,
52512        fidl::encoding::DefaultFuchsiaResourceDialect,
52513    > {
52514        StreamSocketProxyInterface::r#get_tcp_max_segment(self)
52515    }
52516
52517    /// Set `SOL_TCP` -> `TCP_CORK`.
52518    pub fn r#set_tcp_cork(
52519        &self,
52520        mut value: bool,
52521    ) -> fidl::client::QueryResponseFut<
52522        StreamSocketSetTcpCorkResult,
52523        fidl::encoding::DefaultFuchsiaResourceDialect,
52524    > {
52525        StreamSocketProxyInterface::r#set_tcp_cork(self, value)
52526    }
52527
52528    /// Get `SOL_TCP` -> `TCP_CORK`.
52529    pub fn r#get_tcp_cork(
52530        &self,
52531    ) -> fidl::client::QueryResponseFut<
52532        StreamSocketGetTcpCorkResult,
52533        fidl::encoding::DefaultFuchsiaResourceDialect,
52534    > {
52535        StreamSocketProxyInterface::r#get_tcp_cork(self)
52536    }
52537
52538    /// Set `SOL_TCP` -> `TCP_KEEPIDLE`.
52539    pub fn r#set_tcp_keep_alive_idle(
52540        &self,
52541        mut value_secs: u32,
52542    ) -> fidl::client::QueryResponseFut<
52543        StreamSocketSetTcpKeepAliveIdleResult,
52544        fidl::encoding::DefaultFuchsiaResourceDialect,
52545    > {
52546        StreamSocketProxyInterface::r#set_tcp_keep_alive_idle(self, value_secs)
52547    }
52548
52549    /// Get `SOL_TCP` -> `TCP_KEEPIDLE`.
52550    pub fn r#get_tcp_keep_alive_idle(
52551        &self,
52552    ) -> fidl::client::QueryResponseFut<
52553        StreamSocketGetTcpKeepAliveIdleResult,
52554        fidl::encoding::DefaultFuchsiaResourceDialect,
52555    > {
52556        StreamSocketProxyInterface::r#get_tcp_keep_alive_idle(self)
52557    }
52558
52559    /// Set `SOL_TCP` -> `TCP_KEEPINTVL`.
52560    pub fn r#set_tcp_keep_alive_interval(
52561        &self,
52562        mut value_secs: u32,
52563    ) -> fidl::client::QueryResponseFut<
52564        StreamSocketSetTcpKeepAliveIntervalResult,
52565        fidl::encoding::DefaultFuchsiaResourceDialect,
52566    > {
52567        StreamSocketProxyInterface::r#set_tcp_keep_alive_interval(self, value_secs)
52568    }
52569
52570    /// Get `SOL_TCP` -> `TCP_KEEPINTVL`.
52571    pub fn r#get_tcp_keep_alive_interval(
52572        &self,
52573    ) -> fidl::client::QueryResponseFut<
52574        StreamSocketGetTcpKeepAliveIntervalResult,
52575        fidl::encoding::DefaultFuchsiaResourceDialect,
52576    > {
52577        StreamSocketProxyInterface::r#get_tcp_keep_alive_interval(self)
52578    }
52579
52580    /// Set `SOL_TCP` -> `TCP_KEEPCNT`.
52581    pub fn r#set_tcp_keep_alive_count(
52582        &self,
52583        mut value: u32,
52584    ) -> fidl::client::QueryResponseFut<
52585        StreamSocketSetTcpKeepAliveCountResult,
52586        fidl::encoding::DefaultFuchsiaResourceDialect,
52587    > {
52588        StreamSocketProxyInterface::r#set_tcp_keep_alive_count(self, value)
52589    }
52590
52591    /// Get `SOL_TCP` -> `TCP_KEEPCNT`.
52592    pub fn r#get_tcp_keep_alive_count(
52593        &self,
52594    ) -> fidl::client::QueryResponseFut<
52595        StreamSocketGetTcpKeepAliveCountResult,
52596        fidl::encoding::DefaultFuchsiaResourceDialect,
52597    > {
52598        StreamSocketProxyInterface::r#get_tcp_keep_alive_count(self)
52599    }
52600
52601    /// Set `SOL_TCP` -> `TCP_SYNCNT`.
52602    pub fn r#set_tcp_syn_count(
52603        &self,
52604        mut value: u32,
52605    ) -> fidl::client::QueryResponseFut<
52606        StreamSocketSetTcpSynCountResult,
52607        fidl::encoding::DefaultFuchsiaResourceDialect,
52608    > {
52609        StreamSocketProxyInterface::r#set_tcp_syn_count(self, value)
52610    }
52611
52612    /// Get `SOL_TCP` -> `TCP_SYNCNT`.
52613    pub fn r#get_tcp_syn_count(
52614        &self,
52615    ) -> fidl::client::QueryResponseFut<
52616        StreamSocketGetTcpSynCountResult,
52617        fidl::encoding::DefaultFuchsiaResourceDialect,
52618    > {
52619        StreamSocketProxyInterface::r#get_tcp_syn_count(self)
52620    }
52621
52622    /// Set `SOL_TCP` -> `TCP_LINGER2`.
52623    pub fn r#set_tcp_linger(
52624        &self,
52625        mut value_secs: &OptionalUint32,
52626    ) -> fidl::client::QueryResponseFut<
52627        StreamSocketSetTcpLingerResult,
52628        fidl::encoding::DefaultFuchsiaResourceDialect,
52629    > {
52630        StreamSocketProxyInterface::r#set_tcp_linger(self, value_secs)
52631    }
52632
52633    /// Get `SOL_TCP` -> `TCP_LINGER2`.
52634    pub fn r#get_tcp_linger(
52635        &self,
52636    ) -> fidl::client::QueryResponseFut<
52637        StreamSocketGetTcpLingerResult,
52638        fidl::encoding::DefaultFuchsiaResourceDialect,
52639    > {
52640        StreamSocketProxyInterface::r#get_tcp_linger(self)
52641    }
52642
52643    /// Set `SOL_TCP` -> `TCP_DEFER_ACCEPT`.
52644    pub fn r#set_tcp_defer_accept(
52645        &self,
52646        mut value_secs: u32,
52647    ) -> fidl::client::QueryResponseFut<
52648        StreamSocketSetTcpDeferAcceptResult,
52649        fidl::encoding::DefaultFuchsiaResourceDialect,
52650    > {
52651        StreamSocketProxyInterface::r#set_tcp_defer_accept(self, value_secs)
52652    }
52653
52654    /// Get `SOL_TCP` -> `TCP_DEFER_ACCEPT`.
52655    pub fn r#get_tcp_defer_accept(
52656        &self,
52657    ) -> fidl::client::QueryResponseFut<
52658        StreamSocketGetTcpDeferAcceptResult,
52659        fidl::encoding::DefaultFuchsiaResourceDialect,
52660    > {
52661        StreamSocketProxyInterface::r#get_tcp_defer_accept(self)
52662    }
52663
52664    /// Set `SOL_TCP` -> `TCP_WINDOW_CLAMP`.
52665    pub fn r#set_tcp_window_clamp(
52666        &self,
52667        mut value: u32,
52668    ) -> fidl::client::QueryResponseFut<
52669        StreamSocketSetTcpWindowClampResult,
52670        fidl::encoding::DefaultFuchsiaResourceDialect,
52671    > {
52672        StreamSocketProxyInterface::r#set_tcp_window_clamp(self, value)
52673    }
52674
52675    /// Get `SOL_TCP` -> `TCP_WINDOW_CLAMP`.
52676    pub fn r#get_tcp_window_clamp(
52677        &self,
52678    ) -> fidl::client::QueryResponseFut<
52679        StreamSocketGetTcpWindowClampResult,
52680        fidl::encoding::DefaultFuchsiaResourceDialect,
52681    > {
52682        StreamSocketProxyInterface::r#get_tcp_window_clamp(self)
52683    }
52684
52685    /// Get `SOL_TCP` -> `TCP_INFO`.
52686    pub fn r#get_tcp_info(
52687        &self,
52688    ) -> fidl::client::QueryResponseFut<
52689        StreamSocketGetTcpInfoResult,
52690        fidl::encoding::DefaultFuchsiaResourceDialect,
52691    > {
52692        StreamSocketProxyInterface::r#get_tcp_info(self)
52693    }
52694
52695    /// Set `SOL_TCP` -> `TCP_QUICKACK`.
52696    pub fn r#set_tcp_quick_ack(
52697        &self,
52698        mut value: bool,
52699    ) -> fidl::client::QueryResponseFut<
52700        StreamSocketSetTcpQuickAckResult,
52701        fidl::encoding::DefaultFuchsiaResourceDialect,
52702    > {
52703        StreamSocketProxyInterface::r#set_tcp_quick_ack(self, value)
52704    }
52705
52706    /// Get `SOL_TCP` -> `TCP_QUICKACK`.
52707    pub fn r#get_tcp_quick_ack(
52708        &self,
52709    ) -> fidl::client::QueryResponseFut<
52710        StreamSocketGetTcpQuickAckResult,
52711        fidl::encoding::DefaultFuchsiaResourceDialect,
52712    > {
52713        StreamSocketProxyInterface::r#get_tcp_quick_ack(self)
52714    }
52715
52716    /// Set `SOL_TCP` -> `TCP_CONGESTION`.
52717    pub fn r#set_tcp_congestion(
52718        &self,
52719        mut value: TcpCongestionControl,
52720    ) -> fidl::client::QueryResponseFut<
52721        StreamSocketSetTcpCongestionResult,
52722        fidl::encoding::DefaultFuchsiaResourceDialect,
52723    > {
52724        StreamSocketProxyInterface::r#set_tcp_congestion(self, value)
52725    }
52726
52727    /// Get `SOL_TCP` -> `TCP_CONGESTION`.
52728    pub fn r#get_tcp_congestion(
52729        &self,
52730    ) -> fidl::client::QueryResponseFut<
52731        StreamSocketGetTcpCongestionResult,
52732        fidl::encoding::DefaultFuchsiaResourceDialect,
52733    > {
52734        StreamSocketProxyInterface::r#get_tcp_congestion(self)
52735    }
52736
52737    /// Set `SOL_TCP` -> `TCP_USER_TIMEOUT`.
52738    pub fn r#set_tcp_user_timeout(
52739        &self,
52740        mut value_millis: u32,
52741    ) -> fidl::client::QueryResponseFut<
52742        StreamSocketSetTcpUserTimeoutResult,
52743        fidl::encoding::DefaultFuchsiaResourceDialect,
52744    > {
52745        StreamSocketProxyInterface::r#set_tcp_user_timeout(self, value_millis)
52746    }
52747
52748    /// Get `SOL_TCP` -> `TCP_USER_TIMEOUT`.
52749    pub fn r#get_tcp_user_timeout(
52750        &self,
52751    ) -> fidl::client::QueryResponseFut<
52752        StreamSocketGetTcpUserTimeoutResult,
52753        fidl::encoding::DefaultFuchsiaResourceDialect,
52754    > {
52755        StreamSocketProxyInterface::r#get_tcp_user_timeout(self)
52756    }
52757}
52758
52759impl StreamSocketProxyInterface for StreamSocketProxy {
52760    fn r#clone(
52761        &self,
52762        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
52763    ) -> Result<(), fidl::Error> {
52764        self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
52765            (request,),
52766            0x20d8a7aba2168a79,
52767            fidl::encoding::DynamicFlags::empty(),
52768        )
52769    }
52770
52771    type CloseResponseFut = fidl::client::QueryResponseFut<
52772        fidl_fuchsia_unknown::CloseableCloseResult,
52773        fidl::encoding::DefaultFuchsiaResourceDialect,
52774    >;
52775    fn r#close(&self) -> Self::CloseResponseFut {
52776        fn _decode(
52777            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
52778        ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
52779            let _response = fidl::client::decode_transaction_body::<
52780                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
52781                fidl::encoding::DefaultFuchsiaResourceDialect,
52782                0x5ac5d459ad7f657e,
52783            >(_buf?)?;
52784            Ok(_response.map(|x| x))
52785        }
52786        self.client.send_query_and_decode::<
52787            fidl::encoding::EmptyPayload,
52788            fidl_fuchsia_unknown::CloseableCloseResult,
52789        >(
52790            (),
52791            0x5ac5d459ad7f657e,
52792            fidl::encoding::DynamicFlags::empty(),
52793            _decode,
52794        )
52795    }
52796
52797    type QueryResponseFut =
52798        fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>;
52799    fn r#query(&self) -> Self::QueryResponseFut {
52800        fn _decode(
52801            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
52802        ) -> Result<Vec<u8>, fidl::Error> {
52803            let _response = fidl::client::decode_transaction_body::<
52804                fidl_fuchsia_unknown::QueryableQueryResponse,
52805                fidl::encoding::DefaultFuchsiaResourceDialect,
52806                0x2658edee9decfc06,
52807            >(_buf?)?;
52808            Ok(_response.protocol)
52809        }
52810        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<u8>>(
52811            (),
52812            0x2658edee9decfc06,
52813            fidl::encoding::DynamicFlags::empty(),
52814            _decode,
52815        )
52816    }
52817
52818    type SetReuseAddressResponseFut = fidl::client::QueryResponseFut<
52819        BaseSocketSetReuseAddressResult,
52820        fidl::encoding::DefaultFuchsiaResourceDialect,
52821    >;
52822    fn r#set_reuse_address(&self, mut value: bool) -> Self::SetReuseAddressResponseFut {
52823        fn _decode(
52824            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
52825        ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
52826            let _response = fidl::client::decode_transaction_body::<
52827                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
52828                fidl::encoding::DefaultFuchsiaResourceDialect,
52829                0x1fd74ee8b9a4a876,
52830            >(_buf?)?;
52831            Ok(_response.map(|x| x))
52832        }
52833        self.client.send_query_and_decode::<
52834            BaseSocketSetReuseAddressRequest,
52835            BaseSocketSetReuseAddressResult,
52836        >(
52837            (value,),
52838            0x1fd74ee8b9a4a876,
52839            fidl::encoding::DynamicFlags::empty(),
52840            _decode,
52841        )
52842    }
52843
52844    type GetReuseAddressResponseFut = fidl::client::QueryResponseFut<
52845        BaseSocketGetReuseAddressResult,
52846        fidl::encoding::DefaultFuchsiaResourceDialect,
52847    >;
52848    fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut {
52849        fn _decode(
52850            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
52851        ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
52852            let _response = fidl::client::decode_transaction_body::<
52853                fidl::encoding::ResultType<
52854                    BaseSocketGetReuseAddressResponse,
52855                    fidl_fuchsia_posix::Errno,
52856                >,
52857                fidl::encoding::DefaultFuchsiaResourceDialect,
52858                0x67b7206b8d1bc0a5,
52859            >(_buf?)?;
52860            Ok(_response.map(|x| x.value))
52861        }
52862        self.client
52863            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReuseAddressResult>(
52864                (),
52865                0x67b7206b8d1bc0a5,
52866                fidl::encoding::DynamicFlags::empty(),
52867                _decode,
52868            )
52869    }
52870
52871    type GetErrorResponseFut = fidl::client::QueryResponseFut<
52872        BaseSocketGetErrorResult,
52873        fidl::encoding::DefaultFuchsiaResourceDialect,
52874    >;
52875    fn r#get_error(&self) -> Self::GetErrorResponseFut {
52876        fn _decode(
52877            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
52878        ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
52879            let _response = fidl::client::decode_transaction_body::<
52880                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
52881                fidl::encoding::DefaultFuchsiaResourceDialect,
52882                0x5aad39b33e5f6ebb,
52883            >(_buf?)?;
52884            Ok(_response.map(|x| x))
52885        }
52886        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetErrorResult>(
52887            (),
52888            0x5aad39b33e5f6ebb,
52889            fidl::encoding::DynamicFlags::empty(),
52890            _decode,
52891        )
52892    }
52893
52894    type SetBroadcastResponseFut = fidl::client::QueryResponseFut<
52895        BaseSocketSetBroadcastResult,
52896        fidl::encoding::DefaultFuchsiaResourceDialect,
52897    >;
52898    fn r#set_broadcast(&self, mut value: bool) -> Self::SetBroadcastResponseFut {
52899        fn _decode(
52900            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
52901        ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
52902            let _response = fidl::client::decode_transaction_body::<
52903                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
52904                fidl::encoding::DefaultFuchsiaResourceDialect,
52905                0x6023e081ce3cd947,
52906            >(_buf?)?;
52907            Ok(_response.map(|x| x))
52908        }
52909        self.client
52910            .send_query_and_decode::<BaseSocketSetBroadcastRequest, BaseSocketSetBroadcastResult>(
52911                (value,),
52912                0x6023e081ce3cd947,
52913                fidl::encoding::DynamicFlags::empty(),
52914                _decode,
52915            )
52916    }
52917
52918    type GetBroadcastResponseFut = fidl::client::QueryResponseFut<
52919        BaseSocketGetBroadcastResult,
52920        fidl::encoding::DefaultFuchsiaResourceDialect,
52921    >;
52922    fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut {
52923        fn _decode(
52924            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
52925        ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
52926            let _response = fidl::client::decode_transaction_body::<
52927                fidl::encoding::ResultType<
52928                    BaseSocketGetBroadcastResponse,
52929                    fidl_fuchsia_posix::Errno,
52930                >,
52931                fidl::encoding::DefaultFuchsiaResourceDialect,
52932                0x68796fc556f9780d,
52933            >(_buf?)?;
52934            Ok(_response.map(|x| x.value))
52935        }
52936        self.client
52937            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBroadcastResult>(
52938                (),
52939                0x68796fc556f9780d,
52940                fidl::encoding::DynamicFlags::empty(),
52941                _decode,
52942            )
52943    }
52944
52945    type SetSendBufferResponseFut = fidl::client::QueryResponseFut<
52946        BaseSocketSetSendBufferResult,
52947        fidl::encoding::DefaultFuchsiaResourceDialect,
52948    >;
52949    fn r#set_send_buffer(&self, mut value_bytes: u64) -> Self::SetSendBufferResponseFut {
52950        fn _decode(
52951            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
52952        ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
52953            let _response = fidl::client::decode_transaction_body::<
52954                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
52955                fidl::encoding::DefaultFuchsiaResourceDialect,
52956                0x756eac32d73a7a70,
52957            >(_buf?)?;
52958            Ok(_response.map(|x| x))
52959        }
52960        self.client
52961            .send_query_and_decode::<BaseSocketSetSendBufferRequest, BaseSocketSetSendBufferResult>(
52962                (value_bytes,),
52963                0x756eac32d73a7a70,
52964                fidl::encoding::DynamicFlags::empty(),
52965                _decode,
52966            )
52967    }
52968
52969    type GetSendBufferResponseFut = fidl::client::QueryResponseFut<
52970        BaseSocketGetSendBufferResult,
52971        fidl::encoding::DefaultFuchsiaResourceDialect,
52972    >;
52973    fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut {
52974        fn _decode(
52975            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
52976        ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
52977            let _response = fidl::client::decode_transaction_body::<
52978                fidl::encoding::ResultType<
52979                    BaseSocketGetSendBufferResponse,
52980                    fidl_fuchsia_posix::Errno,
52981                >,
52982                fidl::encoding::DefaultFuchsiaResourceDialect,
52983                0x78a52fd9c7b2410b,
52984            >(_buf?)?;
52985            Ok(_response.map(|x| x.value_bytes))
52986        }
52987        self.client
52988            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetSendBufferResult>(
52989                (),
52990                0x78a52fd9c7b2410b,
52991                fidl::encoding::DynamicFlags::empty(),
52992                _decode,
52993            )
52994    }
52995
52996    type SetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
52997        BaseSocketSetReceiveBufferResult,
52998        fidl::encoding::DefaultFuchsiaResourceDialect,
52999    >;
53000    fn r#set_receive_buffer(&self, mut value_bytes: u64) -> Self::SetReceiveBufferResponseFut {
53001        fn _decode(
53002            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53003        ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
53004            let _response = fidl::client::decode_transaction_body::<
53005                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53006                fidl::encoding::DefaultFuchsiaResourceDialect,
53007                0x6b0cf2f1919c7001,
53008            >(_buf?)?;
53009            Ok(_response.map(|x| x))
53010        }
53011        self.client.send_query_and_decode::<
53012            BaseSocketSetReceiveBufferRequest,
53013            BaseSocketSetReceiveBufferResult,
53014        >(
53015            (value_bytes,),
53016            0x6b0cf2f1919c7001,
53017            fidl::encoding::DynamicFlags::empty(),
53018            _decode,
53019        )
53020    }
53021
53022    type GetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
53023        BaseSocketGetReceiveBufferResult,
53024        fidl::encoding::DefaultFuchsiaResourceDialect,
53025    >;
53026    fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut {
53027        fn _decode(
53028            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53029        ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
53030            let _response = fidl::client::decode_transaction_body::<
53031                fidl::encoding::ResultType<
53032                    BaseSocketGetReceiveBufferResponse,
53033                    fidl_fuchsia_posix::Errno,
53034                >,
53035                fidl::encoding::DefaultFuchsiaResourceDialect,
53036                0x14c1a4b64f709e5c,
53037            >(_buf?)?;
53038            Ok(_response.map(|x| x.value_bytes))
53039        }
53040        self.client.send_query_and_decode::<
53041            fidl::encoding::EmptyPayload,
53042            BaseSocketGetReceiveBufferResult,
53043        >(
53044            (),
53045            0x14c1a4b64f709e5c,
53046            fidl::encoding::DynamicFlags::empty(),
53047            _decode,
53048        )
53049    }
53050
53051    type SetKeepAliveResponseFut = fidl::client::QueryResponseFut<
53052        BaseSocketSetKeepAliveResult,
53053        fidl::encoding::DefaultFuchsiaResourceDialect,
53054    >;
53055    fn r#set_keep_alive(&self, mut value: bool) -> Self::SetKeepAliveResponseFut {
53056        fn _decode(
53057            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53058        ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
53059            let _response = fidl::client::decode_transaction_body::<
53060                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53061                fidl::encoding::DefaultFuchsiaResourceDialect,
53062                0x572df8f0b920d2c7,
53063            >(_buf?)?;
53064            Ok(_response.map(|x| x))
53065        }
53066        self.client
53067            .send_query_and_decode::<BaseSocketSetKeepAliveRequest, BaseSocketSetKeepAliveResult>(
53068                (value,),
53069                0x572df8f0b920d2c7,
53070                fidl::encoding::DynamicFlags::empty(),
53071                _decode,
53072            )
53073    }
53074
53075    type GetKeepAliveResponseFut = fidl::client::QueryResponseFut<
53076        BaseSocketGetKeepAliveResult,
53077        fidl::encoding::DefaultFuchsiaResourceDialect,
53078    >;
53079    fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut {
53080        fn _decode(
53081            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53082        ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
53083            let _response = fidl::client::decode_transaction_body::<
53084                fidl::encoding::ResultType<
53085                    BaseSocketGetKeepAliveResponse,
53086                    fidl_fuchsia_posix::Errno,
53087                >,
53088                fidl::encoding::DefaultFuchsiaResourceDialect,
53089                0x2dd29d3215f2c9d2,
53090            >(_buf?)?;
53091            Ok(_response.map(|x| x.value))
53092        }
53093        self.client
53094            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetKeepAliveResult>(
53095                (),
53096                0x2dd29d3215f2c9d2,
53097                fidl::encoding::DynamicFlags::empty(),
53098                _decode,
53099            )
53100    }
53101
53102    type SetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
53103        BaseSocketSetOutOfBandInlineResult,
53104        fidl::encoding::DefaultFuchsiaResourceDialect,
53105    >;
53106    fn r#set_out_of_band_inline(&self, mut value: bool) -> Self::SetOutOfBandInlineResponseFut {
53107        fn _decode(
53108            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53109        ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
53110            let _response = fidl::client::decode_transaction_body::<
53111                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53112                fidl::encoding::DefaultFuchsiaResourceDialect,
53113                0x3ecb49968bee439,
53114            >(_buf?)?;
53115            Ok(_response.map(|x| x))
53116        }
53117        self.client.send_query_and_decode::<
53118            BaseSocketSetOutOfBandInlineRequest,
53119            BaseSocketSetOutOfBandInlineResult,
53120        >(
53121            (value,),
53122            0x3ecb49968bee439,
53123            fidl::encoding::DynamicFlags::empty(),
53124            _decode,
53125        )
53126    }
53127
53128    type GetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
53129        BaseSocketGetOutOfBandInlineResult,
53130        fidl::encoding::DefaultFuchsiaResourceDialect,
53131    >;
53132    fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut {
53133        fn _decode(
53134            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53135        ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
53136            let _response = fidl::client::decode_transaction_body::<
53137                fidl::encoding::ResultType<
53138                    BaseSocketGetOutOfBandInlineResponse,
53139                    fidl_fuchsia_posix::Errno,
53140                >,
53141                fidl::encoding::DefaultFuchsiaResourceDialect,
53142                0x348c1ab3aeca1745,
53143            >(_buf?)?;
53144            Ok(_response.map(|x| x.value))
53145        }
53146        self.client.send_query_and_decode::<
53147            fidl::encoding::EmptyPayload,
53148            BaseSocketGetOutOfBandInlineResult,
53149        >(
53150            (),
53151            0x348c1ab3aeca1745,
53152            fidl::encoding::DynamicFlags::empty(),
53153            _decode,
53154        )
53155    }
53156
53157    type SetNoCheckResponseFut = fidl::client::QueryResponseFut<
53158        BaseSocketSetNoCheckResult,
53159        fidl::encoding::DefaultFuchsiaResourceDialect,
53160    >;
53161    fn r#set_no_check(&self, mut value: bool) -> Self::SetNoCheckResponseFut {
53162        fn _decode(
53163            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53164        ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
53165            let _response = fidl::client::decode_transaction_body::<
53166                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53167                fidl::encoding::DefaultFuchsiaResourceDialect,
53168                0x6bbf00c53a4c78c2,
53169            >(_buf?)?;
53170            Ok(_response.map(|x| x))
53171        }
53172        self.client
53173            .send_query_and_decode::<BaseSocketSetNoCheckRequest, BaseSocketSetNoCheckResult>(
53174                (value,),
53175                0x6bbf00c53a4c78c2,
53176                fidl::encoding::DynamicFlags::empty(),
53177                _decode,
53178            )
53179    }
53180
53181    type GetNoCheckResponseFut = fidl::client::QueryResponseFut<
53182        BaseSocketGetNoCheckResult,
53183        fidl::encoding::DefaultFuchsiaResourceDialect,
53184    >;
53185    fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut {
53186        fn _decode(
53187            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53188        ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
53189            let _response = fidl::client::decode_transaction_body::<
53190                fidl::encoding::ResultType<BaseSocketGetNoCheckResponse, fidl_fuchsia_posix::Errno>,
53191                fidl::encoding::DefaultFuchsiaResourceDialect,
53192                0x2cd4249286417694,
53193            >(_buf?)?;
53194            Ok(_response.map(|x| x.value))
53195        }
53196        self.client
53197            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetNoCheckResult>(
53198                (),
53199                0x2cd4249286417694,
53200                fidl::encoding::DynamicFlags::empty(),
53201                _decode,
53202            )
53203    }
53204
53205    type SetLingerResponseFut = fidl::client::QueryResponseFut<
53206        BaseSocketSetLingerResult,
53207        fidl::encoding::DefaultFuchsiaResourceDialect,
53208    >;
53209    fn r#set_linger(&self, mut linger: bool, mut length_secs: u32) -> Self::SetLingerResponseFut {
53210        fn _decode(
53211            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53212        ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
53213            let _response = fidl::client::decode_transaction_body::<
53214                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53215                fidl::encoding::DefaultFuchsiaResourceDialect,
53216                0x45386351246e998e,
53217            >(_buf?)?;
53218            Ok(_response.map(|x| x))
53219        }
53220        self.client.send_query_and_decode::<BaseSocketSetLingerRequest, BaseSocketSetLingerResult>(
53221            (linger, length_secs),
53222            0x45386351246e998e,
53223            fidl::encoding::DynamicFlags::empty(),
53224            _decode,
53225        )
53226    }
53227
53228    type GetLingerResponseFut = fidl::client::QueryResponseFut<
53229        BaseSocketGetLingerResult,
53230        fidl::encoding::DefaultFuchsiaResourceDialect,
53231    >;
53232    fn r#get_linger(&self) -> Self::GetLingerResponseFut {
53233        fn _decode(
53234            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53235        ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
53236            let _response = fidl::client::decode_transaction_body::<
53237                fidl::encoding::ResultType<BaseSocketGetLingerResponse, fidl_fuchsia_posix::Errno>,
53238                fidl::encoding::DefaultFuchsiaResourceDialect,
53239                0x48eb20fc5ccb0e45,
53240            >(_buf?)?;
53241            Ok(_response.map(|x| (x.linger, x.length_secs)))
53242        }
53243        self.client
53244            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetLingerResult>(
53245                (),
53246                0x48eb20fc5ccb0e45,
53247                fidl::encoding::DynamicFlags::empty(),
53248                _decode,
53249            )
53250    }
53251
53252    type SetReusePortResponseFut = fidl::client::QueryResponseFut<
53253        BaseSocketSetReusePortResult,
53254        fidl::encoding::DefaultFuchsiaResourceDialect,
53255    >;
53256    fn r#set_reuse_port(&self, mut value: bool) -> Self::SetReusePortResponseFut {
53257        fn _decode(
53258            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53259        ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
53260            let _response = fidl::client::decode_transaction_body::<
53261                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53262                fidl::encoding::DefaultFuchsiaResourceDialect,
53263                0x24dd3e5cb36d9ccb,
53264            >(_buf?)?;
53265            Ok(_response.map(|x| x))
53266        }
53267        self.client
53268            .send_query_and_decode::<BaseSocketSetReusePortRequest, BaseSocketSetReusePortResult>(
53269                (value,),
53270                0x24dd3e5cb36d9ccb,
53271                fidl::encoding::DynamicFlags::empty(),
53272                _decode,
53273            )
53274    }
53275
53276    type GetReusePortResponseFut = fidl::client::QueryResponseFut<
53277        BaseSocketGetReusePortResult,
53278        fidl::encoding::DefaultFuchsiaResourceDialect,
53279    >;
53280    fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut {
53281        fn _decode(
53282            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53283        ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
53284            let _response = fidl::client::decode_transaction_body::<
53285                fidl::encoding::ResultType<
53286                    BaseSocketGetReusePortResponse,
53287                    fidl_fuchsia_posix::Errno,
53288                >,
53289                fidl::encoding::DefaultFuchsiaResourceDialect,
53290                0x7a112c1ab54ff828,
53291            >(_buf?)?;
53292            Ok(_response.map(|x| x.value))
53293        }
53294        self.client
53295            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReusePortResult>(
53296                (),
53297                0x7a112c1ab54ff828,
53298                fidl::encoding::DynamicFlags::empty(),
53299                _decode,
53300            )
53301    }
53302
53303    type GetAcceptConnResponseFut = fidl::client::QueryResponseFut<
53304        BaseSocketGetAcceptConnResult,
53305        fidl::encoding::DefaultFuchsiaResourceDialect,
53306    >;
53307    fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut {
53308        fn _decode(
53309            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53310        ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
53311            let _response = fidl::client::decode_transaction_body::<
53312                fidl::encoding::ResultType<
53313                    BaseSocketGetAcceptConnResponse,
53314                    fidl_fuchsia_posix::Errno,
53315                >,
53316                fidl::encoding::DefaultFuchsiaResourceDialect,
53317                0x67ce6db6c2ec8966,
53318            >(_buf?)?;
53319            Ok(_response.map(|x| x.value))
53320        }
53321        self.client
53322            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetAcceptConnResult>(
53323                (),
53324                0x67ce6db6c2ec8966,
53325                fidl::encoding::DynamicFlags::empty(),
53326                _decode,
53327            )
53328    }
53329
53330    type SetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
53331        BaseSocketSetBindToDeviceResult,
53332        fidl::encoding::DefaultFuchsiaResourceDialect,
53333    >;
53334    fn r#set_bind_to_device(&self, mut value: &str) -> Self::SetBindToDeviceResponseFut {
53335        fn _decode(
53336            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53337        ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
53338            let _response = fidl::client::decode_transaction_body::<
53339                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53340                fidl::encoding::DefaultFuchsiaResourceDialect,
53341                0x2118b483f28aafc4,
53342            >(_buf?)?;
53343            Ok(_response.map(|x| x))
53344        }
53345        self.client.send_query_and_decode::<
53346            BaseSocketSetBindToDeviceRequest,
53347            BaseSocketSetBindToDeviceResult,
53348        >(
53349            (value,),
53350            0x2118b483f28aafc4,
53351            fidl::encoding::DynamicFlags::empty(),
53352            _decode,
53353        )
53354    }
53355
53356    type GetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
53357        BaseSocketGetBindToDeviceResult,
53358        fidl::encoding::DefaultFuchsiaResourceDialect,
53359    >;
53360    fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut {
53361        fn _decode(
53362            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53363        ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
53364            let _response = fidl::client::decode_transaction_body::<
53365                fidl::encoding::ResultType<
53366                    BaseSocketGetBindToDeviceResponse,
53367                    fidl_fuchsia_posix::Errno,
53368                >,
53369                fidl::encoding::DefaultFuchsiaResourceDialect,
53370                0x1ab1fbf0ef7906c8,
53371            >(_buf?)?;
53372            Ok(_response.map(|x| x.value))
53373        }
53374        self.client
53375            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBindToDeviceResult>(
53376                (),
53377                0x1ab1fbf0ef7906c8,
53378                fidl::encoding::DynamicFlags::empty(),
53379                _decode,
53380            )
53381    }
53382
53383    type SetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
53384        BaseSocketSetBindToInterfaceIndexResult,
53385        fidl::encoding::DefaultFuchsiaResourceDialect,
53386    >;
53387    fn r#set_bind_to_interface_index(
53388        &self,
53389        mut value: u64,
53390    ) -> Self::SetBindToInterfaceIndexResponseFut {
53391        fn _decode(
53392            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53393        ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
53394            let _response = fidl::client::decode_transaction_body::<
53395                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53396                fidl::encoding::DefaultFuchsiaResourceDialect,
53397                0x6e387a0def00821,
53398            >(_buf?)?;
53399            Ok(_response.map(|x| x))
53400        }
53401        self.client.send_query_and_decode::<
53402            BaseSocketSetBindToInterfaceIndexRequest,
53403            BaseSocketSetBindToInterfaceIndexResult,
53404        >(
53405            (value,),
53406            0x6e387a0def00821,
53407            fidl::encoding::DynamicFlags::empty(),
53408            _decode,
53409        )
53410    }
53411
53412    type GetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
53413        BaseSocketGetBindToInterfaceIndexResult,
53414        fidl::encoding::DefaultFuchsiaResourceDialect,
53415    >;
53416    fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut {
53417        fn _decode(
53418            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53419        ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
53420            let _response = fidl::client::decode_transaction_body::<
53421                fidl::encoding::ResultType<
53422                    BaseSocketGetBindToInterfaceIndexResponse,
53423                    fidl_fuchsia_posix::Errno,
53424                >,
53425                fidl::encoding::DefaultFuchsiaResourceDialect,
53426                0x59c31dd3e3078295,
53427            >(_buf?)?;
53428            Ok(_response.map(|x| x.value))
53429        }
53430        self.client.send_query_and_decode::<
53431            fidl::encoding::EmptyPayload,
53432            BaseSocketGetBindToInterfaceIndexResult,
53433        >(
53434            (),
53435            0x59c31dd3e3078295,
53436            fidl::encoding::DynamicFlags::empty(),
53437            _decode,
53438        )
53439    }
53440
53441    type SetTimestampResponseFut = fidl::client::QueryResponseFut<
53442        BaseSocketSetTimestampResult,
53443        fidl::encoding::DefaultFuchsiaResourceDialect,
53444    >;
53445    fn r#set_timestamp(&self, mut value: TimestampOption) -> Self::SetTimestampResponseFut {
53446        fn _decode(
53447            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53448        ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
53449            let _response = fidl::client::decode_transaction_body::<
53450                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53451                fidl::encoding::DefaultFuchsiaResourceDialect,
53452                0x285d6516c263d839,
53453            >(_buf?)?;
53454            Ok(_response.map(|x| x))
53455        }
53456        self.client
53457            .send_query_and_decode::<BaseSocketSetTimestampRequest, BaseSocketSetTimestampResult>(
53458                (value,),
53459                0x285d6516c263d839,
53460                fidl::encoding::DynamicFlags::empty(),
53461                _decode,
53462            )
53463    }
53464
53465    type GetTimestampResponseFut = fidl::client::QueryResponseFut<
53466        BaseSocketGetTimestampResult,
53467        fidl::encoding::DefaultFuchsiaResourceDialect,
53468    >;
53469    fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut {
53470        fn _decode(
53471            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53472        ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
53473            let _response = fidl::client::decode_transaction_body::<
53474                fidl::encoding::ResultType<
53475                    BaseSocketGetTimestampResponse,
53476                    fidl_fuchsia_posix::Errno,
53477                >,
53478                fidl::encoding::DefaultFuchsiaResourceDialect,
53479                0x49f2fffbbcc2bd27,
53480            >(_buf?)?;
53481            Ok(_response.map(|x| x.value))
53482        }
53483        self.client
53484            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetTimestampResult>(
53485                (),
53486                0x49f2fffbbcc2bd27,
53487                fidl::encoding::DynamicFlags::empty(),
53488                _decode,
53489            )
53490    }
53491
53492    type SetMarkResponseFut = fidl::client::QueryResponseFut<
53493        BaseSocketSetMarkResult,
53494        fidl::encoding::DefaultFuchsiaResourceDialect,
53495    >;
53496    fn r#set_mark(
53497        &self,
53498        mut domain: fidl_fuchsia_net::MarkDomain,
53499        mut mark: &OptionalUint32,
53500    ) -> Self::SetMarkResponseFut {
53501        fn _decode(
53502            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53503        ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
53504            let _response = fidl::client::decode_transaction_body::<
53505                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53506                fidl::encoding::DefaultFuchsiaResourceDialect,
53507                0x6ead6de09f653236,
53508            >(_buf?)?;
53509            Ok(_response.map(|x| x))
53510        }
53511        self.client.send_query_and_decode::<BaseSocketSetMarkRequest, BaseSocketSetMarkResult>(
53512            (domain, mark),
53513            0x6ead6de09f653236,
53514            fidl::encoding::DynamicFlags::empty(),
53515            _decode,
53516        )
53517    }
53518
53519    type GetMarkResponseFut = fidl::client::QueryResponseFut<
53520        BaseSocketGetMarkResult,
53521        fidl::encoding::DefaultFuchsiaResourceDialect,
53522    >;
53523    fn r#get_mark(&self, mut domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut {
53524        fn _decode(
53525            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53526        ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
53527            let _response = fidl::client::decode_transaction_body::<
53528                fidl::encoding::ResultType<BaseSocketGetMarkResponse, fidl_fuchsia_posix::Errno>,
53529                fidl::encoding::DefaultFuchsiaResourceDialect,
53530                0x57a2752c61d93d47,
53531            >(_buf?)?;
53532            Ok(_response.map(|x| x.mark))
53533        }
53534        self.client.send_query_and_decode::<BaseSocketGetMarkRequest, BaseSocketGetMarkResult>(
53535            (domain,),
53536            0x57a2752c61d93d47,
53537            fidl::encoding::DynamicFlags::empty(),
53538            _decode,
53539        )
53540    }
53541
53542    type BindResponseFut = fidl::client::QueryResponseFut<
53543        BaseNetworkSocketBindResult,
53544        fidl::encoding::DefaultFuchsiaResourceDialect,
53545    >;
53546    fn r#bind(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut {
53547        fn _decode(
53548            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53549        ) -> Result<BaseNetworkSocketBindResult, fidl::Error> {
53550            let _response = fidl::client::decode_transaction_body::<
53551                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53552                fidl::encoding::DefaultFuchsiaResourceDialect,
53553                0x4bc6400ae92125d,
53554            >(_buf?)?;
53555            Ok(_response.map(|x| x))
53556        }
53557        self.client
53558            .send_query_and_decode::<BaseNetworkSocketBindRequest, BaseNetworkSocketBindResult>(
53559                (addr,),
53560                0x4bc6400ae92125d,
53561                fidl::encoding::DynamicFlags::empty(),
53562                _decode,
53563            )
53564    }
53565
53566    type ConnectResponseFut = fidl::client::QueryResponseFut<
53567        BaseNetworkSocketConnectResult,
53568        fidl::encoding::DefaultFuchsiaResourceDialect,
53569    >;
53570    fn r#connect(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut {
53571        fn _decode(
53572            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53573        ) -> Result<BaseNetworkSocketConnectResult, fidl::Error> {
53574            let _response = fidl::client::decode_transaction_body::<
53575                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53576                fidl::encoding::DefaultFuchsiaResourceDialect,
53577                0x5f05f19bfdd38871,
53578            >(_buf?)?;
53579            Ok(_response.map(|x| x))
53580        }
53581        self.client.send_query_and_decode::<
53582            BaseNetworkSocketConnectRequest,
53583            BaseNetworkSocketConnectResult,
53584        >(
53585            (addr,),
53586            0x5f05f19bfdd38871,
53587            fidl::encoding::DynamicFlags::empty(),
53588            _decode,
53589        )
53590    }
53591
53592    type DisconnectResponseFut = fidl::client::QueryResponseFut<
53593        BaseNetworkSocketDisconnectResult,
53594        fidl::encoding::DefaultFuchsiaResourceDialect,
53595    >;
53596    fn r#disconnect(&self) -> Self::DisconnectResponseFut {
53597        fn _decode(
53598            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53599        ) -> Result<BaseNetworkSocketDisconnectResult, fidl::Error> {
53600            let _response = fidl::client::decode_transaction_body::<
53601                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53602                fidl::encoding::DefaultFuchsiaResourceDialect,
53603                0x74e63b91f7b29b2,
53604            >(_buf?)?;
53605            Ok(_response.map(|x| x))
53606        }
53607        self.client.send_query_and_decode::<
53608            fidl::encoding::EmptyPayload,
53609            BaseNetworkSocketDisconnectResult,
53610        >(
53611            (),
53612            0x74e63b91f7b29b2,
53613            fidl::encoding::DynamicFlags::empty(),
53614            _decode,
53615        )
53616    }
53617
53618    type GetSockNameResponseFut = fidl::client::QueryResponseFut<
53619        BaseNetworkSocketGetSockNameResult,
53620        fidl::encoding::DefaultFuchsiaResourceDialect,
53621    >;
53622    fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut {
53623        fn _decode(
53624            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53625        ) -> Result<BaseNetworkSocketGetSockNameResult, fidl::Error> {
53626            let _response = fidl::client::decode_transaction_body::<
53627                fidl::encoding::ResultType<
53628                    BaseNetworkSocketGetSockNameResponse,
53629                    fidl_fuchsia_posix::Errno,
53630                >,
53631                fidl::encoding::DefaultFuchsiaResourceDialect,
53632                0x475f23f84a1a4f85,
53633            >(_buf?)?;
53634            Ok(_response.map(|x| x.addr))
53635        }
53636        self.client.send_query_and_decode::<
53637            fidl::encoding::EmptyPayload,
53638            BaseNetworkSocketGetSockNameResult,
53639        >(
53640            (),
53641            0x475f23f84a1a4f85,
53642            fidl::encoding::DynamicFlags::empty(),
53643            _decode,
53644        )
53645    }
53646
53647    type GetPeerNameResponseFut = fidl::client::QueryResponseFut<
53648        BaseNetworkSocketGetPeerNameResult,
53649        fidl::encoding::DefaultFuchsiaResourceDialect,
53650    >;
53651    fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut {
53652        fn _decode(
53653            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53654        ) -> Result<BaseNetworkSocketGetPeerNameResult, fidl::Error> {
53655            let _response = fidl::client::decode_transaction_body::<
53656                fidl::encoding::ResultType<
53657                    BaseNetworkSocketGetPeerNameResponse,
53658                    fidl_fuchsia_posix::Errno,
53659                >,
53660                fidl::encoding::DefaultFuchsiaResourceDialect,
53661                0x1ffecf4bd5b6432e,
53662            >(_buf?)?;
53663            Ok(_response.map(|x| x.addr))
53664        }
53665        self.client.send_query_and_decode::<
53666            fidl::encoding::EmptyPayload,
53667            BaseNetworkSocketGetPeerNameResult,
53668        >(
53669            (),
53670            0x1ffecf4bd5b6432e,
53671            fidl::encoding::DynamicFlags::empty(),
53672            _decode,
53673        )
53674    }
53675
53676    type ShutdownResponseFut = fidl::client::QueryResponseFut<
53677        BaseNetworkSocketShutdownResult,
53678        fidl::encoding::DefaultFuchsiaResourceDialect,
53679    >;
53680    fn r#shutdown(&self, mut mode: ShutdownMode) -> Self::ShutdownResponseFut {
53681        fn _decode(
53682            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53683        ) -> Result<BaseNetworkSocketShutdownResult, fidl::Error> {
53684            let _response = fidl::client::decode_transaction_body::<
53685                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53686                fidl::encoding::DefaultFuchsiaResourceDialect,
53687                0x247f38b6db68c336,
53688            >(_buf?)?;
53689            Ok(_response.map(|x| x))
53690        }
53691        self.client.send_query_and_decode::<
53692            BaseNetworkSocketShutdownRequest,
53693            BaseNetworkSocketShutdownResult,
53694        >(
53695            (mode,),
53696            0x247f38b6db68c336,
53697            fidl::encoding::DynamicFlags::empty(),
53698            _decode,
53699        )
53700    }
53701
53702    type SetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
53703        BaseNetworkSocketSetIpTypeOfServiceResult,
53704        fidl::encoding::DefaultFuchsiaResourceDialect,
53705    >;
53706    fn r#set_ip_type_of_service(&self, mut value: u8) -> Self::SetIpTypeOfServiceResponseFut {
53707        fn _decode(
53708            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53709        ) -> Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error> {
53710            let _response = fidl::client::decode_transaction_body::<
53711                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53712                fidl::encoding::DefaultFuchsiaResourceDialect,
53713                0x995c600475b6d46,
53714            >(_buf?)?;
53715            Ok(_response.map(|x| x))
53716        }
53717        self.client.send_query_and_decode::<
53718            BaseNetworkSocketSetIpTypeOfServiceRequest,
53719            BaseNetworkSocketSetIpTypeOfServiceResult,
53720        >(
53721            (value,),
53722            0x995c600475b6d46,
53723            fidl::encoding::DynamicFlags::empty(),
53724            _decode,
53725        )
53726    }
53727
53728    type GetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
53729        BaseNetworkSocketGetIpTypeOfServiceResult,
53730        fidl::encoding::DefaultFuchsiaResourceDialect,
53731    >;
53732    fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut {
53733        fn _decode(
53734            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53735        ) -> Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error> {
53736            let _response = fidl::client::decode_transaction_body::<
53737                fidl::encoding::ResultType<
53738                    BaseNetworkSocketGetIpTypeOfServiceResponse,
53739                    fidl_fuchsia_posix::Errno,
53740                >,
53741                fidl::encoding::DefaultFuchsiaResourceDialect,
53742                0x3814a04259f75fcb,
53743            >(_buf?)?;
53744            Ok(_response.map(|x| x.value))
53745        }
53746        self.client.send_query_and_decode::<
53747            fidl::encoding::EmptyPayload,
53748            BaseNetworkSocketGetIpTypeOfServiceResult,
53749        >(
53750            (),
53751            0x3814a04259f75fcb,
53752            fidl::encoding::DynamicFlags::empty(),
53753            _decode,
53754        )
53755    }
53756
53757    type SetIpTtlResponseFut = fidl::client::QueryResponseFut<
53758        BaseNetworkSocketSetIpTtlResult,
53759        fidl::encoding::DefaultFuchsiaResourceDialect,
53760    >;
53761    fn r#set_ip_ttl(&self, mut value: &OptionalUint8) -> Self::SetIpTtlResponseFut {
53762        fn _decode(
53763            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53764        ) -> Result<BaseNetworkSocketSetIpTtlResult, fidl::Error> {
53765            let _response = fidl::client::decode_transaction_body::<
53766                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53767                fidl::encoding::DefaultFuchsiaResourceDialect,
53768                0x29e2424b433ae1ef,
53769            >(_buf?)?;
53770            Ok(_response.map(|x| x))
53771        }
53772        self.client.send_query_and_decode::<
53773            BaseNetworkSocketSetIpTtlRequest,
53774            BaseNetworkSocketSetIpTtlResult,
53775        >(
53776            (value,),
53777            0x29e2424b433ae1ef,
53778            fidl::encoding::DynamicFlags::empty(),
53779            _decode,
53780        )
53781    }
53782
53783    type GetIpTtlResponseFut = fidl::client::QueryResponseFut<
53784        BaseNetworkSocketGetIpTtlResult,
53785        fidl::encoding::DefaultFuchsiaResourceDialect,
53786    >;
53787    fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut {
53788        fn _decode(
53789            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53790        ) -> Result<BaseNetworkSocketGetIpTtlResult, fidl::Error> {
53791            let _response = fidl::client::decode_transaction_body::<
53792                fidl::encoding::ResultType<
53793                    BaseNetworkSocketGetIpTtlResponse,
53794                    fidl_fuchsia_posix::Errno,
53795                >,
53796                fidl::encoding::DefaultFuchsiaResourceDialect,
53797                0x47e47fa1f24da471,
53798            >(_buf?)?;
53799            Ok(_response.map(|x| x.value))
53800        }
53801        self.client
53802            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseNetworkSocketGetIpTtlResult>(
53803                (),
53804                0x47e47fa1f24da471,
53805                fidl::encoding::DynamicFlags::empty(),
53806                _decode,
53807            )
53808    }
53809
53810    type SetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
53811        BaseNetworkSocketSetIpPacketInfoResult,
53812        fidl::encoding::DefaultFuchsiaResourceDialect,
53813    >;
53814    fn r#set_ip_packet_info(&self, mut value: bool) -> Self::SetIpPacketInfoResponseFut {
53815        fn _decode(
53816            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53817        ) -> Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error> {
53818            let _response = fidl::client::decode_transaction_body::<
53819                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53820                fidl::encoding::DefaultFuchsiaResourceDialect,
53821                0x392d16bee20c0e16,
53822            >(_buf?)?;
53823            Ok(_response.map(|x| x))
53824        }
53825        self.client.send_query_and_decode::<
53826            BaseNetworkSocketSetIpPacketInfoRequest,
53827            BaseNetworkSocketSetIpPacketInfoResult,
53828        >(
53829            (value,),
53830            0x392d16bee20c0e16,
53831            fidl::encoding::DynamicFlags::empty(),
53832            _decode,
53833        )
53834    }
53835
53836    type GetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
53837        BaseNetworkSocketGetIpPacketInfoResult,
53838        fidl::encoding::DefaultFuchsiaResourceDialect,
53839    >;
53840    fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut {
53841        fn _decode(
53842            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53843        ) -> Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error> {
53844            let _response = fidl::client::decode_transaction_body::<
53845                fidl::encoding::ResultType<
53846                    BaseNetworkSocketGetIpPacketInfoResponse,
53847                    fidl_fuchsia_posix::Errno,
53848                >,
53849                fidl::encoding::DefaultFuchsiaResourceDialect,
53850                0x54b505f242280740,
53851            >(_buf?)?;
53852            Ok(_response.map(|x| x.value))
53853        }
53854        self.client.send_query_and_decode::<
53855            fidl::encoding::EmptyPayload,
53856            BaseNetworkSocketGetIpPacketInfoResult,
53857        >(
53858            (),
53859            0x54b505f242280740,
53860            fidl::encoding::DynamicFlags::empty(),
53861            _decode,
53862        )
53863    }
53864
53865    type SetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
53866        BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
53867        fidl::encoding::DefaultFuchsiaResourceDialect,
53868    >;
53869    fn r#set_ip_receive_type_of_service(
53870        &self,
53871        mut value: bool,
53872    ) -> Self::SetIpReceiveTypeOfServiceResponseFut {
53873        fn _decode(
53874            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53875        ) -> Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error> {
53876            let _response = fidl::client::decode_transaction_body::<
53877                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53878                fidl::encoding::DefaultFuchsiaResourceDialect,
53879                0x6c4f6714995f84ef,
53880            >(_buf?)?;
53881            Ok(_response.map(|x| x))
53882        }
53883        self.client.send_query_and_decode::<
53884            BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
53885            BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
53886        >(
53887            (value,),
53888            0x6c4f6714995f84ef,
53889            fidl::encoding::DynamicFlags::empty(),
53890            _decode,
53891        )
53892    }
53893
53894    type GetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
53895        BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
53896        fidl::encoding::DefaultFuchsiaResourceDialect,
53897    >;
53898    fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut {
53899        fn _decode(
53900            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53901        ) -> Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error> {
53902            let _response = fidl::client::decode_transaction_body::<
53903                fidl::encoding::ResultType<
53904                    BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
53905                    fidl_fuchsia_posix::Errno,
53906                >,
53907                fidl::encoding::DefaultFuchsiaResourceDialect,
53908                0x4158ba7dc2795960,
53909            >(_buf?)?;
53910            Ok(_response.map(|x| x.value))
53911        }
53912        self.client.send_query_and_decode::<
53913            fidl::encoding::EmptyPayload,
53914            BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
53915        >(
53916            (),
53917            0x4158ba7dc2795960,
53918            fidl::encoding::DynamicFlags::empty(),
53919            _decode,
53920        )
53921    }
53922
53923    type SetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
53924        BaseNetworkSocketSetIpReceiveTtlResult,
53925        fidl::encoding::DefaultFuchsiaResourceDialect,
53926    >;
53927    fn r#set_ip_receive_ttl(&self, mut value: bool) -> Self::SetIpReceiveTtlResponseFut {
53928        fn _decode(
53929            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53930        ) -> Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error> {
53931            let _response = fidl::client::decode_transaction_body::<
53932                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53933                fidl::encoding::DefaultFuchsiaResourceDialect,
53934                0x46f15be0ce0ab82b,
53935            >(_buf?)?;
53936            Ok(_response.map(|x| x))
53937        }
53938        self.client.send_query_and_decode::<
53939            BaseNetworkSocketSetIpReceiveTtlRequest,
53940            BaseNetworkSocketSetIpReceiveTtlResult,
53941        >(
53942            (value,),
53943            0x46f15be0ce0ab82b,
53944            fidl::encoding::DynamicFlags::empty(),
53945            _decode,
53946        )
53947    }
53948
53949    type GetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
53950        BaseNetworkSocketGetIpReceiveTtlResult,
53951        fidl::encoding::DefaultFuchsiaResourceDialect,
53952    >;
53953    fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut {
53954        fn _decode(
53955            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53956        ) -> Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error> {
53957            let _response = fidl::client::decode_transaction_body::<
53958                fidl::encoding::ResultType<
53959                    BaseNetworkSocketGetIpReceiveTtlResponse,
53960                    fidl_fuchsia_posix::Errno,
53961                >,
53962                fidl::encoding::DefaultFuchsiaResourceDialect,
53963                0x678ddd5a5dfa2eb5,
53964            >(_buf?)?;
53965            Ok(_response.map(|x| x.value))
53966        }
53967        self.client.send_query_and_decode::<
53968            fidl::encoding::EmptyPayload,
53969            BaseNetworkSocketGetIpReceiveTtlResult,
53970        >(
53971            (),
53972            0x678ddd5a5dfa2eb5,
53973            fidl::encoding::DynamicFlags::empty(),
53974            _decode,
53975        )
53976    }
53977
53978    type SetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
53979        BaseNetworkSocketSetIpMulticastInterfaceResult,
53980        fidl::encoding::DefaultFuchsiaResourceDialect,
53981    >;
53982    fn r#set_ip_multicast_interface(
53983        &self,
53984        mut iface: u64,
53985        mut address: &fidl_fuchsia_net::Ipv4Address,
53986    ) -> Self::SetIpMulticastInterfaceResponseFut {
53987        fn _decode(
53988            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
53989        ) -> Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error> {
53990            let _response = fidl::client::decode_transaction_body::<
53991                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
53992                fidl::encoding::DefaultFuchsiaResourceDialect,
53993                0x752fbfa9b12befe,
53994            >(_buf?)?;
53995            Ok(_response.map(|x| x))
53996        }
53997        self.client.send_query_and_decode::<
53998            BaseNetworkSocketSetIpMulticastInterfaceRequest,
53999            BaseNetworkSocketSetIpMulticastInterfaceResult,
54000        >(
54001            (iface, address,),
54002            0x752fbfa9b12befe,
54003            fidl::encoding::DynamicFlags::empty(),
54004            _decode,
54005        )
54006    }
54007
54008    type GetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
54009        BaseNetworkSocketGetIpMulticastInterfaceResult,
54010        fidl::encoding::DefaultFuchsiaResourceDialect,
54011    >;
54012    fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut {
54013        fn _decode(
54014            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54015        ) -> Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error> {
54016            let _response = fidl::client::decode_transaction_body::<
54017                fidl::encoding::ResultType<
54018                    BaseNetworkSocketGetIpMulticastInterfaceResponse,
54019                    fidl_fuchsia_posix::Errno,
54020                >,
54021                fidl::encoding::DefaultFuchsiaResourceDialect,
54022                0x320bd14c4df046c4,
54023            >(_buf?)?;
54024            Ok(_response.map(|x| x.value))
54025        }
54026        self.client.send_query_and_decode::<
54027            fidl::encoding::EmptyPayload,
54028            BaseNetworkSocketGetIpMulticastInterfaceResult,
54029        >(
54030            (),
54031            0x320bd14c4df046c4,
54032            fidl::encoding::DynamicFlags::empty(),
54033            _decode,
54034        )
54035    }
54036
54037    type SetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
54038        BaseNetworkSocketSetIpMulticastTtlResult,
54039        fidl::encoding::DefaultFuchsiaResourceDialect,
54040    >;
54041    fn r#set_ip_multicast_ttl(
54042        &self,
54043        mut value: &OptionalUint8,
54044    ) -> Self::SetIpMulticastTtlResponseFut {
54045        fn _decode(
54046            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54047        ) -> Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error> {
54048            let _response = fidl::client::decode_transaction_body::<
54049                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54050                fidl::encoding::DefaultFuchsiaResourceDialect,
54051                0x63134d53772916a1,
54052            >(_buf?)?;
54053            Ok(_response.map(|x| x))
54054        }
54055        self.client.send_query_and_decode::<
54056            BaseNetworkSocketSetIpMulticastTtlRequest,
54057            BaseNetworkSocketSetIpMulticastTtlResult,
54058        >(
54059            (value,),
54060            0x63134d53772916a1,
54061            fidl::encoding::DynamicFlags::empty(),
54062            _decode,
54063        )
54064    }
54065
54066    type GetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
54067        BaseNetworkSocketGetIpMulticastTtlResult,
54068        fidl::encoding::DefaultFuchsiaResourceDialect,
54069    >;
54070    fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut {
54071        fn _decode(
54072            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54073        ) -> Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error> {
54074            let _response = fidl::client::decode_transaction_body::<
54075                fidl::encoding::ResultType<
54076                    BaseNetworkSocketGetIpMulticastTtlResponse,
54077                    fidl_fuchsia_posix::Errno,
54078                >,
54079                fidl::encoding::DefaultFuchsiaResourceDialect,
54080                0x4665cd378f39e1a,
54081            >(_buf?)?;
54082            Ok(_response.map(|x| x.value))
54083        }
54084        self.client.send_query_and_decode::<
54085            fidl::encoding::EmptyPayload,
54086            BaseNetworkSocketGetIpMulticastTtlResult,
54087        >(
54088            (),
54089            0x4665cd378f39e1a,
54090            fidl::encoding::DynamicFlags::empty(),
54091            _decode,
54092        )
54093    }
54094
54095    type SetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
54096        BaseNetworkSocketSetIpMulticastLoopbackResult,
54097        fidl::encoding::DefaultFuchsiaResourceDialect,
54098    >;
54099    fn r#set_ip_multicast_loopback(
54100        &self,
54101        mut value: bool,
54102    ) -> Self::SetIpMulticastLoopbackResponseFut {
54103        fn _decode(
54104            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54105        ) -> Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error> {
54106            let _response = fidl::client::decode_transaction_body::<
54107                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54108                fidl::encoding::DefaultFuchsiaResourceDialect,
54109                0x20c55c11f00943ea,
54110            >(_buf?)?;
54111            Ok(_response.map(|x| x))
54112        }
54113        self.client.send_query_and_decode::<
54114            BaseNetworkSocketSetIpMulticastLoopbackRequest,
54115            BaseNetworkSocketSetIpMulticastLoopbackResult,
54116        >(
54117            (value,),
54118            0x20c55c11f00943ea,
54119            fidl::encoding::DynamicFlags::empty(),
54120            _decode,
54121        )
54122    }
54123
54124    type GetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
54125        BaseNetworkSocketGetIpMulticastLoopbackResult,
54126        fidl::encoding::DefaultFuchsiaResourceDialect,
54127    >;
54128    fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut {
54129        fn _decode(
54130            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54131        ) -> Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error> {
54132            let _response = fidl::client::decode_transaction_body::<
54133                fidl::encoding::ResultType<
54134                    BaseNetworkSocketGetIpMulticastLoopbackResponse,
54135                    fidl_fuchsia_posix::Errno,
54136                >,
54137                fidl::encoding::DefaultFuchsiaResourceDialect,
54138                0x3b6b26ff558298f2,
54139            >(_buf?)?;
54140            Ok(_response.map(|x| x.value))
54141        }
54142        self.client.send_query_and_decode::<
54143            fidl::encoding::EmptyPayload,
54144            BaseNetworkSocketGetIpMulticastLoopbackResult,
54145        >(
54146            (),
54147            0x3b6b26ff558298f2,
54148            fidl::encoding::DynamicFlags::empty(),
54149            _decode,
54150        )
54151    }
54152
54153    type AddIpMembershipResponseFut = fidl::client::QueryResponseFut<
54154        BaseNetworkSocketAddIpMembershipResult,
54155        fidl::encoding::DefaultFuchsiaResourceDialect,
54156    >;
54157    fn r#add_ip_membership(
54158        &self,
54159        mut membership: &IpMulticastMembership,
54160    ) -> Self::AddIpMembershipResponseFut {
54161        fn _decode(
54162            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54163        ) -> Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error> {
54164            let _response = fidl::client::decode_transaction_body::<
54165                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54166                fidl::encoding::DefaultFuchsiaResourceDialect,
54167                0x76bc7df115a3b4d0,
54168            >(_buf?)?;
54169            Ok(_response.map(|x| x))
54170        }
54171        self.client.send_query_and_decode::<
54172            BaseNetworkSocketAddIpMembershipRequest,
54173            BaseNetworkSocketAddIpMembershipResult,
54174        >(
54175            (membership,),
54176            0x76bc7df115a3b4d0,
54177            fidl::encoding::DynamicFlags::empty(),
54178            _decode,
54179        )
54180    }
54181
54182    type DropIpMembershipResponseFut = fidl::client::QueryResponseFut<
54183        BaseNetworkSocketDropIpMembershipResult,
54184        fidl::encoding::DefaultFuchsiaResourceDialect,
54185    >;
54186    fn r#drop_ip_membership(
54187        &self,
54188        mut membership: &IpMulticastMembership,
54189    ) -> Self::DropIpMembershipResponseFut {
54190        fn _decode(
54191            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54192        ) -> Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error> {
54193            let _response = fidl::client::decode_transaction_body::<
54194                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54195                fidl::encoding::DefaultFuchsiaResourceDialect,
54196                0x2888f3099188d03,
54197            >(_buf?)?;
54198            Ok(_response.map(|x| x))
54199        }
54200        self.client.send_query_and_decode::<
54201            BaseNetworkSocketDropIpMembershipRequest,
54202            BaseNetworkSocketDropIpMembershipResult,
54203        >(
54204            (membership,),
54205            0x2888f3099188d03,
54206            fidl::encoding::DynamicFlags::empty(),
54207            _decode,
54208        )
54209    }
54210
54211    type SetIpTransparentResponseFut = fidl::client::QueryResponseFut<
54212        BaseNetworkSocketSetIpTransparentResult,
54213        fidl::encoding::DefaultFuchsiaResourceDialect,
54214    >;
54215    fn r#set_ip_transparent(&self, mut value: bool) -> Self::SetIpTransparentResponseFut {
54216        fn _decode(
54217            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54218        ) -> Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error> {
54219            let _response = fidl::client::decode_transaction_body::<
54220                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54221                fidl::encoding::DefaultFuchsiaResourceDialect,
54222                0x1ae532b0c066e3a0,
54223            >(_buf?)?;
54224            Ok(_response.map(|x| x))
54225        }
54226        self.client.send_query_and_decode::<
54227            BaseNetworkSocketSetIpTransparentRequest,
54228            BaseNetworkSocketSetIpTransparentResult,
54229        >(
54230            (value,),
54231            0x1ae532b0c066e3a0,
54232            fidl::encoding::DynamicFlags::empty(),
54233            _decode,
54234        )
54235    }
54236
54237    type GetIpTransparentResponseFut = fidl::client::QueryResponseFut<
54238        BaseNetworkSocketGetIpTransparentResult,
54239        fidl::encoding::DefaultFuchsiaResourceDialect,
54240    >;
54241    fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut {
54242        fn _decode(
54243            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54244        ) -> Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error> {
54245            let _response = fidl::client::decode_transaction_body::<
54246                fidl::encoding::ResultType<
54247                    BaseNetworkSocketGetIpTransparentResponse,
54248                    fidl_fuchsia_posix::Errno,
54249                >,
54250                fidl::encoding::DefaultFuchsiaResourceDialect,
54251                0x51d43695962ebfb5,
54252            >(_buf?)?;
54253            Ok(_response.map(|x| x.value))
54254        }
54255        self.client.send_query_and_decode::<
54256            fidl::encoding::EmptyPayload,
54257            BaseNetworkSocketGetIpTransparentResult,
54258        >(
54259            (),
54260            0x51d43695962ebfb5,
54261            fidl::encoding::DynamicFlags::empty(),
54262            _decode,
54263        )
54264    }
54265
54266    type SetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
54267        BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
54268        fidl::encoding::DefaultFuchsiaResourceDialect,
54269    >;
54270    fn r#set_ip_receive_original_destination_address(
54271        &self,
54272        mut value: bool,
54273    ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut {
54274        fn _decode(
54275            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54276        ) -> Result<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error>
54277        {
54278            let _response = fidl::client::decode_transaction_body::<
54279                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54280                fidl::encoding::DefaultFuchsiaResourceDialect,
54281                0x4722b4ce52f7840,
54282            >(_buf?)?;
54283            Ok(_response.map(|x| x))
54284        }
54285        self.client.send_query_and_decode::<
54286            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
54287            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
54288        >(
54289            (value,),
54290            0x4722b4ce52f7840,
54291            fidl::encoding::DynamicFlags::empty(),
54292            _decode,
54293        )
54294    }
54295
54296    type GetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
54297        BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
54298        fidl::encoding::DefaultFuchsiaResourceDialect,
54299    >;
54300    fn r#get_ip_receive_original_destination_address(
54301        &self,
54302    ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut {
54303        fn _decode(
54304            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54305        ) -> Result<BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error>
54306        {
54307            let _response = fidl::client::decode_transaction_body::<
54308                fidl::encoding::ResultType<
54309                    BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
54310                    fidl_fuchsia_posix::Errno,
54311                >,
54312                fidl::encoding::DefaultFuchsiaResourceDialect,
54313                0x2a0e7dc5d6bfdfe9,
54314            >(_buf?)?;
54315            Ok(_response.map(|x| x.value))
54316        }
54317        self.client.send_query_and_decode::<
54318            fidl::encoding::EmptyPayload,
54319            BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
54320        >(
54321            (),
54322            0x2a0e7dc5d6bfdfe9,
54323            fidl::encoding::DynamicFlags::empty(),
54324            _decode,
54325        )
54326    }
54327
54328    type AddIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
54329        BaseNetworkSocketAddIpv6MembershipResult,
54330        fidl::encoding::DefaultFuchsiaResourceDialect,
54331    >;
54332    fn r#add_ipv6_membership(
54333        &self,
54334        mut membership: &Ipv6MulticastMembership,
54335    ) -> Self::AddIpv6MembershipResponseFut {
54336        fn _decode(
54337            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54338        ) -> Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error> {
54339            let _response = fidl::client::decode_transaction_body::<
54340                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54341                fidl::encoding::DefaultFuchsiaResourceDialect,
54342                0x7c94727acb4ea4b3,
54343            >(_buf?)?;
54344            Ok(_response.map(|x| x))
54345        }
54346        self.client.send_query_and_decode::<
54347            BaseNetworkSocketAddIpv6MembershipRequest,
54348            BaseNetworkSocketAddIpv6MembershipResult,
54349        >(
54350            (membership,),
54351            0x7c94727acb4ea4b3,
54352            fidl::encoding::DynamicFlags::empty(),
54353            _decode,
54354        )
54355    }
54356
54357    type DropIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
54358        BaseNetworkSocketDropIpv6MembershipResult,
54359        fidl::encoding::DefaultFuchsiaResourceDialect,
54360    >;
54361    fn r#drop_ipv6_membership(
54362        &self,
54363        mut membership: &Ipv6MulticastMembership,
54364    ) -> Self::DropIpv6MembershipResponseFut {
54365        fn _decode(
54366            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54367        ) -> Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error> {
54368            let _response = fidl::client::decode_transaction_body::<
54369                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54370                fidl::encoding::DefaultFuchsiaResourceDialect,
54371                0x42104c70ccaba304,
54372            >(_buf?)?;
54373            Ok(_response.map(|x| x))
54374        }
54375        self.client.send_query_and_decode::<
54376            BaseNetworkSocketDropIpv6MembershipRequest,
54377            BaseNetworkSocketDropIpv6MembershipResult,
54378        >(
54379            (membership,),
54380            0x42104c70ccaba304,
54381            fidl::encoding::DynamicFlags::empty(),
54382            _decode,
54383        )
54384    }
54385
54386    type SetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
54387        BaseNetworkSocketSetIpv6MulticastInterfaceResult,
54388        fidl::encoding::DefaultFuchsiaResourceDialect,
54389    >;
54390    fn r#set_ipv6_multicast_interface(
54391        &self,
54392        mut value: u64,
54393    ) -> Self::SetIpv6MulticastInterfaceResponseFut {
54394        fn _decode(
54395            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54396        ) -> Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error> {
54397            let _response = fidl::client::decode_transaction_body::<
54398                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54399                fidl::encoding::DefaultFuchsiaResourceDialect,
54400                0x135f76db3774ab3b,
54401            >(_buf?)?;
54402            Ok(_response.map(|x| x))
54403        }
54404        self.client.send_query_and_decode::<
54405            BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
54406            BaseNetworkSocketSetIpv6MulticastInterfaceResult,
54407        >(
54408            (value,),
54409            0x135f76db3774ab3b,
54410            fidl::encoding::DynamicFlags::empty(),
54411            _decode,
54412        )
54413    }
54414
54415    type GetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
54416        BaseNetworkSocketGetIpv6MulticastInterfaceResult,
54417        fidl::encoding::DefaultFuchsiaResourceDialect,
54418    >;
54419    fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut {
54420        fn _decode(
54421            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54422        ) -> Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error> {
54423            let _response = fidl::client::decode_transaction_body::<
54424                fidl::encoding::ResultType<
54425                    BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
54426                    fidl_fuchsia_posix::Errno,
54427                >,
54428                fidl::encoding::DefaultFuchsiaResourceDialect,
54429                0x1f26fcdd348f1882,
54430            >(_buf?)?;
54431            Ok(_response.map(|x| x.value))
54432        }
54433        self.client.send_query_and_decode::<
54434            fidl::encoding::EmptyPayload,
54435            BaseNetworkSocketGetIpv6MulticastInterfaceResult,
54436        >(
54437            (),
54438            0x1f26fcdd348f1882,
54439            fidl::encoding::DynamicFlags::empty(),
54440            _decode,
54441        )
54442    }
54443
54444    type SetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
54445        BaseNetworkSocketSetIpv6UnicastHopsResult,
54446        fidl::encoding::DefaultFuchsiaResourceDialect,
54447    >;
54448    fn r#set_ipv6_unicast_hops(
54449        &self,
54450        mut value: &OptionalUint8,
54451    ) -> Self::SetIpv6UnicastHopsResponseFut {
54452        fn _decode(
54453            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54454        ) -> Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error> {
54455            let _response = fidl::client::decode_transaction_body::<
54456                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54457                fidl::encoding::DefaultFuchsiaResourceDialect,
54458                0x157d51e98f462859,
54459            >(_buf?)?;
54460            Ok(_response.map(|x| x))
54461        }
54462        self.client.send_query_and_decode::<
54463            BaseNetworkSocketSetIpv6UnicastHopsRequest,
54464            BaseNetworkSocketSetIpv6UnicastHopsResult,
54465        >(
54466            (value,),
54467            0x157d51e98f462859,
54468            fidl::encoding::DynamicFlags::empty(),
54469            _decode,
54470        )
54471    }
54472
54473    type GetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
54474        BaseNetworkSocketGetIpv6UnicastHopsResult,
54475        fidl::encoding::DefaultFuchsiaResourceDialect,
54476    >;
54477    fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut {
54478        fn _decode(
54479            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54480        ) -> Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error> {
54481            let _response = fidl::client::decode_transaction_body::<
54482                fidl::encoding::ResultType<
54483                    BaseNetworkSocketGetIpv6UnicastHopsResponse,
54484                    fidl_fuchsia_posix::Errno,
54485                >,
54486                fidl::encoding::DefaultFuchsiaResourceDialect,
54487                0x21f4641cad8bd8d2,
54488            >(_buf?)?;
54489            Ok(_response.map(|x| x.value))
54490        }
54491        self.client.send_query_and_decode::<
54492            fidl::encoding::EmptyPayload,
54493            BaseNetworkSocketGetIpv6UnicastHopsResult,
54494        >(
54495            (),
54496            0x21f4641cad8bd8d2,
54497            fidl::encoding::DynamicFlags::empty(),
54498            _decode,
54499        )
54500    }
54501
54502    type SetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
54503        BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
54504        fidl::encoding::DefaultFuchsiaResourceDialect,
54505    >;
54506    fn r#set_ipv6_receive_hop_limit(
54507        &self,
54508        mut value: bool,
54509    ) -> Self::SetIpv6ReceiveHopLimitResponseFut {
54510        fn _decode(
54511            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54512        ) -> Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error> {
54513            let _response = fidl::client::decode_transaction_body::<
54514                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54515                fidl::encoding::DefaultFuchsiaResourceDialect,
54516                0x5c24808ed2e84a1e,
54517            >(_buf?)?;
54518            Ok(_response.map(|x| x))
54519        }
54520        self.client.send_query_and_decode::<
54521            BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
54522            BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
54523        >(
54524            (value,),
54525            0x5c24808ed2e84a1e,
54526            fidl::encoding::DynamicFlags::empty(),
54527            _decode,
54528        )
54529    }
54530
54531    type GetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
54532        BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
54533        fidl::encoding::DefaultFuchsiaResourceDialect,
54534    >;
54535    fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut {
54536        fn _decode(
54537            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54538        ) -> Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error> {
54539            let _response = fidl::client::decode_transaction_body::<
54540                fidl::encoding::ResultType<
54541                    BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
54542                    fidl_fuchsia_posix::Errno,
54543                >,
54544                fidl::encoding::DefaultFuchsiaResourceDialect,
54545                0x341e06689885b4c0,
54546            >(_buf?)?;
54547            Ok(_response.map(|x| x.value))
54548        }
54549        self.client.send_query_and_decode::<
54550            fidl::encoding::EmptyPayload,
54551            BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
54552        >(
54553            (),
54554            0x341e06689885b4c0,
54555            fidl::encoding::DynamicFlags::empty(),
54556            _decode,
54557        )
54558    }
54559
54560    type SetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
54561        BaseNetworkSocketSetIpv6MulticastHopsResult,
54562        fidl::encoding::DefaultFuchsiaResourceDialect,
54563    >;
54564    fn r#set_ipv6_multicast_hops(
54565        &self,
54566        mut value: &OptionalUint8,
54567    ) -> Self::SetIpv6MulticastHopsResponseFut {
54568        fn _decode(
54569            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54570        ) -> Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error> {
54571            let _response = fidl::client::decode_transaction_body::<
54572                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54573                fidl::encoding::DefaultFuchsiaResourceDialect,
54574                0x25b9cd4d181f82c1,
54575            >(_buf?)?;
54576            Ok(_response.map(|x| x))
54577        }
54578        self.client.send_query_and_decode::<
54579            BaseNetworkSocketSetIpv6MulticastHopsRequest,
54580            BaseNetworkSocketSetIpv6MulticastHopsResult,
54581        >(
54582            (value,),
54583            0x25b9cd4d181f82c1,
54584            fidl::encoding::DynamicFlags::empty(),
54585            _decode,
54586        )
54587    }
54588
54589    type GetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
54590        BaseNetworkSocketGetIpv6MulticastHopsResult,
54591        fidl::encoding::DefaultFuchsiaResourceDialect,
54592    >;
54593    fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut {
54594        fn _decode(
54595            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54596        ) -> Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error> {
54597            let _response = fidl::client::decode_transaction_body::<
54598                fidl::encoding::ResultType<
54599                    BaseNetworkSocketGetIpv6MulticastHopsResponse,
54600                    fidl_fuchsia_posix::Errno,
54601                >,
54602                fidl::encoding::DefaultFuchsiaResourceDialect,
54603                0x52916948a365012a,
54604            >(_buf?)?;
54605            Ok(_response.map(|x| x.value))
54606        }
54607        self.client.send_query_and_decode::<
54608            fidl::encoding::EmptyPayload,
54609            BaseNetworkSocketGetIpv6MulticastHopsResult,
54610        >(
54611            (),
54612            0x52916948a365012a,
54613            fidl::encoding::DynamicFlags::empty(),
54614            _decode,
54615        )
54616    }
54617
54618    type SetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
54619        BaseNetworkSocketSetIpv6MulticastLoopbackResult,
54620        fidl::encoding::DefaultFuchsiaResourceDialect,
54621    >;
54622    fn r#set_ipv6_multicast_loopback(
54623        &self,
54624        mut value: bool,
54625    ) -> Self::SetIpv6MulticastLoopbackResponseFut {
54626        fn _decode(
54627            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54628        ) -> Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error> {
54629            let _response = fidl::client::decode_transaction_body::<
54630                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54631                fidl::encoding::DefaultFuchsiaResourceDialect,
54632                0x55701c409ff41b40,
54633            >(_buf?)?;
54634            Ok(_response.map(|x| x))
54635        }
54636        self.client.send_query_and_decode::<
54637            BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
54638            BaseNetworkSocketSetIpv6MulticastLoopbackResult,
54639        >(
54640            (value,),
54641            0x55701c409ff41b40,
54642            fidl::encoding::DynamicFlags::empty(),
54643            _decode,
54644        )
54645    }
54646
54647    type GetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
54648        BaseNetworkSocketGetIpv6MulticastLoopbackResult,
54649        fidl::encoding::DefaultFuchsiaResourceDialect,
54650    >;
54651    fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut {
54652        fn _decode(
54653            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54654        ) -> Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error> {
54655            let _response = fidl::client::decode_transaction_body::<
54656                fidl::encoding::ResultType<
54657                    BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
54658                    fidl_fuchsia_posix::Errno,
54659                >,
54660                fidl::encoding::DefaultFuchsiaResourceDialect,
54661                0x4415b701fde319c3,
54662            >(_buf?)?;
54663            Ok(_response.map(|x| x.value))
54664        }
54665        self.client.send_query_and_decode::<
54666            fidl::encoding::EmptyPayload,
54667            BaseNetworkSocketGetIpv6MulticastLoopbackResult,
54668        >(
54669            (),
54670            0x4415b701fde319c3,
54671            fidl::encoding::DynamicFlags::empty(),
54672            _decode,
54673        )
54674    }
54675
54676    type SetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
54677        BaseNetworkSocketSetIpv6OnlyResult,
54678        fidl::encoding::DefaultFuchsiaResourceDialect,
54679    >;
54680    fn r#set_ipv6_only(&self, mut value: bool) -> Self::SetIpv6OnlyResponseFut {
54681        fn _decode(
54682            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54683        ) -> Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
54684            let _response = fidl::client::decode_transaction_body::<
54685                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54686                fidl::encoding::DefaultFuchsiaResourceDialect,
54687                0x4873f1364758cbba,
54688            >(_buf?)?;
54689            Ok(_response.map(|x| x))
54690        }
54691        self.client.send_query_and_decode::<
54692            BaseNetworkSocketSetIpv6OnlyRequest,
54693            BaseNetworkSocketSetIpv6OnlyResult,
54694        >(
54695            (value,),
54696            0x4873f1364758cbba,
54697            fidl::encoding::DynamicFlags::empty(),
54698            _decode,
54699        )
54700    }
54701
54702    type GetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
54703        BaseNetworkSocketGetIpv6OnlyResult,
54704        fidl::encoding::DefaultFuchsiaResourceDialect,
54705    >;
54706    fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut {
54707        fn _decode(
54708            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54709        ) -> Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
54710            let _response = fidl::client::decode_transaction_body::<
54711                fidl::encoding::ResultType<
54712                    BaseNetworkSocketGetIpv6OnlyResponse,
54713                    fidl_fuchsia_posix::Errno,
54714                >,
54715                fidl::encoding::DefaultFuchsiaResourceDialect,
54716                0x4aa3340a1a26b89c,
54717            >(_buf?)?;
54718            Ok(_response.map(|x| x.value))
54719        }
54720        self.client.send_query_and_decode::<
54721            fidl::encoding::EmptyPayload,
54722            BaseNetworkSocketGetIpv6OnlyResult,
54723        >(
54724            (),
54725            0x4aa3340a1a26b89c,
54726            fidl::encoding::DynamicFlags::empty(),
54727            _decode,
54728        )
54729    }
54730
54731    type SetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
54732        BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
54733        fidl::encoding::DefaultFuchsiaResourceDialect,
54734    >;
54735    fn r#set_ipv6_receive_traffic_class(
54736        &self,
54737        mut value: bool,
54738    ) -> Self::SetIpv6ReceiveTrafficClassResponseFut {
54739        fn _decode(
54740            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54741        ) -> Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error> {
54742            let _response = fidl::client::decode_transaction_body::<
54743                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54744                fidl::encoding::DefaultFuchsiaResourceDialect,
54745                0x58f07c8788d099a0,
54746            >(_buf?)?;
54747            Ok(_response.map(|x| x))
54748        }
54749        self.client.send_query_and_decode::<
54750            BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
54751            BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
54752        >(
54753            (value,),
54754            0x58f07c8788d099a0,
54755            fidl::encoding::DynamicFlags::empty(),
54756            _decode,
54757        )
54758    }
54759
54760    type GetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
54761        BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
54762        fidl::encoding::DefaultFuchsiaResourceDialect,
54763    >;
54764    fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut {
54765        fn _decode(
54766            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54767        ) -> Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error> {
54768            let _response = fidl::client::decode_transaction_body::<
54769                fidl::encoding::ResultType<
54770                    BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
54771                    fidl_fuchsia_posix::Errno,
54772                >,
54773                fidl::encoding::DefaultFuchsiaResourceDialect,
54774                0x2e334df1da553ffa,
54775            >(_buf?)?;
54776            Ok(_response.map(|x| x.value))
54777        }
54778        self.client.send_query_and_decode::<
54779            fidl::encoding::EmptyPayload,
54780            BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
54781        >(
54782            (),
54783            0x2e334df1da553ffa,
54784            fidl::encoding::DynamicFlags::empty(),
54785            _decode,
54786        )
54787    }
54788
54789    type SetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
54790        BaseNetworkSocketSetIpv6TrafficClassResult,
54791        fidl::encoding::DefaultFuchsiaResourceDialect,
54792    >;
54793    fn r#set_ipv6_traffic_class(
54794        &self,
54795        mut value: &OptionalUint8,
54796    ) -> Self::SetIpv6TrafficClassResponseFut {
54797        fn _decode(
54798            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54799        ) -> Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error> {
54800            let _response = fidl::client::decode_transaction_body::<
54801                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54802                fidl::encoding::DefaultFuchsiaResourceDialect,
54803                0x6af077800c5a0b4f,
54804            >(_buf?)?;
54805            Ok(_response.map(|x| x))
54806        }
54807        self.client.send_query_and_decode::<
54808            BaseNetworkSocketSetIpv6TrafficClassRequest,
54809            BaseNetworkSocketSetIpv6TrafficClassResult,
54810        >(
54811            (value,),
54812            0x6af077800c5a0b4f,
54813            fidl::encoding::DynamicFlags::empty(),
54814            _decode,
54815        )
54816    }
54817
54818    type GetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
54819        BaseNetworkSocketGetIpv6TrafficClassResult,
54820        fidl::encoding::DefaultFuchsiaResourceDialect,
54821    >;
54822    fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut {
54823        fn _decode(
54824            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54825        ) -> Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error> {
54826            let _response = fidl::client::decode_transaction_body::<
54827                fidl::encoding::ResultType<
54828                    BaseNetworkSocketGetIpv6TrafficClassResponse,
54829                    fidl_fuchsia_posix::Errno,
54830                >,
54831                fidl::encoding::DefaultFuchsiaResourceDialect,
54832                0x6baf6eed8fc2f04,
54833            >(_buf?)?;
54834            Ok(_response.map(|x| x.value))
54835        }
54836        self.client.send_query_and_decode::<
54837            fidl::encoding::EmptyPayload,
54838            BaseNetworkSocketGetIpv6TrafficClassResult,
54839        >(
54840            (),
54841            0x6baf6eed8fc2f04,
54842            fidl::encoding::DynamicFlags::empty(),
54843            _decode,
54844        )
54845    }
54846
54847    type SetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
54848        BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
54849        fidl::encoding::DefaultFuchsiaResourceDialect,
54850    >;
54851    fn r#set_ipv6_receive_packet_info(
54852        &self,
54853        mut value: bool,
54854    ) -> Self::SetIpv6ReceivePacketInfoResponseFut {
54855        fn _decode(
54856            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54857        ) -> Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error> {
54858            let _response = fidl::client::decode_transaction_body::<
54859                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54860                fidl::encoding::DefaultFuchsiaResourceDialect,
54861                0x19259775b1a92768,
54862            >(_buf?)?;
54863            Ok(_response.map(|x| x))
54864        }
54865        self.client.send_query_and_decode::<
54866            BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
54867            BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
54868        >(
54869            (value,),
54870            0x19259775b1a92768,
54871            fidl::encoding::DynamicFlags::empty(),
54872            _decode,
54873        )
54874    }
54875
54876    type GetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
54877        BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
54878        fidl::encoding::DefaultFuchsiaResourceDialect,
54879    >;
54880    fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut {
54881        fn _decode(
54882            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54883        ) -> Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error> {
54884            let _response = fidl::client::decode_transaction_body::<
54885                fidl::encoding::ResultType<
54886                    BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
54887                    fidl_fuchsia_posix::Errno,
54888                >,
54889                fidl::encoding::DefaultFuchsiaResourceDialect,
54890                0x7acd4a2775baec75,
54891            >(_buf?)?;
54892            Ok(_response.map(|x| x.value))
54893        }
54894        self.client.send_query_and_decode::<
54895            fidl::encoding::EmptyPayload,
54896            BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
54897        >(
54898            (),
54899            0x7acd4a2775baec75,
54900            fidl::encoding::DynamicFlags::empty(),
54901            _decode,
54902        )
54903    }
54904
54905    type GetOriginalDestinationResponseFut = fidl::client::QueryResponseFut<
54906        BaseNetworkSocketGetOriginalDestinationResult,
54907        fidl::encoding::DefaultFuchsiaResourceDialect,
54908    >;
54909    fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut {
54910        fn _decode(
54911            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54912        ) -> Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error> {
54913            let _response = fidl::client::decode_transaction_body::<
54914                fidl::encoding::ResultType<
54915                    BaseNetworkSocketGetOriginalDestinationResponse,
54916                    fidl_fuchsia_posix::Errno,
54917                >,
54918                fidl::encoding::DefaultFuchsiaResourceDialect,
54919                0x38bf28f0dafdbac0,
54920            >(_buf?)?;
54921            Ok(_response.map(|x| x.value))
54922        }
54923        self.client.send_query_and_decode::<
54924            fidl::encoding::EmptyPayload,
54925            BaseNetworkSocketGetOriginalDestinationResult,
54926        >(
54927            (),
54928            0x38bf28f0dafdbac0,
54929            fidl::encoding::DynamicFlags::empty(),
54930            _decode,
54931        )
54932    }
54933
54934    type DescribeResponseFut = fidl::client::QueryResponseFut<
54935        StreamSocketDescribeResponse,
54936        fidl::encoding::DefaultFuchsiaResourceDialect,
54937    >;
54938    fn r#describe(&self) -> Self::DescribeResponseFut {
54939        fn _decode(
54940            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54941        ) -> Result<StreamSocketDescribeResponse, fidl::Error> {
54942            let _response = fidl::client::decode_transaction_body::<
54943                StreamSocketDescribeResponse,
54944                fidl::encoding::DefaultFuchsiaResourceDialect,
54945                0x29e22969a7dadc32,
54946            >(_buf?)?;
54947            Ok(_response)
54948        }
54949        self.client
54950            .send_query_and_decode::<fidl::encoding::EmptyPayload, StreamSocketDescribeResponse>(
54951                (),
54952                0x29e22969a7dadc32,
54953                fidl::encoding::DynamicFlags::empty(),
54954                _decode,
54955            )
54956    }
54957
54958    type ListenResponseFut = fidl::client::QueryResponseFut<
54959        StreamSocketListenResult,
54960        fidl::encoding::DefaultFuchsiaResourceDialect,
54961    >;
54962    fn r#listen(&self, mut backlog: i16) -> Self::ListenResponseFut {
54963        fn _decode(
54964            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54965        ) -> Result<StreamSocketListenResult, fidl::Error> {
54966            let _response = fidl::client::decode_transaction_body::<
54967                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
54968                fidl::encoding::DefaultFuchsiaResourceDialect,
54969                0x3d0a65ced3d10108,
54970            >(_buf?)?;
54971            Ok(_response.map(|x| x))
54972        }
54973        self.client.send_query_and_decode::<StreamSocketListenRequest, StreamSocketListenResult>(
54974            (backlog,),
54975            0x3d0a65ced3d10108,
54976            fidl::encoding::DynamicFlags::empty(),
54977            _decode,
54978        )
54979    }
54980
54981    type AcceptResponseFut = fidl::client::QueryResponseFut<
54982        StreamSocketAcceptResult,
54983        fidl::encoding::DefaultFuchsiaResourceDialect,
54984    >;
54985    fn r#accept(&self, mut want_addr: bool) -> Self::AcceptResponseFut {
54986        fn _decode(
54987            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
54988        ) -> Result<StreamSocketAcceptResult, fidl::Error> {
54989            let _response = fidl::client::decode_transaction_body::<
54990                fidl::encoding::ResultType<StreamSocketAcceptResponse, fidl_fuchsia_posix::Errno>,
54991                fidl::encoding::DefaultFuchsiaResourceDialect,
54992                0x5ab7ad620424c163,
54993            >(_buf?)?;
54994            Ok(_response.map(|x| (x.addr, x.s)))
54995        }
54996        self.client.send_query_and_decode::<StreamSocketAcceptRequest, StreamSocketAcceptResult>(
54997            (want_addr,),
54998            0x5ab7ad620424c163,
54999            fidl::encoding::DynamicFlags::empty(),
55000            _decode,
55001        )
55002    }
55003
55004    type GetInfoResponseFut = fidl::client::QueryResponseFut<
55005        StreamSocketGetInfoResult,
55006        fidl::encoding::DefaultFuchsiaResourceDialect,
55007    >;
55008    fn r#get_info(&self) -> Self::GetInfoResponseFut {
55009        fn _decode(
55010            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55011        ) -> Result<StreamSocketGetInfoResult, fidl::Error> {
55012            let _response = fidl::client::decode_transaction_body::<
55013                fidl::encoding::ResultType<StreamSocketGetInfoResponse, fidl_fuchsia_posix::Errno>,
55014                fidl::encoding::DefaultFuchsiaResourceDialect,
55015                0x87cfa55d19f878f,
55016            >(_buf?)?;
55017            Ok(_response.map(|x| (x.domain, x.proto)))
55018        }
55019        self.client
55020            .send_query_and_decode::<fidl::encoding::EmptyPayload, StreamSocketGetInfoResult>(
55021                (),
55022                0x87cfa55d19f878f,
55023                fidl::encoding::DynamicFlags::empty(),
55024                _decode,
55025            )
55026    }
55027
55028    type SetTcpNoDelayResponseFut = fidl::client::QueryResponseFut<
55029        StreamSocketSetTcpNoDelayResult,
55030        fidl::encoding::DefaultFuchsiaResourceDialect,
55031    >;
55032    fn r#set_tcp_no_delay(&self, mut value: bool) -> Self::SetTcpNoDelayResponseFut {
55033        fn _decode(
55034            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55035        ) -> Result<StreamSocketSetTcpNoDelayResult, fidl::Error> {
55036            let _response = fidl::client::decode_transaction_body::<
55037                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
55038                fidl::encoding::DefaultFuchsiaResourceDialect,
55039                0x5a59b778f7333ada,
55040            >(_buf?)?;
55041            Ok(_response.map(|x| x))
55042        }
55043        self.client.send_query_and_decode::<
55044            StreamSocketSetTcpNoDelayRequest,
55045            StreamSocketSetTcpNoDelayResult,
55046        >(
55047            (value,),
55048            0x5a59b778f7333ada,
55049            fidl::encoding::DynamicFlags::empty(),
55050            _decode,
55051        )
55052    }
55053
55054    type GetTcpNoDelayResponseFut = fidl::client::QueryResponseFut<
55055        StreamSocketGetTcpNoDelayResult,
55056        fidl::encoding::DefaultFuchsiaResourceDialect,
55057    >;
55058    fn r#get_tcp_no_delay(&self) -> Self::GetTcpNoDelayResponseFut {
55059        fn _decode(
55060            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55061        ) -> Result<StreamSocketGetTcpNoDelayResult, fidl::Error> {
55062            let _response = fidl::client::decode_transaction_body::<
55063                fidl::encoding::ResultType<
55064                    StreamSocketGetTcpNoDelayResponse,
55065                    fidl_fuchsia_posix::Errno,
55066                >,
55067                fidl::encoding::DefaultFuchsiaResourceDialect,
55068                0xac219a3218b0799,
55069            >(_buf?)?;
55070            Ok(_response.map(|x| x.value))
55071        }
55072        self.client
55073            .send_query_and_decode::<fidl::encoding::EmptyPayload, StreamSocketGetTcpNoDelayResult>(
55074                (),
55075                0xac219a3218b0799,
55076                fidl::encoding::DynamicFlags::empty(),
55077                _decode,
55078            )
55079    }
55080
55081    type SetTcpMaxSegmentResponseFut = fidl::client::QueryResponseFut<
55082        StreamSocketSetTcpMaxSegmentResult,
55083        fidl::encoding::DefaultFuchsiaResourceDialect,
55084    >;
55085    fn r#set_tcp_max_segment(&self, mut value_bytes: u32) -> Self::SetTcpMaxSegmentResponseFut {
55086        fn _decode(
55087            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55088        ) -> Result<StreamSocketSetTcpMaxSegmentResult, fidl::Error> {
55089            let _response = fidl::client::decode_transaction_body::<
55090                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
55091                fidl::encoding::DefaultFuchsiaResourceDialect,
55092                0xb3d30c498266d18,
55093            >(_buf?)?;
55094            Ok(_response.map(|x| x))
55095        }
55096        self.client.send_query_and_decode::<
55097            StreamSocketSetTcpMaxSegmentRequest,
55098            StreamSocketSetTcpMaxSegmentResult,
55099        >(
55100            (value_bytes,),
55101            0xb3d30c498266d18,
55102            fidl::encoding::DynamicFlags::empty(),
55103            _decode,
55104        )
55105    }
55106
55107    type GetTcpMaxSegmentResponseFut = fidl::client::QueryResponseFut<
55108        StreamSocketGetTcpMaxSegmentResult,
55109        fidl::encoding::DefaultFuchsiaResourceDialect,
55110    >;
55111    fn r#get_tcp_max_segment(&self) -> Self::GetTcpMaxSegmentResponseFut {
55112        fn _decode(
55113            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55114        ) -> Result<StreamSocketGetTcpMaxSegmentResult, fidl::Error> {
55115            let _response = fidl::client::decode_transaction_body::<
55116                fidl::encoding::ResultType<
55117                    StreamSocketGetTcpMaxSegmentResponse,
55118                    fidl_fuchsia_posix::Errno,
55119                >,
55120                fidl::encoding::DefaultFuchsiaResourceDialect,
55121                0x637404d1b4b9982c,
55122            >(_buf?)?;
55123            Ok(_response.map(|x| x.value_bytes))
55124        }
55125        self.client.send_query_and_decode::<
55126            fidl::encoding::EmptyPayload,
55127            StreamSocketGetTcpMaxSegmentResult,
55128        >(
55129            (),
55130            0x637404d1b4b9982c,
55131            fidl::encoding::DynamicFlags::empty(),
55132            _decode,
55133        )
55134    }
55135
55136    type SetTcpCorkResponseFut = fidl::client::QueryResponseFut<
55137        StreamSocketSetTcpCorkResult,
55138        fidl::encoding::DefaultFuchsiaResourceDialect,
55139    >;
55140    fn r#set_tcp_cork(&self, mut value: bool) -> Self::SetTcpCorkResponseFut {
55141        fn _decode(
55142            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55143        ) -> Result<StreamSocketSetTcpCorkResult, fidl::Error> {
55144            let _response = fidl::client::decode_transaction_body::<
55145                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
55146                fidl::encoding::DefaultFuchsiaResourceDialect,
55147                0x62e26891541143a0,
55148            >(_buf?)?;
55149            Ok(_response.map(|x| x))
55150        }
55151        self.client
55152            .send_query_and_decode::<StreamSocketSetTcpCorkRequest, StreamSocketSetTcpCorkResult>(
55153                (value,),
55154                0x62e26891541143a0,
55155                fidl::encoding::DynamicFlags::empty(),
55156                _decode,
55157            )
55158    }
55159
55160    type GetTcpCorkResponseFut = fidl::client::QueryResponseFut<
55161        StreamSocketGetTcpCorkResult,
55162        fidl::encoding::DefaultFuchsiaResourceDialect,
55163    >;
55164    fn r#get_tcp_cork(&self) -> Self::GetTcpCorkResponseFut {
55165        fn _decode(
55166            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55167        ) -> Result<StreamSocketGetTcpCorkResult, fidl::Error> {
55168            let _response = fidl::client::decode_transaction_body::<
55169                fidl::encoding::ResultType<
55170                    StreamSocketGetTcpCorkResponse,
55171                    fidl_fuchsia_posix::Errno,
55172                >,
55173                fidl::encoding::DefaultFuchsiaResourceDialect,
55174                0x435bb232e0e74f32,
55175            >(_buf?)?;
55176            Ok(_response.map(|x| x.value))
55177        }
55178        self.client
55179            .send_query_and_decode::<fidl::encoding::EmptyPayload, StreamSocketGetTcpCorkResult>(
55180                (),
55181                0x435bb232e0e74f32,
55182                fidl::encoding::DynamicFlags::empty(),
55183                _decode,
55184            )
55185    }
55186
55187    type SetTcpKeepAliveIdleResponseFut = fidl::client::QueryResponseFut<
55188        StreamSocketSetTcpKeepAliveIdleResult,
55189        fidl::encoding::DefaultFuchsiaResourceDialect,
55190    >;
55191    fn r#set_tcp_keep_alive_idle(
55192        &self,
55193        mut value_secs: u32,
55194    ) -> Self::SetTcpKeepAliveIdleResponseFut {
55195        fn _decode(
55196            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55197        ) -> Result<StreamSocketSetTcpKeepAliveIdleResult, fidl::Error> {
55198            let _response = fidl::client::decode_transaction_body::<
55199                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
55200                fidl::encoding::DefaultFuchsiaResourceDialect,
55201                0x196d053d8363c42,
55202            >(_buf?)?;
55203            Ok(_response.map(|x| x))
55204        }
55205        self.client.send_query_and_decode::<
55206            StreamSocketSetTcpKeepAliveIdleRequest,
55207            StreamSocketSetTcpKeepAliveIdleResult,
55208        >(
55209            (value_secs,),
55210            0x196d053d8363c42,
55211            fidl::encoding::DynamicFlags::empty(),
55212            _decode,
55213        )
55214    }
55215
55216    type GetTcpKeepAliveIdleResponseFut = fidl::client::QueryResponseFut<
55217        StreamSocketGetTcpKeepAliveIdleResult,
55218        fidl::encoding::DefaultFuchsiaResourceDialect,
55219    >;
55220    fn r#get_tcp_keep_alive_idle(&self) -> Self::GetTcpKeepAliveIdleResponseFut {
55221        fn _decode(
55222            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55223        ) -> Result<StreamSocketGetTcpKeepAliveIdleResult, fidl::Error> {
55224            let _response = fidl::client::decode_transaction_body::<
55225                fidl::encoding::ResultType<
55226                    StreamSocketGetTcpKeepAliveIdleResponse,
55227                    fidl_fuchsia_posix::Errno,
55228                >,
55229                fidl::encoding::DefaultFuchsiaResourceDialect,
55230                0x35ec58564879dac,
55231            >(_buf?)?;
55232            Ok(_response.map(|x| x.value_secs))
55233        }
55234        self.client.send_query_and_decode::<
55235            fidl::encoding::EmptyPayload,
55236            StreamSocketGetTcpKeepAliveIdleResult,
55237        >(
55238            (),
55239            0x35ec58564879dac,
55240            fidl::encoding::DynamicFlags::empty(),
55241            _decode,
55242        )
55243    }
55244
55245    type SetTcpKeepAliveIntervalResponseFut = fidl::client::QueryResponseFut<
55246        StreamSocketSetTcpKeepAliveIntervalResult,
55247        fidl::encoding::DefaultFuchsiaResourceDialect,
55248    >;
55249    fn r#set_tcp_keep_alive_interval(
55250        &self,
55251        mut value_secs: u32,
55252    ) -> Self::SetTcpKeepAliveIntervalResponseFut {
55253        fn _decode(
55254            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55255        ) -> Result<StreamSocketSetTcpKeepAliveIntervalResult, fidl::Error> {
55256            let _response = fidl::client::decode_transaction_body::<
55257                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
55258                fidl::encoding::DefaultFuchsiaResourceDialect,
55259                0x485ffbc2da1243f2,
55260            >(_buf?)?;
55261            Ok(_response.map(|x| x))
55262        }
55263        self.client.send_query_and_decode::<
55264            StreamSocketSetTcpKeepAliveIntervalRequest,
55265            StreamSocketSetTcpKeepAliveIntervalResult,
55266        >(
55267            (value_secs,),
55268            0x485ffbc2da1243f2,
55269            fidl::encoding::DynamicFlags::empty(),
55270            _decode,
55271        )
55272    }
55273
55274    type GetTcpKeepAliveIntervalResponseFut = fidl::client::QueryResponseFut<
55275        StreamSocketGetTcpKeepAliveIntervalResult,
55276        fidl::encoding::DefaultFuchsiaResourceDialect,
55277    >;
55278    fn r#get_tcp_keep_alive_interval(&self) -> Self::GetTcpKeepAliveIntervalResponseFut {
55279        fn _decode(
55280            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55281        ) -> Result<StreamSocketGetTcpKeepAliveIntervalResult, fidl::Error> {
55282            let _response = fidl::client::decode_transaction_body::<
55283                fidl::encoding::ResultType<
55284                    StreamSocketGetTcpKeepAliveIntervalResponse,
55285                    fidl_fuchsia_posix::Errno,
55286                >,
55287                fidl::encoding::DefaultFuchsiaResourceDialect,
55288                0x264eaf46306b284,
55289            >(_buf?)?;
55290            Ok(_response.map(|x| x.value_secs))
55291        }
55292        self.client.send_query_and_decode::<
55293            fidl::encoding::EmptyPayload,
55294            StreamSocketGetTcpKeepAliveIntervalResult,
55295        >(
55296            (),
55297            0x264eaf46306b284,
55298            fidl::encoding::DynamicFlags::empty(),
55299            _decode,
55300        )
55301    }
55302
55303    type SetTcpKeepAliveCountResponseFut = fidl::client::QueryResponseFut<
55304        StreamSocketSetTcpKeepAliveCountResult,
55305        fidl::encoding::DefaultFuchsiaResourceDialect,
55306    >;
55307    fn r#set_tcp_keep_alive_count(&self, mut value: u32) -> Self::SetTcpKeepAliveCountResponseFut {
55308        fn _decode(
55309            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55310        ) -> Result<StreamSocketSetTcpKeepAliveCountResult, fidl::Error> {
55311            let _response = fidl::client::decode_transaction_body::<
55312                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
55313                fidl::encoding::DefaultFuchsiaResourceDialect,
55314                0x2ab2e8c111708421,
55315            >(_buf?)?;
55316            Ok(_response.map(|x| x))
55317        }
55318        self.client.send_query_and_decode::<
55319            StreamSocketSetTcpKeepAliveCountRequest,
55320            StreamSocketSetTcpKeepAliveCountResult,
55321        >(
55322            (value,),
55323            0x2ab2e8c111708421,
55324            fidl::encoding::DynamicFlags::empty(),
55325            _decode,
55326        )
55327    }
55328
55329    type GetTcpKeepAliveCountResponseFut = fidl::client::QueryResponseFut<
55330        StreamSocketGetTcpKeepAliveCountResult,
55331        fidl::encoding::DefaultFuchsiaResourceDialect,
55332    >;
55333    fn r#get_tcp_keep_alive_count(&self) -> Self::GetTcpKeepAliveCountResponseFut {
55334        fn _decode(
55335            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55336        ) -> Result<StreamSocketGetTcpKeepAliveCountResult, fidl::Error> {
55337            let _response = fidl::client::decode_transaction_body::<
55338                fidl::encoding::ResultType<
55339                    StreamSocketGetTcpKeepAliveCountResponse,
55340                    fidl_fuchsia_posix::Errno,
55341                >,
55342                fidl::encoding::DefaultFuchsiaResourceDialect,
55343                0x2f176ae271fe7a09,
55344            >(_buf?)?;
55345            Ok(_response.map(|x| x.value))
55346        }
55347        self.client.send_query_and_decode::<
55348            fidl::encoding::EmptyPayload,
55349            StreamSocketGetTcpKeepAliveCountResult,
55350        >(
55351            (),
55352            0x2f176ae271fe7a09,
55353            fidl::encoding::DynamicFlags::empty(),
55354            _decode,
55355        )
55356    }
55357
55358    type SetTcpSynCountResponseFut = fidl::client::QueryResponseFut<
55359        StreamSocketSetTcpSynCountResult,
55360        fidl::encoding::DefaultFuchsiaResourceDialect,
55361    >;
55362    fn r#set_tcp_syn_count(&self, mut value: u32) -> Self::SetTcpSynCountResponseFut {
55363        fn _decode(
55364            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55365        ) -> Result<StreamSocketSetTcpSynCountResult, fidl::Error> {
55366            let _response = fidl::client::decode_transaction_body::<
55367                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
55368                fidl::encoding::DefaultFuchsiaResourceDialect,
55369                0x4dcd6ab5573c1eb3,
55370            >(_buf?)?;
55371            Ok(_response.map(|x| x))
55372        }
55373        self.client.send_query_and_decode::<
55374            StreamSocketSetTcpSynCountRequest,
55375            StreamSocketSetTcpSynCountResult,
55376        >(
55377            (value,),
55378            0x4dcd6ab5573c1eb3,
55379            fidl::encoding::DynamicFlags::empty(),
55380            _decode,
55381        )
55382    }
55383
55384    type GetTcpSynCountResponseFut = fidl::client::QueryResponseFut<
55385        StreamSocketGetTcpSynCountResult,
55386        fidl::encoding::DefaultFuchsiaResourceDialect,
55387    >;
55388    fn r#get_tcp_syn_count(&self) -> Self::GetTcpSynCountResponseFut {
55389        fn _decode(
55390            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55391        ) -> Result<StreamSocketGetTcpSynCountResult, fidl::Error> {
55392            let _response = fidl::client::decode_transaction_body::<
55393                fidl::encoding::ResultType<
55394                    StreamSocketGetTcpSynCountResponse,
55395                    fidl_fuchsia_posix::Errno,
55396                >,
55397                fidl::encoding::DefaultFuchsiaResourceDialect,
55398                0x7d457cba8f5f3ee6,
55399            >(_buf?)?;
55400            Ok(_response.map(|x| x.value))
55401        }
55402        self.client.send_query_and_decode::<
55403            fidl::encoding::EmptyPayload,
55404            StreamSocketGetTcpSynCountResult,
55405        >(
55406            (),
55407            0x7d457cba8f5f3ee6,
55408            fidl::encoding::DynamicFlags::empty(),
55409            _decode,
55410        )
55411    }
55412
55413    type SetTcpLingerResponseFut = fidl::client::QueryResponseFut<
55414        StreamSocketSetTcpLingerResult,
55415        fidl::encoding::DefaultFuchsiaResourceDialect,
55416    >;
55417    fn r#set_tcp_linger(&self, mut value_secs: &OptionalUint32) -> Self::SetTcpLingerResponseFut {
55418        fn _decode(
55419            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55420        ) -> Result<StreamSocketSetTcpLingerResult, fidl::Error> {
55421            let _response = fidl::client::decode_transaction_body::<
55422                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
55423                fidl::encoding::DefaultFuchsiaResourceDialect,
55424                0xd5cc1e8654d36e4,
55425            >(_buf?)?;
55426            Ok(_response.map(|x| x))
55427        }
55428        self.client.send_query_and_decode::<
55429            StreamSocketSetTcpLingerRequest,
55430            StreamSocketSetTcpLingerResult,
55431        >(
55432            (value_secs,),
55433            0xd5cc1e8654d36e4,
55434            fidl::encoding::DynamicFlags::empty(),
55435            _decode,
55436        )
55437    }
55438
55439    type GetTcpLingerResponseFut = fidl::client::QueryResponseFut<
55440        StreamSocketGetTcpLingerResult,
55441        fidl::encoding::DefaultFuchsiaResourceDialect,
55442    >;
55443    fn r#get_tcp_linger(&self) -> Self::GetTcpLingerResponseFut {
55444        fn _decode(
55445            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55446        ) -> Result<StreamSocketGetTcpLingerResult, fidl::Error> {
55447            let _response = fidl::client::decode_transaction_body::<
55448                fidl::encoding::ResultType<
55449                    StreamSocketGetTcpLingerResponse,
55450                    fidl_fuchsia_posix::Errno,
55451                >,
55452                fidl::encoding::DefaultFuchsiaResourceDialect,
55453                0xad870d311cf30eb,
55454            >(_buf?)?;
55455            Ok(_response.map(|x| x.value_secs))
55456        }
55457        self.client
55458            .send_query_and_decode::<fidl::encoding::EmptyPayload, StreamSocketGetTcpLingerResult>(
55459                (),
55460                0xad870d311cf30eb,
55461                fidl::encoding::DynamicFlags::empty(),
55462                _decode,
55463            )
55464    }
55465
55466    type SetTcpDeferAcceptResponseFut = fidl::client::QueryResponseFut<
55467        StreamSocketSetTcpDeferAcceptResult,
55468        fidl::encoding::DefaultFuchsiaResourceDialect,
55469    >;
55470    fn r#set_tcp_defer_accept(&self, mut value_secs: u32) -> Self::SetTcpDeferAcceptResponseFut {
55471        fn _decode(
55472            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55473        ) -> Result<StreamSocketSetTcpDeferAcceptResult, fidl::Error> {
55474            let _response = fidl::client::decode_transaction_body::<
55475                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
55476                fidl::encoding::DefaultFuchsiaResourceDialect,
55477                0x15092f181e57c404,
55478            >(_buf?)?;
55479            Ok(_response.map(|x| x))
55480        }
55481        self.client.send_query_and_decode::<
55482            StreamSocketSetTcpDeferAcceptRequest,
55483            StreamSocketSetTcpDeferAcceptResult,
55484        >(
55485            (value_secs,),
55486            0x15092f181e57c404,
55487            fidl::encoding::DynamicFlags::empty(),
55488            _decode,
55489        )
55490    }
55491
55492    type GetTcpDeferAcceptResponseFut = fidl::client::QueryResponseFut<
55493        StreamSocketGetTcpDeferAcceptResult,
55494        fidl::encoding::DefaultFuchsiaResourceDialect,
55495    >;
55496    fn r#get_tcp_defer_accept(&self) -> Self::GetTcpDeferAcceptResponseFut {
55497        fn _decode(
55498            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55499        ) -> Result<StreamSocketGetTcpDeferAcceptResult, fidl::Error> {
55500            let _response = fidl::client::decode_transaction_body::<
55501                fidl::encoding::ResultType<
55502                    StreamSocketGetTcpDeferAcceptResponse,
55503                    fidl_fuchsia_posix::Errno,
55504                >,
55505                fidl::encoding::DefaultFuchsiaResourceDialect,
55506                0x64589790842cb7c6,
55507            >(_buf?)?;
55508            Ok(_response.map(|x| x.value_secs))
55509        }
55510        self.client.send_query_and_decode::<
55511            fidl::encoding::EmptyPayload,
55512            StreamSocketGetTcpDeferAcceptResult,
55513        >(
55514            (),
55515            0x64589790842cb7c6,
55516            fidl::encoding::DynamicFlags::empty(),
55517            _decode,
55518        )
55519    }
55520
55521    type SetTcpWindowClampResponseFut = fidl::client::QueryResponseFut<
55522        StreamSocketSetTcpWindowClampResult,
55523        fidl::encoding::DefaultFuchsiaResourceDialect,
55524    >;
55525    fn r#set_tcp_window_clamp(&self, mut value: u32) -> Self::SetTcpWindowClampResponseFut {
55526        fn _decode(
55527            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55528        ) -> Result<StreamSocketSetTcpWindowClampResult, fidl::Error> {
55529            let _response = fidl::client::decode_transaction_body::<
55530                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
55531                fidl::encoding::DefaultFuchsiaResourceDialect,
55532                0x4a26ce07d847f1c6,
55533            >(_buf?)?;
55534            Ok(_response.map(|x| x))
55535        }
55536        self.client.send_query_and_decode::<
55537            StreamSocketSetTcpWindowClampRequest,
55538            StreamSocketSetTcpWindowClampResult,
55539        >(
55540            (value,),
55541            0x4a26ce07d847f1c6,
55542            fidl::encoding::DynamicFlags::empty(),
55543            _decode,
55544        )
55545    }
55546
55547    type GetTcpWindowClampResponseFut = fidl::client::QueryResponseFut<
55548        StreamSocketGetTcpWindowClampResult,
55549        fidl::encoding::DefaultFuchsiaResourceDialect,
55550    >;
55551    fn r#get_tcp_window_clamp(&self) -> Self::GetTcpWindowClampResponseFut {
55552        fn _decode(
55553            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55554        ) -> Result<StreamSocketGetTcpWindowClampResult, fidl::Error> {
55555            let _response = fidl::client::decode_transaction_body::<
55556                fidl::encoding::ResultType<
55557                    StreamSocketGetTcpWindowClampResponse,
55558                    fidl_fuchsia_posix::Errno,
55559                >,
55560                fidl::encoding::DefaultFuchsiaResourceDialect,
55561                0x2df6b636bf0a6a4e,
55562            >(_buf?)?;
55563            Ok(_response.map(|x| x.value))
55564        }
55565        self.client.send_query_and_decode::<
55566            fidl::encoding::EmptyPayload,
55567            StreamSocketGetTcpWindowClampResult,
55568        >(
55569            (),
55570            0x2df6b636bf0a6a4e,
55571            fidl::encoding::DynamicFlags::empty(),
55572            _decode,
55573        )
55574    }
55575
55576    type GetTcpInfoResponseFut = fidl::client::QueryResponseFut<
55577        StreamSocketGetTcpInfoResult,
55578        fidl::encoding::DefaultFuchsiaResourceDialect,
55579    >;
55580    fn r#get_tcp_info(&self) -> Self::GetTcpInfoResponseFut {
55581        fn _decode(
55582            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55583        ) -> Result<StreamSocketGetTcpInfoResult, fidl::Error> {
55584            let _response = fidl::client::decode_transaction_body::<
55585                fidl::encoding::ResultType<
55586                    StreamSocketGetTcpInfoResponse,
55587                    fidl_fuchsia_posix::Errno,
55588                >,
55589                fidl::encoding::DefaultFuchsiaResourceDialect,
55590                0x1ffb123d9f03ead2,
55591            >(_buf?)?;
55592            Ok(_response.map(|x| x.info))
55593        }
55594        self.client
55595            .send_query_and_decode::<fidl::encoding::EmptyPayload, StreamSocketGetTcpInfoResult>(
55596                (),
55597                0x1ffb123d9f03ead2,
55598                fidl::encoding::DynamicFlags::empty(),
55599                _decode,
55600            )
55601    }
55602
55603    type SetTcpQuickAckResponseFut = fidl::client::QueryResponseFut<
55604        StreamSocketSetTcpQuickAckResult,
55605        fidl::encoding::DefaultFuchsiaResourceDialect,
55606    >;
55607    fn r#set_tcp_quick_ack(&self, mut value: bool) -> Self::SetTcpQuickAckResponseFut {
55608        fn _decode(
55609            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55610        ) -> Result<StreamSocketSetTcpQuickAckResult, fidl::Error> {
55611            let _response = fidl::client::decode_transaction_body::<
55612                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
55613                fidl::encoding::DefaultFuchsiaResourceDialect,
55614                0x6fa811be8fde7457,
55615            >(_buf?)?;
55616            Ok(_response.map(|x| x))
55617        }
55618        self.client.send_query_and_decode::<
55619            StreamSocketSetTcpQuickAckRequest,
55620            StreamSocketSetTcpQuickAckResult,
55621        >(
55622            (value,),
55623            0x6fa811be8fde7457,
55624            fidl::encoding::DynamicFlags::empty(),
55625            _decode,
55626        )
55627    }
55628
55629    type GetTcpQuickAckResponseFut = fidl::client::QueryResponseFut<
55630        StreamSocketGetTcpQuickAckResult,
55631        fidl::encoding::DefaultFuchsiaResourceDialect,
55632    >;
55633    fn r#get_tcp_quick_ack(&self) -> Self::GetTcpQuickAckResponseFut {
55634        fn _decode(
55635            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55636        ) -> Result<StreamSocketGetTcpQuickAckResult, fidl::Error> {
55637            let _response = fidl::client::decode_transaction_body::<
55638                fidl::encoding::ResultType<
55639                    StreamSocketGetTcpQuickAckResponse,
55640                    fidl_fuchsia_posix::Errno,
55641                >,
55642                fidl::encoding::DefaultFuchsiaResourceDialect,
55643                0x7356a949bef2df32,
55644            >(_buf?)?;
55645            Ok(_response.map(|x| x.value))
55646        }
55647        self.client.send_query_and_decode::<
55648            fidl::encoding::EmptyPayload,
55649            StreamSocketGetTcpQuickAckResult,
55650        >(
55651            (),
55652            0x7356a949bef2df32,
55653            fidl::encoding::DynamicFlags::empty(),
55654            _decode,
55655        )
55656    }
55657
55658    type SetTcpCongestionResponseFut = fidl::client::QueryResponseFut<
55659        StreamSocketSetTcpCongestionResult,
55660        fidl::encoding::DefaultFuchsiaResourceDialect,
55661    >;
55662    fn r#set_tcp_congestion(
55663        &self,
55664        mut value: TcpCongestionControl,
55665    ) -> Self::SetTcpCongestionResponseFut {
55666        fn _decode(
55667            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55668        ) -> Result<StreamSocketSetTcpCongestionResult, fidl::Error> {
55669            let _response = fidl::client::decode_transaction_body::<
55670                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
55671                fidl::encoding::DefaultFuchsiaResourceDialect,
55672                0x7924c6eabde7819e,
55673            >(_buf?)?;
55674            Ok(_response.map(|x| x))
55675        }
55676        self.client.send_query_and_decode::<
55677            StreamSocketSetTcpCongestionRequest,
55678            StreamSocketSetTcpCongestionResult,
55679        >(
55680            (value,),
55681            0x7924c6eabde7819e,
55682            fidl::encoding::DynamicFlags::empty(),
55683            _decode,
55684        )
55685    }
55686
55687    type GetTcpCongestionResponseFut = fidl::client::QueryResponseFut<
55688        StreamSocketGetTcpCongestionResult,
55689        fidl::encoding::DefaultFuchsiaResourceDialect,
55690    >;
55691    fn r#get_tcp_congestion(&self) -> Self::GetTcpCongestionResponseFut {
55692        fn _decode(
55693            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55694        ) -> Result<StreamSocketGetTcpCongestionResult, fidl::Error> {
55695            let _response = fidl::client::decode_transaction_body::<
55696                fidl::encoding::ResultType<
55697                    StreamSocketGetTcpCongestionResponse,
55698                    fidl_fuchsia_posix::Errno,
55699                >,
55700                fidl::encoding::DefaultFuchsiaResourceDialect,
55701                0x11e16397e1b72a47,
55702            >(_buf?)?;
55703            Ok(_response.map(|x| x.value))
55704        }
55705        self.client.send_query_and_decode::<
55706            fidl::encoding::EmptyPayload,
55707            StreamSocketGetTcpCongestionResult,
55708        >(
55709            (),
55710            0x11e16397e1b72a47,
55711            fidl::encoding::DynamicFlags::empty(),
55712            _decode,
55713        )
55714    }
55715
55716    type SetTcpUserTimeoutResponseFut = fidl::client::QueryResponseFut<
55717        StreamSocketSetTcpUserTimeoutResult,
55718        fidl::encoding::DefaultFuchsiaResourceDialect,
55719    >;
55720    fn r#set_tcp_user_timeout(&self, mut value_millis: u32) -> Self::SetTcpUserTimeoutResponseFut {
55721        fn _decode(
55722            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55723        ) -> Result<StreamSocketSetTcpUserTimeoutResult, fidl::Error> {
55724            let _response = fidl::client::decode_transaction_body::<
55725                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
55726                fidl::encoding::DefaultFuchsiaResourceDialect,
55727                0x6b459e81c3741a60,
55728            >(_buf?)?;
55729            Ok(_response.map(|x| x))
55730        }
55731        self.client.send_query_and_decode::<
55732            StreamSocketSetTcpUserTimeoutRequest,
55733            StreamSocketSetTcpUserTimeoutResult,
55734        >(
55735            (value_millis,),
55736            0x6b459e81c3741a60,
55737            fidl::encoding::DynamicFlags::empty(),
55738            _decode,
55739        )
55740    }
55741
55742    type GetTcpUserTimeoutResponseFut = fidl::client::QueryResponseFut<
55743        StreamSocketGetTcpUserTimeoutResult,
55744        fidl::encoding::DefaultFuchsiaResourceDialect,
55745    >;
55746    fn r#get_tcp_user_timeout(&self) -> Self::GetTcpUserTimeoutResponseFut {
55747        fn _decode(
55748            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
55749        ) -> Result<StreamSocketGetTcpUserTimeoutResult, fidl::Error> {
55750            let _response = fidl::client::decode_transaction_body::<
55751                fidl::encoding::ResultType<
55752                    StreamSocketGetTcpUserTimeoutResponse,
55753                    fidl_fuchsia_posix::Errno,
55754                >,
55755                fidl::encoding::DefaultFuchsiaResourceDialect,
55756                0x24bbd5858ad8c380,
55757            >(_buf?)?;
55758            Ok(_response.map(|x| x.value_millis))
55759        }
55760        self.client.send_query_and_decode::<
55761            fidl::encoding::EmptyPayload,
55762            StreamSocketGetTcpUserTimeoutResult,
55763        >(
55764            (),
55765            0x24bbd5858ad8c380,
55766            fidl::encoding::DynamicFlags::empty(),
55767            _decode,
55768        )
55769    }
55770}
55771
55772pub struct StreamSocketEventStream {
55773    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
55774}
55775
55776impl std::marker::Unpin for StreamSocketEventStream {}
55777
55778impl futures::stream::FusedStream for StreamSocketEventStream {
55779    fn is_terminated(&self) -> bool {
55780        self.event_receiver.is_terminated()
55781    }
55782}
55783
55784impl futures::Stream for StreamSocketEventStream {
55785    type Item = Result<StreamSocketEvent, fidl::Error>;
55786
55787    fn poll_next(
55788        mut self: std::pin::Pin<&mut Self>,
55789        cx: &mut std::task::Context<'_>,
55790    ) -> std::task::Poll<Option<Self::Item>> {
55791        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
55792            &mut self.event_receiver,
55793            cx
55794        )?) {
55795            Some(buf) => std::task::Poll::Ready(Some(StreamSocketEvent::decode(buf))),
55796            None => std::task::Poll::Ready(None),
55797        }
55798    }
55799}
55800
55801#[derive(Debug)]
55802pub enum StreamSocketEvent {}
55803
55804impl StreamSocketEvent {
55805    /// Decodes a message buffer as a [`StreamSocketEvent`].
55806    fn decode(
55807        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
55808    ) -> Result<StreamSocketEvent, fidl::Error> {
55809        let (bytes, _handles) = buf.split_mut();
55810        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
55811        debug_assert_eq!(tx_header.tx_id, 0);
55812        match tx_header.ordinal {
55813            _ => Err(fidl::Error::UnknownOrdinal {
55814                ordinal: tx_header.ordinal,
55815                protocol_name: <StreamSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
55816            }),
55817        }
55818    }
55819}
55820
55821/// A Stream of incoming requests for fuchsia.posix.socket/StreamSocket.
55822pub struct StreamSocketRequestStream {
55823    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
55824    is_terminated: bool,
55825}
55826
55827impl std::marker::Unpin for StreamSocketRequestStream {}
55828
55829impl futures::stream::FusedStream for StreamSocketRequestStream {
55830    fn is_terminated(&self) -> bool {
55831        self.is_terminated
55832    }
55833}
55834
55835impl fidl::endpoints::RequestStream for StreamSocketRequestStream {
55836    type Protocol = StreamSocketMarker;
55837    type ControlHandle = StreamSocketControlHandle;
55838
55839    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
55840        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
55841    }
55842
55843    fn control_handle(&self) -> Self::ControlHandle {
55844        StreamSocketControlHandle { inner: self.inner.clone() }
55845    }
55846
55847    fn into_inner(
55848        self,
55849    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
55850    {
55851        (self.inner, self.is_terminated)
55852    }
55853
55854    fn from_inner(
55855        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
55856        is_terminated: bool,
55857    ) -> Self {
55858        Self { inner, is_terminated }
55859    }
55860}
55861
55862impl futures::Stream for StreamSocketRequestStream {
55863    type Item = Result<StreamSocketRequest, fidl::Error>;
55864
55865    fn poll_next(
55866        mut self: std::pin::Pin<&mut Self>,
55867        cx: &mut std::task::Context<'_>,
55868    ) -> std::task::Poll<Option<Self::Item>> {
55869        let this = &mut *self;
55870        if this.inner.check_shutdown(cx) {
55871            this.is_terminated = true;
55872            return std::task::Poll::Ready(None);
55873        }
55874        if this.is_terminated {
55875            panic!("polled StreamSocketRequestStream after completion");
55876        }
55877        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
55878            |bytes, handles| {
55879                match this.inner.channel().read_etc(cx, bytes, handles) {
55880                    std::task::Poll::Ready(Ok(())) => {}
55881                    std::task::Poll::Pending => return std::task::Poll::Pending,
55882                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
55883                        this.is_terminated = true;
55884                        return std::task::Poll::Ready(None);
55885                    }
55886                    std::task::Poll::Ready(Err(e)) => {
55887                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
55888                            e.into(),
55889                        ))))
55890                    }
55891                }
55892
55893                // A message has been received from the channel
55894                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
55895
55896                std::task::Poll::Ready(Some(match header.ordinal {
55897                    0x20d8a7aba2168a79 => {
55898                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
55899                        let mut req = fidl::new_empty!(
55900                            fidl_fuchsia_unknown::CloneableCloneRequest,
55901                            fidl::encoding::DefaultFuchsiaResourceDialect
55902                        );
55903                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_unknown::CloneableCloneRequest>(&header, _body_bytes, handles, &mut req)?;
55904                        let control_handle =
55905                            StreamSocketControlHandle { inner: this.inner.clone() };
55906                        Ok(StreamSocketRequest::Clone { request: req.request, control_handle })
55907                    }
55908                    0x5ac5d459ad7f657e => {
55909                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
55910                        let mut req = fidl::new_empty!(
55911                            fidl::encoding::EmptyPayload,
55912                            fidl::encoding::DefaultFuchsiaResourceDialect
55913                        );
55914                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
55915                        let control_handle =
55916                            StreamSocketControlHandle { inner: this.inner.clone() };
55917                        Ok(StreamSocketRequest::Close {
55918                            responder: StreamSocketCloseResponder {
55919                                control_handle: std::mem::ManuallyDrop::new(control_handle),
55920                                tx_id: header.tx_id,
55921                            },
55922                        })
55923                    }
55924                    0x2658edee9decfc06 => {
55925                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
55926                        let mut req = fidl::new_empty!(
55927                            fidl::encoding::EmptyPayload,
55928                            fidl::encoding::DefaultFuchsiaResourceDialect
55929                        );
55930                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
55931                        let control_handle =
55932                            StreamSocketControlHandle { inner: this.inner.clone() };
55933                        Ok(StreamSocketRequest::Query {
55934                            responder: StreamSocketQueryResponder {
55935                                control_handle: std::mem::ManuallyDrop::new(control_handle),
55936                                tx_id: header.tx_id,
55937                            },
55938                        })
55939                    }
55940                    0x1fd74ee8b9a4a876 => {
55941                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
55942                        let mut req = fidl::new_empty!(
55943                            BaseSocketSetReuseAddressRequest,
55944                            fidl::encoding::DefaultFuchsiaResourceDialect
55945                        );
55946                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReuseAddressRequest>(&header, _body_bytes, handles, &mut req)?;
55947                        let control_handle =
55948                            StreamSocketControlHandle { inner: this.inner.clone() };
55949                        Ok(StreamSocketRequest::SetReuseAddress {
55950                            value: req.value,
55951
55952                            responder: StreamSocketSetReuseAddressResponder {
55953                                control_handle: std::mem::ManuallyDrop::new(control_handle),
55954                                tx_id: header.tx_id,
55955                            },
55956                        })
55957                    }
55958                    0x67b7206b8d1bc0a5 => {
55959                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
55960                        let mut req = fidl::new_empty!(
55961                            fidl::encoding::EmptyPayload,
55962                            fidl::encoding::DefaultFuchsiaResourceDialect
55963                        );
55964                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
55965                        let control_handle =
55966                            StreamSocketControlHandle { inner: this.inner.clone() };
55967                        Ok(StreamSocketRequest::GetReuseAddress {
55968                            responder: StreamSocketGetReuseAddressResponder {
55969                                control_handle: std::mem::ManuallyDrop::new(control_handle),
55970                                tx_id: header.tx_id,
55971                            },
55972                        })
55973                    }
55974                    0x5aad39b33e5f6ebb => {
55975                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
55976                        let mut req = fidl::new_empty!(
55977                            fidl::encoding::EmptyPayload,
55978                            fidl::encoding::DefaultFuchsiaResourceDialect
55979                        );
55980                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
55981                        let control_handle =
55982                            StreamSocketControlHandle { inner: this.inner.clone() };
55983                        Ok(StreamSocketRequest::GetError {
55984                            responder: StreamSocketGetErrorResponder {
55985                                control_handle: std::mem::ManuallyDrop::new(control_handle),
55986                                tx_id: header.tx_id,
55987                            },
55988                        })
55989                    }
55990                    0x6023e081ce3cd947 => {
55991                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
55992                        let mut req = fidl::new_empty!(
55993                            BaseSocketSetBroadcastRequest,
55994                            fidl::encoding::DefaultFuchsiaResourceDialect
55995                        );
55996                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBroadcastRequest>(&header, _body_bytes, handles, &mut req)?;
55997                        let control_handle =
55998                            StreamSocketControlHandle { inner: this.inner.clone() };
55999                        Ok(StreamSocketRequest::SetBroadcast {
56000                            value: req.value,
56001
56002                            responder: StreamSocketSetBroadcastResponder {
56003                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56004                                tx_id: header.tx_id,
56005                            },
56006                        })
56007                    }
56008                    0x68796fc556f9780d => {
56009                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56010                        let mut req = fidl::new_empty!(
56011                            fidl::encoding::EmptyPayload,
56012                            fidl::encoding::DefaultFuchsiaResourceDialect
56013                        );
56014                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56015                        let control_handle =
56016                            StreamSocketControlHandle { inner: this.inner.clone() };
56017                        Ok(StreamSocketRequest::GetBroadcast {
56018                            responder: StreamSocketGetBroadcastResponder {
56019                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56020                                tx_id: header.tx_id,
56021                            },
56022                        })
56023                    }
56024                    0x756eac32d73a7a70 => {
56025                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56026                        let mut req = fidl::new_empty!(
56027                            BaseSocketSetSendBufferRequest,
56028                            fidl::encoding::DefaultFuchsiaResourceDialect
56029                        );
56030                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetSendBufferRequest>(&header, _body_bytes, handles, &mut req)?;
56031                        let control_handle =
56032                            StreamSocketControlHandle { inner: this.inner.clone() };
56033                        Ok(StreamSocketRequest::SetSendBuffer {
56034                            value_bytes: req.value_bytes,
56035
56036                            responder: StreamSocketSetSendBufferResponder {
56037                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56038                                tx_id: header.tx_id,
56039                            },
56040                        })
56041                    }
56042                    0x78a52fd9c7b2410b => {
56043                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56044                        let mut req = fidl::new_empty!(
56045                            fidl::encoding::EmptyPayload,
56046                            fidl::encoding::DefaultFuchsiaResourceDialect
56047                        );
56048                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56049                        let control_handle =
56050                            StreamSocketControlHandle { inner: this.inner.clone() };
56051                        Ok(StreamSocketRequest::GetSendBuffer {
56052                            responder: StreamSocketGetSendBufferResponder {
56053                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56054                                tx_id: header.tx_id,
56055                            },
56056                        })
56057                    }
56058                    0x6b0cf2f1919c7001 => {
56059                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56060                        let mut req = fidl::new_empty!(
56061                            BaseSocketSetReceiveBufferRequest,
56062                            fidl::encoding::DefaultFuchsiaResourceDialect
56063                        );
56064                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReceiveBufferRequest>(&header, _body_bytes, handles, &mut req)?;
56065                        let control_handle =
56066                            StreamSocketControlHandle { inner: this.inner.clone() };
56067                        Ok(StreamSocketRequest::SetReceiveBuffer {
56068                            value_bytes: req.value_bytes,
56069
56070                            responder: StreamSocketSetReceiveBufferResponder {
56071                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56072                                tx_id: header.tx_id,
56073                            },
56074                        })
56075                    }
56076                    0x14c1a4b64f709e5c => {
56077                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56078                        let mut req = fidl::new_empty!(
56079                            fidl::encoding::EmptyPayload,
56080                            fidl::encoding::DefaultFuchsiaResourceDialect
56081                        );
56082                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56083                        let control_handle =
56084                            StreamSocketControlHandle { inner: this.inner.clone() };
56085                        Ok(StreamSocketRequest::GetReceiveBuffer {
56086                            responder: StreamSocketGetReceiveBufferResponder {
56087                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56088                                tx_id: header.tx_id,
56089                            },
56090                        })
56091                    }
56092                    0x572df8f0b920d2c7 => {
56093                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56094                        let mut req = fidl::new_empty!(
56095                            BaseSocketSetKeepAliveRequest,
56096                            fidl::encoding::DefaultFuchsiaResourceDialect
56097                        );
56098                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetKeepAliveRequest>(&header, _body_bytes, handles, &mut req)?;
56099                        let control_handle =
56100                            StreamSocketControlHandle { inner: this.inner.clone() };
56101                        Ok(StreamSocketRequest::SetKeepAlive {
56102                            value: req.value,
56103
56104                            responder: StreamSocketSetKeepAliveResponder {
56105                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56106                                tx_id: header.tx_id,
56107                            },
56108                        })
56109                    }
56110                    0x2dd29d3215f2c9d2 => {
56111                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56112                        let mut req = fidl::new_empty!(
56113                            fidl::encoding::EmptyPayload,
56114                            fidl::encoding::DefaultFuchsiaResourceDialect
56115                        );
56116                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56117                        let control_handle =
56118                            StreamSocketControlHandle { inner: this.inner.clone() };
56119                        Ok(StreamSocketRequest::GetKeepAlive {
56120                            responder: StreamSocketGetKeepAliveResponder {
56121                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56122                                tx_id: header.tx_id,
56123                            },
56124                        })
56125                    }
56126                    0x3ecb49968bee439 => {
56127                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56128                        let mut req = fidl::new_empty!(
56129                            BaseSocketSetOutOfBandInlineRequest,
56130                            fidl::encoding::DefaultFuchsiaResourceDialect
56131                        );
56132                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetOutOfBandInlineRequest>(&header, _body_bytes, handles, &mut req)?;
56133                        let control_handle =
56134                            StreamSocketControlHandle { inner: this.inner.clone() };
56135                        Ok(StreamSocketRequest::SetOutOfBandInline {
56136                            value: req.value,
56137
56138                            responder: StreamSocketSetOutOfBandInlineResponder {
56139                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56140                                tx_id: header.tx_id,
56141                            },
56142                        })
56143                    }
56144                    0x348c1ab3aeca1745 => {
56145                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56146                        let mut req = fidl::new_empty!(
56147                            fidl::encoding::EmptyPayload,
56148                            fidl::encoding::DefaultFuchsiaResourceDialect
56149                        );
56150                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56151                        let control_handle =
56152                            StreamSocketControlHandle { inner: this.inner.clone() };
56153                        Ok(StreamSocketRequest::GetOutOfBandInline {
56154                            responder: StreamSocketGetOutOfBandInlineResponder {
56155                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56156                                tx_id: header.tx_id,
56157                            },
56158                        })
56159                    }
56160                    0x6bbf00c53a4c78c2 => {
56161                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56162                        let mut req = fidl::new_empty!(
56163                            BaseSocketSetNoCheckRequest,
56164                            fidl::encoding::DefaultFuchsiaResourceDialect
56165                        );
56166                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetNoCheckRequest>(&header, _body_bytes, handles, &mut req)?;
56167                        let control_handle =
56168                            StreamSocketControlHandle { inner: this.inner.clone() };
56169                        Ok(StreamSocketRequest::SetNoCheck {
56170                            value: req.value,
56171
56172                            responder: StreamSocketSetNoCheckResponder {
56173                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56174                                tx_id: header.tx_id,
56175                            },
56176                        })
56177                    }
56178                    0x2cd4249286417694 => {
56179                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56180                        let mut req = fidl::new_empty!(
56181                            fidl::encoding::EmptyPayload,
56182                            fidl::encoding::DefaultFuchsiaResourceDialect
56183                        );
56184                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56185                        let control_handle =
56186                            StreamSocketControlHandle { inner: this.inner.clone() };
56187                        Ok(StreamSocketRequest::GetNoCheck {
56188                            responder: StreamSocketGetNoCheckResponder {
56189                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56190                                tx_id: header.tx_id,
56191                            },
56192                        })
56193                    }
56194                    0x45386351246e998e => {
56195                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56196                        let mut req = fidl::new_empty!(
56197                            BaseSocketSetLingerRequest,
56198                            fidl::encoding::DefaultFuchsiaResourceDialect
56199                        );
56200                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetLingerRequest>(&header, _body_bytes, handles, &mut req)?;
56201                        let control_handle =
56202                            StreamSocketControlHandle { inner: this.inner.clone() };
56203                        Ok(StreamSocketRequest::SetLinger {
56204                            linger: req.linger,
56205                            length_secs: req.length_secs,
56206
56207                            responder: StreamSocketSetLingerResponder {
56208                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56209                                tx_id: header.tx_id,
56210                            },
56211                        })
56212                    }
56213                    0x48eb20fc5ccb0e45 => {
56214                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56215                        let mut req = fidl::new_empty!(
56216                            fidl::encoding::EmptyPayload,
56217                            fidl::encoding::DefaultFuchsiaResourceDialect
56218                        );
56219                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56220                        let control_handle =
56221                            StreamSocketControlHandle { inner: this.inner.clone() };
56222                        Ok(StreamSocketRequest::GetLinger {
56223                            responder: StreamSocketGetLingerResponder {
56224                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56225                                tx_id: header.tx_id,
56226                            },
56227                        })
56228                    }
56229                    0x24dd3e5cb36d9ccb => {
56230                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56231                        let mut req = fidl::new_empty!(
56232                            BaseSocketSetReusePortRequest,
56233                            fidl::encoding::DefaultFuchsiaResourceDialect
56234                        );
56235                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReusePortRequest>(&header, _body_bytes, handles, &mut req)?;
56236                        let control_handle =
56237                            StreamSocketControlHandle { inner: this.inner.clone() };
56238                        Ok(StreamSocketRequest::SetReusePort {
56239                            value: req.value,
56240
56241                            responder: StreamSocketSetReusePortResponder {
56242                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56243                                tx_id: header.tx_id,
56244                            },
56245                        })
56246                    }
56247                    0x7a112c1ab54ff828 => {
56248                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56249                        let mut req = fidl::new_empty!(
56250                            fidl::encoding::EmptyPayload,
56251                            fidl::encoding::DefaultFuchsiaResourceDialect
56252                        );
56253                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56254                        let control_handle =
56255                            StreamSocketControlHandle { inner: this.inner.clone() };
56256                        Ok(StreamSocketRequest::GetReusePort {
56257                            responder: StreamSocketGetReusePortResponder {
56258                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56259                                tx_id: header.tx_id,
56260                            },
56261                        })
56262                    }
56263                    0x67ce6db6c2ec8966 => {
56264                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56265                        let mut req = fidl::new_empty!(
56266                            fidl::encoding::EmptyPayload,
56267                            fidl::encoding::DefaultFuchsiaResourceDialect
56268                        );
56269                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56270                        let control_handle =
56271                            StreamSocketControlHandle { inner: this.inner.clone() };
56272                        Ok(StreamSocketRequest::GetAcceptConn {
56273                            responder: StreamSocketGetAcceptConnResponder {
56274                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56275                                tx_id: header.tx_id,
56276                            },
56277                        })
56278                    }
56279                    0x2118b483f28aafc4 => {
56280                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56281                        let mut req = fidl::new_empty!(
56282                            BaseSocketSetBindToDeviceRequest,
56283                            fidl::encoding::DefaultFuchsiaResourceDialect
56284                        );
56285                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToDeviceRequest>(&header, _body_bytes, handles, &mut req)?;
56286                        let control_handle =
56287                            StreamSocketControlHandle { inner: this.inner.clone() };
56288                        Ok(StreamSocketRequest::SetBindToDevice {
56289                            value: req.value,
56290
56291                            responder: StreamSocketSetBindToDeviceResponder {
56292                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56293                                tx_id: header.tx_id,
56294                            },
56295                        })
56296                    }
56297                    0x1ab1fbf0ef7906c8 => {
56298                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56299                        let mut req = fidl::new_empty!(
56300                            fidl::encoding::EmptyPayload,
56301                            fidl::encoding::DefaultFuchsiaResourceDialect
56302                        );
56303                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56304                        let control_handle =
56305                            StreamSocketControlHandle { inner: this.inner.clone() };
56306                        Ok(StreamSocketRequest::GetBindToDevice {
56307                            responder: StreamSocketGetBindToDeviceResponder {
56308                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56309                                tx_id: header.tx_id,
56310                            },
56311                        })
56312                    }
56313                    0x6e387a0def00821 => {
56314                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56315                        let mut req = fidl::new_empty!(
56316                            BaseSocketSetBindToInterfaceIndexRequest,
56317                            fidl::encoding::DefaultFuchsiaResourceDialect
56318                        );
56319                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToInterfaceIndexRequest>(&header, _body_bytes, handles, &mut req)?;
56320                        let control_handle =
56321                            StreamSocketControlHandle { inner: this.inner.clone() };
56322                        Ok(StreamSocketRequest::SetBindToInterfaceIndex {
56323                            value: req.value,
56324
56325                            responder: StreamSocketSetBindToInterfaceIndexResponder {
56326                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56327                                tx_id: header.tx_id,
56328                            },
56329                        })
56330                    }
56331                    0x59c31dd3e3078295 => {
56332                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56333                        let mut req = fidl::new_empty!(
56334                            fidl::encoding::EmptyPayload,
56335                            fidl::encoding::DefaultFuchsiaResourceDialect
56336                        );
56337                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56338                        let control_handle =
56339                            StreamSocketControlHandle { inner: this.inner.clone() };
56340                        Ok(StreamSocketRequest::GetBindToInterfaceIndex {
56341                            responder: StreamSocketGetBindToInterfaceIndexResponder {
56342                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56343                                tx_id: header.tx_id,
56344                            },
56345                        })
56346                    }
56347                    0x285d6516c263d839 => {
56348                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56349                        let mut req = fidl::new_empty!(
56350                            BaseSocketSetTimestampRequest,
56351                            fidl::encoding::DefaultFuchsiaResourceDialect
56352                        );
56353                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetTimestampRequest>(&header, _body_bytes, handles, &mut req)?;
56354                        let control_handle =
56355                            StreamSocketControlHandle { inner: this.inner.clone() };
56356                        Ok(StreamSocketRequest::SetTimestamp {
56357                            value: req.value,
56358
56359                            responder: StreamSocketSetTimestampResponder {
56360                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56361                                tx_id: header.tx_id,
56362                            },
56363                        })
56364                    }
56365                    0x49f2fffbbcc2bd27 => {
56366                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56367                        let mut req = fidl::new_empty!(
56368                            fidl::encoding::EmptyPayload,
56369                            fidl::encoding::DefaultFuchsiaResourceDialect
56370                        );
56371                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56372                        let control_handle =
56373                            StreamSocketControlHandle { inner: this.inner.clone() };
56374                        Ok(StreamSocketRequest::GetTimestamp {
56375                            responder: StreamSocketGetTimestampResponder {
56376                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56377                                tx_id: header.tx_id,
56378                            },
56379                        })
56380                    }
56381                    0x6ead6de09f653236 => {
56382                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56383                        let mut req = fidl::new_empty!(
56384                            BaseSocketSetMarkRequest,
56385                            fidl::encoding::DefaultFuchsiaResourceDialect
56386                        );
56387                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
56388                        let control_handle =
56389                            StreamSocketControlHandle { inner: this.inner.clone() };
56390                        Ok(StreamSocketRequest::SetMark {
56391                            domain: req.domain,
56392                            mark: req.mark,
56393
56394                            responder: StreamSocketSetMarkResponder {
56395                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56396                                tx_id: header.tx_id,
56397                            },
56398                        })
56399                    }
56400                    0x57a2752c61d93d47 => {
56401                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56402                        let mut req = fidl::new_empty!(
56403                            BaseSocketGetMarkRequest,
56404                            fidl::encoding::DefaultFuchsiaResourceDialect
56405                        );
56406                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketGetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
56407                        let control_handle =
56408                            StreamSocketControlHandle { inner: this.inner.clone() };
56409                        Ok(StreamSocketRequest::GetMark {
56410                            domain: req.domain,
56411
56412                            responder: StreamSocketGetMarkResponder {
56413                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56414                                tx_id: header.tx_id,
56415                            },
56416                        })
56417                    }
56418                    0x4bc6400ae92125d => {
56419                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56420                        let mut req = fidl::new_empty!(
56421                            BaseNetworkSocketBindRequest,
56422                            fidl::encoding::DefaultFuchsiaResourceDialect
56423                        );
56424                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketBindRequest>(&header, _body_bytes, handles, &mut req)?;
56425                        let control_handle =
56426                            StreamSocketControlHandle { inner: this.inner.clone() };
56427                        Ok(StreamSocketRequest::Bind {
56428                            addr: req.addr,
56429
56430                            responder: StreamSocketBindResponder {
56431                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56432                                tx_id: header.tx_id,
56433                            },
56434                        })
56435                    }
56436                    0x5f05f19bfdd38871 => {
56437                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56438                        let mut req = fidl::new_empty!(
56439                            BaseNetworkSocketConnectRequest,
56440                            fidl::encoding::DefaultFuchsiaResourceDialect
56441                        );
56442                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketConnectRequest>(&header, _body_bytes, handles, &mut req)?;
56443                        let control_handle =
56444                            StreamSocketControlHandle { inner: this.inner.clone() };
56445                        Ok(StreamSocketRequest::Connect {
56446                            addr: req.addr,
56447
56448                            responder: StreamSocketConnectResponder {
56449                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56450                                tx_id: header.tx_id,
56451                            },
56452                        })
56453                    }
56454                    0x74e63b91f7b29b2 => {
56455                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56456                        let mut req = fidl::new_empty!(
56457                            fidl::encoding::EmptyPayload,
56458                            fidl::encoding::DefaultFuchsiaResourceDialect
56459                        );
56460                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56461                        let control_handle =
56462                            StreamSocketControlHandle { inner: this.inner.clone() };
56463                        Ok(StreamSocketRequest::Disconnect {
56464                            responder: StreamSocketDisconnectResponder {
56465                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56466                                tx_id: header.tx_id,
56467                            },
56468                        })
56469                    }
56470                    0x475f23f84a1a4f85 => {
56471                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56472                        let mut req = fidl::new_empty!(
56473                            fidl::encoding::EmptyPayload,
56474                            fidl::encoding::DefaultFuchsiaResourceDialect
56475                        );
56476                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56477                        let control_handle =
56478                            StreamSocketControlHandle { inner: this.inner.clone() };
56479                        Ok(StreamSocketRequest::GetSockName {
56480                            responder: StreamSocketGetSockNameResponder {
56481                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56482                                tx_id: header.tx_id,
56483                            },
56484                        })
56485                    }
56486                    0x1ffecf4bd5b6432e => {
56487                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56488                        let mut req = fidl::new_empty!(
56489                            fidl::encoding::EmptyPayload,
56490                            fidl::encoding::DefaultFuchsiaResourceDialect
56491                        );
56492                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56493                        let control_handle =
56494                            StreamSocketControlHandle { inner: this.inner.clone() };
56495                        Ok(StreamSocketRequest::GetPeerName {
56496                            responder: StreamSocketGetPeerNameResponder {
56497                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56498                                tx_id: header.tx_id,
56499                            },
56500                        })
56501                    }
56502                    0x247f38b6db68c336 => {
56503                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56504                        let mut req = fidl::new_empty!(
56505                            BaseNetworkSocketShutdownRequest,
56506                            fidl::encoding::DefaultFuchsiaResourceDialect
56507                        );
56508                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketShutdownRequest>(&header, _body_bytes, handles, &mut req)?;
56509                        let control_handle =
56510                            StreamSocketControlHandle { inner: this.inner.clone() };
56511                        Ok(StreamSocketRequest::Shutdown {
56512                            mode: req.mode,
56513
56514                            responder: StreamSocketShutdownResponder {
56515                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56516                                tx_id: header.tx_id,
56517                            },
56518                        })
56519                    }
56520                    0x995c600475b6d46 => {
56521                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56522                        let mut req = fidl::new_empty!(
56523                            BaseNetworkSocketSetIpTypeOfServiceRequest,
56524                            fidl::encoding::DefaultFuchsiaResourceDialect
56525                        );
56526                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
56527                        let control_handle =
56528                            StreamSocketControlHandle { inner: this.inner.clone() };
56529                        Ok(StreamSocketRequest::SetIpTypeOfService {
56530                            value: req.value,
56531
56532                            responder: StreamSocketSetIpTypeOfServiceResponder {
56533                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56534                                tx_id: header.tx_id,
56535                            },
56536                        })
56537                    }
56538                    0x3814a04259f75fcb => {
56539                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56540                        let mut req = fidl::new_empty!(
56541                            fidl::encoding::EmptyPayload,
56542                            fidl::encoding::DefaultFuchsiaResourceDialect
56543                        );
56544                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56545                        let control_handle =
56546                            StreamSocketControlHandle { inner: this.inner.clone() };
56547                        Ok(StreamSocketRequest::GetIpTypeOfService {
56548                            responder: StreamSocketGetIpTypeOfServiceResponder {
56549                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56550                                tx_id: header.tx_id,
56551                            },
56552                        })
56553                    }
56554                    0x29e2424b433ae1ef => {
56555                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56556                        let mut req = fidl::new_empty!(
56557                            BaseNetworkSocketSetIpTtlRequest,
56558                            fidl::encoding::DefaultFuchsiaResourceDialect
56559                        );
56560                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTtlRequest>(&header, _body_bytes, handles, &mut req)?;
56561                        let control_handle =
56562                            StreamSocketControlHandle { inner: this.inner.clone() };
56563                        Ok(StreamSocketRequest::SetIpTtl {
56564                            value: req.value,
56565
56566                            responder: StreamSocketSetIpTtlResponder {
56567                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56568                                tx_id: header.tx_id,
56569                            },
56570                        })
56571                    }
56572                    0x47e47fa1f24da471 => {
56573                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56574                        let mut req = fidl::new_empty!(
56575                            fidl::encoding::EmptyPayload,
56576                            fidl::encoding::DefaultFuchsiaResourceDialect
56577                        );
56578                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56579                        let control_handle =
56580                            StreamSocketControlHandle { inner: this.inner.clone() };
56581                        Ok(StreamSocketRequest::GetIpTtl {
56582                            responder: StreamSocketGetIpTtlResponder {
56583                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56584                                tx_id: header.tx_id,
56585                            },
56586                        })
56587                    }
56588                    0x392d16bee20c0e16 => {
56589                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56590                        let mut req = fidl::new_empty!(
56591                            BaseNetworkSocketSetIpPacketInfoRequest,
56592                            fidl::encoding::DefaultFuchsiaResourceDialect
56593                        );
56594                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpPacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
56595                        let control_handle =
56596                            StreamSocketControlHandle { inner: this.inner.clone() };
56597                        Ok(StreamSocketRequest::SetIpPacketInfo {
56598                            value: req.value,
56599
56600                            responder: StreamSocketSetIpPacketInfoResponder {
56601                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56602                                tx_id: header.tx_id,
56603                            },
56604                        })
56605                    }
56606                    0x54b505f242280740 => {
56607                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56608                        let mut req = fidl::new_empty!(
56609                            fidl::encoding::EmptyPayload,
56610                            fidl::encoding::DefaultFuchsiaResourceDialect
56611                        );
56612                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56613                        let control_handle =
56614                            StreamSocketControlHandle { inner: this.inner.clone() };
56615                        Ok(StreamSocketRequest::GetIpPacketInfo {
56616                            responder: StreamSocketGetIpPacketInfoResponder {
56617                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56618                                tx_id: header.tx_id,
56619                            },
56620                        })
56621                    }
56622                    0x6c4f6714995f84ef => {
56623                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56624                        let mut req = fidl::new_empty!(
56625                            BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
56626                            fidl::encoding::DefaultFuchsiaResourceDialect
56627                        );
56628                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
56629                        let control_handle =
56630                            StreamSocketControlHandle { inner: this.inner.clone() };
56631                        Ok(StreamSocketRequest::SetIpReceiveTypeOfService {
56632                            value: req.value,
56633
56634                            responder: StreamSocketSetIpReceiveTypeOfServiceResponder {
56635                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56636                                tx_id: header.tx_id,
56637                            },
56638                        })
56639                    }
56640                    0x4158ba7dc2795960 => {
56641                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56642                        let mut req = fidl::new_empty!(
56643                            fidl::encoding::EmptyPayload,
56644                            fidl::encoding::DefaultFuchsiaResourceDialect
56645                        );
56646                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56647                        let control_handle =
56648                            StreamSocketControlHandle { inner: this.inner.clone() };
56649                        Ok(StreamSocketRequest::GetIpReceiveTypeOfService {
56650                            responder: StreamSocketGetIpReceiveTypeOfServiceResponder {
56651                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56652                                tx_id: header.tx_id,
56653                            },
56654                        })
56655                    }
56656                    0x46f15be0ce0ab82b => {
56657                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56658                        let mut req = fidl::new_empty!(
56659                            BaseNetworkSocketSetIpReceiveTtlRequest,
56660                            fidl::encoding::DefaultFuchsiaResourceDialect
56661                        );
56662                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveTtlRequest>(&header, _body_bytes, handles, &mut req)?;
56663                        let control_handle =
56664                            StreamSocketControlHandle { inner: this.inner.clone() };
56665                        Ok(StreamSocketRequest::SetIpReceiveTtl {
56666                            value: req.value,
56667
56668                            responder: StreamSocketSetIpReceiveTtlResponder {
56669                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56670                                tx_id: header.tx_id,
56671                            },
56672                        })
56673                    }
56674                    0x678ddd5a5dfa2eb5 => {
56675                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56676                        let mut req = fidl::new_empty!(
56677                            fidl::encoding::EmptyPayload,
56678                            fidl::encoding::DefaultFuchsiaResourceDialect
56679                        );
56680                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56681                        let control_handle =
56682                            StreamSocketControlHandle { inner: this.inner.clone() };
56683                        Ok(StreamSocketRequest::GetIpReceiveTtl {
56684                            responder: StreamSocketGetIpReceiveTtlResponder {
56685                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56686                                tx_id: header.tx_id,
56687                            },
56688                        })
56689                    }
56690                    0x752fbfa9b12befe => {
56691                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56692                        let mut req = fidl::new_empty!(
56693                            BaseNetworkSocketSetIpMulticastInterfaceRequest,
56694                            fidl::encoding::DefaultFuchsiaResourceDialect
56695                        );
56696                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
56697                        let control_handle =
56698                            StreamSocketControlHandle { inner: this.inner.clone() };
56699                        Ok(StreamSocketRequest::SetIpMulticastInterface {
56700                            iface: req.iface,
56701                            address: req.address,
56702
56703                            responder: StreamSocketSetIpMulticastInterfaceResponder {
56704                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56705                                tx_id: header.tx_id,
56706                            },
56707                        })
56708                    }
56709                    0x320bd14c4df046c4 => {
56710                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56711                        let mut req = fidl::new_empty!(
56712                            fidl::encoding::EmptyPayload,
56713                            fidl::encoding::DefaultFuchsiaResourceDialect
56714                        );
56715                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56716                        let control_handle =
56717                            StreamSocketControlHandle { inner: this.inner.clone() };
56718                        Ok(StreamSocketRequest::GetIpMulticastInterface {
56719                            responder: StreamSocketGetIpMulticastInterfaceResponder {
56720                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56721                                tx_id: header.tx_id,
56722                            },
56723                        })
56724                    }
56725                    0x63134d53772916a1 => {
56726                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56727                        let mut req = fidl::new_empty!(
56728                            BaseNetworkSocketSetIpMulticastTtlRequest,
56729                            fidl::encoding::DefaultFuchsiaResourceDialect
56730                        );
56731                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastTtlRequest>(&header, _body_bytes, handles, &mut req)?;
56732                        let control_handle =
56733                            StreamSocketControlHandle { inner: this.inner.clone() };
56734                        Ok(StreamSocketRequest::SetIpMulticastTtl {
56735                            value: req.value,
56736
56737                            responder: StreamSocketSetIpMulticastTtlResponder {
56738                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56739                                tx_id: header.tx_id,
56740                            },
56741                        })
56742                    }
56743                    0x4665cd378f39e1a => {
56744                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56745                        let mut req = fidl::new_empty!(
56746                            fidl::encoding::EmptyPayload,
56747                            fidl::encoding::DefaultFuchsiaResourceDialect
56748                        );
56749                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56750                        let control_handle =
56751                            StreamSocketControlHandle { inner: this.inner.clone() };
56752                        Ok(StreamSocketRequest::GetIpMulticastTtl {
56753                            responder: StreamSocketGetIpMulticastTtlResponder {
56754                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56755                                tx_id: header.tx_id,
56756                            },
56757                        })
56758                    }
56759                    0x20c55c11f00943ea => {
56760                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56761                        let mut req = fidl::new_empty!(
56762                            BaseNetworkSocketSetIpMulticastLoopbackRequest,
56763                            fidl::encoding::DefaultFuchsiaResourceDialect
56764                        );
56765                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
56766                        let control_handle =
56767                            StreamSocketControlHandle { inner: this.inner.clone() };
56768                        Ok(StreamSocketRequest::SetIpMulticastLoopback {
56769                            value: req.value,
56770
56771                            responder: StreamSocketSetIpMulticastLoopbackResponder {
56772                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56773                                tx_id: header.tx_id,
56774                            },
56775                        })
56776                    }
56777                    0x3b6b26ff558298f2 => {
56778                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56779                        let mut req = fidl::new_empty!(
56780                            fidl::encoding::EmptyPayload,
56781                            fidl::encoding::DefaultFuchsiaResourceDialect
56782                        );
56783                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56784                        let control_handle =
56785                            StreamSocketControlHandle { inner: this.inner.clone() };
56786                        Ok(StreamSocketRequest::GetIpMulticastLoopback {
56787                            responder: StreamSocketGetIpMulticastLoopbackResponder {
56788                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56789                                tx_id: header.tx_id,
56790                            },
56791                        })
56792                    }
56793                    0x76bc7df115a3b4d0 => {
56794                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56795                        let mut req = fidl::new_empty!(
56796                            BaseNetworkSocketAddIpMembershipRequest,
56797                            fidl::encoding::DefaultFuchsiaResourceDialect
56798                        );
56799                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketAddIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
56800                        let control_handle =
56801                            StreamSocketControlHandle { inner: this.inner.clone() };
56802                        Ok(StreamSocketRequest::AddIpMembership {
56803                            membership: req.membership,
56804
56805                            responder: StreamSocketAddIpMembershipResponder {
56806                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56807                                tx_id: header.tx_id,
56808                            },
56809                        })
56810                    }
56811                    0x2888f3099188d03 => {
56812                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56813                        let mut req = fidl::new_empty!(
56814                            BaseNetworkSocketDropIpMembershipRequest,
56815                            fidl::encoding::DefaultFuchsiaResourceDialect
56816                        );
56817                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketDropIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
56818                        let control_handle =
56819                            StreamSocketControlHandle { inner: this.inner.clone() };
56820                        Ok(StreamSocketRequest::DropIpMembership {
56821                            membership: req.membership,
56822
56823                            responder: StreamSocketDropIpMembershipResponder {
56824                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56825                                tx_id: header.tx_id,
56826                            },
56827                        })
56828                    }
56829                    0x1ae532b0c066e3a0 => {
56830                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56831                        let mut req = fidl::new_empty!(
56832                            BaseNetworkSocketSetIpTransparentRequest,
56833                            fidl::encoding::DefaultFuchsiaResourceDialect
56834                        );
56835                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTransparentRequest>(&header, _body_bytes, handles, &mut req)?;
56836                        let control_handle =
56837                            StreamSocketControlHandle { inner: this.inner.clone() };
56838                        Ok(StreamSocketRequest::SetIpTransparent {
56839                            value: req.value,
56840
56841                            responder: StreamSocketSetIpTransparentResponder {
56842                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56843                                tx_id: header.tx_id,
56844                            },
56845                        })
56846                    }
56847                    0x51d43695962ebfb5 => {
56848                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56849                        let mut req = fidl::new_empty!(
56850                            fidl::encoding::EmptyPayload,
56851                            fidl::encoding::DefaultFuchsiaResourceDialect
56852                        );
56853                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56854                        let control_handle =
56855                            StreamSocketControlHandle { inner: this.inner.clone() };
56856                        Ok(StreamSocketRequest::GetIpTransparent {
56857                            responder: StreamSocketGetIpTransparentResponder {
56858                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56859                                tx_id: header.tx_id,
56860                            },
56861                        })
56862                    }
56863                    0x4722b4ce52f7840 => {
56864                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56865                        let mut req = fidl::new_empty!(
56866                            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
56867                            fidl::encoding::DefaultFuchsiaResourceDialect
56868                        );
56869                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest>(&header, _body_bytes, handles, &mut req)?;
56870                        let control_handle =
56871                            StreamSocketControlHandle { inner: this.inner.clone() };
56872                        Ok(StreamSocketRequest::SetIpReceiveOriginalDestinationAddress {
56873                            value: req.value,
56874
56875                            responder:
56876                                StreamSocketSetIpReceiveOriginalDestinationAddressResponder {
56877                                    control_handle: std::mem::ManuallyDrop::new(control_handle),
56878                                    tx_id: header.tx_id,
56879                                },
56880                        })
56881                    }
56882                    0x2a0e7dc5d6bfdfe9 => {
56883                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56884                        let mut req = fidl::new_empty!(
56885                            fidl::encoding::EmptyPayload,
56886                            fidl::encoding::DefaultFuchsiaResourceDialect
56887                        );
56888                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56889                        let control_handle =
56890                            StreamSocketControlHandle { inner: this.inner.clone() };
56891                        Ok(StreamSocketRequest::GetIpReceiveOriginalDestinationAddress {
56892                            responder:
56893                                StreamSocketGetIpReceiveOriginalDestinationAddressResponder {
56894                                    control_handle: std::mem::ManuallyDrop::new(control_handle),
56895                                    tx_id: header.tx_id,
56896                                },
56897                        })
56898                    }
56899                    0x7c94727acb4ea4b3 => {
56900                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56901                        let mut req = fidl::new_empty!(
56902                            BaseNetworkSocketAddIpv6MembershipRequest,
56903                            fidl::encoding::DefaultFuchsiaResourceDialect
56904                        );
56905                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketAddIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
56906                        let control_handle =
56907                            StreamSocketControlHandle { inner: this.inner.clone() };
56908                        Ok(StreamSocketRequest::AddIpv6Membership {
56909                            membership: req.membership,
56910
56911                            responder: StreamSocketAddIpv6MembershipResponder {
56912                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56913                                tx_id: header.tx_id,
56914                            },
56915                        })
56916                    }
56917                    0x42104c70ccaba304 => {
56918                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56919                        let mut req = fidl::new_empty!(
56920                            BaseNetworkSocketDropIpv6MembershipRequest,
56921                            fidl::encoding::DefaultFuchsiaResourceDialect
56922                        );
56923                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketDropIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
56924                        let control_handle =
56925                            StreamSocketControlHandle { inner: this.inner.clone() };
56926                        Ok(StreamSocketRequest::DropIpv6Membership {
56927                            membership: req.membership,
56928
56929                            responder: StreamSocketDropIpv6MembershipResponder {
56930                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56931                                tx_id: header.tx_id,
56932                            },
56933                        })
56934                    }
56935                    0x135f76db3774ab3b => {
56936                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56937                        let mut req = fidl::new_empty!(
56938                            BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
56939                            fidl::encoding::DefaultFuchsiaResourceDialect
56940                        );
56941                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
56942                        let control_handle =
56943                            StreamSocketControlHandle { inner: this.inner.clone() };
56944                        Ok(StreamSocketRequest::SetIpv6MulticastInterface {
56945                            value: req.value,
56946
56947                            responder: StreamSocketSetIpv6MulticastInterfaceResponder {
56948                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56949                                tx_id: header.tx_id,
56950                            },
56951                        })
56952                    }
56953                    0x1f26fcdd348f1882 => {
56954                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56955                        let mut req = fidl::new_empty!(
56956                            fidl::encoding::EmptyPayload,
56957                            fidl::encoding::DefaultFuchsiaResourceDialect
56958                        );
56959                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56960                        let control_handle =
56961                            StreamSocketControlHandle { inner: this.inner.clone() };
56962                        Ok(StreamSocketRequest::GetIpv6MulticastInterface {
56963                            responder: StreamSocketGetIpv6MulticastInterfaceResponder {
56964                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56965                                tx_id: header.tx_id,
56966                            },
56967                        })
56968                    }
56969                    0x157d51e98f462859 => {
56970                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56971                        let mut req = fidl::new_empty!(
56972                            BaseNetworkSocketSetIpv6UnicastHopsRequest,
56973                            fidl::encoding::DefaultFuchsiaResourceDialect
56974                        );
56975                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6UnicastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
56976                        let control_handle =
56977                            StreamSocketControlHandle { inner: this.inner.clone() };
56978                        Ok(StreamSocketRequest::SetIpv6UnicastHops {
56979                            value: req.value,
56980
56981                            responder: StreamSocketSetIpv6UnicastHopsResponder {
56982                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56983                                tx_id: header.tx_id,
56984                            },
56985                        })
56986                    }
56987                    0x21f4641cad8bd8d2 => {
56988                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
56989                        let mut req = fidl::new_empty!(
56990                            fidl::encoding::EmptyPayload,
56991                            fidl::encoding::DefaultFuchsiaResourceDialect
56992                        );
56993                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
56994                        let control_handle =
56995                            StreamSocketControlHandle { inner: this.inner.clone() };
56996                        Ok(StreamSocketRequest::GetIpv6UnicastHops {
56997                            responder: StreamSocketGetIpv6UnicastHopsResponder {
56998                                control_handle: std::mem::ManuallyDrop::new(control_handle),
56999                                tx_id: header.tx_id,
57000                            },
57001                        })
57002                    }
57003                    0x5c24808ed2e84a1e => {
57004                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57005                        let mut req = fidl::new_empty!(
57006                            BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
57007                            fidl::encoding::DefaultFuchsiaResourceDialect
57008                        );
57009                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceiveHopLimitRequest>(&header, _body_bytes, handles, &mut req)?;
57010                        let control_handle =
57011                            StreamSocketControlHandle { inner: this.inner.clone() };
57012                        Ok(StreamSocketRequest::SetIpv6ReceiveHopLimit {
57013                            value: req.value,
57014
57015                            responder: StreamSocketSetIpv6ReceiveHopLimitResponder {
57016                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57017                                tx_id: header.tx_id,
57018                            },
57019                        })
57020                    }
57021                    0x341e06689885b4c0 => {
57022                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57023                        let mut req = fidl::new_empty!(
57024                            fidl::encoding::EmptyPayload,
57025                            fidl::encoding::DefaultFuchsiaResourceDialect
57026                        );
57027                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57028                        let control_handle =
57029                            StreamSocketControlHandle { inner: this.inner.clone() };
57030                        Ok(StreamSocketRequest::GetIpv6ReceiveHopLimit {
57031                            responder: StreamSocketGetIpv6ReceiveHopLimitResponder {
57032                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57033                                tx_id: header.tx_id,
57034                            },
57035                        })
57036                    }
57037                    0x25b9cd4d181f82c1 => {
57038                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57039                        let mut req = fidl::new_empty!(
57040                            BaseNetworkSocketSetIpv6MulticastHopsRequest,
57041                            fidl::encoding::DefaultFuchsiaResourceDialect
57042                        );
57043                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
57044                        let control_handle =
57045                            StreamSocketControlHandle { inner: this.inner.clone() };
57046                        Ok(StreamSocketRequest::SetIpv6MulticastHops {
57047                            value: req.value,
57048
57049                            responder: StreamSocketSetIpv6MulticastHopsResponder {
57050                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57051                                tx_id: header.tx_id,
57052                            },
57053                        })
57054                    }
57055                    0x52916948a365012a => {
57056                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57057                        let mut req = fidl::new_empty!(
57058                            fidl::encoding::EmptyPayload,
57059                            fidl::encoding::DefaultFuchsiaResourceDialect
57060                        );
57061                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57062                        let control_handle =
57063                            StreamSocketControlHandle { inner: this.inner.clone() };
57064                        Ok(StreamSocketRequest::GetIpv6MulticastHops {
57065                            responder: StreamSocketGetIpv6MulticastHopsResponder {
57066                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57067                                tx_id: header.tx_id,
57068                            },
57069                        })
57070                    }
57071                    0x55701c409ff41b40 => {
57072                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57073                        let mut req = fidl::new_empty!(
57074                            BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
57075                            fidl::encoding::DefaultFuchsiaResourceDialect
57076                        );
57077                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
57078                        let control_handle =
57079                            StreamSocketControlHandle { inner: this.inner.clone() };
57080                        Ok(StreamSocketRequest::SetIpv6MulticastLoopback {
57081                            value: req.value,
57082
57083                            responder: StreamSocketSetIpv6MulticastLoopbackResponder {
57084                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57085                                tx_id: header.tx_id,
57086                            },
57087                        })
57088                    }
57089                    0x4415b701fde319c3 => {
57090                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57091                        let mut req = fidl::new_empty!(
57092                            fidl::encoding::EmptyPayload,
57093                            fidl::encoding::DefaultFuchsiaResourceDialect
57094                        );
57095                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57096                        let control_handle =
57097                            StreamSocketControlHandle { inner: this.inner.clone() };
57098                        Ok(StreamSocketRequest::GetIpv6MulticastLoopback {
57099                            responder: StreamSocketGetIpv6MulticastLoopbackResponder {
57100                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57101                                tx_id: header.tx_id,
57102                            },
57103                        })
57104                    }
57105                    0x4873f1364758cbba => {
57106                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57107                        let mut req = fidl::new_empty!(
57108                            BaseNetworkSocketSetIpv6OnlyRequest,
57109                            fidl::encoding::DefaultFuchsiaResourceDialect
57110                        );
57111                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6OnlyRequest>(&header, _body_bytes, handles, &mut req)?;
57112                        let control_handle =
57113                            StreamSocketControlHandle { inner: this.inner.clone() };
57114                        Ok(StreamSocketRequest::SetIpv6Only {
57115                            value: req.value,
57116
57117                            responder: StreamSocketSetIpv6OnlyResponder {
57118                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57119                                tx_id: header.tx_id,
57120                            },
57121                        })
57122                    }
57123                    0x4aa3340a1a26b89c => {
57124                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57125                        let mut req = fidl::new_empty!(
57126                            fidl::encoding::EmptyPayload,
57127                            fidl::encoding::DefaultFuchsiaResourceDialect
57128                        );
57129                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57130                        let control_handle =
57131                            StreamSocketControlHandle { inner: this.inner.clone() };
57132                        Ok(StreamSocketRequest::GetIpv6Only {
57133                            responder: StreamSocketGetIpv6OnlyResponder {
57134                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57135                                tx_id: header.tx_id,
57136                            },
57137                        })
57138                    }
57139                    0x58f07c8788d099a0 => {
57140                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57141                        let mut req = fidl::new_empty!(
57142                            BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
57143                            fidl::encoding::DefaultFuchsiaResourceDialect
57144                        );
57145                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
57146                        let control_handle =
57147                            StreamSocketControlHandle { inner: this.inner.clone() };
57148                        Ok(StreamSocketRequest::SetIpv6ReceiveTrafficClass {
57149                            value: req.value,
57150
57151                            responder: StreamSocketSetIpv6ReceiveTrafficClassResponder {
57152                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57153                                tx_id: header.tx_id,
57154                            },
57155                        })
57156                    }
57157                    0x2e334df1da553ffa => {
57158                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57159                        let mut req = fidl::new_empty!(
57160                            fidl::encoding::EmptyPayload,
57161                            fidl::encoding::DefaultFuchsiaResourceDialect
57162                        );
57163                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57164                        let control_handle =
57165                            StreamSocketControlHandle { inner: this.inner.clone() };
57166                        Ok(StreamSocketRequest::GetIpv6ReceiveTrafficClass {
57167                            responder: StreamSocketGetIpv6ReceiveTrafficClassResponder {
57168                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57169                                tx_id: header.tx_id,
57170                            },
57171                        })
57172                    }
57173                    0x6af077800c5a0b4f => {
57174                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57175                        let mut req = fidl::new_empty!(
57176                            BaseNetworkSocketSetIpv6TrafficClassRequest,
57177                            fidl::encoding::DefaultFuchsiaResourceDialect
57178                        );
57179                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6TrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
57180                        let control_handle =
57181                            StreamSocketControlHandle { inner: this.inner.clone() };
57182                        Ok(StreamSocketRequest::SetIpv6TrafficClass {
57183                            value: req.value,
57184
57185                            responder: StreamSocketSetIpv6TrafficClassResponder {
57186                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57187                                tx_id: header.tx_id,
57188                            },
57189                        })
57190                    }
57191                    0x6baf6eed8fc2f04 => {
57192                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57193                        let mut req = fidl::new_empty!(
57194                            fidl::encoding::EmptyPayload,
57195                            fidl::encoding::DefaultFuchsiaResourceDialect
57196                        );
57197                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57198                        let control_handle =
57199                            StreamSocketControlHandle { inner: this.inner.clone() };
57200                        Ok(StreamSocketRequest::GetIpv6TrafficClass {
57201                            responder: StreamSocketGetIpv6TrafficClassResponder {
57202                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57203                                tx_id: header.tx_id,
57204                            },
57205                        })
57206                    }
57207                    0x19259775b1a92768 => {
57208                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57209                        let mut req = fidl::new_empty!(
57210                            BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
57211                            fidl::encoding::DefaultFuchsiaResourceDialect
57212                        );
57213                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceivePacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
57214                        let control_handle =
57215                            StreamSocketControlHandle { inner: this.inner.clone() };
57216                        Ok(StreamSocketRequest::SetIpv6ReceivePacketInfo {
57217                            value: req.value,
57218
57219                            responder: StreamSocketSetIpv6ReceivePacketInfoResponder {
57220                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57221                                tx_id: header.tx_id,
57222                            },
57223                        })
57224                    }
57225                    0x7acd4a2775baec75 => {
57226                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57227                        let mut req = fidl::new_empty!(
57228                            fidl::encoding::EmptyPayload,
57229                            fidl::encoding::DefaultFuchsiaResourceDialect
57230                        );
57231                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57232                        let control_handle =
57233                            StreamSocketControlHandle { inner: this.inner.clone() };
57234                        Ok(StreamSocketRequest::GetIpv6ReceivePacketInfo {
57235                            responder: StreamSocketGetIpv6ReceivePacketInfoResponder {
57236                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57237                                tx_id: header.tx_id,
57238                            },
57239                        })
57240                    }
57241                    0x38bf28f0dafdbac0 => {
57242                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57243                        let mut req = fidl::new_empty!(
57244                            fidl::encoding::EmptyPayload,
57245                            fidl::encoding::DefaultFuchsiaResourceDialect
57246                        );
57247                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57248                        let control_handle =
57249                            StreamSocketControlHandle { inner: this.inner.clone() };
57250                        Ok(StreamSocketRequest::GetOriginalDestination {
57251                            responder: StreamSocketGetOriginalDestinationResponder {
57252                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57253                                tx_id: header.tx_id,
57254                            },
57255                        })
57256                    }
57257                    0x29e22969a7dadc32 => {
57258                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57259                        let mut req = fidl::new_empty!(
57260                            fidl::encoding::EmptyPayload,
57261                            fidl::encoding::DefaultFuchsiaResourceDialect
57262                        );
57263                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57264                        let control_handle =
57265                            StreamSocketControlHandle { inner: this.inner.clone() };
57266                        Ok(StreamSocketRequest::Describe {
57267                            responder: StreamSocketDescribeResponder {
57268                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57269                                tx_id: header.tx_id,
57270                            },
57271                        })
57272                    }
57273                    0x3d0a65ced3d10108 => {
57274                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57275                        let mut req = fidl::new_empty!(
57276                            StreamSocketListenRequest,
57277                            fidl::encoding::DefaultFuchsiaResourceDialect
57278                        );
57279                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketListenRequest>(&header, _body_bytes, handles, &mut req)?;
57280                        let control_handle =
57281                            StreamSocketControlHandle { inner: this.inner.clone() };
57282                        Ok(StreamSocketRequest::Listen {
57283                            backlog: req.backlog,
57284
57285                            responder: StreamSocketListenResponder {
57286                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57287                                tx_id: header.tx_id,
57288                            },
57289                        })
57290                    }
57291                    0x5ab7ad620424c163 => {
57292                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57293                        let mut req = fidl::new_empty!(
57294                            StreamSocketAcceptRequest,
57295                            fidl::encoding::DefaultFuchsiaResourceDialect
57296                        );
57297                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketAcceptRequest>(&header, _body_bytes, handles, &mut req)?;
57298                        let control_handle =
57299                            StreamSocketControlHandle { inner: this.inner.clone() };
57300                        Ok(StreamSocketRequest::Accept {
57301                            want_addr: req.want_addr,
57302
57303                            responder: StreamSocketAcceptResponder {
57304                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57305                                tx_id: header.tx_id,
57306                            },
57307                        })
57308                    }
57309                    0x87cfa55d19f878f => {
57310                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57311                        let mut req = fidl::new_empty!(
57312                            fidl::encoding::EmptyPayload,
57313                            fidl::encoding::DefaultFuchsiaResourceDialect
57314                        );
57315                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57316                        let control_handle =
57317                            StreamSocketControlHandle { inner: this.inner.clone() };
57318                        Ok(StreamSocketRequest::GetInfo {
57319                            responder: StreamSocketGetInfoResponder {
57320                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57321                                tx_id: header.tx_id,
57322                            },
57323                        })
57324                    }
57325                    0x5a59b778f7333ada => {
57326                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57327                        let mut req = fidl::new_empty!(
57328                            StreamSocketSetTcpNoDelayRequest,
57329                            fidl::encoding::DefaultFuchsiaResourceDialect
57330                        );
57331                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpNoDelayRequest>(&header, _body_bytes, handles, &mut req)?;
57332                        let control_handle =
57333                            StreamSocketControlHandle { inner: this.inner.clone() };
57334                        Ok(StreamSocketRequest::SetTcpNoDelay {
57335                            value: req.value,
57336
57337                            responder: StreamSocketSetTcpNoDelayResponder {
57338                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57339                                tx_id: header.tx_id,
57340                            },
57341                        })
57342                    }
57343                    0xac219a3218b0799 => {
57344                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57345                        let mut req = fidl::new_empty!(
57346                            fidl::encoding::EmptyPayload,
57347                            fidl::encoding::DefaultFuchsiaResourceDialect
57348                        );
57349                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57350                        let control_handle =
57351                            StreamSocketControlHandle { inner: this.inner.clone() };
57352                        Ok(StreamSocketRequest::GetTcpNoDelay {
57353                            responder: StreamSocketGetTcpNoDelayResponder {
57354                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57355                                tx_id: header.tx_id,
57356                            },
57357                        })
57358                    }
57359                    0xb3d30c498266d18 => {
57360                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57361                        let mut req = fidl::new_empty!(
57362                            StreamSocketSetTcpMaxSegmentRequest,
57363                            fidl::encoding::DefaultFuchsiaResourceDialect
57364                        );
57365                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpMaxSegmentRequest>(&header, _body_bytes, handles, &mut req)?;
57366                        let control_handle =
57367                            StreamSocketControlHandle { inner: this.inner.clone() };
57368                        Ok(StreamSocketRequest::SetTcpMaxSegment {
57369                            value_bytes: req.value_bytes,
57370
57371                            responder: StreamSocketSetTcpMaxSegmentResponder {
57372                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57373                                tx_id: header.tx_id,
57374                            },
57375                        })
57376                    }
57377                    0x637404d1b4b9982c => {
57378                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57379                        let mut req = fidl::new_empty!(
57380                            fidl::encoding::EmptyPayload,
57381                            fidl::encoding::DefaultFuchsiaResourceDialect
57382                        );
57383                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57384                        let control_handle =
57385                            StreamSocketControlHandle { inner: this.inner.clone() };
57386                        Ok(StreamSocketRequest::GetTcpMaxSegment {
57387                            responder: StreamSocketGetTcpMaxSegmentResponder {
57388                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57389                                tx_id: header.tx_id,
57390                            },
57391                        })
57392                    }
57393                    0x62e26891541143a0 => {
57394                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57395                        let mut req = fidl::new_empty!(
57396                            StreamSocketSetTcpCorkRequest,
57397                            fidl::encoding::DefaultFuchsiaResourceDialect
57398                        );
57399                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpCorkRequest>(&header, _body_bytes, handles, &mut req)?;
57400                        let control_handle =
57401                            StreamSocketControlHandle { inner: this.inner.clone() };
57402                        Ok(StreamSocketRequest::SetTcpCork {
57403                            value: req.value,
57404
57405                            responder: StreamSocketSetTcpCorkResponder {
57406                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57407                                tx_id: header.tx_id,
57408                            },
57409                        })
57410                    }
57411                    0x435bb232e0e74f32 => {
57412                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57413                        let mut req = fidl::new_empty!(
57414                            fidl::encoding::EmptyPayload,
57415                            fidl::encoding::DefaultFuchsiaResourceDialect
57416                        );
57417                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57418                        let control_handle =
57419                            StreamSocketControlHandle { inner: this.inner.clone() };
57420                        Ok(StreamSocketRequest::GetTcpCork {
57421                            responder: StreamSocketGetTcpCorkResponder {
57422                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57423                                tx_id: header.tx_id,
57424                            },
57425                        })
57426                    }
57427                    0x196d053d8363c42 => {
57428                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57429                        let mut req = fidl::new_empty!(
57430                            StreamSocketSetTcpKeepAliveIdleRequest,
57431                            fidl::encoding::DefaultFuchsiaResourceDialect
57432                        );
57433                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpKeepAliveIdleRequest>(&header, _body_bytes, handles, &mut req)?;
57434                        let control_handle =
57435                            StreamSocketControlHandle { inner: this.inner.clone() };
57436                        Ok(StreamSocketRequest::SetTcpKeepAliveIdle {
57437                            value_secs: req.value_secs,
57438
57439                            responder: StreamSocketSetTcpKeepAliveIdleResponder {
57440                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57441                                tx_id: header.tx_id,
57442                            },
57443                        })
57444                    }
57445                    0x35ec58564879dac => {
57446                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57447                        let mut req = fidl::new_empty!(
57448                            fidl::encoding::EmptyPayload,
57449                            fidl::encoding::DefaultFuchsiaResourceDialect
57450                        );
57451                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57452                        let control_handle =
57453                            StreamSocketControlHandle { inner: this.inner.clone() };
57454                        Ok(StreamSocketRequest::GetTcpKeepAliveIdle {
57455                            responder: StreamSocketGetTcpKeepAliveIdleResponder {
57456                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57457                                tx_id: header.tx_id,
57458                            },
57459                        })
57460                    }
57461                    0x485ffbc2da1243f2 => {
57462                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57463                        let mut req = fidl::new_empty!(
57464                            StreamSocketSetTcpKeepAliveIntervalRequest,
57465                            fidl::encoding::DefaultFuchsiaResourceDialect
57466                        );
57467                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpKeepAliveIntervalRequest>(&header, _body_bytes, handles, &mut req)?;
57468                        let control_handle =
57469                            StreamSocketControlHandle { inner: this.inner.clone() };
57470                        Ok(StreamSocketRequest::SetTcpKeepAliveInterval {
57471                            value_secs: req.value_secs,
57472
57473                            responder: StreamSocketSetTcpKeepAliveIntervalResponder {
57474                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57475                                tx_id: header.tx_id,
57476                            },
57477                        })
57478                    }
57479                    0x264eaf46306b284 => {
57480                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57481                        let mut req = fidl::new_empty!(
57482                            fidl::encoding::EmptyPayload,
57483                            fidl::encoding::DefaultFuchsiaResourceDialect
57484                        );
57485                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57486                        let control_handle =
57487                            StreamSocketControlHandle { inner: this.inner.clone() };
57488                        Ok(StreamSocketRequest::GetTcpKeepAliveInterval {
57489                            responder: StreamSocketGetTcpKeepAliveIntervalResponder {
57490                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57491                                tx_id: header.tx_id,
57492                            },
57493                        })
57494                    }
57495                    0x2ab2e8c111708421 => {
57496                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57497                        let mut req = fidl::new_empty!(
57498                            StreamSocketSetTcpKeepAliveCountRequest,
57499                            fidl::encoding::DefaultFuchsiaResourceDialect
57500                        );
57501                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpKeepAliveCountRequest>(&header, _body_bytes, handles, &mut req)?;
57502                        let control_handle =
57503                            StreamSocketControlHandle { inner: this.inner.clone() };
57504                        Ok(StreamSocketRequest::SetTcpKeepAliveCount {
57505                            value: req.value,
57506
57507                            responder: StreamSocketSetTcpKeepAliveCountResponder {
57508                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57509                                tx_id: header.tx_id,
57510                            },
57511                        })
57512                    }
57513                    0x2f176ae271fe7a09 => {
57514                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57515                        let mut req = fidl::new_empty!(
57516                            fidl::encoding::EmptyPayload,
57517                            fidl::encoding::DefaultFuchsiaResourceDialect
57518                        );
57519                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57520                        let control_handle =
57521                            StreamSocketControlHandle { inner: this.inner.clone() };
57522                        Ok(StreamSocketRequest::GetTcpKeepAliveCount {
57523                            responder: StreamSocketGetTcpKeepAliveCountResponder {
57524                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57525                                tx_id: header.tx_id,
57526                            },
57527                        })
57528                    }
57529                    0x4dcd6ab5573c1eb3 => {
57530                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57531                        let mut req = fidl::new_empty!(
57532                            StreamSocketSetTcpSynCountRequest,
57533                            fidl::encoding::DefaultFuchsiaResourceDialect
57534                        );
57535                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpSynCountRequest>(&header, _body_bytes, handles, &mut req)?;
57536                        let control_handle =
57537                            StreamSocketControlHandle { inner: this.inner.clone() };
57538                        Ok(StreamSocketRequest::SetTcpSynCount {
57539                            value: req.value,
57540
57541                            responder: StreamSocketSetTcpSynCountResponder {
57542                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57543                                tx_id: header.tx_id,
57544                            },
57545                        })
57546                    }
57547                    0x7d457cba8f5f3ee6 => {
57548                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57549                        let mut req = fidl::new_empty!(
57550                            fidl::encoding::EmptyPayload,
57551                            fidl::encoding::DefaultFuchsiaResourceDialect
57552                        );
57553                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57554                        let control_handle =
57555                            StreamSocketControlHandle { inner: this.inner.clone() };
57556                        Ok(StreamSocketRequest::GetTcpSynCount {
57557                            responder: StreamSocketGetTcpSynCountResponder {
57558                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57559                                tx_id: header.tx_id,
57560                            },
57561                        })
57562                    }
57563                    0xd5cc1e8654d36e4 => {
57564                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57565                        let mut req = fidl::new_empty!(
57566                            StreamSocketSetTcpLingerRequest,
57567                            fidl::encoding::DefaultFuchsiaResourceDialect
57568                        );
57569                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpLingerRequest>(&header, _body_bytes, handles, &mut req)?;
57570                        let control_handle =
57571                            StreamSocketControlHandle { inner: this.inner.clone() };
57572                        Ok(StreamSocketRequest::SetTcpLinger {
57573                            value_secs: req.value_secs,
57574
57575                            responder: StreamSocketSetTcpLingerResponder {
57576                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57577                                tx_id: header.tx_id,
57578                            },
57579                        })
57580                    }
57581                    0xad870d311cf30eb => {
57582                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57583                        let mut req = fidl::new_empty!(
57584                            fidl::encoding::EmptyPayload,
57585                            fidl::encoding::DefaultFuchsiaResourceDialect
57586                        );
57587                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57588                        let control_handle =
57589                            StreamSocketControlHandle { inner: this.inner.clone() };
57590                        Ok(StreamSocketRequest::GetTcpLinger {
57591                            responder: StreamSocketGetTcpLingerResponder {
57592                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57593                                tx_id: header.tx_id,
57594                            },
57595                        })
57596                    }
57597                    0x15092f181e57c404 => {
57598                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57599                        let mut req = fidl::new_empty!(
57600                            StreamSocketSetTcpDeferAcceptRequest,
57601                            fidl::encoding::DefaultFuchsiaResourceDialect
57602                        );
57603                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpDeferAcceptRequest>(&header, _body_bytes, handles, &mut req)?;
57604                        let control_handle =
57605                            StreamSocketControlHandle { inner: this.inner.clone() };
57606                        Ok(StreamSocketRequest::SetTcpDeferAccept {
57607                            value_secs: req.value_secs,
57608
57609                            responder: StreamSocketSetTcpDeferAcceptResponder {
57610                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57611                                tx_id: header.tx_id,
57612                            },
57613                        })
57614                    }
57615                    0x64589790842cb7c6 => {
57616                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57617                        let mut req = fidl::new_empty!(
57618                            fidl::encoding::EmptyPayload,
57619                            fidl::encoding::DefaultFuchsiaResourceDialect
57620                        );
57621                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57622                        let control_handle =
57623                            StreamSocketControlHandle { inner: this.inner.clone() };
57624                        Ok(StreamSocketRequest::GetTcpDeferAccept {
57625                            responder: StreamSocketGetTcpDeferAcceptResponder {
57626                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57627                                tx_id: header.tx_id,
57628                            },
57629                        })
57630                    }
57631                    0x4a26ce07d847f1c6 => {
57632                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57633                        let mut req = fidl::new_empty!(
57634                            StreamSocketSetTcpWindowClampRequest,
57635                            fidl::encoding::DefaultFuchsiaResourceDialect
57636                        );
57637                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpWindowClampRequest>(&header, _body_bytes, handles, &mut req)?;
57638                        let control_handle =
57639                            StreamSocketControlHandle { inner: this.inner.clone() };
57640                        Ok(StreamSocketRequest::SetTcpWindowClamp {
57641                            value: req.value,
57642
57643                            responder: StreamSocketSetTcpWindowClampResponder {
57644                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57645                                tx_id: header.tx_id,
57646                            },
57647                        })
57648                    }
57649                    0x2df6b636bf0a6a4e => {
57650                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57651                        let mut req = fidl::new_empty!(
57652                            fidl::encoding::EmptyPayload,
57653                            fidl::encoding::DefaultFuchsiaResourceDialect
57654                        );
57655                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57656                        let control_handle =
57657                            StreamSocketControlHandle { inner: this.inner.clone() };
57658                        Ok(StreamSocketRequest::GetTcpWindowClamp {
57659                            responder: StreamSocketGetTcpWindowClampResponder {
57660                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57661                                tx_id: header.tx_id,
57662                            },
57663                        })
57664                    }
57665                    0x1ffb123d9f03ead2 => {
57666                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57667                        let mut req = fidl::new_empty!(
57668                            fidl::encoding::EmptyPayload,
57669                            fidl::encoding::DefaultFuchsiaResourceDialect
57670                        );
57671                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57672                        let control_handle =
57673                            StreamSocketControlHandle { inner: this.inner.clone() };
57674                        Ok(StreamSocketRequest::GetTcpInfo {
57675                            responder: StreamSocketGetTcpInfoResponder {
57676                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57677                                tx_id: header.tx_id,
57678                            },
57679                        })
57680                    }
57681                    0x6fa811be8fde7457 => {
57682                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57683                        let mut req = fidl::new_empty!(
57684                            StreamSocketSetTcpQuickAckRequest,
57685                            fidl::encoding::DefaultFuchsiaResourceDialect
57686                        );
57687                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpQuickAckRequest>(&header, _body_bytes, handles, &mut req)?;
57688                        let control_handle =
57689                            StreamSocketControlHandle { inner: this.inner.clone() };
57690                        Ok(StreamSocketRequest::SetTcpQuickAck {
57691                            value: req.value,
57692
57693                            responder: StreamSocketSetTcpQuickAckResponder {
57694                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57695                                tx_id: header.tx_id,
57696                            },
57697                        })
57698                    }
57699                    0x7356a949bef2df32 => {
57700                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57701                        let mut req = fidl::new_empty!(
57702                            fidl::encoding::EmptyPayload,
57703                            fidl::encoding::DefaultFuchsiaResourceDialect
57704                        );
57705                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57706                        let control_handle =
57707                            StreamSocketControlHandle { inner: this.inner.clone() };
57708                        Ok(StreamSocketRequest::GetTcpQuickAck {
57709                            responder: StreamSocketGetTcpQuickAckResponder {
57710                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57711                                tx_id: header.tx_id,
57712                            },
57713                        })
57714                    }
57715                    0x7924c6eabde7819e => {
57716                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57717                        let mut req = fidl::new_empty!(
57718                            StreamSocketSetTcpCongestionRequest,
57719                            fidl::encoding::DefaultFuchsiaResourceDialect
57720                        );
57721                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpCongestionRequest>(&header, _body_bytes, handles, &mut req)?;
57722                        let control_handle =
57723                            StreamSocketControlHandle { inner: this.inner.clone() };
57724                        Ok(StreamSocketRequest::SetTcpCongestion {
57725                            value: req.value,
57726
57727                            responder: StreamSocketSetTcpCongestionResponder {
57728                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57729                                tx_id: header.tx_id,
57730                            },
57731                        })
57732                    }
57733                    0x11e16397e1b72a47 => {
57734                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57735                        let mut req = fidl::new_empty!(
57736                            fidl::encoding::EmptyPayload,
57737                            fidl::encoding::DefaultFuchsiaResourceDialect
57738                        );
57739                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57740                        let control_handle =
57741                            StreamSocketControlHandle { inner: this.inner.clone() };
57742                        Ok(StreamSocketRequest::GetTcpCongestion {
57743                            responder: StreamSocketGetTcpCongestionResponder {
57744                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57745                                tx_id: header.tx_id,
57746                            },
57747                        })
57748                    }
57749                    0x6b459e81c3741a60 => {
57750                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57751                        let mut req = fidl::new_empty!(
57752                            StreamSocketSetTcpUserTimeoutRequest,
57753                            fidl::encoding::DefaultFuchsiaResourceDialect
57754                        );
57755                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<StreamSocketSetTcpUserTimeoutRequest>(&header, _body_bytes, handles, &mut req)?;
57756                        let control_handle =
57757                            StreamSocketControlHandle { inner: this.inner.clone() };
57758                        Ok(StreamSocketRequest::SetTcpUserTimeout {
57759                            value_millis: req.value_millis,
57760
57761                            responder: StreamSocketSetTcpUserTimeoutResponder {
57762                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57763                                tx_id: header.tx_id,
57764                            },
57765                        })
57766                    }
57767                    0x24bbd5858ad8c380 => {
57768                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
57769                        let mut req = fidl::new_empty!(
57770                            fidl::encoding::EmptyPayload,
57771                            fidl::encoding::DefaultFuchsiaResourceDialect
57772                        );
57773                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
57774                        let control_handle =
57775                            StreamSocketControlHandle { inner: this.inner.clone() };
57776                        Ok(StreamSocketRequest::GetTcpUserTimeout {
57777                            responder: StreamSocketGetTcpUserTimeoutResponder {
57778                                control_handle: std::mem::ManuallyDrop::new(control_handle),
57779                                tx_id: header.tx_id,
57780                            },
57781                        })
57782                    }
57783                    _ => Err(fidl::Error::UnknownOrdinal {
57784                        ordinal: header.ordinal,
57785                        protocol_name:
57786                            <StreamSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
57787                    }),
57788                }))
57789            },
57790        )
57791    }
57792}
57793
57794/// A stream socket.
57795///
57796/// All methods on this type are nonblocking; their exact behaviors match their
57797/// Linux counterparts.
57798///
57799/// *Warning:* This protocol is not yet ready for direct use by clients.
57800/// Instead, clients should use the BSD sockets API to interact with sockets.
57801/// We plan to change this protocol substantially and clients that couple
57802/// directly to this protocol will make those changes more difficult.
57803#[derive(Debug)]
57804pub enum StreamSocketRequest {
57805    Clone {
57806        request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
57807        control_handle: StreamSocketControlHandle,
57808    },
57809    /// Terminates the connection.
57810    ///
57811    /// After calling `Close`, the client must not send any other requests.
57812    ///
57813    /// Servers, after sending the status response, should close the connection
57814    /// regardless of status and without sending an epitaph.
57815    ///
57816    /// Closing the client end of the channel should be semantically equivalent
57817    /// to calling `Close` without knowing when the close has completed or its
57818    /// status.
57819    Close {
57820        responder: StreamSocketCloseResponder,
57821    },
57822    Query {
57823        responder: StreamSocketQueryResponder,
57824    },
57825    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
57826    SetReuseAddress {
57827        value: bool,
57828        responder: StreamSocketSetReuseAddressResponder,
57829    },
57830    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
57831    GetReuseAddress {
57832        responder: StreamSocketGetReuseAddressResponder,
57833    },
57834    /// Get `SOL_SOCKET` -> `SO_ERROR`.
57835    /// Returns the last error if there is an error set on the socket.
57836    GetError {
57837        responder: StreamSocketGetErrorResponder,
57838    },
57839    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
57840    SetBroadcast {
57841        value: bool,
57842        responder: StreamSocketSetBroadcastResponder,
57843    },
57844    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
57845    GetBroadcast {
57846        responder: StreamSocketGetBroadcastResponder,
57847    },
57848    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
57849    SetSendBuffer {
57850        value_bytes: u64,
57851        responder: StreamSocketSetSendBufferResponder,
57852    },
57853    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
57854    GetSendBuffer {
57855        responder: StreamSocketGetSendBufferResponder,
57856    },
57857    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
57858    SetReceiveBuffer {
57859        value_bytes: u64,
57860        responder: StreamSocketSetReceiveBufferResponder,
57861    },
57862    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
57863    GetReceiveBuffer {
57864        responder: StreamSocketGetReceiveBufferResponder,
57865    },
57866    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
57867    SetKeepAlive {
57868        value: bool,
57869        responder: StreamSocketSetKeepAliveResponder,
57870    },
57871    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
57872    GetKeepAlive {
57873        responder: StreamSocketGetKeepAliveResponder,
57874    },
57875    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
57876    SetOutOfBandInline {
57877        value: bool,
57878        responder: StreamSocketSetOutOfBandInlineResponder,
57879    },
57880    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
57881    GetOutOfBandInline {
57882        responder: StreamSocketGetOutOfBandInlineResponder,
57883    },
57884    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
57885    SetNoCheck {
57886        value: bool,
57887        responder: StreamSocketSetNoCheckResponder,
57888    },
57889    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
57890    GetNoCheck {
57891        responder: StreamSocketGetNoCheckResponder,
57892    },
57893    /// Set `SOL_SOCKET` -> `SO_LINGER`.
57894    SetLinger {
57895        linger: bool,
57896        length_secs: u32,
57897        responder: StreamSocketSetLingerResponder,
57898    },
57899    /// Get `SOL_SOCKET` -> `SO_LINGER`.
57900    GetLinger {
57901        responder: StreamSocketGetLingerResponder,
57902    },
57903    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
57904    SetReusePort {
57905        value: bool,
57906        responder: StreamSocketSetReusePortResponder,
57907    },
57908    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
57909    GetReusePort {
57910        responder: StreamSocketGetReusePortResponder,
57911    },
57912    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
57913    GetAcceptConn {
57914        responder: StreamSocketGetAcceptConnResponder,
57915    },
57916    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
57917    SetBindToDevice {
57918        value: String,
57919        responder: StreamSocketSetBindToDeviceResponder,
57920    },
57921    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
57922    GetBindToDevice {
57923        responder: StreamSocketGetBindToDeviceResponder,
57924    },
57925    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
57926    /// If `value` is 0, this clears the bound interface.
57927    SetBindToInterfaceIndex {
57928        value: u64,
57929        responder: StreamSocketSetBindToInterfaceIndexResponder,
57930    },
57931    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
57932    GetBindToInterfaceIndex {
57933        responder: StreamSocketGetBindToInterfaceIndexResponder,
57934    },
57935    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
57936    SetTimestamp {
57937        value: TimestampOption,
57938        responder: StreamSocketSetTimestampResponder,
57939    },
57940    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
57941    GetTimestamp {
57942        responder: StreamSocketGetTimestampResponder,
57943    },
57944    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
57945    /// unlike the standard SO_MARK, this API has multiple mark domains and each
57946    /// mark can be set independently in each domain.
57947    SetMark {
57948        domain: fidl_fuchsia_net::MarkDomain,
57949        mark: OptionalUint32,
57950        responder: StreamSocketSetMarkResponder,
57951    },
57952    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
57953    /// unlike the standard SO_MARK, this API has multiple mark domains and each
57954    /// mark can be retrieved independently in each domain.
57955    GetMark {
57956        domain: fidl_fuchsia_net::MarkDomain,
57957        responder: StreamSocketGetMarkResponder,
57958    },
57959    /// Sets the local address used for the socket.
57960    Bind {
57961        addr: fidl_fuchsia_net::SocketAddress,
57962        responder: StreamSocketBindResponder,
57963    },
57964    /// Initiates a connection to a remote address.
57965    Connect {
57966        addr: fidl_fuchsia_net::SocketAddress,
57967        responder: StreamSocketConnectResponder,
57968    },
57969    /// Clears connection information from this socket.
57970    Disconnect {
57971        responder: StreamSocketDisconnectResponder,
57972    },
57973    /// Retrieves the local socket address.
57974    GetSockName {
57975        responder: StreamSocketGetSockNameResponder,
57976    },
57977    /// Retrieves the remote socket address.
57978    GetPeerName {
57979        responder: StreamSocketGetPeerNameResponder,
57980    },
57981    /// Shuts down part of the socket.
57982    Shutdown {
57983        mode: ShutdownMode,
57984        responder: StreamSocketShutdownResponder,
57985    },
57986    /// Set `SOL_IP` -> `IP_TOS`.
57987    SetIpTypeOfService {
57988        value: u8,
57989        responder: StreamSocketSetIpTypeOfServiceResponder,
57990    },
57991    /// Get `SOL_IP` -> `IP_TOS`.
57992    GetIpTypeOfService {
57993        responder: StreamSocketGetIpTypeOfServiceResponder,
57994    },
57995    /// Set `SOL_IP` -> `IP_TTL`.
57996    SetIpTtl {
57997        value: OptionalUint8,
57998        responder: StreamSocketSetIpTtlResponder,
57999    },
58000    /// Get `SOL_IP` -> `IP_TTL`.
58001    GetIpTtl {
58002        responder: StreamSocketGetIpTtlResponder,
58003    },
58004    /// Set `SOL_IP` -> `IP_PKTINFO`.
58005    SetIpPacketInfo {
58006        value: bool,
58007        responder: StreamSocketSetIpPacketInfoResponder,
58008    },
58009    /// Get `SOL_IP` -> `IP_PKTINFO`.
58010    GetIpPacketInfo {
58011        responder: StreamSocketGetIpPacketInfoResponder,
58012    },
58013    /// Set `SOL_IP` -> `IP_RECVTOS`.
58014    SetIpReceiveTypeOfService {
58015        value: bool,
58016        responder: StreamSocketSetIpReceiveTypeOfServiceResponder,
58017    },
58018    /// Get `SOL_IP` -> `IP_RECVTOS`.
58019    GetIpReceiveTypeOfService {
58020        responder: StreamSocketGetIpReceiveTypeOfServiceResponder,
58021    },
58022    /// Set `SOL_IP` -> `IP_RECVTTL`.
58023    SetIpReceiveTtl {
58024        value: bool,
58025        responder: StreamSocketSetIpReceiveTtlResponder,
58026    },
58027    /// Get `SOL_IP` -> `IP_RECVTTL`.
58028    GetIpReceiveTtl {
58029        responder: StreamSocketGetIpReceiveTtlResponder,
58030    },
58031    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
58032    SetIpMulticastInterface {
58033        iface: u64,
58034        address: fidl_fuchsia_net::Ipv4Address,
58035        responder: StreamSocketSetIpMulticastInterfaceResponder,
58036    },
58037    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
58038    GetIpMulticastInterface {
58039        responder: StreamSocketGetIpMulticastInterfaceResponder,
58040    },
58041    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
58042    SetIpMulticastTtl {
58043        value: OptionalUint8,
58044        responder: StreamSocketSetIpMulticastTtlResponder,
58045    },
58046    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
58047    GetIpMulticastTtl {
58048        responder: StreamSocketGetIpMulticastTtlResponder,
58049    },
58050    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
58051    SetIpMulticastLoopback {
58052        value: bool,
58053        responder: StreamSocketSetIpMulticastLoopbackResponder,
58054    },
58055    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
58056    GetIpMulticastLoopback {
58057        responder: StreamSocketGetIpMulticastLoopbackResponder,
58058    },
58059    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
58060    AddIpMembership {
58061        membership: IpMulticastMembership,
58062        responder: StreamSocketAddIpMembershipResponder,
58063    },
58064    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
58065    DropIpMembership {
58066        membership: IpMulticastMembership,
58067        responder: StreamSocketDropIpMembershipResponder,
58068    },
58069    /// Set `SOL_IP` -> `IP_TRANSPARENT`
58070    SetIpTransparent {
58071        value: bool,
58072        responder: StreamSocketSetIpTransparentResponder,
58073    },
58074    /// Get `SOL_IP` -> `IP_TRANSPARENT`
58075    GetIpTransparent {
58076        responder: StreamSocketGetIpTransparentResponder,
58077    },
58078    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
58079    SetIpReceiveOriginalDestinationAddress {
58080        value: bool,
58081        responder: StreamSocketSetIpReceiveOriginalDestinationAddressResponder,
58082    },
58083    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
58084    GetIpReceiveOriginalDestinationAddress {
58085        responder: StreamSocketGetIpReceiveOriginalDestinationAddressResponder,
58086    },
58087    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
58088    AddIpv6Membership {
58089        membership: Ipv6MulticastMembership,
58090        responder: StreamSocketAddIpv6MembershipResponder,
58091    },
58092    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
58093    DropIpv6Membership {
58094        membership: Ipv6MulticastMembership,
58095        responder: StreamSocketDropIpv6MembershipResponder,
58096    },
58097    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
58098    SetIpv6MulticastInterface {
58099        value: u64,
58100        responder: StreamSocketSetIpv6MulticastInterfaceResponder,
58101    },
58102    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
58103    GetIpv6MulticastInterface {
58104        responder: StreamSocketGetIpv6MulticastInterfaceResponder,
58105    },
58106    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
58107    SetIpv6UnicastHops {
58108        value: OptionalUint8,
58109        responder: StreamSocketSetIpv6UnicastHopsResponder,
58110    },
58111    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
58112    GetIpv6UnicastHops {
58113        responder: StreamSocketGetIpv6UnicastHopsResponder,
58114    },
58115    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
58116    SetIpv6ReceiveHopLimit {
58117        value: bool,
58118        responder: StreamSocketSetIpv6ReceiveHopLimitResponder,
58119    },
58120    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
58121    GetIpv6ReceiveHopLimit {
58122        responder: StreamSocketGetIpv6ReceiveHopLimitResponder,
58123    },
58124    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
58125    SetIpv6MulticastHops {
58126        value: OptionalUint8,
58127        responder: StreamSocketSetIpv6MulticastHopsResponder,
58128    },
58129    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
58130    GetIpv6MulticastHops {
58131        responder: StreamSocketGetIpv6MulticastHopsResponder,
58132    },
58133    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
58134    SetIpv6MulticastLoopback {
58135        value: bool,
58136        responder: StreamSocketSetIpv6MulticastLoopbackResponder,
58137    },
58138    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
58139    GetIpv6MulticastLoopback {
58140        responder: StreamSocketGetIpv6MulticastLoopbackResponder,
58141    },
58142    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
58143    SetIpv6Only {
58144        value: bool,
58145        responder: StreamSocketSetIpv6OnlyResponder,
58146    },
58147    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
58148    GetIpv6Only {
58149        responder: StreamSocketGetIpv6OnlyResponder,
58150    },
58151    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
58152    SetIpv6ReceiveTrafficClass {
58153        value: bool,
58154        responder: StreamSocketSetIpv6ReceiveTrafficClassResponder,
58155    },
58156    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
58157    GetIpv6ReceiveTrafficClass {
58158        responder: StreamSocketGetIpv6ReceiveTrafficClassResponder,
58159    },
58160    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
58161    SetIpv6TrafficClass {
58162        value: OptionalUint8,
58163        responder: StreamSocketSetIpv6TrafficClassResponder,
58164    },
58165    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
58166    GetIpv6TrafficClass {
58167        responder: StreamSocketGetIpv6TrafficClassResponder,
58168    },
58169    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
58170    SetIpv6ReceivePacketInfo {
58171        value: bool,
58172        responder: StreamSocketSetIpv6ReceivePacketInfoResponder,
58173    },
58174    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
58175    GetIpv6ReceivePacketInfo {
58176        responder: StreamSocketGetIpv6ReceivePacketInfoResponder,
58177    },
58178    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
58179    GetOriginalDestination {
58180        responder: StreamSocketGetOriginalDestinationResponder,
58181    },
58182    Describe {
58183        responder: StreamSocketDescribeResponder,
58184    },
58185    /// Begins listening for new incoming connections. At most `backlog`
58186    /// connections will be buffered.
58187    Listen {
58188        backlog: i16,
58189        responder: StreamSocketListenResponder,
58190    },
58191    /// Accepts a buffered incoming connection.
58192    Accept {
58193        want_addr: bool,
58194        responder: StreamSocketAcceptResponder,
58195    },
58196    /// Retrieves creation information from the socket.
58197    GetInfo {
58198        responder: StreamSocketGetInfoResponder,
58199    },
58200    /// Set `SOL_TCP` -> `TCP_NODELAY`.
58201    SetTcpNoDelay {
58202        value: bool,
58203        responder: StreamSocketSetTcpNoDelayResponder,
58204    },
58205    /// Get `SOL_TCP` -> `TCP_NODELAY`.
58206    GetTcpNoDelay {
58207        responder: StreamSocketGetTcpNoDelayResponder,
58208    },
58209    /// Set `SOL_TCP` -> `TCP_MAXSEG`.
58210    SetTcpMaxSegment {
58211        value_bytes: u32,
58212        responder: StreamSocketSetTcpMaxSegmentResponder,
58213    },
58214    /// Get `SOL_TCP` -> `TCP_MAXSEG`.
58215    GetTcpMaxSegment {
58216        responder: StreamSocketGetTcpMaxSegmentResponder,
58217    },
58218    /// Set `SOL_TCP` -> `TCP_CORK`.
58219    SetTcpCork {
58220        value: bool,
58221        responder: StreamSocketSetTcpCorkResponder,
58222    },
58223    /// Get `SOL_TCP` -> `TCP_CORK`.
58224    GetTcpCork {
58225        responder: StreamSocketGetTcpCorkResponder,
58226    },
58227    /// Set `SOL_TCP` -> `TCP_KEEPIDLE`.
58228    SetTcpKeepAliveIdle {
58229        value_secs: u32,
58230        responder: StreamSocketSetTcpKeepAliveIdleResponder,
58231    },
58232    /// Get `SOL_TCP` -> `TCP_KEEPIDLE`.
58233    GetTcpKeepAliveIdle {
58234        responder: StreamSocketGetTcpKeepAliveIdleResponder,
58235    },
58236    /// Set `SOL_TCP` -> `TCP_KEEPINTVL`.
58237    SetTcpKeepAliveInterval {
58238        value_secs: u32,
58239        responder: StreamSocketSetTcpKeepAliveIntervalResponder,
58240    },
58241    /// Get `SOL_TCP` -> `TCP_KEEPINTVL`.
58242    GetTcpKeepAliveInterval {
58243        responder: StreamSocketGetTcpKeepAliveIntervalResponder,
58244    },
58245    /// Set `SOL_TCP` -> `TCP_KEEPCNT`.
58246    SetTcpKeepAliveCount {
58247        value: u32,
58248        responder: StreamSocketSetTcpKeepAliveCountResponder,
58249    },
58250    /// Get `SOL_TCP` -> `TCP_KEEPCNT`.
58251    GetTcpKeepAliveCount {
58252        responder: StreamSocketGetTcpKeepAliveCountResponder,
58253    },
58254    /// Set `SOL_TCP` -> `TCP_SYNCNT`.
58255    SetTcpSynCount {
58256        value: u32,
58257        responder: StreamSocketSetTcpSynCountResponder,
58258    },
58259    /// Get `SOL_TCP` -> `TCP_SYNCNT`.
58260    GetTcpSynCount {
58261        responder: StreamSocketGetTcpSynCountResponder,
58262    },
58263    /// Set `SOL_TCP` -> `TCP_LINGER2`.
58264    SetTcpLinger {
58265        value_secs: OptionalUint32,
58266        responder: StreamSocketSetTcpLingerResponder,
58267    },
58268    /// Get `SOL_TCP` -> `TCP_LINGER2`.
58269    GetTcpLinger {
58270        responder: StreamSocketGetTcpLingerResponder,
58271    },
58272    /// Set `SOL_TCP` -> `TCP_DEFER_ACCEPT`.
58273    SetTcpDeferAccept {
58274        value_secs: u32,
58275        responder: StreamSocketSetTcpDeferAcceptResponder,
58276    },
58277    /// Get `SOL_TCP` -> `TCP_DEFER_ACCEPT`.
58278    GetTcpDeferAccept {
58279        responder: StreamSocketGetTcpDeferAcceptResponder,
58280    },
58281    /// Set `SOL_TCP` -> `TCP_WINDOW_CLAMP`.
58282    SetTcpWindowClamp {
58283        value: u32,
58284        responder: StreamSocketSetTcpWindowClampResponder,
58285    },
58286    /// Get `SOL_TCP` -> `TCP_WINDOW_CLAMP`.
58287    GetTcpWindowClamp {
58288        responder: StreamSocketGetTcpWindowClampResponder,
58289    },
58290    /// Get `SOL_TCP` -> `TCP_INFO`.
58291    GetTcpInfo {
58292        responder: StreamSocketGetTcpInfoResponder,
58293    },
58294    /// Set `SOL_TCP` -> `TCP_QUICKACK`.
58295    SetTcpQuickAck {
58296        value: bool,
58297        responder: StreamSocketSetTcpQuickAckResponder,
58298    },
58299    /// Get `SOL_TCP` -> `TCP_QUICKACK`.
58300    GetTcpQuickAck {
58301        responder: StreamSocketGetTcpQuickAckResponder,
58302    },
58303    /// Set `SOL_TCP` -> `TCP_CONGESTION`.
58304    SetTcpCongestion {
58305        value: TcpCongestionControl,
58306        responder: StreamSocketSetTcpCongestionResponder,
58307    },
58308    /// Get `SOL_TCP` -> `TCP_CONGESTION`.
58309    GetTcpCongestion {
58310        responder: StreamSocketGetTcpCongestionResponder,
58311    },
58312    /// Set `SOL_TCP` -> `TCP_USER_TIMEOUT`.
58313    SetTcpUserTimeout {
58314        value_millis: u32,
58315        responder: StreamSocketSetTcpUserTimeoutResponder,
58316    },
58317    /// Get `SOL_TCP` -> `TCP_USER_TIMEOUT`.
58318    GetTcpUserTimeout {
58319        responder: StreamSocketGetTcpUserTimeoutResponder,
58320    },
58321}
58322
58323impl StreamSocketRequest {
58324    #[allow(irrefutable_let_patterns)]
58325    pub fn into_clone(
58326        self,
58327    ) -> Option<(
58328        fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
58329        StreamSocketControlHandle,
58330    )> {
58331        if let StreamSocketRequest::Clone { request, control_handle } = self {
58332            Some((request, control_handle))
58333        } else {
58334            None
58335        }
58336    }
58337
58338    #[allow(irrefutable_let_patterns)]
58339    pub fn into_close(self) -> Option<(StreamSocketCloseResponder)> {
58340        if let StreamSocketRequest::Close { responder } = self {
58341            Some((responder))
58342        } else {
58343            None
58344        }
58345    }
58346
58347    #[allow(irrefutable_let_patterns)]
58348    pub fn into_query(self) -> Option<(StreamSocketQueryResponder)> {
58349        if let StreamSocketRequest::Query { responder } = self {
58350            Some((responder))
58351        } else {
58352            None
58353        }
58354    }
58355
58356    #[allow(irrefutable_let_patterns)]
58357    pub fn into_set_reuse_address(self) -> Option<(bool, StreamSocketSetReuseAddressResponder)> {
58358        if let StreamSocketRequest::SetReuseAddress { value, responder } = self {
58359            Some((value, responder))
58360        } else {
58361            None
58362        }
58363    }
58364
58365    #[allow(irrefutable_let_patterns)]
58366    pub fn into_get_reuse_address(self) -> Option<(StreamSocketGetReuseAddressResponder)> {
58367        if let StreamSocketRequest::GetReuseAddress { responder } = self {
58368            Some((responder))
58369        } else {
58370            None
58371        }
58372    }
58373
58374    #[allow(irrefutable_let_patterns)]
58375    pub fn into_get_error(self) -> Option<(StreamSocketGetErrorResponder)> {
58376        if let StreamSocketRequest::GetError { responder } = self {
58377            Some((responder))
58378        } else {
58379            None
58380        }
58381    }
58382
58383    #[allow(irrefutable_let_patterns)]
58384    pub fn into_set_broadcast(self) -> Option<(bool, StreamSocketSetBroadcastResponder)> {
58385        if let StreamSocketRequest::SetBroadcast { value, responder } = self {
58386            Some((value, responder))
58387        } else {
58388            None
58389        }
58390    }
58391
58392    #[allow(irrefutable_let_patterns)]
58393    pub fn into_get_broadcast(self) -> Option<(StreamSocketGetBroadcastResponder)> {
58394        if let StreamSocketRequest::GetBroadcast { responder } = self {
58395            Some((responder))
58396        } else {
58397            None
58398        }
58399    }
58400
58401    #[allow(irrefutable_let_patterns)]
58402    pub fn into_set_send_buffer(self) -> Option<(u64, StreamSocketSetSendBufferResponder)> {
58403        if let StreamSocketRequest::SetSendBuffer { value_bytes, responder } = self {
58404            Some((value_bytes, responder))
58405        } else {
58406            None
58407        }
58408    }
58409
58410    #[allow(irrefutable_let_patterns)]
58411    pub fn into_get_send_buffer(self) -> Option<(StreamSocketGetSendBufferResponder)> {
58412        if let StreamSocketRequest::GetSendBuffer { responder } = self {
58413            Some((responder))
58414        } else {
58415            None
58416        }
58417    }
58418
58419    #[allow(irrefutable_let_patterns)]
58420    pub fn into_set_receive_buffer(self) -> Option<(u64, StreamSocketSetReceiveBufferResponder)> {
58421        if let StreamSocketRequest::SetReceiveBuffer { value_bytes, responder } = self {
58422            Some((value_bytes, responder))
58423        } else {
58424            None
58425        }
58426    }
58427
58428    #[allow(irrefutable_let_patterns)]
58429    pub fn into_get_receive_buffer(self) -> Option<(StreamSocketGetReceiveBufferResponder)> {
58430        if let StreamSocketRequest::GetReceiveBuffer { responder } = self {
58431            Some((responder))
58432        } else {
58433            None
58434        }
58435    }
58436
58437    #[allow(irrefutable_let_patterns)]
58438    pub fn into_set_keep_alive(self) -> Option<(bool, StreamSocketSetKeepAliveResponder)> {
58439        if let StreamSocketRequest::SetKeepAlive { value, responder } = self {
58440            Some((value, responder))
58441        } else {
58442            None
58443        }
58444    }
58445
58446    #[allow(irrefutable_let_patterns)]
58447    pub fn into_get_keep_alive(self) -> Option<(StreamSocketGetKeepAliveResponder)> {
58448        if let StreamSocketRequest::GetKeepAlive { responder } = self {
58449            Some((responder))
58450        } else {
58451            None
58452        }
58453    }
58454
58455    #[allow(irrefutable_let_patterns)]
58456    pub fn into_set_out_of_band_inline(
58457        self,
58458    ) -> Option<(bool, StreamSocketSetOutOfBandInlineResponder)> {
58459        if let StreamSocketRequest::SetOutOfBandInline { value, responder } = self {
58460            Some((value, responder))
58461        } else {
58462            None
58463        }
58464    }
58465
58466    #[allow(irrefutable_let_patterns)]
58467    pub fn into_get_out_of_band_inline(self) -> Option<(StreamSocketGetOutOfBandInlineResponder)> {
58468        if let StreamSocketRequest::GetOutOfBandInline { responder } = self {
58469            Some((responder))
58470        } else {
58471            None
58472        }
58473    }
58474
58475    #[allow(irrefutable_let_patterns)]
58476    pub fn into_set_no_check(self) -> Option<(bool, StreamSocketSetNoCheckResponder)> {
58477        if let StreamSocketRequest::SetNoCheck { value, responder } = self {
58478            Some((value, responder))
58479        } else {
58480            None
58481        }
58482    }
58483
58484    #[allow(irrefutable_let_patterns)]
58485    pub fn into_get_no_check(self) -> Option<(StreamSocketGetNoCheckResponder)> {
58486        if let StreamSocketRequest::GetNoCheck { responder } = self {
58487            Some((responder))
58488        } else {
58489            None
58490        }
58491    }
58492
58493    #[allow(irrefutable_let_patterns)]
58494    pub fn into_set_linger(self) -> Option<(bool, u32, StreamSocketSetLingerResponder)> {
58495        if let StreamSocketRequest::SetLinger { linger, length_secs, responder } = self {
58496            Some((linger, length_secs, responder))
58497        } else {
58498            None
58499        }
58500    }
58501
58502    #[allow(irrefutable_let_patterns)]
58503    pub fn into_get_linger(self) -> Option<(StreamSocketGetLingerResponder)> {
58504        if let StreamSocketRequest::GetLinger { responder } = self {
58505            Some((responder))
58506        } else {
58507            None
58508        }
58509    }
58510
58511    #[allow(irrefutable_let_patterns)]
58512    pub fn into_set_reuse_port(self) -> Option<(bool, StreamSocketSetReusePortResponder)> {
58513        if let StreamSocketRequest::SetReusePort { value, responder } = self {
58514            Some((value, responder))
58515        } else {
58516            None
58517        }
58518    }
58519
58520    #[allow(irrefutable_let_patterns)]
58521    pub fn into_get_reuse_port(self) -> Option<(StreamSocketGetReusePortResponder)> {
58522        if let StreamSocketRequest::GetReusePort { responder } = self {
58523            Some((responder))
58524        } else {
58525            None
58526        }
58527    }
58528
58529    #[allow(irrefutable_let_patterns)]
58530    pub fn into_get_accept_conn(self) -> Option<(StreamSocketGetAcceptConnResponder)> {
58531        if let StreamSocketRequest::GetAcceptConn { responder } = self {
58532            Some((responder))
58533        } else {
58534            None
58535        }
58536    }
58537
58538    #[allow(irrefutable_let_patterns)]
58539    pub fn into_set_bind_to_device(self) -> Option<(String, StreamSocketSetBindToDeviceResponder)> {
58540        if let StreamSocketRequest::SetBindToDevice { value, responder } = self {
58541            Some((value, responder))
58542        } else {
58543            None
58544        }
58545    }
58546
58547    #[allow(irrefutable_let_patterns)]
58548    pub fn into_get_bind_to_device(self) -> Option<(StreamSocketGetBindToDeviceResponder)> {
58549        if let StreamSocketRequest::GetBindToDevice { responder } = self {
58550            Some((responder))
58551        } else {
58552            None
58553        }
58554    }
58555
58556    #[allow(irrefutable_let_patterns)]
58557    pub fn into_set_bind_to_interface_index(
58558        self,
58559    ) -> Option<(u64, StreamSocketSetBindToInterfaceIndexResponder)> {
58560        if let StreamSocketRequest::SetBindToInterfaceIndex { value, responder } = self {
58561            Some((value, responder))
58562        } else {
58563            None
58564        }
58565    }
58566
58567    #[allow(irrefutable_let_patterns)]
58568    pub fn into_get_bind_to_interface_index(
58569        self,
58570    ) -> Option<(StreamSocketGetBindToInterfaceIndexResponder)> {
58571        if let StreamSocketRequest::GetBindToInterfaceIndex { responder } = self {
58572            Some((responder))
58573        } else {
58574            None
58575        }
58576    }
58577
58578    #[allow(irrefutable_let_patterns)]
58579    pub fn into_set_timestamp(
58580        self,
58581    ) -> Option<(TimestampOption, StreamSocketSetTimestampResponder)> {
58582        if let StreamSocketRequest::SetTimestamp { value, responder } = self {
58583            Some((value, responder))
58584        } else {
58585            None
58586        }
58587    }
58588
58589    #[allow(irrefutable_let_patterns)]
58590    pub fn into_get_timestamp(self) -> Option<(StreamSocketGetTimestampResponder)> {
58591        if let StreamSocketRequest::GetTimestamp { responder } = self {
58592            Some((responder))
58593        } else {
58594            None
58595        }
58596    }
58597
58598    #[allow(irrefutable_let_patterns)]
58599    pub fn into_set_mark(
58600        self,
58601    ) -> Option<(fidl_fuchsia_net::MarkDomain, OptionalUint32, StreamSocketSetMarkResponder)> {
58602        if let StreamSocketRequest::SetMark { domain, mark, responder } = self {
58603            Some((domain, mark, responder))
58604        } else {
58605            None
58606        }
58607    }
58608
58609    #[allow(irrefutable_let_patterns)]
58610    pub fn into_get_mark(
58611        self,
58612    ) -> Option<(fidl_fuchsia_net::MarkDomain, StreamSocketGetMarkResponder)> {
58613        if let StreamSocketRequest::GetMark { domain, responder } = self {
58614            Some((domain, responder))
58615        } else {
58616            None
58617        }
58618    }
58619
58620    #[allow(irrefutable_let_patterns)]
58621    pub fn into_bind(self) -> Option<(fidl_fuchsia_net::SocketAddress, StreamSocketBindResponder)> {
58622        if let StreamSocketRequest::Bind { addr, responder } = self {
58623            Some((addr, responder))
58624        } else {
58625            None
58626        }
58627    }
58628
58629    #[allow(irrefutable_let_patterns)]
58630    pub fn into_connect(
58631        self,
58632    ) -> Option<(fidl_fuchsia_net::SocketAddress, StreamSocketConnectResponder)> {
58633        if let StreamSocketRequest::Connect { addr, responder } = self {
58634            Some((addr, responder))
58635        } else {
58636            None
58637        }
58638    }
58639
58640    #[allow(irrefutable_let_patterns)]
58641    pub fn into_disconnect(self) -> Option<(StreamSocketDisconnectResponder)> {
58642        if let StreamSocketRequest::Disconnect { responder } = self {
58643            Some((responder))
58644        } else {
58645            None
58646        }
58647    }
58648
58649    #[allow(irrefutable_let_patterns)]
58650    pub fn into_get_sock_name(self) -> Option<(StreamSocketGetSockNameResponder)> {
58651        if let StreamSocketRequest::GetSockName { responder } = self {
58652            Some((responder))
58653        } else {
58654            None
58655        }
58656    }
58657
58658    #[allow(irrefutable_let_patterns)]
58659    pub fn into_get_peer_name(self) -> Option<(StreamSocketGetPeerNameResponder)> {
58660        if let StreamSocketRequest::GetPeerName { responder } = self {
58661            Some((responder))
58662        } else {
58663            None
58664        }
58665    }
58666
58667    #[allow(irrefutable_let_patterns)]
58668    pub fn into_shutdown(self) -> Option<(ShutdownMode, StreamSocketShutdownResponder)> {
58669        if let StreamSocketRequest::Shutdown { mode, responder } = self {
58670            Some((mode, responder))
58671        } else {
58672            None
58673        }
58674    }
58675
58676    #[allow(irrefutable_let_patterns)]
58677    pub fn into_set_ip_type_of_service(
58678        self,
58679    ) -> Option<(u8, StreamSocketSetIpTypeOfServiceResponder)> {
58680        if let StreamSocketRequest::SetIpTypeOfService { value, responder } = self {
58681            Some((value, responder))
58682        } else {
58683            None
58684        }
58685    }
58686
58687    #[allow(irrefutable_let_patterns)]
58688    pub fn into_get_ip_type_of_service(self) -> Option<(StreamSocketGetIpTypeOfServiceResponder)> {
58689        if let StreamSocketRequest::GetIpTypeOfService { responder } = self {
58690            Some((responder))
58691        } else {
58692            None
58693        }
58694    }
58695
58696    #[allow(irrefutable_let_patterns)]
58697    pub fn into_set_ip_ttl(self) -> Option<(OptionalUint8, StreamSocketSetIpTtlResponder)> {
58698        if let StreamSocketRequest::SetIpTtl { value, responder } = self {
58699            Some((value, responder))
58700        } else {
58701            None
58702        }
58703    }
58704
58705    #[allow(irrefutable_let_patterns)]
58706    pub fn into_get_ip_ttl(self) -> Option<(StreamSocketGetIpTtlResponder)> {
58707        if let StreamSocketRequest::GetIpTtl { responder } = self {
58708            Some((responder))
58709        } else {
58710            None
58711        }
58712    }
58713
58714    #[allow(irrefutable_let_patterns)]
58715    pub fn into_set_ip_packet_info(self) -> Option<(bool, StreamSocketSetIpPacketInfoResponder)> {
58716        if let StreamSocketRequest::SetIpPacketInfo { value, responder } = self {
58717            Some((value, responder))
58718        } else {
58719            None
58720        }
58721    }
58722
58723    #[allow(irrefutable_let_patterns)]
58724    pub fn into_get_ip_packet_info(self) -> Option<(StreamSocketGetIpPacketInfoResponder)> {
58725        if let StreamSocketRequest::GetIpPacketInfo { responder } = self {
58726            Some((responder))
58727        } else {
58728            None
58729        }
58730    }
58731
58732    #[allow(irrefutable_let_patterns)]
58733    pub fn into_set_ip_receive_type_of_service(
58734        self,
58735    ) -> Option<(bool, StreamSocketSetIpReceiveTypeOfServiceResponder)> {
58736        if let StreamSocketRequest::SetIpReceiveTypeOfService { value, responder } = self {
58737            Some((value, responder))
58738        } else {
58739            None
58740        }
58741    }
58742
58743    #[allow(irrefutable_let_patterns)]
58744    pub fn into_get_ip_receive_type_of_service(
58745        self,
58746    ) -> Option<(StreamSocketGetIpReceiveTypeOfServiceResponder)> {
58747        if let StreamSocketRequest::GetIpReceiveTypeOfService { responder } = self {
58748            Some((responder))
58749        } else {
58750            None
58751        }
58752    }
58753
58754    #[allow(irrefutable_let_patterns)]
58755    pub fn into_set_ip_receive_ttl(self) -> Option<(bool, StreamSocketSetIpReceiveTtlResponder)> {
58756        if let StreamSocketRequest::SetIpReceiveTtl { value, responder } = self {
58757            Some((value, responder))
58758        } else {
58759            None
58760        }
58761    }
58762
58763    #[allow(irrefutable_let_patterns)]
58764    pub fn into_get_ip_receive_ttl(self) -> Option<(StreamSocketGetIpReceiveTtlResponder)> {
58765        if let StreamSocketRequest::GetIpReceiveTtl { responder } = self {
58766            Some((responder))
58767        } else {
58768            None
58769        }
58770    }
58771
58772    #[allow(irrefutable_let_patterns)]
58773    pub fn into_set_ip_multicast_interface(
58774        self,
58775    ) -> Option<(u64, fidl_fuchsia_net::Ipv4Address, StreamSocketSetIpMulticastInterfaceResponder)>
58776    {
58777        if let StreamSocketRequest::SetIpMulticastInterface { iface, address, responder } = self {
58778            Some((iface, address, responder))
58779        } else {
58780            None
58781        }
58782    }
58783
58784    #[allow(irrefutable_let_patterns)]
58785    pub fn into_get_ip_multicast_interface(
58786        self,
58787    ) -> Option<(StreamSocketGetIpMulticastInterfaceResponder)> {
58788        if let StreamSocketRequest::GetIpMulticastInterface { responder } = self {
58789            Some((responder))
58790        } else {
58791            None
58792        }
58793    }
58794
58795    #[allow(irrefutable_let_patterns)]
58796    pub fn into_set_ip_multicast_ttl(
58797        self,
58798    ) -> Option<(OptionalUint8, StreamSocketSetIpMulticastTtlResponder)> {
58799        if let StreamSocketRequest::SetIpMulticastTtl { value, responder } = self {
58800            Some((value, responder))
58801        } else {
58802            None
58803        }
58804    }
58805
58806    #[allow(irrefutable_let_patterns)]
58807    pub fn into_get_ip_multicast_ttl(self) -> Option<(StreamSocketGetIpMulticastTtlResponder)> {
58808        if let StreamSocketRequest::GetIpMulticastTtl { responder } = self {
58809            Some((responder))
58810        } else {
58811            None
58812        }
58813    }
58814
58815    #[allow(irrefutable_let_patterns)]
58816    pub fn into_set_ip_multicast_loopback(
58817        self,
58818    ) -> Option<(bool, StreamSocketSetIpMulticastLoopbackResponder)> {
58819        if let StreamSocketRequest::SetIpMulticastLoopback { value, responder } = self {
58820            Some((value, responder))
58821        } else {
58822            None
58823        }
58824    }
58825
58826    #[allow(irrefutable_let_patterns)]
58827    pub fn into_get_ip_multicast_loopback(
58828        self,
58829    ) -> Option<(StreamSocketGetIpMulticastLoopbackResponder)> {
58830        if let StreamSocketRequest::GetIpMulticastLoopback { responder } = self {
58831            Some((responder))
58832        } else {
58833            None
58834        }
58835    }
58836
58837    #[allow(irrefutable_let_patterns)]
58838    pub fn into_add_ip_membership(
58839        self,
58840    ) -> Option<(IpMulticastMembership, StreamSocketAddIpMembershipResponder)> {
58841        if let StreamSocketRequest::AddIpMembership { membership, responder } = self {
58842            Some((membership, responder))
58843        } else {
58844            None
58845        }
58846    }
58847
58848    #[allow(irrefutable_let_patterns)]
58849    pub fn into_drop_ip_membership(
58850        self,
58851    ) -> Option<(IpMulticastMembership, StreamSocketDropIpMembershipResponder)> {
58852        if let StreamSocketRequest::DropIpMembership { membership, responder } = self {
58853            Some((membership, responder))
58854        } else {
58855            None
58856        }
58857    }
58858
58859    #[allow(irrefutable_let_patterns)]
58860    pub fn into_set_ip_transparent(self) -> Option<(bool, StreamSocketSetIpTransparentResponder)> {
58861        if let StreamSocketRequest::SetIpTransparent { value, responder } = self {
58862            Some((value, responder))
58863        } else {
58864            None
58865        }
58866    }
58867
58868    #[allow(irrefutable_let_patterns)]
58869    pub fn into_get_ip_transparent(self) -> Option<(StreamSocketGetIpTransparentResponder)> {
58870        if let StreamSocketRequest::GetIpTransparent { responder } = self {
58871            Some((responder))
58872        } else {
58873            None
58874        }
58875    }
58876
58877    #[allow(irrefutable_let_patterns)]
58878    pub fn into_set_ip_receive_original_destination_address(
58879        self,
58880    ) -> Option<(bool, StreamSocketSetIpReceiveOriginalDestinationAddressResponder)> {
58881        if let StreamSocketRequest::SetIpReceiveOriginalDestinationAddress { value, responder } =
58882            self
58883        {
58884            Some((value, responder))
58885        } else {
58886            None
58887        }
58888    }
58889
58890    #[allow(irrefutable_let_patterns)]
58891    pub fn into_get_ip_receive_original_destination_address(
58892        self,
58893    ) -> Option<(StreamSocketGetIpReceiveOriginalDestinationAddressResponder)> {
58894        if let StreamSocketRequest::GetIpReceiveOriginalDestinationAddress { responder } = self {
58895            Some((responder))
58896        } else {
58897            None
58898        }
58899    }
58900
58901    #[allow(irrefutable_let_patterns)]
58902    pub fn into_add_ipv6_membership(
58903        self,
58904    ) -> Option<(Ipv6MulticastMembership, StreamSocketAddIpv6MembershipResponder)> {
58905        if let StreamSocketRequest::AddIpv6Membership { membership, responder } = self {
58906            Some((membership, responder))
58907        } else {
58908            None
58909        }
58910    }
58911
58912    #[allow(irrefutable_let_patterns)]
58913    pub fn into_drop_ipv6_membership(
58914        self,
58915    ) -> Option<(Ipv6MulticastMembership, StreamSocketDropIpv6MembershipResponder)> {
58916        if let StreamSocketRequest::DropIpv6Membership { membership, responder } = self {
58917            Some((membership, responder))
58918        } else {
58919            None
58920        }
58921    }
58922
58923    #[allow(irrefutable_let_patterns)]
58924    pub fn into_set_ipv6_multicast_interface(
58925        self,
58926    ) -> Option<(u64, StreamSocketSetIpv6MulticastInterfaceResponder)> {
58927        if let StreamSocketRequest::SetIpv6MulticastInterface { value, responder } = self {
58928            Some((value, responder))
58929        } else {
58930            None
58931        }
58932    }
58933
58934    #[allow(irrefutable_let_patterns)]
58935    pub fn into_get_ipv6_multicast_interface(
58936        self,
58937    ) -> Option<(StreamSocketGetIpv6MulticastInterfaceResponder)> {
58938        if let StreamSocketRequest::GetIpv6MulticastInterface { responder } = self {
58939            Some((responder))
58940        } else {
58941            None
58942        }
58943    }
58944
58945    #[allow(irrefutable_let_patterns)]
58946    pub fn into_set_ipv6_unicast_hops(
58947        self,
58948    ) -> Option<(OptionalUint8, StreamSocketSetIpv6UnicastHopsResponder)> {
58949        if let StreamSocketRequest::SetIpv6UnicastHops { value, responder } = self {
58950            Some((value, responder))
58951        } else {
58952            None
58953        }
58954    }
58955
58956    #[allow(irrefutable_let_patterns)]
58957    pub fn into_get_ipv6_unicast_hops(self) -> Option<(StreamSocketGetIpv6UnicastHopsResponder)> {
58958        if let StreamSocketRequest::GetIpv6UnicastHops { responder } = self {
58959            Some((responder))
58960        } else {
58961            None
58962        }
58963    }
58964
58965    #[allow(irrefutable_let_patterns)]
58966    pub fn into_set_ipv6_receive_hop_limit(
58967        self,
58968    ) -> Option<(bool, StreamSocketSetIpv6ReceiveHopLimitResponder)> {
58969        if let StreamSocketRequest::SetIpv6ReceiveHopLimit { value, responder } = self {
58970            Some((value, responder))
58971        } else {
58972            None
58973        }
58974    }
58975
58976    #[allow(irrefutable_let_patterns)]
58977    pub fn into_get_ipv6_receive_hop_limit(
58978        self,
58979    ) -> Option<(StreamSocketGetIpv6ReceiveHopLimitResponder)> {
58980        if let StreamSocketRequest::GetIpv6ReceiveHopLimit { responder } = self {
58981            Some((responder))
58982        } else {
58983            None
58984        }
58985    }
58986
58987    #[allow(irrefutable_let_patterns)]
58988    pub fn into_set_ipv6_multicast_hops(
58989        self,
58990    ) -> Option<(OptionalUint8, StreamSocketSetIpv6MulticastHopsResponder)> {
58991        if let StreamSocketRequest::SetIpv6MulticastHops { value, responder } = self {
58992            Some((value, responder))
58993        } else {
58994            None
58995        }
58996    }
58997
58998    #[allow(irrefutable_let_patterns)]
58999    pub fn into_get_ipv6_multicast_hops(
59000        self,
59001    ) -> Option<(StreamSocketGetIpv6MulticastHopsResponder)> {
59002        if let StreamSocketRequest::GetIpv6MulticastHops { responder } = self {
59003            Some((responder))
59004        } else {
59005            None
59006        }
59007    }
59008
59009    #[allow(irrefutable_let_patterns)]
59010    pub fn into_set_ipv6_multicast_loopback(
59011        self,
59012    ) -> Option<(bool, StreamSocketSetIpv6MulticastLoopbackResponder)> {
59013        if let StreamSocketRequest::SetIpv6MulticastLoopback { value, responder } = self {
59014            Some((value, responder))
59015        } else {
59016            None
59017        }
59018    }
59019
59020    #[allow(irrefutable_let_patterns)]
59021    pub fn into_get_ipv6_multicast_loopback(
59022        self,
59023    ) -> Option<(StreamSocketGetIpv6MulticastLoopbackResponder)> {
59024        if let StreamSocketRequest::GetIpv6MulticastLoopback { responder } = self {
59025            Some((responder))
59026        } else {
59027            None
59028        }
59029    }
59030
59031    #[allow(irrefutable_let_patterns)]
59032    pub fn into_set_ipv6_only(self) -> Option<(bool, StreamSocketSetIpv6OnlyResponder)> {
59033        if let StreamSocketRequest::SetIpv6Only { value, responder } = self {
59034            Some((value, responder))
59035        } else {
59036            None
59037        }
59038    }
59039
59040    #[allow(irrefutable_let_patterns)]
59041    pub fn into_get_ipv6_only(self) -> Option<(StreamSocketGetIpv6OnlyResponder)> {
59042        if let StreamSocketRequest::GetIpv6Only { responder } = self {
59043            Some((responder))
59044        } else {
59045            None
59046        }
59047    }
59048
59049    #[allow(irrefutable_let_patterns)]
59050    pub fn into_set_ipv6_receive_traffic_class(
59051        self,
59052    ) -> Option<(bool, StreamSocketSetIpv6ReceiveTrafficClassResponder)> {
59053        if let StreamSocketRequest::SetIpv6ReceiveTrafficClass { value, responder } = self {
59054            Some((value, responder))
59055        } else {
59056            None
59057        }
59058    }
59059
59060    #[allow(irrefutable_let_patterns)]
59061    pub fn into_get_ipv6_receive_traffic_class(
59062        self,
59063    ) -> Option<(StreamSocketGetIpv6ReceiveTrafficClassResponder)> {
59064        if let StreamSocketRequest::GetIpv6ReceiveTrafficClass { responder } = self {
59065            Some((responder))
59066        } else {
59067            None
59068        }
59069    }
59070
59071    #[allow(irrefutable_let_patterns)]
59072    pub fn into_set_ipv6_traffic_class(
59073        self,
59074    ) -> Option<(OptionalUint8, StreamSocketSetIpv6TrafficClassResponder)> {
59075        if let StreamSocketRequest::SetIpv6TrafficClass { value, responder } = self {
59076            Some((value, responder))
59077        } else {
59078            None
59079        }
59080    }
59081
59082    #[allow(irrefutable_let_patterns)]
59083    pub fn into_get_ipv6_traffic_class(self) -> Option<(StreamSocketGetIpv6TrafficClassResponder)> {
59084        if let StreamSocketRequest::GetIpv6TrafficClass { responder } = self {
59085            Some((responder))
59086        } else {
59087            None
59088        }
59089    }
59090
59091    #[allow(irrefutable_let_patterns)]
59092    pub fn into_set_ipv6_receive_packet_info(
59093        self,
59094    ) -> Option<(bool, StreamSocketSetIpv6ReceivePacketInfoResponder)> {
59095        if let StreamSocketRequest::SetIpv6ReceivePacketInfo { value, responder } = self {
59096            Some((value, responder))
59097        } else {
59098            None
59099        }
59100    }
59101
59102    #[allow(irrefutable_let_patterns)]
59103    pub fn into_get_ipv6_receive_packet_info(
59104        self,
59105    ) -> Option<(StreamSocketGetIpv6ReceivePacketInfoResponder)> {
59106        if let StreamSocketRequest::GetIpv6ReceivePacketInfo { responder } = self {
59107            Some((responder))
59108        } else {
59109            None
59110        }
59111    }
59112
59113    #[allow(irrefutable_let_patterns)]
59114    pub fn into_get_original_destination(
59115        self,
59116    ) -> Option<(StreamSocketGetOriginalDestinationResponder)> {
59117        if let StreamSocketRequest::GetOriginalDestination { responder } = self {
59118            Some((responder))
59119        } else {
59120            None
59121        }
59122    }
59123
59124    #[allow(irrefutable_let_patterns)]
59125    pub fn into_describe(self) -> Option<(StreamSocketDescribeResponder)> {
59126        if let StreamSocketRequest::Describe { responder } = self {
59127            Some((responder))
59128        } else {
59129            None
59130        }
59131    }
59132
59133    #[allow(irrefutable_let_patterns)]
59134    pub fn into_listen(self) -> Option<(i16, StreamSocketListenResponder)> {
59135        if let StreamSocketRequest::Listen { backlog, responder } = self {
59136            Some((backlog, responder))
59137        } else {
59138            None
59139        }
59140    }
59141
59142    #[allow(irrefutable_let_patterns)]
59143    pub fn into_accept(self) -> Option<(bool, StreamSocketAcceptResponder)> {
59144        if let StreamSocketRequest::Accept { want_addr, responder } = self {
59145            Some((want_addr, responder))
59146        } else {
59147            None
59148        }
59149    }
59150
59151    #[allow(irrefutable_let_patterns)]
59152    pub fn into_get_info(self) -> Option<(StreamSocketGetInfoResponder)> {
59153        if let StreamSocketRequest::GetInfo { responder } = self {
59154            Some((responder))
59155        } else {
59156            None
59157        }
59158    }
59159
59160    #[allow(irrefutable_let_patterns)]
59161    pub fn into_set_tcp_no_delay(self) -> Option<(bool, StreamSocketSetTcpNoDelayResponder)> {
59162        if let StreamSocketRequest::SetTcpNoDelay { value, responder } = self {
59163            Some((value, responder))
59164        } else {
59165            None
59166        }
59167    }
59168
59169    #[allow(irrefutable_let_patterns)]
59170    pub fn into_get_tcp_no_delay(self) -> Option<(StreamSocketGetTcpNoDelayResponder)> {
59171        if let StreamSocketRequest::GetTcpNoDelay { responder } = self {
59172            Some((responder))
59173        } else {
59174            None
59175        }
59176    }
59177
59178    #[allow(irrefutable_let_patterns)]
59179    pub fn into_set_tcp_max_segment(self) -> Option<(u32, StreamSocketSetTcpMaxSegmentResponder)> {
59180        if let StreamSocketRequest::SetTcpMaxSegment { value_bytes, responder } = self {
59181            Some((value_bytes, responder))
59182        } else {
59183            None
59184        }
59185    }
59186
59187    #[allow(irrefutable_let_patterns)]
59188    pub fn into_get_tcp_max_segment(self) -> Option<(StreamSocketGetTcpMaxSegmentResponder)> {
59189        if let StreamSocketRequest::GetTcpMaxSegment { responder } = self {
59190            Some((responder))
59191        } else {
59192            None
59193        }
59194    }
59195
59196    #[allow(irrefutable_let_patterns)]
59197    pub fn into_set_tcp_cork(self) -> Option<(bool, StreamSocketSetTcpCorkResponder)> {
59198        if let StreamSocketRequest::SetTcpCork { value, responder } = self {
59199            Some((value, responder))
59200        } else {
59201            None
59202        }
59203    }
59204
59205    #[allow(irrefutable_let_patterns)]
59206    pub fn into_get_tcp_cork(self) -> Option<(StreamSocketGetTcpCorkResponder)> {
59207        if let StreamSocketRequest::GetTcpCork { responder } = self {
59208            Some((responder))
59209        } else {
59210            None
59211        }
59212    }
59213
59214    #[allow(irrefutable_let_patterns)]
59215    pub fn into_set_tcp_keep_alive_idle(
59216        self,
59217    ) -> Option<(u32, StreamSocketSetTcpKeepAliveIdleResponder)> {
59218        if let StreamSocketRequest::SetTcpKeepAliveIdle { value_secs, responder } = self {
59219            Some((value_secs, responder))
59220        } else {
59221            None
59222        }
59223    }
59224
59225    #[allow(irrefutable_let_patterns)]
59226    pub fn into_get_tcp_keep_alive_idle(
59227        self,
59228    ) -> Option<(StreamSocketGetTcpKeepAliveIdleResponder)> {
59229        if let StreamSocketRequest::GetTcpKeepAliveIdle { responder } = self {
59230            Some((responder))
59231        } else {
59232            None
59233        }
59234    }
59235
59236    #[allow(irrefutable_let_patterns)]
59237    pub fn into_set_tcp_keep_alive_interval(
59238        self,
59239    ) -> Option<(u32, StreamSocketSetTcpKeepAliveIntervalResponder)> {
59240        if let StreamSocketRequest::SetTcpKeepAliveInterval { value_secs, responder } = self {
59241            Some((value_secs, responder))
59242        } else {
59243            None
59244        }
59245    }
59246
59247    #[allow(irrefutable_let_patterns)]
59248    pub fn into_get_tcp_keep_alive_interval(
59249        self,
59250    ) -> Option<(StreamSocketGetTcpKeepAliveIntervalResponder)> {
59251        if let StreamSocketRequest::GetTcpKeepAliveInterval { responder } = self {
59252            Some((responder))
59253        } else {
59254            None
59255        }
59256    }
59257
59258    #[allow(irrefutable_let_patterns)]
59259    pub fn into_set_tcp_keep_alive_count(
59260        self,
59261    ) -> Option<(u32, StreamSocketSetTcpKeepAliveCountResponder)> {
59262        if let StreamSocketRequest::SetTcpKeepAliveCount { value, responder } = self {
59263            Some((value, responder))
59264        } else {
59265            None
59266        }
59267    }
59268
59269    #[allow(irrefutable_let_patterns)]
59270    pub fn into_get_tcp_keep_alive_count(
59271        self,
59272    ) -> Option<(StreamSocketGetTcpKeepAliveCountResponder)> {
59273        if let StreamSocketRequest::GetTcpKeepAliveCount { responder } = self {
59274            Some((responder))
59275        } else {
59276            None
59277        }
59278    }
59279
59280    #[allow(irrefutable_let_patterns)]
59281    pub fn into_set_tcp_syn_count(self) -> Option<(u32, StreamSocketSetTcpSynCountResponder)> {
59282        if let StreamSocketRequest::SetTcpSynCount { value, responder } = self {
59283            Some((value, responder))
59284        } else {
59285            None
59286        }
59287    }
59288
59289    #[allow(irrefutable_let_patterns)]
59290    pub fn into_get_tcp_syn_count(self) -> Option<(StreamSocketGetTcpSynCountResponder)> {
59291        if let StreamSocketRequest::GetTcpSynCount { responder } = self {
59292            Some((responder))
59293        } else {
59294            None
59295        }
59296    }
59297
59298    #[allow(irrefutable_let_patterns)]
59299    pub fn into_set_tcp_linger(
59300        self,
59301    ) -> Option<(OptionalUint32, StreamSocketSetTcpLingerResponder)> {
59302        if let StreamSocketRequest::SetTcpLinger { value_secs, responder } = self {
59303            Some((value_secs, responder))
59304        } else {
59305            None
59306        }
59307    }
59308
59309    #[allow(irrefutable_let_patterns)]
59310    pub fn into_get_tcp_linger(self) -> Option<(StreamSocketGetTcpLingerResponder)> {
59311        if let StreamSocketRequest::GetTcpLinger { responder } = self {
59312            Some((responder))
59313        } else {
59314            None
59315        }
59316    }
59317
59318    #[allow(irrefutable_let_patterns)]
59319    pub fn into_set_tcp_defer_accept(
59320        self,
59321    ) -> Option<(u32, StreamSocketSetTcpDeferAcceptResponder)> {
59322        if let StreamSocketRequest::SetTcpDeferAccept { value_secs, responder } = self {
59323            Some((value_secs, responder))
59324        } else {
59325            None
59326        }
59327    }
59328
59329    #[allow(irrefutable_let_patterns)]
59330    pub fn into_get_tcp_defer_accept(self) -> Option<(StreamSocketGetTcpDeferAcceptResponder)> {
59331        if let StreamSocketRequest::GetTcpDeferAccept { responder } = self {
59332            Some((responder))
59333        } else {
59334            None
59335        }
59336    }
59337
59338    #[allow(irrefutable_let_patterns)]
59339    pub fn into_set_tcp_window_clamp(
59340        self,
59341    ) -> Option<(u32, StreamSocketSetTcpWindowClampResponder)> {
59342        if let StreamSocketRequest::SetTcpWindowClamp { value, responder } = self {
59343            Some((value, responder))
59344        } else {
59345            None
59346        }
59347    }
59348
59349    #[allow(irrefutable_let_patterns)]
59350    pub fn into_get_tcp_window_clamp(self) -> Option<(StreamSocketGetTcpWindowClampResponder)> {
59351        if let StreamSocketRequest::GetTcpWindowClamp { responder } = self {
59352            Some((responder))
59353        } else {
59354            None
59355        }
59356    }
59357
59358    #[allow(irrefutable_let_patterns)]
59359    pub fn into_get_tcp_info(self) -> Option<(StreamSocketGetTcpInfoResponder)> {
59360        if let StreamSocketRequest::GetTcpInfo { responder } = self {
59361            Some((responder))
59362        } else {
59363            None
59364        }
59365    }
59366
59367    #[allow(irrefutable_let_patterns)]
59368    pub fn into_set_tcp_quick_ack(self) -> Option<(bool, StreamSocketSetTcpQuickAckResponder)> {
59369        if let StreamSocketRequest::SetTcpQuickAck { value, responder } = self {
59370            Some((value, responder))
59371        } else {
59372            None
59373        }
59374    }
59375
59376    #[allow(irrefutable_let_patterns)]
59377    pub fn into_get_tcp_quick_ack(self) -> Option<(StreamSocketGetTcpQuickAckResponder)> {
59378        if let StreamSocketRequest::GetTcpQuickAck { responder } = self {
59379            Some((responder))
59380        } else {
59381            None
59382        }
59383    }
59384
59385    #[allow(irrefutable_let_patterns)]
59386    pub fn into_set_tcp_congestion(
59387        self,
59388    ) -> Option<(TcpCongestionControl, StreamSocketSetTcpCongestionResponder)> {
59389        if let StreamSocketRequest::SetTcpCongestion { value, responder } = self {
59390            Some((value, responder))
59391        } else {
59392            None
59393        }
59394    }
59395
59396    #[allow(irrefutable_let_patterns)]
59397    pub fn into_get_tcp_congestion(self) -> Option<(StreamSocketGetTcpCongestionResponder)> {
59398        if let StreamSocketRequest::GetTcpCongestion { responder } = self {
59399            Some((responder))
59400        } else {
59401            None
59402        }
59403    }
59404
59405    #[allow(irrefutable_let_patterns)]
59406    pub fn into_set_tcp_user_timeout(
59407        self,
59408    ) -> Option<(u32, StreamSocketSetTcpUserTimeoutResponder)> {
59409        if let StreamSocketRequest::SetTcpUserTimeout { value_millis, responder } = self {
59410            Some((value_millis, responder))
59411        } else {
59412            None
59413        }
59414    }
59415
59416    #[allow(irrefutable_let_patterns)]
59417    pub fn into_get_tcp_user_timeout(self) -> Option<(StreamSocketGetTcpUserTimeoutResponder)> {
59418        if let StreamSocketRequest::GetTcpUserTimeout { responder } = self {
59419            Some((responder))
59420        } else {
59421            None
59422        }
59423    }
59424
59425    /// Name of the method defined in FIDL
59426    pub fn method_name(&self) -> &'static str {
59427        match *self {
59428            StreamSocketRequest::Clone { .. } => "clone",
59429            StreamSocketRequest::Close { .. } => "close",
59430            StreamSocketRequest::Query { .. } => "query",
59431            StreamSocketRequest::SetReuseAddress { .. } => "set_reuse_address",
59432            StreamSocketRequest::GetReuseAddress { .. } => "get_reuse_address",
59433            StreamSocketRequest::GetError { .. } => "get_error",
59434            StreamSocketRequest::SetBroadcast { .. } => "set_broadcast",
59435            StreamSocketRequest::GetBroadcast { .. } => "get_broadcast",
59436            StreamSocketRequest::SetSendBuffer { .. } => "set_send_buffer",
59437            StreamSocketRequest::GetSendBuffer { .. } => "get_send_buffer",
59438            StreamSocketRequest::SetReceiveBuffer { .. } => "set_receive_buffer",
59439            StreamSocketRequest::GetReceiveBuffer { .. } => "get_receive_buffer",
59440            StreamSocketRequest::SetKeepAlive { .. } => "set_keep_alive",
59441            StreamSocketRequest::GetKeepAlive { .. } => "get_keep_alive",
59442            StreamSocketRequest::SetOutOfBandInline { .. } => "set_out_of_band_inline",
59443            StreamSocketRequest::GetOutOfBandInline { .. } => "get_out_of_band_inline",
59444            StreamSocketRequest::SetNoCheck { .. } => "set_no_check",
59445            StreamSocketRequest::GetNoCheck { .. } => "get_no_check",
59446            StreamSocketRequest::SetLinger { .. } => "set_linger",
59447            StreamSocketRequest::GetLinger { .. } => "get_linger",
59448            StreamSocketRequest::SetReusePort { .. } => "set_reuse_port",
59449            StreamSocketRequest::GetReusePort { .. } => "get_reuse_port",
59450            StreamSocketRequest::GetAcceptConn { .. } => "get_accept_conn",
59451            StreamSocketRequest::SetBindToDevice { .. } => "set_bind_to_device",
59452            StreamSocketRequest::GetBindToDevice { .. } => "get_bind_to_device",
59453            StreamSocketRequest::SetBindToInterfaceIndex { .. } => "set_bind_to_interface_index",
59454            StreamSocketRequest::GetBindToInterfaceIndex { .. } => "get_bind_to_interface_index",
59455            StreamSocketRequest::SetTimestamp { .. } => "set_timestamp",
59456            StreamSocketRequest::GetTimestamp { .. } => "get_timestamp",
59457            StreamSocketRequest::SetMark { .. } => "set_mark",
59458            StreamSocketRequest::GetMark { .. } => "get_mark",
59459            StreamSocketRequest::Bind { .. } => "bind",
59460            StreamSocketRequest::Connect { .. } => "connect",
59461            StreamSocketRequest::Disconnect { .. } => "disconnect",
59462            StreamSocketRequest::GetSockName { .. } => "get_sock_name",
59463            StreamSocketRequest::GetPeerName { .. } => "get_peer_name",
59464            StreamSocketRequest::Shutdown { .. } => "shutdown",
59465            StreamSocketRequest::SetIpTypeOfService { .. } => "set_ip_type_of_service",
59466            StreamSocketRequest::GetIpTypeOfService { .. } => "get_ip_type_of_service",
59467            StreamSocketRequest::SetIpTtl { .. } => "set_ip_ttl",
59468            StreamSocketRequest::GetIpTtl { .. } => "get_ip_ttl",
59469            StreamSocketRequest::SetIpPacketInfo { .. } => "set_ip_packet_info",
59470            StreamSocketRequest::GetIpPacketInfo { .. } => "get_ip_packet_info",
59471            StreamSocketRequest::SetIpReceiveTypeOfService { .. } => {
59472                "set_ip_receive_type_of_service"
59473            }
59474            StreamSocketRequest::GetIpReceiveTypeOfService { .. } => {
59475                "get_ip_receive_type_of_service"
59476            }
59477            StreamSocketRequest::SetIpReceiveTtl { .. } => "set_ip_receive_ttl",
59478            StreamSocketRequest::GetIpReceiveTtl { .. } => "get_ip_receive_ttl",
59479            StreamSocketRequest::SetIpMulticastInterface { .. } => "set_ip_multicast_interface",
59480            StreamSocketRequest::GetIpMulticastInterface { .. } => "get_ip_multicast_interface",
59481            StreamSocketRequest::SetIpMulticastTtl { .. } => "set_ip_multicast_ttl",
59482            StreamSocketRequest::GetIpMulticastTtl { .. } => "get_ip_multicast_ttl",
59483            StreamSocketRequest::SetIpMulticastLoopback { .. } => "set_ip_multicast_loopback",
59484            StreamSocketRequest::GetIpMulticastLoopback { .. } => "get_ip_multicast_loopback",
59485            StreamSocketRequest::AddIpMembership { .. } => "add_ip_membership",
59486            StreamSocketRequest::DropIpMembership { .. } => "drop_ip_membership",
59487            StreamSocketRequest::SetIpTransparent { .. } => "set_ip_transparent",
59488            StreamSocketRequest::GetIpTransparent { .. } => "get_ip_transparent",
59489            StreamSocketRequest::SetIpReceiveOriginalDestinationAddress { .. } => {
59490                "set_ip_receive_original_destination_address"
59491            }
59492            StreamSocketRequest::GetIpReceiveOriginalDestinationAddress { .. } => {
59493                "get_ip_receive_original_destination_address"
59494            }
59495            StreamSocketRequest::AddIpv6Membership { .. } => "add_ipv6_membership",
59496            StreamSocketRequest::DropIpv6Membership { .. } => "drop_ipv6_membership",
59497            StreamSocketRequest::SetIpv6MulticastInterface { .. } => "set_ipv6_multicast_interface",
59498            StreamSocketRequest::GetIpv6MulticastInterface { .. } => "get_ipv6_multicast_interface",
59499            StreamSocketRequest::SetIpv6UnicastHops { .. } => "set_ipv6_unicast_hops",
59500            StreamSocketRequest::GetIpv6UnicastHops { .. } => "get_ipv6_unicast_hops",
59501            StreamSocketRequest::SetIpv6ReceiveHopLimit { .. } => "set_ipv6_receive_hop_limit",
59502            StreamSocketRequest::GetIpv6ReceiveHopLimit { .. } => "get_ipv6_receive_hop_limit",
59503            StreamSocketRequest::SetIpv6MulticastHops { .. } => "set_ipv6_multicast_hops",
59504            StreamSocketRequest::GetIpv6MulticastHops { .. } => "get_ipv6_multicast_hops",
59505            StreamSocketRequest::SetIpv6MulticastLoopback { .. } => "set_ipv6_multicast_loopback",
59506            StreamSocketRequest::GetIpv6MulticastLoopback { .. } => "get_ipv6_multicast_loopback",
59507            StreamSocketRequest::SetIpv6Only { .. } => "set_ipv6_only",
59508            StreamSocketRequest::GetIpv6Only { .. } => "get_ipv6_only",
59509            StreamSocketRequest::SetIpv6ReceiveTrafficClass { .. } => {
59510                "set_ipv6_receive_traffic_class"
59511            }
59512            StreamSocketRequest::GetIpv6ReceiveTrafficClass { .. } => {
59513                "get_ipv6_receive_traffic_class"
59514            }
59515            StreamSocketRequest::SetIpv6TrafficClass { .. } => "set_ipv6_traffic_class",
59516            StreamSocketRequest::GetIpv6TrafficClass { .. } => "get_ipv6_traffic_class",
59517            StreamSocketRequest::SetIpv6ReceivePacketInfo { .. } => "set_ipv6_receive_packet_info",
59518            StreamSocketRequest::GetIpv6ReceivePacketInfo { .. } => "get_ipv6_receive_packet_info",
59519            StreamSocketRequest::GetOriginalDestination { .. } => "get_original_destination",
59520            StreamSocketRequest::Describe { .. } => "describe",
59521            StreamSocketRequest::Listen { .. } => "listen",
59522            StreamSocketRequest::Accept { .. } => "accept",
59523            StreamSocketRequest::GetInfo { .. } => "get_info",
59524            StreamSocketRequest::SetTcpNoDelay { .. } => "set_tcp_no_delay",
59525            StreamSocketRequest::GetTcpNoDelay { .. } => "get_tcp_no_delay",
59526            StreamSocketRequest::SetTcpMaxSegment { .. } => "set_tcp_max_segment",
59527            StreamSocketRequest::GetTcpMaxSegment { .. } => "get_tcp_max_segment",
59528            StreamSocketRequest::SetTcpCork { .. } => "set_tcp_cork",
59529            StreamSocketRequest::GetTcpCork { .. } => "get_tcp_cork",
59530            StreamSocketRequest::SetTcpKeepAliveIdle { .. } => "set_tcp_keep_alive_idle",
59531            StreamSocketRequest::GetTcpKeepAliveIdle { .. } => "get_tcp_keep_alive_idle",
59532            StreamSocketRequest::SetTcpKeepAliveInterval { .. } => "set_tcp_keep_alive_interval",
59533            StreamSocketRequest::GetTcpKeepAliveInterval { .. } => "get_tcp_keep_alive_interval",
59534            StreamSocketRequest::SetTcpKeepAliveCount { .. } => "set_tcp_keep_alive_count",
59535            StreamSocketRequest::GetTcpKeepAliveCount { .. } => "get_tcp_keep_alive_count",
59536            StreamSocketRequest::SetTcpSynCount { .. } => "set_tcp_syn_count",
59537            StreamSocketRequest::GetTcpSynCount { .. } => "get_tcp_syn_count",
59538            StreamSocketRequest::SetTcpLinger { .. } => "set_tcp_linger",
59539            StreamSocketRequest::GetTcpLinger { .. } => "get_tcp_linger",
59540            StreamSocketRequest::SetTcpDeferAccept { .. } => "set_tcp_defer_accept",
59541            StreamSocketRequest::GetTcpDeferAccept { .. } => "get_tcp_defer_accept",
59542            StreamSocketRequest::SetTcpWindowClamp { .. } => "set_tcp_window_clamp",
59543            StreamSocketRequest::GetTcpWindowClamp { .. } => "get_tcp_window_clamp",
59544            StreamSocketRequest::GetTcpInfo { .. } => "get_tcp_info",
59545            StreamSocketRequest::SetTcpQuickAck { .. } => "set_tcp_quick_ack",
59546            StreamSocketRequest::GetTcpQuickAck { .. } => "get_tcp_quick_ack",
59547            StreamSocketRequest::SetTcpCongestion { .. } => "set_tcp_congestion",
59548            StreamSocketRequest::GetTcpCongestion { .. } => "get_tcp_congestion",
59549            StreamSocketRequest::SetTcpUserTimeout { .. } => "set_tcp_user_timeout",
59550            StreamSocketRequest::GetTcpUserTimeout { .. } => "get_tcp_user_timeout",
59551        }
59552    }
59553}
59554
59555#[derive(Debug, Clone)]
59556pub struct StreamSocketControlHandle {
59557    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
59558}
59559
59560impl fidl::endpoints::ControlHandle for StreamSocketControlHandle {
59561    fn shutdown(&self) {
59562        self.inner.shutdown()
59563    }
59564    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
59565        self.inner.shutdown_with_epitaph(status)
59566    }
59567
59568    fn is_closed(&self) -> bool {
59569        self.inner.channel().is_closed()
59570    }
59571    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
59572        self.inner.channel().on_closed()
59573    }
59574
59575    #[cfg(target_os = "fuchsia")]
59576    fn signal_peer(
59577        &self,
59578        clear_mask: zx::Signals,
59579        set_mask: zx::Signals,
59580    ) -> Result<(), zx_status::Status> {
59581        use fidl::Peered;
59582        self.inner.channel().signal_peer(clear_mask, set_mask)
59583    }
59584}
59585
59586impl StreamSocketControlHandle {}
59587
59588#[must_use = "FIDL methods require a response to be sent"]
59589#[derive(Debug)]
59590pub struct StreamSocketCloseResponder {
59591    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
59592    tx_id: u32,
59593}
59594
59595/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
59596/// if the responder is dropped without sending a response, so that the client
59597/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
59598impl std::ops::Drop for StreamSocketCloseResponder {
59599    fn drop(&mut self) {
59600        self.control_handle.shutdown();
59601        // Safety: drops once, never accessed again
59602        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
59603    }
59604}
59605
59606impl fidl::endpoints::Responder for StreamSocketCloseResponder {
59607    type ControlHandle = StreamSocketControlHandle;
59608
59609    fn control_handle(&self) -> &StreamSocketControlHandle {
59610        &self.control_handle
59611    }
59612
59613    fn drop_without_shutdown(mut self) {
59614        // Safety: drops once, never accessed again due to mem::forget
59615        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
59616        // Prevent Drop from running (which would shut down the channel)
59617        std::mem::forget(self);
59618    }
59619}
59620
59621impl StreamSocketCloseResponder {
59622    /// Sends a response to the FIDL transaction.
59623    ///
59624    /// Sets the channel to shutdown if an error occurs.
59625    pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
59626        let _result = self.send_raw(result);
59627        if _result.is_err() {
59628            self.control_handle.shutdown();
59629        }
59630        self.drop_without_shutdown();
59631        _result
59632    }
59633
59634    /// Similar to "send" but does not shutdown the channel if an error occurs.
59635    pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
59636        let _result = self.send_raw(result);
59637        self.drop_without_shutdown();
59638        _result
59639    }
59640
59641    fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
59642        self.control_handle
59643            .inner
59644            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
59645                result,
59646                self.tx_id,
59647                0x5ac5d459ad7f657e,
59648                fidl::encoding::DynamicFlags::empty(),
59649            )
59650    }
59651}
59652
59653#[must_use = "FIDL methods require a response to be sent"]
59654#[derive(Debug)]
59655pub struct StreamSocketQueryResponder {
59656    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
59657    tx_id: u32,
59658}
59659
59660/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
59661/// if the responder is dropped without sending a response, so that the client
59662/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
59663impl std::ops::Drop for StreamSocketQueryResponder {
59664    fn drop(&mut self) {
59665        self.control_handle.shutdown();
59666        // Safety: drops once, never accessed again
59667        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
59668    }
59669}
59670
59671impl fidl::endpoints::Responder for StreamSocketQueryResponder {
59672    type ControlHandle = StreamSocketControlHandle;
59673
59674    fn control_handle(&self) -> &StreamSocketControlHandle {
59675        &self.control_handle
59676    }
59677
59678    fn drop_without_shutdown(mut self) {
59679        // Safety: drops once, never accessed again due to mem::forget
59680        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
59681        // Prevent Drop from running (which would shut down the channel)
59682        std::mem::forget(self);
59683    }
59684}
59685
59686impl StreamSocketQueryResponder {
59687    /// Sends a response to the FIDL transaction.
59688    ///
59689    /// Sets the channel to shutdown if an error occurs.
59690    pub fn send(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
59691        let _result = self.send_raw(protocol);
59692        if _result.is_err() {
59693            self.control_handle.shutdown();
59694        }
59695        self.drop_without_shutdown();
59696        _result
59697    }
59698
59699    /// Similar to "send" but does not shutdown the channel if an error occurs.
59700    pub fn send_no_shutdown_on_err(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
59701        let _result = self.send_raw(protocol);
59702        self.drop_without_shutdown();
59703        _result
59704    }
59705
59706    fn send_raw(&self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
59707        self.control_handle.inner.send::<fidl_fuchsia_unknown::QueryableQueryResponse>(
59708            (protocol,),
59709            self.tx_id,
59710            0x2658edee9decfc06,
59711            fidl::encoding::DynamicFlags::empty(),
59712        )
59713    }
59714}
59715
59716#[must_use = "FIDL methods require a response to be sent"]
59717#[derive(Debug)]
59718pub struct StreamSocketSetReuseAddressResponder {
59719    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
59720    tx_id: u32,
59721}
59722
59723/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
59724/// if the responder is dropped without sending a response, so that the client
59725/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
59726impl std::ops::Drop for StreamSocketSetReuseAddressResponder {
59727    fn drop(&mut self) {
59728        self.control_handle.shutdown();
59729        // Safety: drops once, never accessed again
59730        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
59731    }
59732}
59733
59734impl fidl::endpoints::Responder for StreamSocketSetReuseAddressResponder {
59735    type ControlHandle = StreamSocketControlHandle;
59736
59737    fn control_handle(&self) -> &StreamSocketControlHandle {
59738        &self.control_handle
59739    }
59740
59741    fn drop_without_shutdown(mut self) {
59742        // Safety: drops once, never accessed again due to mem::forget
59743        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
59744        // Prevent Drop from running (which would shut down the channel)
59745        std::mem::forget(self);
59746    }
59747}
59748
59749impl StreamSocketSetReuseAddressResponder {
59750    /// Sends a response to the FIDL transaction.
59751    ///
59752    /// Sets the channel to shutdown if an error occurs.
59753    pub fn send(
59754        self,
59755        mut result: Result<(), fidl_fuchsia_posix::Errno>,
59756    ) -> Result<(), fidl::Error> {
59757        let _result = self.send_raw(result);
59758        if _result.is_err() {
59759            self.control_handle.shutdown();
59760        }
59761        self.drop_without_shutdown();
59762        _result
59763    }
59764
59765    /// Similar to "send" but does not shutdown the channel if an error occurs.
59766    pub fn send_no_shutdown_on_err(
59767        self,
59768        mut result: Result<(), fidl_fuchsia_posix::Errno>,
59769    ) -> Result<(), fidl::Error> {
59770        let _result = self.send_raw(result);
59771        self.drop_without_shutdown();
59772        _result
59773    }
59774
59775    fn send_raw(
59776        &self,
59777        mut result: Result<(), fidl_fuchsia_posix::Errno>,
59778    ) -> Result<(), fidl::Error> {
59779        self.control_handle.inner.send::<fidl::encoding::ResultType<
59780            fidl::encoding::EmptyStruct,
59781            fidl_fuchsia_posix::Errno,
59782        >>(
59783            result,
59784            self.tx_id,
59785            0x1fd74ee8b9a4a876,
59786            fidl::encoding::DynamicFlags::empty(),
59787        )
59788    }
59789}
59790
59791#[must_use = "FIDL methods require a response to be sent"]
59792#[derive(Debug)]
59793pub struct StreamSocketGetReuseAddressResponder {
59794    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
59795    tx_id: u32,
59796}
59797
59798/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
59799/// if the responder is dropped without sending a response, so that the client
59800/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
59801impl std::ops::Drop for StreamSocketGetReuseAddressResponder {
59802    fn drop(&mut self) {
59803        self.control_handle.shutdown();
59804        // Safety: drops once, never accessed again
59805        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
59806    }
59807}
59808
59809impl fidl::endpoints::Responder for StreamSocketGetReuseAddressResponder {
59810    type ControlHandle = StreamSocketControlHandle;
59811
59812    fn control_handle(&self) -> &StreamSocketControlHandle {
59813        &self.control_handle
59814    }
59815
59816    fn drop_without_shutdown(mut self) {
59817        // Safety: drops once, never accessed again due to mem::forget
59818        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
59819        // Prevent Drop from running (which would shut down the channel)
59820        std::mem::forget(self);
59821    }
59822}
59823
59824impl StreamSocketGetReuseAddressResponder {
59825    /// Sends a response to the FIDL transaction.
59826    ///
59827    /// Sets the channel to shutdown if an error occurs.
59828    pub fn send(
59829        self,
59830        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
59831    ) -> Result<(), fidl::Error> {
59832        let _result = self.send_raw(result);
59833        if _result.is_err() {
59834            self.control_handle.shutdown();
59835        }
59836        self.drop_without_shutdown();
59837        _result
59838    }
59839
59840    /// Similar to "send" but does not shutdown the channel if an error occurs.
59841    pub fn send_no_shutdown_on_err(
59842        self,
59843        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
59844    ) -> Result<(), fidl::Error> {
59845        let _result = self.send_raw(result);
59846        self.drop_without_shutdown();
59847        _result
59848    }
59849
59850    fn send_raw(
59851        &self,
59852        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
59853    ) -> Result<(), fidl::Error> {
59854        self.control_handle.inner.send::<fidl::encoding::ResultType<
59855            BaseSocketGetReuseAddressResponse,
59856            fidl_fuchsia_posix::Errno,
59857        >>(
59858            result.map(|value| (value,)),
59859            self.tx_id,
59860            0x67b7206b8d1bc0a5,
59861            fidl::encoding::DynamicFlags::empty(),
59862        )
59863    }
59864}
59865
59866#[must_use = "FIDL methods require a response to be sent"]
59867#[derive(Debug)]
59868pub struct StreamSocketGetErrorResponder {
59869    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
59870    tx_id: u32,
59871}
59872
59873/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
59874/// if the responder is dropped without sending a response, so that the client
59875/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
59876impl std::ops::Drop for StreamSocketGetErrorResponder {
59877    fn drop(&mut self) {
59878        self.control_handle.shutdown();
59879        // Safety: drops once, never accessed again
59880        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
59881    }
59882}
59883
59884impl fidl::endpoints::Responder for StreamSocketGetErrorResponder {
59885    type ControlHandle = StreamSocketControlHandle;
59886
59887    fn control_handle(&self) -> &StreamSocketControlHandle {
59888        &self.control_handle
59889    }
59890
59891    fn drop_without_shutdown(mut self) {
59892        // Safety: drops once, never accessed again due to mem::forget
59893        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
59894        // Prevent Drop from running (which would shut down the channel)
59895        std::mem::forget(self);
59896    }
59897}
59898
59899impl StreamSocketGetErrorResponder {
59900    /// Sends a response to the FIDL transaction.
59901    ///
59902    /// Sets the channel to shutdown if an error occurs.
59903    pub fn send(
59904        self,
59905        mut result: Result<(), fidl_fuchsia_posix::Errno>,
59906    ) -> Result<(), fidl::Error> {
59907        let _result = self.send_raw(result);
59908        if _result.is_err() {
59909            self.control_handle.shutdown();
59910        }
59911        self.drop_without_shutdown();
59912        _result
59913    }
59914
59915    /// Similar to "send" but does not shutdown the channel if an error occurs.
59916    pub fn send_no_shutdown_on_err(
59917        self,
59918        mut result: Result<(), fidl_fuchsia_posix::Errno>,
59919    ) -> Result<(), fidl::Error> {
59920        let _result = self.send_raw(result);
59921        self.drop_without_shutdown();
59922        _result
59923    }
59924
59925    fn send_raw(
59926        &self,
59927        mut result: Result<(), fidl_fuchsia_posix::Errno>,
59928    ) -> Result<(), fidl::Error> {
59929        self.control_handle.inner.send::<fidl::encoding::ResultType<
59930            fidl::encoding::EmptyStruct,
59931            fidl_fuchsia_posix::Errno,
59932        >>(
59933            result,
59934            self.tx_id,
59935            0x5aad39b33e5f6ebb,
59936            fidl::encoding::DynamicFlags::empty(),
59937        )
59938    }
59939}
59940
59941#[must_use = "FIDL methods require a response to be sent"]
59942#[derive(Debug)]
59943pub struct StreamSocketSetBroadcastResponder {
59944    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
59945    tx_id: u32,
59946}
59947
59948/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
59949/// if the responder is dropped without sending a response, so that the client
59950/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
59951impl std::ops::Drop for StreamSocketSetBroadcastResponder {
59952    fn drop(&mut self) {
59953        self.control_handle.shutdown();
59954        // Safety: drops once, never accessed again
59955        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
59956    }
59957}
59958
59959impl fidl::endpoints::Responder for StreamSocketSetBroadcastResponder {
59960    type ControlHandle = StreamSocketControlHandle;
59961
59962    fn control_handle(&self) -> &StreamSocketControlHandle {
59963        &self.control_handle
59964    }
59965
59966    fn drop_without_shutdown(mut self) {
59967        // Safety: drops once, never accessed again due to mem::forget
59968        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
59969        // Prevent Drop from running (which would shut down the channel)
59970        std::mem::forget(self);
59971    }
59972}
59973
59974impl StreamSocketSetBroadcastResponder {
59975    /// Sends a response to the FIDL transaction.
59976    ///
59977    /// Sets the channel to shutdown if an error occurs.
59978    pub fn send(
59979        self,
59980        mut result: Result<(), fidl_fuchsia_posix::Errno>,
59981    ) -> Result<(), fidl::Error> {
59982        let _result = self.send_raw(result);
59983        if _result.is_err() {
59984            self.control_handle.shutdown();
59985        }
59986        self.drop_without_shutdown();
59987        _result
59988    }
59989
59990    /// Similar to "send" but does not shutdown the channel if an error occurs.
59991    pub fn send_no_shutdown_on_err(
59992        self,
59993        mut result: Result<(), fidl_fuchsia_posix::Errno>,
59994    ) -> Result<(), fidl::Error> {
59995        let _result = self.send_raw(result);
59996        self.drop_without_shutdown();
59997        _result
59998    }
59999
60000    fn send_raw(
60001        &self,
60002        mut result: Result<(), fidl_fuchsia_posix::Errno>,
60003    ) -> Result<(), fidl::Error> {
60004        self.control_handle.inner.send::<fidl::encoding::ResultType<
60005            fidl::encoding::EmptyStruct,
60006            fidl_fuchsia_posix::Errno,
60007        >>(
60008            result,
60009            self.tx_id,
60010            0x6023e081ce3cd947,
60011            fidl::encoding::DynamicFlags::empty(),
60012        )
60013    }
60014}
60015
60016#[must_use = "FIDL methods require a response to be sent"]
60017#[derive(Debug)]
60018pub struct StreamSocketGetBroadcastResponder {
60019    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
60020    tx_id: u32,
60021}
60022
60023/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
60024/// if the responder is dropped without sending a response, so that the client
60025/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
60026impl std::ops::Drop for StreamSocketGetBroadcastResponder {
60027    fn drop(&mut self) {
60028        self.control_handle.shutdown();
60029        // Safety: drops once, never accessed again
60030        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60031    }
60032}
60033
60034impl fidl::endpoints::Responder for StreamSocketGetBroadcastResponder {
60035    type ControlHandle = StreamSocketControlHandle;
60036
60037    fn control_handle(&self) -> &StreamSocketControlHandle {
60038        &self.control_handle
60039    }
60040
60041    fn drop_without_shutdown(mut self) {
60042        // Safety: drops once, never accessed again due to mem::forget
60043        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60044        // Prevent Drop from running (which would shut down the channel)
60045        std::mem::forget(self);
60046    }
60047}
60048
60049impl StreamSocketGetBroadcastResponder {
60050    /// Sends a response to the FIDL transaction.
60051    ///
60052    /// Sets the channel to shutdown if an error occurs.
60053    pub fn send(
60054        self,
60055        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
60056    ) -> Result<(), fidl::Error> {
60057        let _result = self.send_raw(result);
60058        if _result.is_err() {
60059            self.control_handle.shutdown();
60060        }
60061        self.drop_without_shutdown();
60062        _result
60063    }
60064
60065    /// Similar to "send" but does not shutdown the channel if an error occurs.
60066    pub fn send_no_shutdown_on_err(
60067        self,
60068        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
60069    ) -> Result<(), fidl::Error> {
60070        let _result = self.send_raw(result);
60071        self.drop_without_shutdown();
60072        _result
60073    }
60074
60075    fn send_raw(
60076        &self,
60077        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
60078    ) -> Result<(), fidl::Error> {
60079        self.control_handle.inner.send::<fidl::encoding::ResultType<
60080            BaseSocketGetBroadcastResponse,
60081            fidl_fuchsia_posix::Errno,
60082        >>(
60083            result.map(|value| (value,)),
60084            self.tx_id,
60085            0x68796fc556f9780d,
60086            fidl::encoding::DynamicFlags::empty(),
60087        )
60088    }
60089}
60090
60091#[must_use = "FIDL methods require a response to be sent"]
60092#[derive(Debug)]
60093pub struct StreamSocketSetSendBufferResponder {
60094    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
60095    tx_id: u32,
60096}
60097
60098/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
60099/// if the responder is dropped without sending a response, so that the client
60100/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
60101impl std::ops::Drop for StreamSocketSetSendBufferResponder {
60102    fn drop(&mut self) {
60103        self.control_handle.shutdown();
60104        // Safety: drops once, never accessed again
60105        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60106    }
60107}
60108
60109impl fidl::endpoints::Responder for StreamSocketSetSendBufferResponder {
60110    type ControlHandle = StreamSocketControlHandle;
60111
60112    fn control_handle(&self) -> &StreamSocketControlHandle {
60113        &self.control_handle
60114    }
60115
60116    fn drop_without_shutdown(mut self) {
60117        // Safety: drops once, never accessed again due to mem::forget
60118        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60119        // Prevent Drop from running (which would shut down the channel)
60120        std::mem::forget(self);
60121    }
60122}
60123
60124impl StreamSocketSetSendBufferResponder {
60125    /// Sends a response to the FIDL transaction.
60126    ///
60127    /// Sets the channel to shutdown if an error occurs.
60128    pub fn send(
60129        self,
60130        mut result: Result<(), fidl_fuchsia_posix::Errno>,
60131    ) -> Result<(), fidl::Error> {
60132        let _result = self.send_raw(result);
60133        if _result.is_err() {
60134            self.control_handle.shutdown();
60135        }
60136        self.drop_without_shutdown();
60137        _result
60138    }
60139
60140    /// Similar to "send" but does not shutdown the channel if an error occurs.
60141    pub fn send_no_shutdown_on_err(
60142        self,
60143        mut result: Result<(), fidl_fuchsia_posix::Errno>,
60144    ) -> Result<(), fidl::Error> {
60145        let _result = self.send_raw(result);
60146        self.drop_without_shutdown();
60147        _result
60148    }
60149
60150    fn send_raw(
60151        &self,
60152        mut result: Result<(), fidl_fuchsia_posix::Errno>,
60153    ) -> Result<(), fidl::Error> {
60154        self.control_handle.inner.send::<fidl::encoding::ResultType<
60155            fidl::encoding::EmptyStruct,
60156            fidl_fuchsia_posix::Errno,
60157        >>(
60158            result,
60159            self.tx_id,
60160            0x756eac32d73a7a70,
60161            fidl::encoding::DynamicFlags::empty(),
60162        )
60163    }
60164}
60165
60166#[must_use = "FIDL methods require a response to be sent"]
60167#[derive(Debug)]
60168pub struct StreamSocketGetSendBufferResponder {
60169    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
60170    tx_id: u32,
60171}
60172
60173/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
60174/// if the responder is dropped without sending a response, so that the client
60175/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
60176impl std::ops::Drop for StreamSocketGetSendBufferResponder {
60177    fn drop(&mut self) {
60178        self.control_handle.shutdown();
60179        // Safety: drops once, never accessed again
60180        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60181    }
60182}
60183
60184impl fidl::endpoints::Responder for StreamSocketGetSendBufferResponder {
60185    type ControlHandle = StreamSocketControlHandle;
60186
60187    fn control_handle(&self) -> &StreamSocketControlHandle {
60188        &self.control_handle
60189    }
60190
60191    fn drop_without_shutdown(mut self) {
60192        // Safety: drops once, never accessed again due to mem::forget
60193        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60194        // Prevent Drop from running (which would shut down the channel)
60195        std::mem::forget(self);
60196    }
60197}
60198
60199impl StreamSocketGetSendBufferResponder {
60200    /// Sends a response to the FIDL transaction.
60201    ///
60202    /// Sets the channel to shutdown if an error occurs.
60203    pub fn send(
60204        self,
60205        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
60206    ) -> Result<(), fidl::Error> {
60207        let _result = self.send_raw(result);
60208        if _result.is_err() {
60209            self.control_handle.shutdown();
60210        }
60211        self.drop_without_shutdown();
60212        _result
60213    }
60214
60215    /// Similar to "send" but does not shutdown the channel if an error occurs.
60216    pub fn send_no_shutdown_on_err(
60217        self,
60218        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
60219    ) -> Result<(), fidl::Error> {
60220        let _result = self.send_raw(result);
60221        self.drop_without_shutdown();
60222        _result
60223    }
60224
60225    fn send_raw(
60226        &self,
60227        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
60228    ) -> Result<(), fidl::Error> {
60229        self.control_handle.inner.send::<fidl::encoding::ResultType<
60230            BaseSocketGetSendBufferResponse,
60231            fidl_fuchsia_posix::Errno,
60232        >>(
60233            result.map(|value_bytes| (value_bytes,)),
60234            self.tx_id,
60235            0x78a52fd9c7b2410b,
60236            fidl::encoding::DynamicFlags::empty(),
60237        )
60238    }
60239}
60240
60241#[must_use = "FIDL methods require a response to be sent"]
60242#[derive(Debug)]
60243pub struct StreamSocketSetReceiveBufferResponder {
60244    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
60245    tx_id: u32,
60246}
60247
60248/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
60249/// if the responder is dropped without sending a response, so that the client
60250/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
60251impl std::ops::Drop for StreamSocketSetReceiveBufferResponder {
60252    fn drop(&mut self) {
60253        self.control_handle.shutdown();
60254        // Safety: drops once, never accessed again
60255        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60256    }
60257}
60258
60259impl fidl::endpoints::Responder for StreamSocketSetReceiveBufferResponder {
60260    type ControlHandle = StreamSocketControlHandle;
60261
60262    fn control_handle(&self) -> &StreamSocketControlHandle {
60263        &self.control_handle
60264    }
60265
60266    fn drop_without_shutdown(mut self) {
60267        // Safety: drops once, never accessed again due to mem::forget
60268        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60269        // Prevent Drop from running (which would shut down the channel)
60270        std::mem::forget(self);
60271    }
60272}
60273
60274impl StreamSocketSetReceiveBufferResponder {
60275    /// Sends a response to the FIDL transaction.
60276    ///
60277    /// Sets the channel to shutdown if an error occurs.
60278    pub fn send(
60279        self,
60280        mut result: Result<(), fidl_fuchsia_posix::Errno>,
60281    ) -> Result<(), fidl::Error> {
60282        let _result = self.send_raw(result);
60283        if _result.is_err() {
60284            self.control_handle.shutdown();
60285        }
60286        self.drop_without_shutdown();
60287        _result
60288    }
60289
60290    /// Similar to "send" but does not shutdown the channel if an error occurs.
60291    pub fn send_no_shutdown_on_err(
60292        self,
60293        mut result: Result<(), fidl_fuchsia_posix::Errno>,
60294    ) -> Result<(), fidl::Error> {
60295        let _result = self.send_raw(result);
60296        self.drop_without_shutdown();
60297        _result
60298    }
60299
60300    fn send_raw(
60301        &self,
60302        mut result: Result<(), fidl_fuchsia_posix::Errno>,
60303    ) -> Result<(), fidl::Error> {
60304        self.control_handle.inner.send::<fidl::encoding::ResultType<
60305            fidl::encoding::EmptyStruct,
60306            fidl_fuchsia_posix::Errno,
60307        >>(
60308            result,
60309            self.tx_id,
60310            0x6b0cf2f1919c7001,
60311            fidl::encoding::DynamicFlags::empty(),
60312        )
60313    }
60314}
60315
60316#[must_use = "FIDL methods require a response to be sent"]
60317#[derive(Debug)]
60318pub struct StreamSocketGetReceiveBufferResponder {
60319    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
60320    tx_id: u32,
60321}
60322
60323/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
60324/// if the responder is dropped without sending a response, so that the client
60325/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
60326impl std::ops::Drop for StreamSocketGetReceiveBufferResponder {
60327    fn drop(&mut self) {
60328        self.control_handle.shutdown();
60329        // Safety: drops once, never accessed again
60330        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60331    }
60332}
60333
60334impl fidl::endpoints::Responder for StreamSocketGetReceiveBufferResponder {
60335    type ControlHandle = StreamSocketControlHandle;
60336
60337    fn control_handle(&self) -> &StreamSocketControlHandle {
60338        &self.control_handle
60339    }
60340
60341    fn drop_without_shutdown(mut self) {
60342        // Safety: drops once, never accessed again due to mem::forget
60343        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60344        // Prevent Drop from running (which would shut down the channel)
60345        std::mem::forget(self);
60346    }
60347}
60348
60349impl StreamSocketGetReceiveBufferResponder {
60350    /// Sends a response to the FIDL transaction.
60351    ///
60352    /// Sets the channel to shutdown if an error occurs.
60353    pub fn send(
60354        self,
60355        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
60356    ) -> Result<(), fidl::Error> {
60357        let _result = self.send_raw(result);
60358        if _result.is_err() {
60359            self.control_handle.shutdown();
60360        }
60361        self.drop_without_shutdown();
60362        _result
60363    }
60364
60365    /// Similar to "send" but does not shutdown the channel if an error occurs.
60366    pub fn send_no_shutdown_on_err(
60367        self,
60368        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
60369    ) -> Result<(), fidl::Error> {
60370        let _result = self.send_raw(result);
60371        self.drop_without_shutdown();
60372        _result
60373    }
60374
60375    fn send_raw(
60376        &self,
60377        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
60378    ) -> Result<(), fidl::Error> {
60379        self.control_handle.inner.send::<fidl::encoding::ResultType<
60380            BaseSocketGetReceiveBufferResponse,
60381            fidl_fuchsia_posix::Errno,
60382        >>(
60383            result.map(|value_bytes| (value_bytes,)),
60384            self.tx_id,
60385            0x14c1a4b64f709e5c,
60386            fidl::encoding::DynamicFlags::empty(),
60387        )
60388    }
60389}
60390
60391#[must_use = "FIDL methods require a response to be sent"]
60392#[derive(Debug)]
60393pub struct StreamSocketSetKeepAliveResponder {
60394    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
60395    tx_id: u32,
60396}
60397
60398/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
60399/// if the responder is dropped without sending a response, so that the client
60400/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
60401impl std::ops::Drop for StreamSocketSetKeepAliveResponder {
60402    fn drop(&mut self) {
60403        self.control_handle.shutdown();
60404        // Safety: drops once, never accessed again
60405        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60406    }
60407}
60408
60409impl fidl::endpoints::Responder for StreamSocketSetKeepAliveResponder {
60410    type ControlHandle = StreamSocketControlHandle;
60411
60412    fn control_handle(&self) -> &StreamSocketControlHandle {
60413        &self.control_handle
60414    }
60415
60416    fn drop_without_shutdown(mut self) {
60417        // Safety: drops once, never accessed again due to mem::forget
60418        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60419        // Prevent Drop from running (which would shut down the channel)
60420        std::mem::forget(self);
60421    }
60422}
60423
60424impl StreamSocketSetKeepAliveResponder {
60425    /// Sends a response to the FIDL transaction.
60426    ///
60427    /// Sets the channel to shutdown if an error occurs.
60428    pub fn send(
60429        self,
60430        mut result: Result<(), fidl_fuchsia_posix::Errno>,
60431    ) -> Result<(), fidl::Error> {
60432        let _result = self.send_raw(result);
60433        if _result.is_err() {
60434            self.control_handle.shutdown();
60435        }
60436        self.drop_without_shutdown();
60437        _result
60438    }
60439
60440    /// Similar to "send" but does not shutdown the channel if an error occurs.
60441    pub fn send_no_shutdown_on_err(
60442        self,
60443        mut result: Result<(), fidl_fuchsia_posix::Errno>,
60444    ) -> Result<(), fidl::Error> {
60445        let _result = self.send_raw(result);
60446        self.drop_without_shutdown();
60447        _result
60448    }
60449
60450    fn send_raw(
60451        &self,
60452        mut result: Result<(), fidl_fuchsia_posix::Errno>,
60453    ) -> Result<(), fidl::Error> {
60454        self.control_handle.inner.send::<fidl::encoding::ResultType<
60455            fidl::encoding::EmptyStruct,
60456            fidl_fuchsia_posix::Errno,
60457        >>(
60458            result,
60459            self.tx_id,
60460            0x572df8f0b920d2c7,
60461            fidl::encoding::DynamicFlags::empty(),
60462        )
60463    }
60464}
60465
60466#[must_use = "FIDL methods require a response to be sent"]
60467#[derive(Debug)]
60468pub struct StreamSocketGetKeepAliveResponder {
60469    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
60470    tx_id: u32,
60471}
60472
60473/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
60474/// if the responder is dropped without sending a response, so that the client
60475/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
60476impl std::ops::Drop for StreamSocketGetKeepAliveResponder {
60477    fn drop(&mut self) {
60478        self.control_handle.shutdown();
60479        // Safety: drops once, never accessed again
60480        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60481    }
60482}
60483
60484impl fidl::endpoints::Responder for StreamSocketGetKeepAliveResponder {
60485    type ControlHandle = StreamSocketControlHandle;
60486
60487    fn control_handle(&self) -> &StreamSocketControlHandle {
60488        &self.control_handle
60489    }
60490
60491    fn drop_without_shutdown(mut self) {
60492        // Safety: drops once, never accessed again due to mem::forget
60493        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60494        // Prevent Drop from running (which would shut down the channel)
60495        std::mem::forget(self);
60496    }
60497}
60498
60499impl StreamSocketGetKeepAliveResponder {
60500    /// Sends a response to the FIDL transaction.
60501    ///
60502    /// Sets the channel to shutdown if an error occurs.
60503    pub fn send(
60504        self,
60505        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
60506    ) -> Result<(), fidl::Error> {
60507        let _result = self.send_raw(result);
60508        if _result.is_err() {
60509            self.control_handle.shutdown();
60510        }
60511        self.drop_without_shutdown();
60512        _result
60513    }
60514
60515    /// Similar to "send" but does not shutdown the channel if an error occurs.
60516    pub fn send_no_shutdown_on_err(
60517        self,
60518        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
60519    ) -> Result<(), fidl::Error> {
60520        let _result = self.send_raw(result);
60521        self.drop_without_shutdown();
60522        _result
60523    }
60524
60525    fn send_raw(
60526        &self,
60527        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
60528    ) -> Result<(), fidl::Error> {
60529        self.control_handle.inner.send::<fidl::encoding::ResultType<
60530            BaseSocketGetKeepAliveResponse,
60531            fidl_fuchsia_posix::Errno,
60532        >>(
60533            result.map(|value| (value,)),
60534            self.tx_id,
60535            0x2dd29d3215f2c9d2,
60536            fidl::encoding::DynamicFlags::empty(),
60537        )
60538    }
60539}
60540
60541#[must_use = "FIDL methods require a response to be sent"]
60542#[derive(Debug)]
60543pub struct StreamSocketSetOutOfBandInlineResponder {
60544    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
60545    tx_id: u32,
60546}
60547
60548/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
60549/// if the responder is dropped without sending a response, so that the client
60550/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
60551impl std::ops::Drop for StreamSocketSetOutOfBandInlineResponder {
60552    fn drop(&mut self) {
60553        self.control_handle.shutdown();
60554        // Safety: drops once, never accessed again
60555        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60556    }
60557}
60558
60559impl fidl::endpoints::Responder for StreamSocketSetOutOfBandInlineResponder {
60560    type ControlHandle = StreamSocketControlHandle;
60561
60562    fn control_handle(&self) -> &StreamSocketControlHandle {
60563        &self.control_handle
60564    }
60565
60566    fn drop_without_shutdown(mut self) {
60567        // Safety: drops once, never accessed again due to mem::forget
60568        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60569        // Prevent Drop from running (which would shut down the channel)
60570        std::mem::forget(self);
60571    }
60572}
60573
60574impl StreamSocketSetOutOfBandInlineResponder {
60575    /// Sends a response to the FIDL transaction.
60576    ///
60577    /// Sets the channel to shutdown if an error occurs.
60578    pub fn send(
60579        self,
60580        mut result: Result<(), fidl_fuchsia_posix::Errno>,
60581    ) -> Result<(), fidl::Error> {
60582        let _result = self.send_raw(result);
60583        if _result.is_err() {
60584            self.control_handle.shutdown();
60585        }
60586        self.drop_without_shutdown();
60587        _result
60588    }
60589
60590    /// Similar to "send" but does not shutdown the channel if an error occurs.
60591    pub fn send_no_shutdown_on_err(
60592        self,
60593        mut result: Result<(), fidl_fuchsia_posix::Errno>,
60594    ) -> Result<(), fidl::Error> {
60595        let _result = self.send_raw(result);
60596        self.drop_without_shutdown();
60597        _result
60598    }
60599
60600    fn send_raw(
60601        &self,
60602        mut result: Result<(), fidl_fuchsia_posix::Errno>,
60603    ) -> Result<(), fidl::Error> {
60604        self.control_handle.inner.send::<fidl::encoding::ResultType<
60605            fidl::encoding::EmptyStruct,
60606            fidl_fuchsia_posix::Errno,
60607        >>(
60608            result,
60609            self.tx_id,
60610            0x3ecb49968bee439,
60611            fidl::encoding::DynamicFlags::empty(),
60612        )
60613    }
60614}
60615
60616#[must_use = "FIDL methods require a response to be sent"]
60617#[derive(Debug)]
60618pub struct StreamSocketGetOutOfBandInlineResponder {
60619    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
60620    tx_id: u32,
60621}
60622
60623/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
60624/// if the responder is dropped without sending a response, so that the client
60625/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
60626impl std::ops::Drop for StreamSocketGetOutOfBandInlineResponder {
60627    fn drop(&mut self) {
60628        self.control_handle.shutdown();
60629        // Safety: drops once, never accessed again
60630        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60631    }
60632}
60633
60634impl fidl::endpoints::Responder for StreamSocketGetOutOfBandInlineResponder {
60635    type ControlHandle = StreamSocketControlHandle;
60636
60637    fn control_handle(&self) -> &StreamSocketControlHandle {
60638        &self.control_handle
60639    }
60640
60641    fn drop_without_shutdown(mut self) {
60642        // Safety: drops once, never accessed again due to mem::forget
60643        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60644        // Prevent Drop from running (which would shut down the channel)
60645        std::mem::forget(self);
60646    }
60647}
60648
60649impl StreamSocketGetOutOfBandInlineResponder {
60650    /// Sends a response to the FIDL transaction.
60651    ///
60652    /// Sets the channel to shutdown if an error occurs.
60653    pub fn send(
60654        self,
60655        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
60656    ) -> Result<(), fidl::Error> {
60657        let _result = self.send_raw(result);
60658        if _result.is_err() {
60659            self.control_handle.shutdown();
60660        }
60661        self.drop_without_shutdown();
60662        _result
60663    }
60664
60665    /// Similar to "send" but does not shutdown the channel if an error occurs.
60666    pub fn send_no_shutdown_on_err(
60667        self,
60668        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
60669    ) -> Result<(), fidl::Error> {
60670        let _result = self.send_raw(result);
60671        self.drop_without_shutdown();
60672        _result
60673    }
60674
60675    fn send_raw(
60676        &self,
60677        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
60678    ) -> Result<(), fidl::Error> {
60679        self.control_handle.inner.send::<fidl::encoding::ResultType<
60680            BaseSocketGetOutOfBandInlineResponse,
60681            fidl_fuchsia_posix::Errno,
60682        >>(
60683            result.map(|value| (value,)),
60684            self.tx_id,
60685            0x348c1ab3aeca1745,
60686            fidl::encoding::DynamicFlags::empty(),
60687        )
60688    }
60689}
60690
60691#[must_use = "FIDL methods require a response to be sent"]
60692#[derive(Debug)]
60693pub struct StreamSocketSetNoCheckResponder {
60694    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
60695    tx_id: u32,
60696}
60697
60698/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
60699/// if the responder is dropped without sending a response, so that the client
60700/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
60701impl std::ops::Drop for StreamSocketSetNoCheckResponder {
60702    fn drop(&mut self) {
60703        self.control_handle.shutdown();
60704        // Safety: drops once, never accessed again
60705        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60706    }
60707}
60708
60709impl fidl::endpoints::Responder for StreamSocketSetNoCheckResponder {
60710    type ControlHandle = StreamSocketControlHandle;
60711
60712    fn control_handle(&self) -> &StreamSocketControlHandle {
60713        &self.control_handle
60714    }
60715
60716    fn drop_without_shutdown(mut self) {
60717        // Safety: drops once, never accessed again due to mem::forget
60718        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60719        // Prevent Drop from running (which would shut down the channel)
60720        std::mem::forget(self);
60721    }
60722}
60723
60724impl StreamSocketSetNoCheckResponder {
60725    /// Sends a response to the FIDL transaction.
60726    ///
60727    /// Sets the channel to shutdown if an error occurs.
60728    pub fn send(
60729        self,
60730        mut result: Result<(), fidl_fuchsia_posix::Errno>,
60731    ) -> Result<(), fidl::Error> {
60732        let _result = self.send_raw(result);
60733        if _result.is_err() {
60734            self.control_handle.shutdown();
60735        }
60736        self.drop_without_shutdown();
60737        _result
60738    }
60739
60740    /// Similar to "send" but does not shutdown the channel if an error occurs.
60741    pub fn send_no_shutdown_on_err(
60742        self,
60743        mut result: Result<(), fidl_fuchsia_posix::Errno>,
60744    ) -> Result<(), fidl::Error> {
60745        let _result = self.send_raw(result);
60746        self.drop_without_shutdown();
60747        _result
60748    }
60749
60750    fn send_raw(
60751        &self,
60752        mut result: Result<(), fidl_fuchsia_posix::Errno>,
60753    ) -> Result<(), fidl::Error> {
60754        self.control_handle.inner.send::<fidl::encoding::ResultType<
60755            fidl::encoding::EmptyStruct,
60756            fidl_fuchsia_posix::Errno,
60757        >>(
60758            result,
60759            self.tx_id,
60760            0x6bbf00c53a4c78c2,
60761            fidl::encoding::DynamicFlags::empty(),
60762        )
60763    }
60764}
60765
60766#[must_use = "FIDL methods require a response to be sent"]
60767#[derive(Debug)]
60768pub struct StreamSocketGetNoCheckResponder {
60769    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
60770    tx_id: u32,
60771}
60772
60773/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
60774/// if the responder is dropped without sending a response, so that the client
60775/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
60776impl std::ops::Drop for StreamSocketGetNoCheckResponder {
60777    fn drop(&mut self) {
60778        self.control_handle.shutdown();
60779        // Safety: drops once, never accessed again
60780        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60781    }
60782}
60783
60784impl fidl::endpoints::Responder for StreamSocketGetNoCheckResponder {
60785    type ControlHandle = StreamSocketControlHandle;
60786
60787    fn control_handle(&self) -> &StreamSocketControlHandle {
60788        &self.control_handle
60789    }
60790
60791    fn drop_without_shutdown(mut self) {
60792        // Safety: drops once, never accessed again due to mem::forget
60793        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60794        // Prevent Drop from running (which would shut down the channel)
60795        std::mem::forget(self);
60796    }
60797}
60798
60799impl StreamSocketGetNoCheckResponder {
60800    /// Sends a response to the FIDL transaction.
60801    ///
60802    /// Sets the channel to shutdown if an error occurs.
60803    pub fn send(
60804        self,
60805        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
60806    ) -> Result<(), fidl::Error> {
60807        let _result = self.send_raw(result);
60808        if _result.is_err() {
60809            self.control_handle.shutdown();
60810        }
60811        self.drop_without_shutdown();
60812        _result
60813    }
60814
60815    /// Similar to "send" but does not shutdown the channel if an error occurs.
60816    pub fn send_no_shutdown_on_err(
60817        self,
60818        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
60819    ) -> Result<(), fidl::Error> {
60820        let _result = self.send_raw(result);
60821        self.drop_without_shutdown();
60822        _result
60823    }
60824
60825    fn send_raw(
60826        &self,
60827        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
60828    ) -> Result<(), fidl::Error> {
60829        self.control_handle.inner.send::<fidl::encoding::ResultType<
60830            BaseSocketGetNoCheckResponse,
60831            fidl_fuchsia_posix::Errno,
60832        >>(
60833            result.map(|value| (value,)),
60834            self.tx_id,
60835            0x2cd4249286417694,
60836            fidl::encoding::DynamicFlags::empty(),
60837        )
60838    }
60839}
60840
60841#[must_use = "FIDL methods require a response to be sent"]
60842#[derive(Debug)]
60843pub struct StreamSocketSetLingerResponder {
60844    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
60845    tx_id: u32,
60846}
60847
60848/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
60849/// if the responder is dropped without sending a response, so that the client
60850/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
60851impl std::ops::Drop for StreamSocketSetLingerResponder {
60852    fn drop(&mut self) {
60853        self.control_handle.shutdown();
60854        // Safety: drops once, never accessed again
60855        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60856    }
60857}
60858
60859impl fidl::endpoints::Responder for StreamSocketSetLingerResponder {
60860    type ControlHandle = StreamSocketControlHandle;
60861
60862    fn control_handle(&self) -> &StreamSocketControlHandle {
60863        &self.control_handle
60864    }
60865
60866    fn drop_without_shutdown(mut self) {
60867        // Safety: drops once, never accessed again due to mem::forget
60868        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60869        // Prevent Drop from running (which would shut down the channel)
60870        std::mem::forget(self);
60871    }
60872}
60873
60874impl StreamSocketSetLingerResponder {
60875    /// Sends a response to the FIDL transaction.
60876    ///
60877    /// Sets the channel to shutdown if an error occurs.
60878    pub fn send(
60879        self,
60880        mut result: Result<(), fidl_fuchsia_posix::Errno>,
60881    ) -> Result<(), fidl::Error> {
60882        let _result = self.send_raw(result);
60883        if _result.is_err() {
60884            self.control_handle.shutdown();
60885        }
60886        self.drop_without_shutdown();
60887        _result
60888    }
60889
60890    /// Similar to "send" but does not shutdown the channel if an error occurs.
60891    pub fn send_no_shutdown_on_err(
60892        self,
60893        mut result: Result<(), fidl_fuchsia_posix::Errno>,
60894    ) -> Result<(), fidl::Error> {
60895        let _result = self.send_raw(result);
60896        self.drop_without_shutdown();
60897        _result
60898    }
60899
60900    fn send_raw(
60901        &self,
60902        mut result: Result<(), fidl_fuchsia_posix::Errno>,
60903    ) -> Result<(), fidl::Error> {
60904        self.control_handle.inner.send::<fidl::encoding::ResultType<
60905            fidl::encoding::EmptyStruct,
60906            fidl_fuchsia_posix::Errno,
60907        >>(
60908            result,
60909            self.tx_id,
60910            0x45386351246e998e,
60911            fidl::encoding::DynamicFlags::empty(),
60912        )
60913    }
60914}
60915
60916#[must_use = "FIDL methods require a response to be sent"]
60917#[derive(Debug)]
60918pub struct StreamSocketGetLingerResponder {
60919    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
60920    tx_id: u32,
60921}
60922
60923/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
60924/// if the responder is dropped without sending a response, so that the client
60925/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
60926impl std::ops::Drop for StreamSocketGetLingerResponder {
60927    fn drop(&mut self) {
60928        self.control_handle.shutdown();
60929        // Safety: drops once, never accessed again
60930        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60931    }
60932}
60933
60934impl fidl::endpoints::Responder for StreamSocketGetLingerResponder {
60935    type ControlHandle = StreamSocketControlHandle;
60936
60937    fn control_handle(&self) -> &StreamSocketControlHandle {
60938        &self.control_handle
60939    }
60940
60941    fn drop_without_shutdown(mut self) {
60942        // Safety: drops once, never accessed again due to mem::forget
60943        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
60944        // Prevent Drop from running (which would shut down the channel)
60945        std::mem::forget(self);
60946    }
60947}
60948
60949impl StreamSocketGetLingerResponder {
60950    /// Sends a response to the FIDL transaction.
60951    ///
60952    /// Sets the channel to shutdown if an error occurs.
60953    pub fn send(
60954        self,
60955        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
60956    ) -> Result<(), fidl::Error> {
60957        let _result = self.send_raw(result);
60958        if _result.is_err() {
60959            self.control_handle.shutdown();
60960        }
60961        self.drop_without_shutdown();
60962        _result
60963    }
60964
60965    /// Similar to "send" but does not shutdown the channel if an error occurs.
60966    pub fn send_no_shutdown_on_err(
60967        self,
60968        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
60969    ) -> Result<(), fidl::Error> {
60970        let _result = self.send_raw(result);
60971        self.drop_without_shutdown();
60972        _result
60973    }
60974
60975    fn send_raw(
60976        &self,
60977        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
60978    ) -> Result<(), fidl::Error> {
60979        self.control_handle.inner.send::<fidl::encoding::ResultType<
60980            BaseSocketGetLingerResponse,
60981            fidl_fuchsia_posix::Errno,
60982        >>(
60983            result,
60984            self.tx_id,
60985            0x48eb20fc5ccb0e45,
60986            fidl::encoding::DynamicFlags::empty(),
60987        )
60988    }
60989}
60990
60991#[must_use = "FIDL methods require a response to be sent"]
60992#[derive(Debug)]
60993pub struct StreamSocketSetReusePortResponder {
60994    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
60995    tx_id: u32,
60996}
60997
60998/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
60999/// if the responder is dropped without sending a response, so that the client
61000/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
61001impl std::ops::Drop for StreamSocketSetReusePortResponder {
61002    fn drop(&mut self) {
61003        self.control_handle.shutdown();
61004        // Safety: drops once, never accessed again
61005        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61006    }
61007}
61008
61009impl fidl::endpoints::Responder for StreamSocketSetReusePortResponder {
61010    type ControlHandle = StreamSocketControlHandle;
61011
61012    fn control_handle(&self) -> &StreamSocketControlHandle {
61013        &self.control_handle
61014    }
61015
61016    fn drop_without_shutdown(mut self) {
61017        // Safety: drops once, never accessed again due to mem::forget
61018        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61019        // Prevent Drop from running (which would shut down the channel)
61020        std::mem::forget(self);
61021    }
61022}
61023
61024impl StreamSocketSetReusePortResponder {
61025    /// Sends a response to the FIDL transaction.
61026    ///
61027    /// Sets the channel to shutdown if an error occurs.
61028    pub fn send(
61029        self,
61030        mut result: Result<(), fidl_fuchsia_posix::Errno>,
61031    ) -> Result<(), fidl::Error> {
61032        let _result = self.send_raw(result);
61033        if _result.is_err() {
61034            self.control_handle.shutdown();
61035        }
61036        self.drop_without_shutdown();
61037        _result
61038    }
61039
61040    /// Similar to "send" but does not shutdown the channel if an error occurs.
61041    pub fn send_no_shutdown_on_err(
61042        self,
61043        mut result: Result<(), fidl_fuchsia_posix::Errno>,
61044    ) -> Result<(), fidl::Error> {
61045        let _result = self.send_raw(result);
61046        self.drop_without_shutdown();
61047        _result
61048    }
61049
61050    fn send_raw(
61051        &self,
61052        mut result: Result<(), fidl_fuchsia_posix::Errno>,
61053    ) -> Result<(), fidl::Error> {
61054        self.control_handle.inner.send::<fidl::encoding::ResultType<
61055            fidl::encoding::EmptyStruct,
61056            fidl_fuchsia_posix::Errno,
61057        >>(
61058            result,
61059            self.tx_id,
61060            0x24dd3e5cb36d9ccb,
61061            fidl::encoding::DynamicFlags::empty(),
61062        )
61063    }
61064}
61065
61066#[must_use = "FIDL methods require a response to be sent"]
61067#[derive(Debug)]
61068pub struct StreamSocketGetReusePortResponder {
61069    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
61070    tx_id: u32,
61071}
61072
61073/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
61074/// if the responder is dropped without sending a response, so that the client
61075/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
61076impl std::ops::Drop for StreamSocketGetReusePortResponder {
61077    fn drop(&mut self) {
61078        self.control_handle.shutdown();
61079        // Safety: drops once, never accessed again
61080        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61081    }
61082}
61083
61084impl fidl::endpoints::Responder for StreamSocketGetReusePortResponder {
61085    type ControlHandle = StreamSocketControlHandle;
61086
61087    fn control_handle(&self) -> &StreamSocketControlHandle {
61088        &self.control_handle
61089    }
61090
61091    fn drop_without_shutdown(mut self) {
61092        // Safety: drops once, never accessed again due to mem::forget
61093        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61094        // Prevent Drop from running (which would shut down the channel)
61095        std::mem::forget(self);
61096    }
61097}
61098
61099impl StreamSocketGetReusePortResponder {
61100    /// Sends a response to the FIDL transaction.
61101    ///
61102    /// Sets the channel to shutdown if an error occurs.
61103    pub fn send(
61104        self,
61105        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
61106    ) -> Result<(), fidl::Error> {
61107        let _result = self.send_raw(result);
61108        if _result.is_err() {
61109            self.control_handle.shutdown();
61110        }
61111        self.drop_without_shutdown();
61112        _result
61113    }
61114
61115    /// Similar to "send" but does not shutdown the channel if an error occurs.
61116    pub fn send_no_shutdown_on_err(
61117        self,
61118        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
61119    ) -> Result<(), fidl::Error> {
61120        let _result = self.send_raw(result);
61121        self.drop_without_shutdown();
61122        _result
61123    }
61124
61125    fn send_raw(
61126        &self,
61127        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
61128    ) -> Result<(), fidl::Error> {
61129        self.control_handle.inner.send::<fidl::encoding::ResultType<
61130            BaseSocketGetReusePortResponse,
61131            fidl_fuchsia_posix::Errno,
61132        >>(
61133            result.map(|value| (value,)),
61134            self.tx_id,
61135            0x7a112c1ab54ff828,
61136            fidl::encoding::DynamicFlags::empty(),
61137        )
61138    }
61139}
61140
61141#[must_use = "FIDL methods require a response to be sent"]
61142#[derive(Debug)]
61143pub struct StreamSocketGetAcceptConnResponder {
61144    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
61145    tx_id: u32,
61146}
61147
61148/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
61149/// if the responder is dropped without sending a response, so that the client
61150/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
61151impl std::ops::Drop for StreamSocketGetAcceptConnResponder {
61152    fn drop(&mut self) {
61153        self.control_handle.shutdown();
61154        // Safety: drops once, never accessed again
61155        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61156    }
61157}
61158
61159impl fidl::endpoints::Responder for StreamSocketGetAcceptConnResponder {
61160    type ControlHandle = StreamSocketControlHandle;
61161
61162    fn control_handle(&self) -> &StreamSocketControlHandle {
61163        &self.control_handle
61164    }
61165
61166    fn drop_without_shutdown(mut self) {
61167        // Safety: drops once, never accessed again due to mem::forget
61168        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61169        // Prevent Drop from running (which would shut down the channel)
61170        std::mem::forget(self);
61171    }
61172}
61173
61174impl StreamSocketGetAcceptConnResponder {
61175    /// Sends a response to the FIDL transaction.
61176    ///
61177    /// Sets the channel to shutdown if an error occurs.
61178    pub fn send(
61179        self,
61180        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
61181    ) -> Result<(), fidl::Error> {
61182        let _result = self.send_raw(result);
61183        if _result.is_err() {
61184            self.control_handle.shutdown();
61185        }
61186        self.drop_without_shutdown();
61187        _result
61188    }
61189
61190    /// Similar to "send" but does not shutdown the channel if an error occurs.
61191    pub fn send_no_shutdown_on_err(
61192        self,
61193        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
61194    ) -> Result<(), fidl::Error> {
61195        let _result = self.send_raw(result);
61196        self.drop_without_shutdown();
61197        _result
61198    }
61199
61200    fn send_raw(
61201        &self,
61202        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
61203    ) -> Result<(), fidl::Error> {
61204        self.control_handle.inner.send::<fidl::encoding::ResultType<
61205            BaseSocketGetAcceptConnResponse,
61206            fidl_fuchsia_posix::Errno,
61207        >>(
61208            result.map(|value| (value,)),
61209            self.tx_id,
61210            0x67ce6db6c2ec8966,
61211            fidl::encoding::DynamicFlags::empty(),
61212        )
61213    }
61214}
61215
61216#[must_use = "FIDL methods require a response to be sent"]
61217#[derive(Debug)]
61218pub struct StreamSocketSetBindToDeviceResponder {
61219    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
61220    tx_id: u32,
61221}
61222
61223/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
61224/// if the responder is dropped without sending a response, so that the client
61225/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
61226impl std::ops::Drop for StreamSocketSetBindToDeviceResponder {
61227    fn drop(&mut self) {
61228        self.control_handle.shutdown();
61229        // Safety: drops once, never accessed again
61230        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61231    }
61232}
61233
61234impl fidl::endpoints::Responder for StreamSocketSetBindToDeviceResponder {
61235    type ControlHandle = StreamSocketControlHandle;
61236
61237    fn control_handle(&self) -> &StreamSocketControlHandle {
61238        &self.control_handle
61239    }
61240
61241    fn drop_without_shutdown(mut self) {
61242        // Safety: drops once, never accessed again due to mem::forget
61243        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61244        // Prevent Drop from running (which would shut down the channel)
61245        std::mem::forget(self);
61246    }
61247}
61248
61249impl StreamSocketSetBindToDeviceResponder {
61250    /// Sends a response to the FIDL transaction.
61251    ///
61252    /// Sets the channel to shutdown if an error occurs.
61253    pub fn send(
61254        self,
61255        mut result: Result<(), fidl_fuchsia_posix::Errno>,
61256    ) -> Result<(), fidl::Error> {
61257        let _result = self.send_raw(result);
61258        if _result.is_err() {
61259            self.control_handle.shutdown();
61260        }
61261        self.drop_without_shutdown();
61262        _result
61263    }
61264
61265    /// Similar to "send" but does not shutdown the channel if an error occurs.
61266    pub fn send_no_shutdown_on_err(
61267        self,
61268        mut result: Result<(), fidl_fuchsia_posix::Errno>,
61269    ) -> Result<(), fidl::Error> {
61270        let _result = self.send_raw(result);
61271        self.drop_without_shutdown();
61272        _result
61273    }
61274
61275    fn send_raw(
61276        &self,
61277        mut result: Result<(), fidl_fuchsia_posix::Errno>,
61278    ) -> Result<(), fidl::Error> {
61279        self.control_handle.inner.send::<fidl::encoding::ResultType<
61280            fidl::encoding::EmptyStruct,
61281            fidl_fuchsia_posix::Errno,
61282        >>(
61283            result,
61284            self.tx_id,
61285            0x2118b483f28aafc4,
61286            fidl::encoding::DynamicFlags::empty(),
61287        )
61288    }
61289}
61290
61291#[must_use = "FIDL methods require a response to be sent"]
61292#[derive(Debug)]
61293pub struct StreamSocketGetBindToDeviceResponder {
61294    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
61295    tx_id: u32,
61296}
61297
61298/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
61299/// if the responder is dropped without sending a response, so that the client
61300/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
61301impl std::ops::Drop for StreamSocketGetBindToDeviceResponder {
61302    fn drop(&mut self) {
61303        self.control_handle.shutdown();
61304        // Safety: drops once, never accessed again
61305        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61306    }
61307}
61308
61309impl fidl::endpoints::Responder for StreamSocketGetBindToDeviceResponder {
61310    type ControlHandle = StreamSocketControlHandle;
61311
61312    fn control_handle(&self) -> &StreamSocketControlHandle {
61313        &self.control_handle
61314    }
61315
61316    fn drop_without_shutdown(mut self) {
61317        // Safety: drops once, never accessed again due to mem::forget
61318        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61319        // Prevent Drop from running (which would shut down the channel)
61320        std::mem::forget(self);
61321    }
61322}
61323
61324impl StreamSocketGetBindToDeviceResponder {
61325    /// Sends a response to the FIDL transaction.
61326    ///
61327    /// Sets the channel to shutdown if an error occurs.
61328    pub fn send(
61329        self,
61330        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
61331    ) -> Result<(), fidl::Error> {
61332        let _result = self.send_raw(result);
61333        if _result.is_err() {
61334            self.control_handle.shutdown();
61335        }
61336        self.drop_without_shutdown();
61337        _result
61338    }
61339
61340    /// Similar to "send" but does not shutdown the channel if an error occurs.
61341    pub fn send_no_shutdown_on_err(
61342        self,
61343        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
61344    ) -> Result<(), fidl::Error> {
61345        let _result = self.send_raw(result);
61346        self.drop_without_shutdown();
61347        _result
61348    }
61349
61350    fn send_raw(
61351        &self,
61352        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
61353    ) -> Result<(), fidl::Error> {
61354        self.control_handle.inner.send::<fidl::encoding::ResultType<
61355            BaseSocketGetBindToDeviceResponse,
61356            fidl_fuchsia_posix::Errno,
61357        >>(
61358            result.map(|value| (value,)),
61359            self.tx_id,
61360            0x1ab1fbf0ef7906c8,
61361            fidl::encoding::DynamicFlags::empty(),
61362        )
61363    }
61364}
61365
61366#[must_use = "FIDL methods require a response to be sent"]
61367#[derive(Debug)]
61368pub struct StreamSocketSetBindToInterfaceIndexResponder {
61369    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
61370    tx_id: u32,
61371}
61372
61373/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
61374/// if the responder is dropped without sending a response, so that the client
61375/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
61376impl std::ops::Drop for StreamSocketSetBindToInterfaceIndexResponder {
61377    fn drop(&mut self) {
61378        self.control_handle.shutdown();
61379        // Safety: drops once, never accessed again
61380        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61381    }
61382}
61383
61384impl fidl::endpoints::Responder for StreamSocketSetBindToInterfaceIndexResponder {
61385    type ControlHandle = StreamSocketControlHandle;
61386
61387    fn control_handle(&self) -> &StreamSocketControlHandle {
61388        &self.control_handle
61389    }
61390
61391    fn drop_without_shutdown(mut self) {
61392        // Safety: drops once, never accessed again due to mem::forget
61393        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61394        // Prevent Drop from running (which would shut down the channel)
61395        std::mem::forget(self);
61396    }
61397}
61398
61399impl StreamSocketSetBindToInterfaceIndexResponder {
61400    /// Sends a response to the FIDL transaction.
61401    ///
61402    /// Sets the channel to shutdown if an error occurs.
61403    pub fn send(
61404        self,
61405        mut result: Result<(), fidl_fuchsia_posix::Errno>,
61406    ) -> Result<(), fidl::Error> {
61407        let _result = self.send_raw(result);
61408        if _result.is_err() {
61409            self.control_handle.shutdown();
61410        }
61411        self.drop_without_shutdown();
61412        _result
61413    }
61414
61415    /// Similar to "send" but does not shutdown the channel if an error occurs.
61416    pub fn send_no_shutdown_on_err(
61417        self,
61418        mut result: Result<(), fidl_fuchsia_posix::Errno>,
61419    ) -> Result<(), fidl::Error> {
61420        let _result = self.send_raw(result);
61421        self.drop_without_shutdown();
61422        _result
61423    }
61424
61425    fn send_raw(
61426        &self,
61427        mut result: Result<(), fidl_fuchsia_posix::Errno>,
61428    ) -> Result<(), fidl::Error> {
61429        self.control_handle.inner.send::<fidl::encoding::ResultType<
61430            fidl::encoding::EmptyStruct,
61431            fidl_fuchsia_posix::Errno,
61432        >>(
61433            result,
61434            self.tx_id,
61435            0x6e387a0def00821,
61436            fidl::encoding::DynamicFlags::empty(),
61437        )
61438    }
61439}
61440
61441#[must_use = "FIDL methods require a response to be sent"]
61442#[derive(Debug)]
61443pub struct StreamSocketGetBindToInterfaceIndexResponder {
61444    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
61445    tx_id: u32,
61446}
61447
61448/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
61449/// if the responder is dropped without sending a response, so that the client
61450/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
61451impl std::ops::Drop for StreamSocketGetBindToInterfaceIndexResponder {
61452    fn drop(&mut self) {
61453        self.control_handle.shutdown();
61454        // Safety: drops once, never accessed again
61455        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61456    }
61457}
61458
61459impl fidl::endpoints::Responder for StreamSocketGetBindToInterfaceIndexResponder {
61460    type ControlHandle = StreamSocketControlHandle;
61461
61462    fn control_handle(&self) -> &StreamSocketControlHandle {
61463        &self.control_handle
61464    }
61465
61466    fn drop_without_shutdown(mut self) {
61467        // Safety: drops once, never accessed again due to mem::forget
61468        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61469        // Prevent Drop from running (which would shut down the channel)
61470        std::mem::forget(self);
61471    }
61472}
61473
61474impl StreamSocketGetBindToInterfaceIndexResponder {
61475    /// Sends a response to the FIDL transaction.
61476    ///
61477    /// Sets the channel to shutdown if an error occurs.
61478    pub fn send(
61479        self,
61480        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
61481    ) -> Result<(), fidl::Error> {
61482        let _result = self.send_raw(result);
61483        if _result.is_err() {
61484            self.control_handle.shutdown();
61485        }
61486        self.drop_without_shutdown();
61487        _result
61488    }
61489
61490    /// Similar to "send" but does not shutdown the channel if an error occurs.
61491    pub fn send_no_shutdown_on_err(
61492        self,
61493        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
61494    ) -> Result<(), fidl::Error> {
61495        let _result = self.send_raw(result);
61496        self.drop_without_shutdown();
61497        _result
61498    }
61499
61500    fn send_raw(
61501        &self,
61502        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
61503    ) -> Result<(), fidl::Error> {
61504        self.control_handle.inner.send::<fidl::encoding::ResultType<
61505            BaseSocketGetBindToInterfaceIndexResponse,
61506            fidl_fuchsia_posix::Errno,
61507        >>(
61508            result.map(|value| (value,)),
61509            self.tx_id,
61510            0x59c31dd3e3078295,
61511            fidl::encoding::DynamicFlags::empty(),
61512        )
61513    }
61514}
61515
61516#[must_use = "FIDL methods require a response to be sent"]
61517#[derive(Debug)]
61518pub struct StreamSocketSetTimestampResponder {
61519    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
61520    tx_id: u32,
61521}
61522
61523/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
61524/// if the responder is dropped without sending a response, so that the client
61525/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
61526impl std::ops::Drop for StreamSocketSetTimestampResponder {
61527    fn drop(&mut self) {
61528        self.control_handle.shutdown();
61529        // Safety: drops once, never accessed again
61530        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61531    }
61532}
61533
61534impl fidl::endpoints::Responder for StreamSocketSetTimestampResponder {
61535    type ControlHandle = StreamSocketControlHandle;
61536
61537    fn control_handle(&self) -> &StreamSocketControlHandle {
61538        &self.control_handle
61539    }
61540
61541    fn drop_without_shutdown(mut self) {
61542        // Safety: drops once, never accessed again due to mem::forget
61543        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61544        // Prevent Drop from running (which would shut down the channel)
61545        std::mem::forget(self);
61546    }
61547}
61548
61549impl StreamSocketSetTimestampResponder {
61550    /// Sends a response to the FIDL transaction.
61551    ///
61552    /// Sets the channel to shutdown if an error occurs.
61553    pub fn send(
61554        self,
61555        mut result: Result<(), fidl_fuchsia_posix::Errno>,
61556    ) -> Result<(), fidl::Error> {
61557        let _result = self.send_raw(result);
61558        if _result.is_err() {
61559            self.control_handle.shutdown();
61560        }
61561        self.drop_without_shutdown();
61562        _result
61563    }
61564
61565    /// Similar to "send" but does not shutdown the channel if an error occurs.
61566    pub fn send_no_shutdown_on_err(
61567        self,
61568        mut result: Result<(), fidl_fuchsia_posix::Errno>,
61569    ) -> Result<(), fidl::Error> {
61570        let _result = self.send_raw(result);
61571        self.drop_without_shutdown();
61572        _result
61573    }
61574
61575    fn send_raw(
61576        &self,
61577        mut result: Result<(), fidl_fuchsia_posix::Errno>,
61578    ) -> Result<(), fidl::Error> {
61579        self.control_handle.inner.send::<fidl::encoding::ResultType<
61580            fidl::encoding::EmptyStruct,
61581            fidl_fuchsia_posix::Errno,
61582        >>(
61583            result,
61584            self.tx_id,
61585            0x285d6516c263d839,
61586            fidl::encoding::DynamicFlags::empty(),
61587        )
61588    }
61589}
61590
61591#[must_use = "FIDL methods require a response to be sent"]
61592#[derive(Debug)]
61593pub struct StreamSocketGetTimestampResponder {
61594    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
61595    tx_id: u32,
61596}
61597
61598/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
61599/// if the responder is dropped without sending a response, so that the client
61600/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
61601impl std::ops::Drop for StreamSocketGetTimestampResponder {
61602    fn drop(&mut self) {
61603        self.control_handle.shutdown();
61604        // Safety: drops once, never accessed again
61605        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61606    }
61607}
61608
61609impl fidl::endpoints::Responder for StreamSocketGetTimestampResponder {
61610    type ControlHandle = StreamSocketControlHandle;
61611
61612    fn control_handle(&self) -> &StreamSocketControlHandle {
61613        &self.control_handle
61614    }
61615
61616    fn drop_without_shutdown(mut self) {
61617        // Safety: drops once, never accessed again due to mem::forget
61618        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61619        // Prevent Drop from running (which would shut down the channel)
61620        std::mem::forget(self);
61621    }
61622}
61623
61624impl StreamSocketGetTimestampResponder {
61625    /// Sends a response to the FIDL transaction.
61626    ///
61627    /// Sets the channel to shutdown if an error occurs.
61628    pub fn send(
61629        self,
61630        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
61631    ) -> Result<(), fidl::Error> {
61632        let _result = self.send_raw(result);
61633        if _result.is_err() {
61634            self.control_handle.shutdown();
61635        }
61636        self.drop_without_shutdown();
61637        _result
61638    }
61639
61640    /// Similar to "send" but does not shutdown the channel if an error occurs.
61641    pub fn send_no_shutdown_on_err(
61642        self,
61643        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
61644    ) -> Result<(), fidl::Error> {
61645        let _result = self.send_raw(result);
61646        self.drop_without_shutdown();
61647        _result
61648    }
61649
61650    fn send_raw(
61651        &self,
61652        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
61653    ) -> Result<(), fidl::Error> {
61654        self.control_handle.inner.send::<fidl::encoding::ResultType<
61655            BaseSocketGetTimestampResponse,
61656            fidl_fuchsia_posix::Errno,
61657        >>(
61658            result.map(|value| (value,)),
61659            self.tx_id,
61660            0x49f2fffbbcc2bd27,
61661            fidl::encoding::DynamicFlags::empty(),
61662        )
61663    }
61664}
61665
61666#[must_use = "FIDL methods require a response to be sent"]
61667#[derive(Debug)]
61668pub struct StreamSocketSetMarkResponder {
61669    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
61670    tx_id: u32,
61671}
61672
61673/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
61674/// if the responder is dropped without sending a response, so that the client
61675/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
61676impl std::ops::Drop for StreamSocketSetMarkResponder {
61677    fn drop(&mut self) {
61678        self.control_handle.shutdown();
61679        // Safety: drops once, never accessed again
61680        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61681    }
61682}
61683
61684impl fidl::endpoints::Responder for StreamSocketSetMarkResponder {
61685    type ControlHandle = StreamSocketControlHandle;
61686
61687    fn control_handle(&self) -> &StreamSocketControlHandle {
61688        &self.control_handle
61689    }
61690
61691    fn drop_without_shutdown(mut self) {
61692        // Safety: drops once, never accessed again due to mem::forget
61693        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61694        // Prevent Drop from running (which would shut down the channel)
61695        std::mem::forget(self);
61696    }
61697}
61698
61699impl StreamSocketSetMarkResponder {
61700    /// Sends a response to the FIDL transaction.
61701    ///
61702    /// Sets the channel to shutdown if an error occurs.
61703    pub fn send(
61704        self,
61705        mut result: Result<(), fidl_fuchsia_posix::Errno>,
61706    ) -> Result<(), fidl::Error> {
61707        let _result = self.send_raw(result);
61708        if _result.is_err() {
61709            self.control_handle.shutdown();
61710        }
61711        self.drop_without_shutdown();
61712        _result
61713    }
61714
61715    /// Similar to "send" but does not shutdown the channel if an error occurs.
61716    pub fn send_no_shutdown_on_err(
61717        self,
61718        mut result: Result<(), fidl_fuchsia_posix::Errno>,
61719    ) -> Result<(), fidl::Error> {
61720        let _result = self.send_raw(result);
61721        self.drop_without_shutdown();
61722        _result
61723    }
61724
61725    fn send_raw(
61726        &self,
61727        mut result: Result<(), fidl_fuchsia_posix::Errno>,
61728    ) -> Result<(), fidl::Error> {
61729        self.control_handle.inner.send::<fidl::encoding::ResultType<
61730            fidl::encoding::EmptyStruct,
61731            fidl_fuchsia_posix::Errno,
61732        >>(
61733            result,
61734            self.tx_id,
61735            0x6ead6de09f653236,
61736            fidl::encoding::DynamicFlags::empty(),
61737        )
61738    }
61739}
61740
61741#[must_use = "FIDL methods require a response to be sent"]
61742#[derive(Debug)]
61743pub struct StreamSocketGetMarkResponder {
61744    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
61745    tx_id: u32,
61746}
61747
61748/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
61749/// if the responder is dropped without sending a response, so that the client
61750/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
61751impl std::ops::Drop for StreamSocketGetMarkResponder {
61752    fn drop(&mut self) {
61753        self.control_handle.shutdown();
61754        // Safety: drops once, never accessed again
61755        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61756    }
61757}
61758
61759impl fidl::endpoints::Responder for StreamSocketGetMarkResponder {
61760    type ControlHandle = StreamSocketControlHandle;
61761
61762    fn control_handle(&self) -> &StreamSocketControlHandle {
61763        &self.control_handle
61764    }
61765
61766    fn drop_without_shutdown(mut self) {
61767        // Safety: drops once, never accessed again due to mem::forget
61768        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61769        // Prevent Drop from running (which would shut down the channel)
61770        std::mem::forget(self);
61771    }
61772}
61773
61774impl StreamSocketGetMarkResponder {
61775    /// Sends a response to the FIDL transaction.
61776    ///
61777    /// Sets the channel to shutdown if an error occurs.
61778    pub fn send(
61779        self,
61780        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
61781    ) -> Result<(), fidl::Error> {
61782        let _result = self.send_raw(result);
61783        if _result.is_err() {
61784            self.control_handle.shutdown();
61785        }
61786        self.drop_without_shutdown();
61787        _result
61788    }
61789
61790    /// Similar to "send" but does not shutdown the channel if an error occurs.
61791    pub fn send_no_shutdown_on_err(
61792        self,
61793        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
61794    ) -> Result<(), fidl::Error> {
61795        let _result = self.send_raw(result);
61796        self.drop_without_shutdown();
61797        _result
61798    }
61799
61800    fn send_raw(
61801        &self,
61802        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
61803    ) -> Result<(), fidl::Error> {
61804        self.control_handle.inner.send::<fidl::encoding::ResultType<
61805            BaseSocketGetMarkResponse,
61806            fidl_fuchsia_posix::Errno,
61807        >>(
61808            result.map(|mark| (mark,)),
61809            self.tx_id,
61810            0x57a2752c61d93d47,
61811            fidl::encoding::DynamicFlags::empty(),
61812        )
61813    }
61814}
61815
61816#[must_use = "FIDL methods require a response to be sent"]
61817#[derive(Debug)]
61818pub struct StreamSocketBindResponder {
61819    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
61820    tx_id: u32,
61821}
61822
61823/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
61824/// if the responder is dropped without sending a response, so that the client
61825/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
61826impl std::ops::Drop for StreamSocketBindResponder {
61827    fn drop(&mut self) {
61828        self.control_handle.shutdown();
61829        // Safety: drops once, never accessed again
61830        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61831    }
61832}
61833
61834impl fidl::endpoints::Responder for StreamSocketBindResponder {
61835    type ControlHandle = StreamSocketControlHandle;
61836
61837    fn control_handle(&self) -> &StreamSocketControlHandle {
61838        &self.control_handle
61839    }
61840
61841    fn drop_without_shutdown(mut self) {
61842        // Safety: drops once, never accessed again due to mem::forget
61843        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61844        // Prevent Drop from running (which would shut down the channel)
61845        std::mem::forget(self);
61846    }
61847}
61848
61849impl StreamSocketBindResponder {
61850    /// Sends a response to the FIDL transaction.
61851    ///
61852    /// Sets the channel to shutdown if an error occurs.
61853    pub fn send(
61854        self,
61855        mut result: Result<(), fidl_fuchsia_posix::Errno>,
61856    ) -> Result<(), fidl::Error> {
61857        let _result = self.send_raw(result);
61858        if _result.is_err() {
61859            self.control_handle.shutdown();
61860        }
61861        self.drop_without_shutdown();
61862        _result
61863    }
61864
61865    /// Similar to "send" but does not shutdown the channel if an error occurs.
61866    pub fn send_no_shutdown_on_err(
61867        self,
61868        mut result: Result<(), fidl_fuchsia_posix::Errno>,
61869    ) -> Result<(), fidl::Error> {
61870        let _result = self.send_raw(result);
61871        self.drop_without_shutdown();
61872        _result
61873    }
61874
61875    fn send_raw(
61876        &self,
61877        mut result: Result<(), fidl_fuchsia_posix::Errno>,
61878    ) -> Result<(), fidl::Error> {
61879        self.control_handle.inner.send::<fidl::encoding::ResultType<
61880            fidl::encoding::EmptyStruct,
61881            fidl_fuchsia_posix::Errno,
61882        >>(
61883            result,
61884            self.tx_id,
61885            0x4bc6400ae92125d,
61886            fidl::encoding::DynamicFlags::empty(),
61887        )
61888    }
61889}
61890
61891#[must_use = "FIDL methods require a response to be sent"]
61892#[derive(Debug)]
61893pub struct StreamSocketConnectResponder {
61894    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
61895    tx_id: u32,
61896}
61897
61898/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
61899/// if the responder is dropped without sending a response, so that the client
61900/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
61901impl std::ops::Drop for StreamSocketConnectResponder {
61902    fn drop(&mut self) {
61903        self.control_handle.shutdown();
61904        // Safety: drops once, never accessed again
61905        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61906    }
61907}
61908
61909impl fidl::endpoints::Responder for StreamSocketConnectResponder {
61910    type ControlHandle = StreamSocketControlHandle;
61911
61912    fn control_handle(&self) -> &StreamSocketControlHandle {
61913        &self.control_handle
61914    }
61915
61916    fn drop_without_shutdown(mut self) {
61917        // Safety: drops once, never accessed again due to mem::forget
61918        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61919        // Prevent Drop from running (which would shut down the channel)
61920        std::mem::forget(self);
61921    }
61922}
61923
61924impl StreamSocketConnectResponder {
61925    /// Sends a response to the FIDL transaction.
61926    ///
61927    /// Sets the channel to shutdown if an error occurs.
61928    pub fn send(
61929        self,
61930        mut result: Result<(), fidl_fuchsia_posix::Errno>,
61931    ) -> Result<(), fidl::Error> {
61932        let _result = self.send_raw(result);
61933        if _result.is_err() {
61934            self.control_handle.shutdown();
61935        }
61936        self.drop_without_shutdown();
61937        _result
61938    }
61939
61940    /// Similar to "send" but does not shutdown the channel if an error occurs.
61941    pub fn send_no_shutdown_on_err(
61942        self,
61943        mut result: Result<(), fidl_fuchsia_posix::Errno>,
61944    ) -> Result<(), fidl::Error> {
61945        let _result = self.send_raw(result);
61946        self.drop_without_shutdown();
61947        _result
61948    }
61949
61950    fn send_raw(
61951        &self,
61952        mut result: Result<(), fidl_fuchsia_posix::Errno>,
61953    ) -> Result<(), fidl::Error> {
61954        self.control_handle.inner.send::<fidl::encoding::ResultType<
61955            fidl::encoding::EmptyStruct,
61956            fidl_fuchsia_posix::Errno,
61957        >>(
61958            result,
61959            self.tx_id,
61960            0x5f05f19bfdd38871,
61961            fidl::encoding::DynamicFlags::empty(),
61962        )
61963    }
61964}
61965
61966#[must_use = "FIDL methods require a response to be sent"]
61967#[derive(Debug)]
61968pub struct StreamSocketDisconnectResponder {
61969    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
61970    tx_id: u32,
61971}
61972
61973/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
61974/// if the responder is dropped without sending a response, so that the client
61975/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
61976impl std::ops::Drop for StreamSocketDisconnectResponder {
61977    fn drop(&mut self) {
61978        self.control_handle.shutdown();
61979        // Safety: drops once, never accessed again
61980        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61981    }
61982}
61983
61984impl fidl::endpoints::Responder for StreamSocketDisconnectResponder {
61985    type ControlHandle = StreamSocketControlHandle;
61986
61987    fn control_handle(&self) -> &StreamSocketControlHandle {
61988        &self.control_handle
61989    }
61990
61991    fn drop_without_shutdown(mut self) {
61992        // Safety: drops once, never accessed again due to mem::forget
61993        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
61994        // Prevent Drop from running (which would shut down the channel)
61995        std::mem::forget(self);
61996    }
61997}
61998
61999impl StreamSocketDisconnectResponder {
62000    /// Sends a response to the FIDL transaction.
62001    ///
62002    /// Sets the channel to shutdown if an error occurs.
62003    pub fn send(
62004        self,
62005        mut result: Result<(), fidl_fuchsia_posix::Errno>,
62006    ) -> Result<(), fidl::Error> {
62007        let _result = self.send_raw(result);
62008        if _result.is_err() {
62009            self.control_handle.shutdown();
62010        }
62011        self.drop_without_shutdown();
62012        _result
62013    }
62014
62015    /// Similar to "send" but does not shutdown the channel if an error occurs.
62016    pub fn send_no_shutdown_on_err(
62017        self,
62018        mut result: Result<(), fidl_fuchsia_posix::Errno>,
62019    ) -> Result<(), fidl::Error> {
62020        let _result = self.send_raw(result);
62021        self.drop_without_shutdown();
62022        _result
62023    }
62024
62025    fn send_raw(
62026        &self,
62027        mut result: Result<(), fidl_fuchsia_posix::Errno>,
62028    ) -> Result<(), fidl::Error> {
62029        self.control_handle.inner.send::<fidl::encoding::ResultType<
62030            fidl::encoding::EmptyStruct,
62031            fidl_fuchsia_posix::Errno,
62032        >>(
62033            result,
62034            self.tx_id,
62035            0x74e63b91f7b29b2,
62036            fidl::encoding::DynamicFlags::empty(),
62037        )
62038    }
62039}
62040
62041#[must_use = "FIDL methods require a response to be sent"]
62042#[derive(Debug)]
62043pub struct StreamSocketGetSockNameResponder {
62044    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
62045    tx_id: u32,
62046}
62047
62048/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
62049/// if the responder is dropped without sending a response, so that the client
62050/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
62051impl std::ops::Drop for StreamSocketGetSockNameResponder {
62052    fn drop(&mut self) {
62053        self.control_handle.shutdown();
62054        // Safety: drops once, never accessed again
62055        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62056    }
62057}
62058
62059impl fidl::endpoints::Responder for StreamSocketGetSockNameResponder {
62060    type ControlHandle = StreamSocketControlHandle;
62061
62062    fn control_handle(&self) -> &StreamSocketControlHandle {
62063        &self.control_handle
62064    }
62065
62066    fn drop_without_shutdown(mut self) {
62067        // Safety: drops once, never accessed again due to mem::forget
62068        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62069        // Prevent Drop from running (which would shut down the channel)
62070        std::mem::forget(self);
62071    }
62072}
62073
62074impl StreamSocketGetSockNameResponder {
62075    /// Sends a response to the FIDL transaction.
62076    ///
62077    /// Sets the channel to shutdown if an error occurs.
62078    pub fn send(
62079        self,
62080        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
62081    ) -> Result<(), fidl::Error> {
62082        let _result = self.send_raw(result);
62083        if _result.is_err() {
62084            self.control_handle.shutdown();
62085        }
62086        self.drop_without_shutdown();
62087        _result
62088    }
62089
62090    /// Similar to "send" but does not shutdown the channel if an error occurs.
62091    pub fn send_no_shutdown_on_err(
62092        self,
62093        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
62094    ) -> Result<(), fidl::Error> {
62095        let _result = self.send_raw(result);
62096        self.drop_without_shutdown();
62097        _result
62098    }
62099
62100    fn send_raw(
62101        &self,
62102        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
62103    ) -> Result<(), fidl::Error> {
62104        self.control_handle.inner.send::<fidl::encoding::ResultType<
62105            BaseNetworkSocketGetSockNameResponse,
62106            fidl_fuchsia_posix::Errno,
62107        >>(
62108            result.map(|addr| (addr,)),
62109            self.tx_id,
62110            0x475f23f84a1a4f85,
62111            fidl::encoding::DynamicFlags::empty(),
62112        )
62113    }
62114}
62115
62116#[must_use = "FIDL methods require a response to be sent"]
62117#[derive(Debug)]
62118pub struct StreamSocketGetPeerNameResponder {
62119    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
62120    tx_id: u32,
62121}
62122
62123/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
62124/// if the responder is dropped without sending a response, so that the client
62125/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
62126impl std::ops::Drop for StreamSocketGetPeerNameResponder {
62127    fn drop(&mut self) {
62128        self.control_handle.shutdown();
62129        // Safety: drops once, never accessed again
62130        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62131    }
62132}
62133
62134impl fidl::endpoints::Responder for StreamSocketGetPeerNameResponder {
62135    type ControlHandle = StreamSocketControlHandle;
62136
62137    fn control_handle(&self) -> &StreamSocketControlHandle {
62138        &self.control_handle
62139    }
62140
62141    fn drop_without_shutdown(mut self) {
62142        // Safety: drops once, never accessed again due to mem::forget
62143        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62144        // Prevent Drop from running (which would shut down the channel)
62145        std::mem::forget(self);
62146    }
62147}
62148
62149impl StreamSocketGetPeerNameResponder {
62150    /// Sends a response to the FIDL transaction.
62151    ///
62152    /// Sets the channel to shutdown if an error occurs.
62153    pub fn send(
62154        self,
62155        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
62156    ) -> Result<(), fidl::Error> {
62157        let _result = self.send_raw(result);
62158        if _result.is_err() {
62159            self.control_handle.shutdown();
62160        }
62161        self.drop_without_shutdown();
62162        _result
62163    }
62164
62165    /// Similar to "send" but does not shutdown the channel if an error occurs.
62166    pub fn send_no_shutdown_on_err(
62167        self,
62168        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
62169    ) -> Result<(), fidl::Error> {
62170        let _result = self.send_raw(result);
62171        self.drop_without_shutdown();
62172        _result
62173    }
62174
62175    fn send_raw(
62176        &self,
62177        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
62178    ) -> Result<(), fidl::Error> {
62179        self.control_handle.inner.send::<fidl::encoding::ResultType<
62180            BaseNetworkSocketGetPeerNameResponse,
62181            fidl_fuchsia_posix::Errno,
62182        >>(
62183            result.map(|addr| (addr,)),
62184            self.tx_id,
62185            0x1ffecf4bd5b6432e,
62186            fidl::encoding::DynamicFlags::empty(),
62187        )
62188    }
62189}
62190
62191#[must_use = "FIDL methods require a response to be sent"]
62192#[derive(Debug)]
62193pub struct StreamSocketShutdownResponder {
62194    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
62195    tx_id: u32,
62196}
62197
62198/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
62199/// if the responder is dropped without sending a response, so that the client
62200/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
62201impl std::ops::Drop for StreamSocketShutdownResponder {
62202    fn drop(&mut self) {
62203        self.control_handle.shutdown();
62204        // Safety: drops once, never accessed again
62205        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62206    }
62207}
62208
62209impl fidl::endpoints::Responder for StreamSocketShutdownResponder {
62210    type ControlHandle = StreamSocketControlHandle;
62211
62212    fn control_handle(&self) -> &StreamSocketControlHandle {
62213        &self.control_handle
62214    }
62215
62216    fn drop_without_shutdown(mut self) {
62217        // Safety: drops once, never accessed again due to mem::forget
62218        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62219        // Prevent Drop from running (which would shut down the channel)
62220        std::mem::forget(self);
62221    }
62222}
62223
62224impl StreamSocketShutdownResponder {
62225    /// Sends a response to the FIDL transaction.
62226    ///
62227    /// Sets the channel to shutdown if an error occurs.
62228    pub fn send(
62229        self,
62230        mut result: Result<(), fidl_fuchsia_posix::Errno>,
62231    ) -> Result<(), fidl::Error> {
62232        let _result = self.send_raw(result);
62233        if _result.is_err() {
62234            self.control_handle.shutdown();
62235        }
62236        self.drop_without_shutdown();
62237        _result
62238    }
62239
62240    /// Similar to "send" but does not shutdown the channel if an error occurs.
62241    pub fn send_no_shutdown_on_err(
62242        self,
62243        mut result: Result<(), fidl_fuchsia_posix::Errno>,
62244    ) -> Result<(), fidl::Error> {
62245        let _result = self.send_raw(result);
62246        self.drop_without_shutdown();
62247        _result
62248    }
62249
62250    fn send_raw(
62251        &self,
62252        mut result: Result<(), fidl_fuchsia_posix::Errno>,
62253    ) -> Result<(), fidl::Error> {
62254        self.control_handle.inner.send::<fidl::encoding::ResultType<
62255            fidl::encoding::EmptyStruct,
62256            fidl_fuchsia_posix::Errno,
62257        >>(
62258            result,
62259            self.tx_id,
62260            0x247f38b6db68c336,
62261            fidl::encoding::DynamicFlags::empty(),
62262        )
62263    }
62264}
62265
62266#[must_use = "FIDL methods require a response to be sent"]
62267#[derive(Debug)]
62268pub struct StreamSocketSetIpTypeOfServiceResponder {
62269    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
62270    tx_id: u32,
62271}
62272
62273/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
62274/// if the responder is dropped without sending a response, so that the client
62275/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
62276impl std::ops::Drop for StreamSocketSetIpTypeOfServiceResponder {
62277    fn drop(&mut self) {
62278        self.control_handle.shutdown();
62279        // Safety: drops once, never accessed again
62280        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62281    }
62282}
62283
62284impl fidl::endpoints::Responder for StreamSocketSetIpTypeOfServiceResponder {
62285    type ControlHandle = StreamSocketControlHandle;
62286
62287    fn control_handle(&self) -> &StreamSocketControlHandle {
62288        &self.control_handle
62289    }
62290
62291    fn drop_without_shutdown(mut self) {
62292        // Safety: drops once, never accessed again due to mem::forget
62293        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62294        // Prevent Drop from running (which would shut down the channel)
62295        std::mem::forget(self);
62296    }
62297}
62298
62299impl StreamSocketSetIpTypeOfServiceResponder {
62300    /// Sends a response to the FIDL transaction.
62301    ///
62302    /// Sets the channel to shutdown if an error occurs.
62303    pub fn send(
62304        self,
62305        mut result: Result<(), fidl_fuchsia_posix::Errno>,
62306    ) -> Result<(), fidl::Error> {
62307        let _result = self.send_raw(result);
62308        if _result.is_err() {
62309            self.control_handle.shutdown();
62310        }
62311        self.drop_without_shutdown();
62312        _result
62313    }
62314
62315    /// Similar to "send" but does not shutdown the channel if an error occurs.
62316    pub fn send_no_shutdown_on_err(
62317        self,
62318        mut result: Result<(), fidl_fuchsia_posix::Errno>,
62319    ) -> Result<(), fidl::Error> {
62320        let _result = self.send_raw(result);
62321        self.drop_without_shutdown();
62322        _result
62323    }
62324
62325    fn send_raw(
62326        &self,
62327        mut result: Result<(), fidl_fuchsia_posix::Errno>,
62328    ) -> Result<(), fidl::Error> {
62329        self.control_handle.inner.send::<fidl::encoding::ResultType<
62330            fidl::encoding::EmptyStruct,
62331            fidl_fuchsia_posix::Errno,
62332        >>(
62333            result,
62334            self.tx_id,
62335            0x995c600475b6d46,
62336            fidl::encoding::DynamicFlags::empty(),
62337        )
62338    }
62339}
62340
62341#[must_use = "FIDL methods require a response to be sent"]
62342#[derive(Debug)]
62343pub struct StreamSocketGetIpTypeOfServiceResponder {
62344    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
62345    tx_id: u32,
62346}
62347
62348/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
62349/// if the responder is dropped without sending a response, so that the client
62350/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
62351impl std::ops::Drop for StreamSocketGetIpTypeOfServiceResponder {
62352    fn drop(&mut self) {
62353        self.control_handle.shutdown();
62354        // Safety: drops once, never accessed again
62355        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62356    }
62357}
62358
62359impl fidl::endpoints::Responder for StreamSocketGetIpTypeOfServiceResponder {
62360    type ControlHandle = StreamSocketControlHandle;
62361
62362    fn control_handle(&self) -> &StreamSocketControlHandle {
62363        &self.control_handle
62364    }
62365
62366    fn drop_without_shutdown(mut self) {
62367        // Safety: drops once, never accessed again due to mem::forget
62368        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62369        // Prevent Drop from running (which would shut down the channel)
62370        std::mem::forget(self);
62371    }
62372}
62373
62374impl StreamSocketGetIpTypeOfServiceResponder {
62375    /// Sends a response to the FIDL transaction.
62376    ///
62377    /// Sets the channel to shutdown if an error occurs.
62378    pub fn send(
62379        self,
62380        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
62381    ) -> Result<(), fidl::Error> {
62382        let _result = self.send_raw(result);
62383        if _result.is_err() {
62384            self.control_handle.shutdown();
62385        }
62386        self.drop_without_shutdown();
62387        _result
62388    }
62389
62390    /// Similar to "send" but does not shutdown the channel if an error occurs.
62391    pub fn send_no_shutdown_on_err(
62392        self,
62393        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
62394    ) -> Result<(), fidl::Error> {
62395        let _result = self.send_raw(result);
62396        self.drop_without_shutdown();
62397        _result
62398    }
62399
62400    fn send_raw(
62401        &self,
62402        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
62403    ) -> Result<(), fidl::Error> {
62404        self.control_handle.inner.send::<fidl::encoding::ResultType<
62405            BaseNetworkSocketGetIpTypeOfServiceResponse,
62406            fidl_fuchsia_posix::Errno,
62407        >>(
62408            result.map(|value| (value,)),
62409            self.tx_id,
62410            0x3814a04259f75fcb,
62411            fidl::encoding::DynamicFlags::empty(),
62412        )
62413    }
62414}
62415
62416#[must_use = "FIDL methods require a response to be sent"]
62417#[derive(Debug)]
62418pub struct StreamSocketSetIpTtlResponder {
62419    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
62420    tx_id: u32,
62421}
62422
62423/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
62424/// if the responder is dropped without sending a response, so that the client
62425/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
62426impl std::ops::Drop for StreamSocketSetIpTtlResponder {
62427    fn drop(&mut self) {
62428        self.control_handle.shutdown();
62429        // Safety: drops once, never accessed again
62430        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62431    }
62432}
62433
62434impl fidl::endpoints::Responder for StreamSocketSetIpTtlResponder {
62435    type ControlHandle = StreamSocketControlHandle;
62436
62437    fn control_handle(&self) -> &StreamSocketControlHandle {
62438        &self.control_handle
62439    }
62440
62441    fn drop_without_shutdown(mut self) {
62442        // Safety: drops once, never accessed again due to mem::forget
62443        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62444        // Prevent Drop from running (which would shut down the channel)
62445        std::mem::forget(self);
62446    }
62447}
62448
62449impl StreamSocketSetIpTtlResponder {
62450    /// Sends a response to the FIDL transaction.
62451    ///
62452    /// Sets the channel to shutdown if an error occurs.
62453    pub fn send(
62454        self,
62455        mut result: Result<(), fidl_fuchsia_posix::Errno>,
62456    ) -> Result<(), fidl::Error> {
62457        let _result = self.send_raw(result);
62458        if _result.is_err() {
62459            self.control_handle.shutdown();
62460        }
62461        self.drop_without_shutdown();
62462        _result
62463    }
62464
62465    /// Similar to "send" but does not shutdown the channel if an error occurs.
62466    pub fn send_no_shutdown_on_err(
62467        self,
62468        mut result: Result<(), fidl_fuchsia_posix::Errno>,
62469    ) -> Result<(), fidl::Error> {
62470        let _result = self.send_raw(result);
62471        self.drop_without_shutdown();
62472        _result
62473    }
62474
62475    fn send_raw(
62476        &self,
62477        mut result: Result<(), fidl_fuchsia_posix::Errno>,
62478    ) -> Result<(), fidl::Error> {
62479        self.control_handle.inner.send::<fidl::encoding::ResultType<
62480            fidl::encoding::EmptyStruct,
62481            fidl_fuchsia_posix::Errno,
62482        >>(
62483            result,
62484            self.tx_id,
62485            0x29e2424b433ae1ef,
62486            fidl::encoding::DynamicFlags::empty(),
62487        )
62488    }
62489}
62490
62491#[must_use = "FIDL methods require a response to be sent"]
62492#[derive(Debug)]
62493pub struct StreamSocketGetIpTtlResponder {
62494    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
62495    tx_id: u32,
62496}
62497
62498/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
62499/// if the responder is dropped without sending a response, so that the client
62500/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
62501impl std::ops::Drop for StreamSocketGetIpTtlResponder {
62502    fn drop(&mut self) {
62503        self.control_handle.shutdown();
62504        // Safety: drops once, never accessed again
62505        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62506    }
62507}
62508
62509impl fidl::endpoints::Responder for StreamSocketGetIpTtlResponder {
62510    type ControlHandle = StreamSocketControlHandle;
62511
62512    fn control_handle(&self) -> &StreamSocketControlHandle {
62513        &self.control_handle
62514    }
62515
62516    fn drop_without_shutdown(mut self) {
62517        // Safety: drops once, never accessed again due to mem::forget
62518        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62519        // Prevent Drop from running (which would shut down the channel)
62520        std::mem::forget(self);
62521    }
62522}
62523
62524impl StreamSocketGetIpTtlResponder {
62525    /// Sends a response to the FIDL transaction.
62526    ///
62527    /// Sets the channel to shutdown if an error occurs.
62528    pub fn send(
62529        self,
62530        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
62531    ) -> Result<(), fidl::Error> {
62532        let _result = self.send_raw(result);
62533        if _result.is_err() {
62534            self.control_handle.shutdown();
62535        }
62536        self.drop_without_shutdown();
62537        _result
62538    }
62539
62540    /// Similar to "send" but does not shutdown the channel if an error occurs.
62541    pub fn send_no_shutdown_on_err(
62542        self,
62543        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
62544    ) -> Result<(), fidl::Error> {
62545        let _result = self.send_raw(result);
62546        self.drop_without_shutdown();
62547        _result
62548    }
62549
62550    fn send_raw(
62551        &self,
62552        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
62553    ) -> Result<(), fidl::Error> {
62554        self.control_handle.inner.send::<fidl::encoding::ResultType<
62555            BaseNetworkSocketGetIpTtlResponse,
62556            fidl_fuchsia_posix::Errno,
62557        >>(
62558            result.map(|value| (value,)),
62559            self.tx_id,
62560            0x47e47fa1f24da471,
62561            fidl::encoding::DynamicFlags::empty(),
62562        )
62563    }
62564}
62565
62566#[must_use = "FIDL methods require a response to be sent"]
62567#[derive(Debug)]
62568pub struct StreamSocketSetIpPacketInfoResponder {
62569    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
62570    tx_id: u32,
62571}
62572
62573/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
62574/// if the responder is dropped without sending a response, so that the client
62575/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
62576impl std::ops::Drop for StreamSocketSetIpPacketInfoResponder {
62577    fn drop(&mut self) {
62578        self.control_handle.shutdown();
62579        // Safety: drops once, never accessed again
62580        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62581    }
62582}
62583
62584impl fidl::endpoints::Responder for StreamSocketSetIpPacketInfoResponder {
62585    type ControlHandle = StreamSocketControlHandle;
62586
62587    fn control_handle(&self) -> &StreamSocketControlHandle {
62588        &self.control_handle
62589    }
62590
62591    fn drop_without_shutdown(mut self) {
62592        // Safety: drops once, never accessed again due to mem::forget
62593        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62594        // Prevent Drop from running (which would shut down the channel)
62595        std::mem::forget(self);
62596    }
62597}
62598
62599impl StreamSocketSetIpPacketInfoResponder {
62600    /// Sends a response to the FIDL transaction.
62601    ///
62602    /// Sets the channel to shutdown if an error occurs.
62603    pub fn send(
62604        self,
62605        mut result: Result<(), fidl_fuchsia_posix::Errno>,
62606    ) -> Result<(), fidl::Error> {
62607        let _result = self.send_raw(result);
62608        if _result.is_err() {
62609            self.control_handle.shutdown();
62610        }
62611        self.drop_without_shutdown();
62612        _result
62613    }
62614
62615    /// Similar to "send" but does not shutdown the channel if an error occurs.
62616    pub fn send_no_shutdown_on_err(
62617        self,
62618        mut result: Result<(), fidl_fuchsia_posix::Errno>,
62619    ) -> Result<(), fidl::Error> {
62620        let _result = self.send_raw(result);
62621        self.drop_without_shutdown();
62622        _result
62623    }
62624
62625    fn send_raw(
62626        &self,
62627        mut result: Result<(), fidl_fuchsia_posix::Errno>,
62628    ) -> Result<(), fidl::Error> {
62629        self.control_handle.inner.send::<fidl::encoding::ResultType<
62630            fidl::encoding::EmptyStruct,
62631            fidl_fuchsia_posix::Errno,
62632        >>(
62633            result,
62634            self.tx_id,
62635            0x392d16bee20c0e16,
62636            fidl::encoding::DynamicFlags::empty(),
62637        )
62638    }
62639}
62640
62641#[must_use = "FIDL methods require a response to be sent"]
62642#[derive(Debug)]
62643pub struct StreamSocketGetIpPacketInfoResponder {
62644    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
62645    tx_id: u32,
62646}
62647
62648/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
62649/// if the responder is dropped without sending a response, so that the client
62650/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
62651impl std::ops::Drop for StreamSocketGetIpPacketInfoResponder {
62652    fn drop(&mut self) {
62653        self.control_handle.shutdown();
62654        // Safety: drops once, never accessed again
62655        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62656    }
62657}
62658
62659impl fidl::endpoints::Responder for StreamSocketGetIpPacketInfoResponder {
62660    type ControlHandle = StreamSocketControlHandle;
62661
62662    fn control_handle(&self) -> &StreamSocketControlHandle {
62663        &self.control_handle
62664    }
62665
62666    fn drop_without_shutdown(mut self) {
62667        // Safety: drops once, never accessed again due to mem::forget
62668        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62669        // Prevent Drop from running (which would shut down the channel)
62670        std::mem::forget(self);
62671    }
62672}
62673
62674impl StreamSocketGetIpPacketInfoResponder {
62675    /// Sends a response to the FIDL transaction.
62676    ///
62677    /// Sets the channel to shutdown if an error occurs.
62678    pub fn send(
62679        self,
62680        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
62681    ) -> Result<(), fidl::Error> {
62682        let _result = self.send_raw(result);
62683        if _result.is_err() {
62684            self.control_handle.shutdown();
62685        }
62686        self.drop_without_shutdown();
62687        _result
62688    }
62689
62690    /// Similar to "send" but does not shutdown the channel if an error occurs.
62691    pub fn send_no_shutdown_on_err(
62692        self,
62693        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
62694    ) -> Result<(), fidl::Error> {
62695        let _result = self.send_raw(result);
62696        self.drop_without_shutdown();
62697        _result
62698    }
62699
62700    fn send_raw(
62701        &self,
62702        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
62703    ) -> Result<(), fidl::Error> {
62704        self.control_handle.inner.send::<fidl::encoding::ResultType<
62705            BaseNetworkSocketGetIpPacketInfoResponse,
62706            fidl_fuchsia_posix::Errno,
62707        >>(
62708            result.map(|value| (value,)),
62709            self.tx_id,
62710            0x54b505f242280740,
62711            fidl::encoding::DynamicFlags::empty(),
62712        )
62713    }
62714}
62715
62716#[must_use = "FIDL methods require a response to be sent"]
62717#[derive(Debug)]
62718pub struct StreamSocketSetIpReceiveTypeOfServiceResponder {
62719    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
62720    tx_id: u32,
62721}
62722
62723/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
62724/// if the responder is dropped without sending a response, so that the client
62725/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
62726impl std::ops::Drop for StreamSocketSetIpReceiveTypeOfServiceResponder {
62727    fn drop(&mut self) {
62728        self.control_handle.shutdown();
62729        // Safety: drops once, never accessed again
62730        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62731    }
62732}
62733
62734impl fidl::endpoints::Responder for StreamSocketSetIpReceiveTypeOfServiceResponder {
62735    type ControlHandle = StreamSocketControlHandle;
62736
62737    fn control_handle(&self) -> &StreamSocketControlHandle {
62738        &self.control_handle
62739    }
62740
62741    fn drop_without_shutdown(mut self) {
62742        // Safety: drops once, never accessed again due to mem::forget
62743        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62744        // Prevent Drop from running (which would shut down the channel)
62745        std::mem::forget(self);
62746    }
62747}
62748
62749impl StreamSocketSetIpReceiveTypeOfServiceResponder {
62750    /// Sends a response to the FIDL transaction.
62751    ///
62752    /// Sets the channel to shutdown if an error occurs.
62753    pub fn send(
62754        self,
62755        mut result: Result<(), fidl_fuchsia_posix::Errno>,
62756    ) -> Result<(), fidl::Error> {
62757        let _result = self.send_raw(result);
62758        if _result.is_err() {
62759            self.control_handle.shutdown();
62760        }
62761        self.drop_without_shutdown();
62762        _result
62763    }
62764
62765    /// Similar to "send" but does not shutdown the channel if an error occurs.
62766    pub fn send_no_shutdown_on_err(
62767        self,
62768        mut result: Result<(), fidl_fuchsia_posix::Errno>,
62769    ) -> Result<(), fidl::Error> {
62770        let _result = self.send_raw(result);
62771        self.drop_without_shutdown();
62772        _result
62773    }
62774
62775    fn send_raw(
62776        &self,
62777        mut result: Result<(), fidl_fuchsia_posix::Errno>,
62778    ) -> Result<(), fidl::Error> {
62779        self.control_handle.inner.send::<fidl::encoding::ResultType<
62780            fidl::encoding::EmptyStruct,
62781            fidl_fuchsia_posix::Errno,
62782        >>(
62783            result,
62784            self.tx_id,
62785            0x6c4f6714995f84ef,
62786            fidl::encoding::DynamicFlags::empty(),
62787        )
62788    }
62789}
62790
62791#[must_use = "FIDL methods require a response to be sent"]
62792#[derive(Debug)]
62793pub struct StreamSocketGetIpReceiveTypeOfServiceResponder {
62794    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
62795    tx_id: u32,
62796}
62797
62798/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
62799/// if the responder is dropped without sending a response, so that the client
62800/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
62801impl std::ops::Drop for StreamSocketGetIpReceiveTypeOfServiceResponder {
62802    fn drop(&mut self) {
62803        self.control_handle.shutdown();
62804        // Safety: drops once, never accessed again
62805        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62806    }
62807}
62808
62809impl fidl::endpoints::Responder for StreamSocketGetIpReceiveTypeOfServiceResponder {
62810    type ControlHandle = StreamSocketControlHandle;
62811
62812    fn control_handle(&self) -> &StreamSocketControlHandle {
62813        &self.control_handle
62814    }
62815
62816    fn drop_without_shutdown(mut self) {
62817        // Safety: drops once, never accessed again due to mem::forget
62818        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62819        // Prevent Drop from running (which would shut down the channel)
62820        std::mem::forget(self);
62821    }
62822}
62823
62824impl StreamSocketGetIpReceiveTypeOfServiceResponder {
62825    /// Sends a response to the FIDL transaction.
62826    ///
62827    /// Sets the channel to shutdown if an error occurs.
62828    pub fn send(
62829        self,
62830        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
62831    ) -> Result<(), fidl::Error> {
62832        let _result = self.send_raw(result);
62833        if _result.is_err() {
62834            self.control_handle.shutdown();
62835        }
62836        self.drop_without_shutdown();
62837        _result
62838    }
62839
62840    /// Similar to "send" but does not shutdown the channel if an error occurs.
62841    pub fn send_no_shutdown_on_err(
62842        self,
62843        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
62844    ) -> Result<(), fidl::Error> {
62845        let _result = self.send_raw(result);
62846        self.drop_without_shutdown();
62847        _result
62848    }
62849
62850    fn send_raw(
62851        &self,
62852        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
62853    ) -> Result<(), fidl::Error> {
62854        self.control_handle.inner.send::<fidl::encoding::ResultType<
62855            BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
62856            fidl_fuchsia_posix::Errno,
62857        >>(
62858            result.map(|value| (value,)),
62859            self.tx_id,
62860            0x4158ba7dc2795960,
62861            fidl::encoding::DynamicFlags::empty(),
62862        )
62863    }
62864}
62865
62866#[must_use = "FIDL methods require a response to be sent"]
62867#[derive(Debug)]
62868pub struct StreamSocketSetIpReceiveTtlResponder {
62869    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
62870    tx_id: u32,
62871}
62872
62873/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
62874/// if the responder is dropped without sending a response, so that the client
62875/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
62876impl std::ops::Drop for StreamSocketSetIpReceiveTtlResponder {
62877    fn drop(&mut self) {
62878        self.control_handle.shutdown();
62879        // Safety: drops once, never accessed again
62880        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62881    }
62882}
62883
62884impl fidl::endpoints::Responder for StreamSocketSetIpReceiveTtlResponder {
62885    type ControlHandle = StreamSocketControlHandle;
62886
62887    fn control_handle(&self) -> &StreamSocketControlHandle {
62888        &self.control_handle
62889    }
62890
62891    fn drop_without_shutdown(mut self) {
62892        // Safety: drops once, never accessed again due to mem::forget
62893        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62894        // Prevent Drop from running (which would shut down the channel)
62895        std::mem::forget(self);
62896    }
62897}
62898
62899impl StreamSocketSetIpReceiveTtlResponder {
62900    /// Sends a response to the FIDL transaction.
62901    ///
62902    /// Sets the channel to shutdown if an error occurs.
62903    pub fn send(
62904        self,
62905        mut result: Result<(), fidl_fuchsia_posix::Errno>,
62906    ) -> Result<(), fidl::Error> {
62907        let _result = self.send_raw(result);
62908        if _result.is_err() {
62909            self.control_handle.shutdown();
62910        }
62911        self.drop_without_shutdown();
62912        _result
62913    }
62914
62915    /// Similar to "send" but does not shutdown the channel if an error occurs.
62916    pub fn send_no_shutdown_on_err(
62917        self,
62918        mut result: Result<(), fidl_fuchsia_posix::Errno>,
62919    ) -> Result<(), fidl::Error> {
62920        let _result = self.send_raw(result);
62921        self.drop_without_shutdown();
62922        _result
62923    }
62924
62925    fn send_raw(
62926        &self,
62927        mut result: Result<(), fidl_fuchsia_posix::Errno>,
62928    ) -> Result<(), fidl::Error> {
62929        self.control_handle.inner.send::<fidl::encoding::ResultType<
62930            fidl::encoding::EmptyStruct,
62931            fidl_fuchsia_posix::Errno,
62932        >>(
62933            result,
62934            self.tx_id,
62935            0x46f15be0ce0ab82b,
62936            fidl::encoding::DynamicFlags::empty(),
62937        )
62938    }
62939}
62940
62941#[must_use = "FIDL methods require a response to be sent"]
62942#[derive(Debug)]
62943pub struct StreamSocketGetIpReceiveTtlResponder {
62944    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
62945    tx_id: u32,
62946}
62947
62948/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
62949/// if the responder is dropped without sending a response, so that the client
62950/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
62951impl std::ops::Drop for StreamSocketGetIpReceiveTtlResponder {
62952    fn drop(&mut self) {
62953        self.control_handle.shutdown();
62954        // Safety: drops once, never accessed again
62955        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62956    }
62957}
62958
62959impl fidl::endpoints::Responder for StreamSocketGetIpReceiveTtlResponder {
62960    type ControlHandle = StreamSocketControlHandle;
62961
62962    fn control_handle(&self) -> &StreamSocketControlHandle {
62963        &self.control_handle
62964    }
62965
62966    fn drop_without_shutdown(mut self) {
62967        // Safety: drops once, never accessed again due to mem::forget
62968        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
62969        // Prevent Drop from running (which would shut down the channel)
62970        std::mem::forget(self);
62971    }
62972}
62973
62974impl StreamSocketGetIpReceiveTtlResponder {
62975    /// Sends a response to the FIDL transaction.
62976    ///
62977    /// Sets the channel to shutdown if an error occurs.
62978    pub fn send(
62979        self,
62980        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
62981    ) -> Result<(), fidl::Error> {
62982        let _result = self.send_raw(result);
62983        if _result.is_err() {
62984            self.control_handle.shutdown();
62985        }
62986        self.drop_without_shutdown();
62987        _result
62988    }
62989
62990    /// Similar to "send" but does not shutdown the channel if an error occurs.
62991    pub fn send_no_shutdown_on_err(
62992        self,
62993        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
62994    ) -> Result<(), fidl::Error> {
62995        let _result = self.send_raw(result);
62996        self.drop_without_shutdown();
62997        _result
62998    }
62999
63000    fn send_raw(
63001        &self,
63002        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
63003    ) -> Result<(), fidl::Error> {
63004        self.control_handle.inner.send::<fidl::encoding::ResultType<
63005            BaseNetworkSocketGetIpReceiveTtlResponse,
63006            fidl_fuchsia_posix::Errno,
63007        >>(
63008            result.map(|value| (value,)),
63009            self.tx_id,
63010            0x678ddd5a5dfa2eb5,
63011            fidl::encoding::DynamicFlags::empty(),
63012        )
63013    }
63014}
63015
63016#[must_use = "FIDL methods require a response to be sent"]
63017#[derive(Debug)]
63018pub struct StreamSocketSetIpMulticastInterfaceResponder {
63019    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
63020    tx_id: u32,
63021}
63022
63023/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
63024/// if the responder is dropped without sending a response, so that the client
63025/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
63026impl std::ops::Drop for StreamSocketSetIpMulticastInterfaceResponder {
63027    fn drop(&mut self) {
63028        self.control_handle.shutdown();
63029        // Safety: drops once, never accessed again
63030        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63031    }
63032}
63033
63034impl fidl::endpoints::Responder for StreamSocketSetIpMulticastInterfaceResponder {
63035    type ControlHandle = StreamSocketControlHandle;
63036
63037    fn control_handle(&self) -> &StreamSocketControlHandle {
63038        &self.control_handle
63039    }
63040
63041    fn drop_without_shutdown(mut self) {
63042        // Safety: drops once, never accessed again due to mem::forget
63043        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63044        // Prevent Drop from running (which would shut down the channel)
63045        std::mem::forget(self);
63046    }
63047}
63048
63049impl StreamSocketSetIpMulticastInterfaceResponder {
63050    /// Sends a response to the FIDL transaction.
63051    ///
63052    /// Sets the channel to shutdown if an error occurs.
63053    pub fn send(
63054        self,
63055        mut result: Result<(), fidl_fuchsia_posix::Errno>,
63056    ) -> Result<(), fidl::Error> {
63057        let _result = self.send_raw(result);
63058        if _result.is_err() {
63059            self.control_handle.shutdown();
63060        }
63061        self.drop_without_shutdown();
63062        _result
63063    }
63064
63065    /// Similar to "send" but does not shutdown the channel if an error occurs.
63066    pub fn send_no_shutdown_on_err(
63067        self,
63068        mut result: Result<(), fidl_fuchsia_posix::Errno>,
63069    ) -> Result<(), fidl::Error> {
63070        let _result = self.send_raw(result);
63071        self.drop_without_shutdown();
63072        _result
63073    }
63074
63075    fn send_raw(
63076        &self,
63077        mut result: Result<(), fidl_fuchsia_posix::Errno>,
63078    ) -> Result<(), fidl::Error> {
63079        self.control_handle.inner.send::<fidl::encoding::ResultType<
63080            fidl::encoding::EmptyStruct,
63081            fidl_fuchsia_posix::Errno,
63082        >>(
63083            result,
63084            self.tx_id,
63085            0x752fbfa9b12befe,
63086            fidl::encoding::DynamicFlags::empty(),
63087        )
63088    }
63089}
63090
63091#[must_use = "FIDL methods require a response to be sent"]
63092#[derive(Debug)]
63093pub struct StreamSocketGetIpMulticastInterfaceResponder {
63094    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
63095    tx_id: u32,
63096}
63097
63098/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
63099/// if the responder is dropped without sending a response, so that the client
63100/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
63101impl std::ops::Drop for StreamSocketGetIpMulticastInterfaceResponder {
63102    fn drop(&mut self) {
63103        self.control_handle.shutdown();
63104        // Safety: drops once, never accessed again
63105        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63106    }
63107}
63108
63109impl fidl::endpoints::Responder for StreamSocketGetIpMulticastInterfaceResponder {
63110    type ControlHandle = StreamSocketControlHandle;
63111
63112    fn control_handle(&self) -> &StreamSocketControlHandle {
63113        &self.control_handle
63114    }
63115
63116    fn drop_without_shutdown(mut self) {
63117        // Safety: drops once, never accessed again due to mem::forget
63118        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63119        // Prevent Drop from running (which would shut down the channel)
63120        std::mem::forget(self);
63121    }
63122}
63123
63124impl StreamSocketGetIpMulticastInterfaceResponder {
63125    /// Sends a response to the FIDL transaction.
63126    ///
63127    /// Sets the channel to shutdown if an error occurs.
63128    pub fn send(
63129        self,
63130        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
63131    ) -> Result<(), fidl::Error> {
63132        let _result = self.send_raw(result);
63133        if _result.is_err() {
63134            self.control_handle.shutdown();
63135        }
63136        self.drop_without_shutdown();
63137        _result
63138    }
63139
63140    /// Similar to "send" but does not shutdown the channel if an error occurs.
63141    pub fn send_no_shutdown_on_err(
63142        self,
63143        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
63144    ) -> Result<(), fidl::Error> {
63145        let _result = self.send_raw(result);
63146        self.drop_without_shutdown();
63147        _result
63148    }
63149
63150    fn send_raw(
63151        &self,
63152        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
63153    ) -> Result<(), fidl::Error> {
63154        self.control_handle.inner.send::<fidl::encoding::ResultType<
63155            BaseNetworkSocketGetIpMulticastInterfaceResponse,
63156            fidl_fuchsia_posix::Errno,
63157        >>(
63158            result.map(|value| (value,)),
63159            self.tx_id,
63160            0x320bd14c4df046c4,
63161            fidl::encoding::DynamicFlags::empty(),
63162        )
63163    }
63164}
63165
63166#[must_use = "FIDL methods require a response to be sent"]
63167#[derive(Debug)]
63168pub struct StreamSocketSetIpMulticastTtlResponder {
63169    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
63170    tx_id: u32,
63171}
63172
63173/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
63174/// if the responder is dropped without sending a response, so that the client
63175/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
63176impl std::ops::Drop for StreamSocketSetIpMulticastTtlResponder {
63177    fn drop(&mut self) {
63178        self.control_handle.shutdown();
63179        // Safety: drops once, never accessed again
63180        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63181    }
63182}
63183
63184impl fidl::endpoints::Responder for StreamSocketSetIpMulticastTtlResponder {
63185    type ControlHandle = StreamSocketControlHandle;
63186
63187    fn control_handle(&self) -> &StreamSocketControlHandle {
63188        &self.control_handle
63189    }
63190
63191    fn drop_without_shutdown(mut self) {
63192        // Safety: drops once, never accessed again due to mem::forget
63193        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63194        // Prevent Drop from running (which would shut down the channel)
63195        std::mem::forget(self);
63196    }
63197}
63198
63199impl StreamSocketSetIpMulticastTtlResponder {
63200    /// Sends a response to the FIDL transaction.
63201    ///
63202    /// Sets the channel to shutdown if an error occurs.
63203    pub fn send(
63204        self,
63205        mut result: Result<(), fidl_fuchsia_posix::Errno>,
63206    ) -> Result<(), fidl::Error> {
63207        let _result = self.send_raw(result);
63208        if _result.is_err() {
63209            self.control_handle.shutdown();
63210        }
63211        self.drop_without_shutdown();
63212        _result
63213    }
63214
63215    /// Similar to "send" but does not shutdown the channel if an error occurs.
63216    pub fn send_no_shutdown_on_err(
63217        self,
63218        mut result: Result<(), fidl_fuchsia_posix::Errno>,
63219    ) -> Result<(), fidl::Error> {
63220        let _result = self.send_raw(result);
63221        self.drop_without_shutdown();
63222        _result
63223    }
63224
63225    fn send_raw(
63226        &self,
63227        mut result: Result<(), fidl_fuchsia_posix::Errno>,
63228    ) -> Result<(), fidl::Error> {
63229        self.control_handle.inner.send::<fidl::encoding::ResultType<
63230            fidl::encoding::EmptyStruct,
63231            fidl_fuchsia_posix::Errno,
63232        >>(
63233            result,
63234            self.tx_id,
63235            0x63134d53772916a1,
63236            fidl::encoding::DynamicFlags::empty(),
63237        )
63238    }
63239}
63240
63241#[must_use = "FIDL methods require a response to be sent"]
63242#[derive(Debug)]
63243pub struct StreamSocketGetIpMulticastTtlResponder {
63244    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
63245    tx_id: u32,
63246}
63247
63248/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
63249/// if the responder is dropped without sending a response, so that the client
63250/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
63251impl std::ops::Drop for StreamSocketGetIpMulticastTtlResponder {
63252    fn drop(&mut self) {
63253        self.control_handle.shutdown();
63254        // Safety: drops once, never accessed again
63255        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63256    }
63257}
63258
63259impl fidl::endpoints::Responder for StreamSocketGetIpMulticastTtlResponder {
63260    type ControlHandle = StreamSocketControlHandle;
63261
63262    fn control_handle(&self) -> &StreamSocketControlHandle {
63263        &self.control_handle
63264    }
63265
63266    fn drop_without_shutdown(mut self) {
63267        // Safety: drops once, never accessed again due to mem::forget
63268        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63269        // Prevent Drop from running (which would shut down the channel)
63270        std::mem::forget(self);
63271    }
63272}
63273
63274impl StreamSocketGetIpMulticastTtlResponder {
63275    /// Sends a response to the FIDL transaction.
63276    ///
63277    /// Sets the channel to shutdown if an error occurs.
63278    pub fn send(
63279        self,
63280        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
63281    ) -> Result<(), fidl::Error> {
63282        let _result = self.send_raw(result);
63283        if _result.is_err() {
63284            self.control_handle.shutdown();
63285        }
63286        self.drop_without_shutdown();
63287        _result
63288    }
63289
63290    /// Similar to "send" but does not shutdown the channel if an error occurs.
63291    pub fn send_no_shutdown_on_err(
63292        self,
63293        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
63294    ) -> Result<(), fidl::Error> {
63295        let _result = self.send_raw(result);
63296        self.drop_without_shutdown();
63297        _result
63298    }
63299
63300    fn send_raw(
63301        &self,
63302        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
63303    ) -> Result<(), fidl::Error> {
63304        self.control_handle.inner.send::<fidl::encoding::ResultType<
63305            BaseNetworkSocketGetIpMulticastTtlResponse,
63306            fidl_fuchsia_posix::Errno,
63307        >>(
63308            result.map(|value| (value,)),
63309            self.tx_id,
63310            0x4665cd378f39e1a,
63311            fidl::encoding::DynamicFlags::empty(),
63312        )
63313    }
63314}
63315
63316#[must_use = "FIDL methods require a response to be sent"]
63317#[derive(Debug)]
63318pub struct StreamSocketSetIpMulticastLoopbackResponder {
63319    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
63320    tx_id: u32,
63321}
63322
63323/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
63324/// if the responder is dropped without sending a response, so that the client
63325/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
63326impl std::ops::Drop for StreamSocketSetIpMulticastLoopbackResponder {
63327    fn drop(&mut self) {
63328        self.control_handle.shutdown();
63329        // Safety: drops once, never accessed again
63330        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63331    }
63332}
63333
63334impl fidl::endpoints::Responder for StreamSocketSetIpMulticastLoopbackResponder {
63335    type ControlHandle = StreamSocketControlHandle;
63336
63337    fn control_handle(&self) -> &StreamSocketControlHandle {
63338        &self.control_handle
63339    }
63340
63341    fn drop_without_shutdown(mut self) {
63342        // Safety: drops once, never accessed again due to mem::forget
63343        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63344        // Prevent Drop from running (which would shut down the channel)
63345        std::mem::forget(self);
63346    }
63347}
63348
63349impl StreamSocketSetIpMulticastLoopbackResponder {
63350    /// Sends a response to the FIDL transaction.
63351    ///
63352    /// Sets the channel to shutdown if an error occurs.
63353    pub fn send(
63354        self,
63355        mut result: Result<(), fidl_fuchsia_posix::Errno>,
63356    ) -> Result<(), fidl::Error> {
63357        let _result = self.send_raw(result);
63358        if _result.is_err() {
63359            self.control_handle.shutdown();
63360        }
63361        self.drop_without_shutdown();
63362        _result
63363    }
63364
63365    /// Similar to "send" but does not shutdown the channel if an error occurs.
63366    pub fn send_no_shutdown_on_err(
63367        self,
63368        mut result: Result<(), fidl_fuchsia_posix::Errno>,
63369    ) -> Result<(), fidl::Error> {
63370        let _result = self.send_raw(result);
63371        self.drop_without_shutdown();
63372        _result
63373    }
63374
63375    fn send_raw(
63376        &self,
63377        mut result: Result<(), fidl_fuchsia_posix::Errno>,
63378    ) -> Result<(), fidl::Error> {
63379        self.control_handle.inner.send::<fidl::encoding::ResultType<
63380            fidl::encoding::EmptyStruct,
63381            fidl_fuchsia_posix::Errno,
63382        >>(
63383            result,
63384            self.tx_id,
63385            0x20c55c11f00943ea,
63386            fidl::encoding::DynamicFlags::empty(),
63387        )
63388    }
63389}
63390
63391#[must_use = "FIDL methods require a response to be sent"]
63392#[derive(Debug)]
63393pub struct StreamSocketGetIpMulticastLoopbackResponder {
63394    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
63395    tx_id: u32,
63396}
63397
63398/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
63399/// if the responder is dropped without sending a response, so that the client
63400/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
63401impl std::ops::Drop for StreamSocketGetIpMulticastLoopbackResponder {
63402    fn drop(&mut self) {
63403        self.control_handle.shutdown();
63404        // Safety: drops once, never accessed again
63405        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63406    }
63407}
63408
63409impl fidl::endpoints::Responder for StreamSocketGetIpMulticastLoopbackResponder {
63410    type ControlHandle = StreamSocketControlHandle;
63411
63412    fn control_handle(&self) -> &StreamSocketControlHandle {
63413        &self.control_handle
63414    }
63415
63416    fn drop_without_shutdown(mut self) {
63417        // Safety: drops once, never accessed again due to mem::forget
63418        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63419        // Prevent Drop from running (which would shut down the channel)
63420        std::mem::forget(self);
63421    }
63422}
63423
63424impl StreamSocketGetIpMulticastLoopbackResponder {
63425    /// Sends a response to the FIDL transaction.
63426    ///
63427    /// Sets the channel to shutdown if an error occurs.
63428    pub fn send(
63429        self,
63430        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
63431    ) -> Result<(), fidl::Error> {
63432        let _result = self.send_raw(result);
63433        if _result.is_err() {
63434            self.control_handle.shutdown();
63435        }
63436        self.drop_without_shutdown();
63437        _result
63438    }
63439
63440    /// Similar to "send" but does not shutdown the channel if an error occurs.
63441    pub fn send_no_shutdown_on_err(
63442        self,
63443        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
63444    ) -> Result<(), fidl::Error> {
63445        let _result = self.send_raw(result);
63446        self.drop_without_shutdown();
63447        _result
63448    }
63449
63450    fn send_raw(
63451        &self,
63452        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
63453    ) -> Result<(), fidl::Error> {
63454        self.control_handle.inner.send::<fidl::encoding::ResultType<
63455            BaseNetworkSocketGetIpMulticastLoopbackResponse,
63456            fidl_fuchsia_posix::Errno,
63457        >>(
63458            result.map(|value| (value,)),
63459            self.tx_id,
63460            0x3b6b26ff558298f2,
63461            fidl::encoding::DynamicFlags::empty(),
63462        )
63463    }
63464}
63465
63466#[must_use = "FIDL methods require a response to be sent"]
63467#[derive(Debug)]
63468pub struct StreamSocketAddIpMembershipResponder {
63469    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
63470    tx_id: u32,
63471}
63472
63473/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
63474/// if the responder is dropped without sending a response, so that the client
63475/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
63476impl std::ops::Drop for StreamSocketAddIpMembershipResponder {
63477    fn drop(&mut self) {
63478        self.control_handle.shutdown();
63479        // Safety: drops once, never accessed again
63480        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63481    }
63482}
63483
63484impl fidl::endpoints::Responder for StreamSocketAddIpMembershipResponder {
63485    type ControlHandle = StreamSocketControlHandle;
63486
63487    fn control_handle(&self) -> &StreamSocketControlHandle {
63488        &self.control_handle
63489    }
63490
63491    fn drop_without_shutdown(mut self) {
63492        // Safety: drops once, never accessed again due to mem::forget
63493        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63494        // Prevent Drop from running (which would shut down the channel)
63495        std::mem::forget(self);
63496    }
63497}
63498
63499impl StreamSocketAddIpMembershipResponder {
63500    /// Sends a response to the FIDL transaction.
63501    ///
63502    /// Sets the channel to shutdown if an error occurs.
63503    pub fn send(
63504        self,
63505        mut result: Result<(), fidl_fuchsia_posix::Errno>,
63506    ) -> Result<(), fidl::Error> {
63507        let _result = self.send_raw(result);
63508        if _result.is_err() {
63509            self.control_handle.shutdown();
63510        }
63511        self.drop_without_shutdown();
63512        _result
63513    }
63514
63515    /// Similar to "send" but does not shutdown the channel if an error occurs.
63516    pub fn send_no_shutdown_on_err(
63517        self,
63518        mut result: Result<(), fidl_fuchsia_posix::Errno>,
63519    ) -> Result<(), fidl::Error> {
63520        let _result = self.send_raw(result);
63521        self.drop_without_shutdown();
63522        _result
63523    }
63524
63525    fn send_raw(
63526        &self,
63527        mut result: Result<(), fidl_fuchsia_posix::Errno>,
63528    ) -> Result<(), fidl::Error> {
63529        self.control_handle.inner.send::<fidl::encoding::ResultType<
63530            fidl::encoding::EmptyStruct,
63531            fidl_fuchsia_posix::Errno,
63532        >>(
63533            result,
63534            self.tx_id,
63535            0x76bc7df115a3b4d0,
63536            fidl::encoding::DynamicFlags::empty(),
63537        )
63538    }
63539}
63540
63541#[must_use = "FIDL methods require a response to be sent"]
63542#[derive(Debug)]
63543pub struct StreamSocketDropIpMembershipResponder {
63544    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
63545    tx_id: u32,
63546}
63547
63548/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
63549/// if the responder is dropped without sending a response, so that the client
63550/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
63551impl std::ops::Drop for StreamSocketDropIpMembershipResponder {
63552    fn drop(&mut self) {
63553        self.control_handle.shutdown();
63554        // Safety: drops once, never accessed again
63555        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63556    }
63557}
63558
63559impl fidl::endpoints::Responder for StreamSocketDropIpMembershipResponder {
63560    type ControlHandle = StreamSocketControlHandle;
63561
63562    fn control_handle(&self) -> &StreamSocketControlHandle {
63563        &self.control_handle
63564    }
63565
63566    fn drop_without_shutdown(mut self) {
63567        // Safety: drops once, never accessed again due to mem::forget
63568        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63569        // Prevent Drop from running (which would shut down the channel)
63570        std::mem::forget(self);
63571    }
63572}
63573
63574impl StreamSocketDropIpMembershipResponder {
63575    /// Sends a response to the FIDL transaction.
63576    ///
63577    /// Sets the channel to shutdown if an error occurs.
63578    pub fn send(
63579        self,
63580        mut result: Result<(), fidl_fuchsia_posix::Errno>,
63581    ) -> Result<(), fidl::Error> {
63582        let _result = self.send_raw(result);
63583        if _result.is_err() {
63584            self.control_handle.shutdown();
63585        }
63586        self.drop_without_shutdown();
63587        _result
63588    }
63589
63590    /// Similar to "send" but does not shutdown the channel if an error occurs.
63591    pub fn send_no_shutdown_on_err(
63592        self,
63593        mut result: Result<(), fidl_fuchsia_posix::Errno>,
63594    ) -> Result<(), fidl::Error> {
63595        let _result = self.send_raw(result);
63596        self.drop_without_shutdown();
63597        _result
63598    }
63599
63600    fn send_raw(
63601        &self,
63602        mut result: Result<(), fidl_fuchsia_posix::Errno>,
63603    ) -> Result<(), fidl::Error> {
63604        self.control_handle.inner.send::<fidl::encoding::ResultType<
63605            fidl::encoding::EmptyStruct,
63606            fidl_fuchsia_posix::Errno,
63607        >>(
63608            result,
63609            self.tx_id,
63610            0x2888f3099188d03,
63611            fidl::encoding::DynamicFlags::empty(),
63612        )
63613    }
63614}
63615
63616#[must_use = "FIDL methods require a response to be sent"]
63617#[derive(Debug)]
63618pub struct StreamSocketSetIpTransparentResponder {
63619    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
63620    tx_id: u32,
63621}
63622
63623/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
63624/// if the responder is dropped without sending a response, so that the client
63625/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
63626impl std::ops::Drop for StreamSocketSetIpTransparentResponder {
63627    fn drop(&mut self) {
63628        self.control_handle.shutdown();
63629        // Safety: drops once, never accessed again
63630        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63631    }
63632}
63633
63634impl fidl::endpoints::Responder for StreamSocketSetIpTransparentResponder {
63635    type ControlHandle = StreamSocketControlHandle;
63636
63637    fn control_handle(&self) -> &StreamSocketControlHandle {
63638        &self.control_handle
63639    }
63640
63641    fn drop_without_shutdown(mut self) {
63642        // Safety: drops once, never accessed again due to mem::forget
63643        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63644        // Prevent Drop from running (which would shut down the channel)
63645        std::mem::forget(self);
63646    }
63647}
63648
63649impl StreamSocketSetIpTransparentResponder {
63650    /// Sends a response to the FIDL transaction.
63651    ///
63652    /// Sets the channel to shutdown if an error occurs.
63653    pub fn send(
63654        self,
63655        mut result: Result<(), fidl_fuchsia_posix::Errno>,
63656    ) -> Result<(), fidl::Error> {
63657        let _result = self.send_raw(result);
63658        if _result.is_err() {
63659            self.control_handle.shutdown();
63660        }
63661        self.drop_without_shutdown();
63662        _result
63663    }
63664
63665    /// Similar to "send" but does not shutdown the channel if an error occurs.
63666    pub fn send_no_shutdown_on_err(
63667        self,
63668        mut result: Result<(), fidl_fuchsia_posix::Errno>,
63669    ) -> Result<(), fidl::Error> {
63670        let _result = self.send_raw(result);
63671        self.drop_without_shutdown();
63672        _result
63673    }
63674
63675    fn send_raw(
63676        &self,
63677        mut result: Result<(), fidl_fuchsia_posix::Errno>,
63678    ) -> Result<(), fidl::Error> {
63679        self.control_handle.inner.send::<fidl::encoding::ResultType<
63680            fidl::encoding::EmptyStruct,
63681            fidl_fuchsia_posix::Errno,
63682        >>(
63683            result,
63684            self.tx_id,
63685            0x1ae532b0c066e3a0,
63686            fidl::encoding::DynamicFlags::empty(),
63687        )
63688    }
63689}
63690
63691#[must_use = "FIDL methods require a response to be sent"]
63692#[derive(Debug)]
63693pub struct StreamSocketGetIpTransparentResponder {
63694    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
63695    tx_id: u32,
63696}
63697
63698/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
63699/// if the responder is dropped without sending a response, so that the client
63700/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
63701impl std::ops::Drop for StreamSocketGetIpTransparentResponder {
63702    fn drop(&mut self) {
63703        self.control_handle.shutdown();
63704        // Safety: drops once, never accessed again
63705        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63706    }
63707}
63708
63709impl fidl::endpoints::Responder for StreamSocketGetIpTransparentResponder {
63710    type ControlHandle = StreamSocketControlHandle;
63711
63712    fn control_handle(&self) -> &StreamSocketControlHandle {
63713        &self.control_handle
63714    }
63715
63716    fn drop_without_shutdown(mut self) {
63717        // Safety: drops once, never accessed again due to mem::forget
63718        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63719        // Prevent Drop from running (which would shut down the channel)
63720        std::mem::forget(self);
63721    }
63722}
63723
63724impl StreamSocketGetIpTransparentResponder {
63725    /// Sends a response to the FIDL transaction.
63726    ///
63727    /// Sets the channel to shutdown if an error occurs.
63728    pub fn send(
63729        self,
63730        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
63731    ) -> Result<(), fidl::Error> {
63732        let _result = self.send_raw(result);
63733        if _result.is_err() {
63734            self.control_handle.shutdown();
63735        }
63736        self.drop_without_shutdown();
63737        _result
63738    }
63739
63740    /// Similar to "send" but does not shutdown the channel if an error occurs.
63741    pub fn send_no_shutdown_on_err(
63742        self,
63743        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
63744    ) -> Result<(), fidl::Error> {
63745        let _result = self.send_raw(result);
63746        self.drop_without_shutdown();
63747        _result
63748    }
63749
63750    fn send_raw(
63751        &self,
63752        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
63753    ) -> Result<(), fidl::Error> {
63754        self.control_handle.inner.send::<fidl::encoding::ResultType<
63755            BaseNetworkSocketGetIpTransparentResponse,
63756            fidl_fuchsia_posix::Errno,
63757        >>(
63758            result.map(|value| (value,)),
63759            self.tx_id,
63760            0x51d43695962ebfb5,
63761            fidl::encoding::DynamicFlags::empty(),
63762        )
63763    }
63764}
63765
63766#[must_use = "FIDL methods require a response to be sent"]
63767#[derive(Debug)]
63768pub struct StreamSocketSetIpReceiveOriginalDestinationAddressResponder {
63769    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
63770    tx_id: u32,
63771}
63772
63773/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
63774/// if the responder is dropped without sending a response, so that the client
63775/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
63776impl std::ops::Drop for StreamSocketSetIpReceiveOriginalDestinationAddressResponder {
63777    fn drop(&mut self) {
63778        self.control_handle.shutdown();
63779        // Safety: drops once, never accessed again
63780        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63781    }
63782}
63783
63784impl fidl::endpoints::Responder for StreamSocketSetIpReceiveOriginalDestinationAddressResponder {
63785    type ControlHandle = StreamSocketControlHandle;
63786
63787    fn control_handle(&self) -> &StreamSocketControlHandle {
63788        &self.control_handle
63789    }
63790
63791    fn drop_without_shutdown(mut self) {
63792        // Safety: drops once, never accessed again due to mem::forget
63793        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63794        // Prevent Drop from running (which would shut down the channel)
63795        std::mem::forget(self);
63796    }
63797}
63798
63799impl StreamSocketSetIpReceiveOriginalDestinationAddressResponder {
63800    /// Sends a response to the FIDL transaction.
63801    ///
63802    /// Sets the channel to shutdown if an error occurs.
63803    pub fn send(
63804        self,
63805        mut result: Result<(), fidl_fuchsia_posix::Errno>,
63806    ) -> Result<(), fidl::Error> {
63807        let _result = self.send_raw(result);
63808        if _result.is_err() {
63809            self.control_handle.shutdown();
63810        }
63811        self.drop_without_shutdown();
63812        _result
63813    }
63814
63815    /// Similar to "send" but does not shutdown the channel if an error occurs.
63816    pub fn send_no_shutdown_on_err(
63817        self,
63818        mut result: Result<(), fidl_fuchsia_posix::Errno>,
63819    ) -> Result<(), fidl::Error> {
63820        let _result = self.send_raw(result);
63821        self.drop_without_shutdown();
63822        _result
63823    }
63824
63825    fn send_raw(
63826        &self,
63827        mut result: Result<(), fidl_fuchsia_posix::Errno>,
63828    ) -> Result<(), fidl::Error> {
63829        self.control_handle.inner.send::<fidl::encoding::ResultType<
63830            fidl::encoding::EmptyStruct,
63831            fidl_fuchsia_posix::Errno,
63832        >>(
63833            result,
63834            self.tx_id,
63835            0x4722b4ce52f7840,
63836            fidl::encoding::DynamicFlags::empty(),
63837        )
63838    }
63839}
63840
63841#[must_use = "FIDL methods require a response to be sent"]
63842#[derive(Debug)]
63843pub struct StreamSocketGetIpReceiveOriginalDestinationAddressResponder {
63844    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
63845    tx_id: u32,
63846}
63847
63848/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
63849/// if the responder is dropped without sending a response, so that the client
63850/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
63851impl std::ops::Drop for StreamSocketGetIpReceiveOriginalDestinationAddressResponder {
63852    fn drop(&mut self) {
63853        self.control_handle.shutdown();
63854        // Safety: drops once, never accessed again
63855        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63856    }
63857}
63858
63859impl fidl::endpoints::Responder for StreamSocketGetIpReceiveOriginalDestinationAddressResponder {
63860    type ControlHandle = StreamSocketControlHandle;
63861
63862    fn control_handle(&self) -> &StreamSocketControlHandle {
63863        &self.control_handle
63864    }
63865
63866    fn drop_without_shutdown(mut self) {
63867        // Safety: drops once, never accessed again due to mem::forget
63868        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63869        // Prevent Drop from running (which would shut down the channel)
63870        std::mem::forget(self);
63871    }
63872}
63873
63874impl StreamSocketGetIpReceiveOriginalDestinationAddressResponder {
63875    /// Sends a response to the FIDL transaction.
63876    ///
63877    /// Sets the channel to shutdown if an error occurs.
63878    pub fn send(
63879        self,
63880        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
63881    ) -> Result<(), fidl::Error> {
63882        let _result = self.send_raw(result);
63883        if _result.is_err() {
63884            self.control_handle.shutdown();
63885        }
63886        self.drop_without_shutdown();
63887        _result
63888    }
63889
63890    /// Similar to "send" but does not shutdown the channel if an error occurs.
63891    pub fn send_no_shutdown_on_err(
63892        self,
63893        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
63894    ) -> Result<(), fidl::Error> {
63895        let _result = self.send_raw(result);
63896        self.drop_without_shutdown();
63897        _result
63898    }
63899
63900    fn send_raw(
63901        &self,
63902        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
63903    ) -> Result<(), fidl::Error> {
63904        self.control_handle.inner.send::<fidl::encoding::ResultType<
63905            BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
63906            fidl_fuchsia_posix::Errno,
63907        >>(
63908            result.map(|value| (value,)),
63909            self.tx_id,
63910            0x2a0e7dc5d6bfdfe9,
63911            fidl::encoding::DynamicFlags::empty(),
63912        )
63913    }
63914}
63915
63916#[must_use = "FIDL methods require a response to be sent"]
63917#[derive(Debug)]
63918pub struct StreamSocketAddIpv6MembershipResponder {
63919    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
63920    tx_id: u32,
63921}
63922
63923/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
63924/// if the responder is dropped without sending a response, so that the client
63925/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
63926impl std::ops::Drop for StreamSocketAddIpv6MembershipResponder {
63927    fn drop(&mut self) {
63928        self.control_handle.shutdown();
63929        // Safety: drops once, never accessed again
63930        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63931    }
63932}
63933
63934impl fidl::endpoints::Responder for StreamSocketAddIpv6MembershipResponder {
63935    type ControlHandle = StreamSocketControlHandle;
63936
63937    fn control_handle(&self) -> &StreamSocketControlHandle {
63938        &self.control_handle
63939    }
63940
63941    fn drop_without_shutdown(mut self) {
63942        // Safety: drops once, never accessed again due to mem::forget
63943        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
63944        // Prevent Drop from running (which would shut down the channel)
63945        std::mem::forget(self);
63946    }
63947}
63948
63949impl StreamSocketAddIpv6MembershipResponder {
63950    /// Sends a response to the FIDL transaction.
63951    ///
63952    /// Sets the channel to shutdown if an error occurs.
63953    pub fn send(
63954        self,
63955        mut result: Result<(), fidl_fuchsia_posix::Errno>,
63956    ) -> Result<(), fidl::Error> {
63957        let _result = self.send_raw(result);
63958        if _result.is_err() {
63959            self.control_handle.shutdown();
63960        }
63961        self.drop_without_shutdown();
63962        _result
63963    }
63964
63965    /// Similar to "send" but does not shutdown the channel if an error occurs.
63966    pub fn send_no_shutdown_on_err(
63967        self,
63968        mut result: Result<(), fidl_fuchsia_posix::Errno>,
63969    ) -> Result<(), fidl::Error> {
63970        let _result = self.send_raw(result);
63971        self.drop_without_shutdown();
63972        _result
63973    }
63974
63975    fn send_raw(
63976        &self,
63977        mut result: Result<(), fidl_fuchsia_posix::Errno>,
63978    ) -> Result<(), fidl::Error> {
63979        self.control_handle.inner.send::<fidl::encoding::ResultType<
63980            fidl::encoding::EmptyStruct,
63981            fidl_fuchsia_posix::Errno,
63982        >>(
63983            result,
63984            self.tx_id,
63985            0x7c94727acb4ea4b3,
63986            fidl::encoding::DynamicFlags::empty(),
63987        )
63988    }
63989}
63990
63991#[must_use = "FIDL methods require a response to be sent"]
63992#[derive(Debug)]
63993pub struct StreamSocketDropIpv6MembershipResponder {
63994    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
63995    tx_id: u32,
63996}
63997
63998/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
63999/// if the responder is dropped without sending a response, so that the client
64000/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
64001impl std::ops::Drop for StreamSocketDropIpv6MembershipResponder {
64002    fn drop(&mut self) {
64003        self.control_handle.shutdown();
64004        // Safety: drops once, never accessed again
64005        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64006    }
64007}
64008
64009impl fidl::endpoints::Responder for StreamSocketDropIpv6MembershipResponder {
64010    type ControlHandle = StreamSocketControlHandle;
64011
64012    fn control_handle(&self) -> &StreamSocketControlHandle {
64013        &self.control_handle
64014    }
64015
64016    fn drop_without_shutdown(mut self) {
64017        // Safety: drops once, never accessed again due to mem::forget
64018        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64019        // Prevent Drop from running (which would shut down the channel)
64020        std::mem::forget(self);
64021    }
64022}
64023
64024impl StreamSocketDropIpv6MembershipResponder {
64025    /// Sends a response to the FIDL transaction.
64026    ///
64027    /// Sets the channel to shutdown if an error occurs.
64028    pub fn send(
64029        self,
64030        mut result: Result<(), fidl_fuchsia_posix::Errno>,
64031    ) -> Result<(), fidl::Error> {
64032        let _result = self.send_raw(result);
64033        if _result.is_err() {
64034            self.control_handle.shutdown();
64035        }
64036        self.drop_without_shutdown();
64037        _result
64038    }
64039
64040    /// Similar to "send" but does not shutdown the channel if an error occurs.
64041    pub fn send_no_shutdown_on_err(
64042        self,
64043        mut result: Result<(), fidl_fuchsia_posix::Errno>,
64044    ) -> Result<(), fidl::Error> {
64045        let _result = self.send_raw(result);
64046        self.drop_without_shutdown();
64047        _result
64048    }
64049
64050    fn send_raw(
64051        &self,
64052        mut result: Result<(), fidl_fuchsia_posix::Errno>,
64053    ) -> Result<(), fidl::Error> {
64054        self.control_handle.inner.send::<fidl::encoding::ResultType<
64055            fidl::encoding::EmptyStruct,
64056            fidl_fuchsia_posix::Errno,
64057        >>(
64058            result,
64059            self.tx_id,
64060            0x42104c70ccaba304,
64061            fidl::encoding::DynamicFlags::empty(),
64062        )
64063    }
64064}
64065
64066#[must_use = "FIDL methods require a response to be sent"]
64067#[derive(Debug)]
64068pub struct StreamSocketSetIpv6MulticastInterfaceResponder {
64069    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
64070    tx_id: u32,
64071}
64072
64073/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
64074/// if the responder is dropped without sending a response, so that the client
64075/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
64076impl std::ops::Drop for StreamSocketSetIpv6MulticastInterfaceResponder {
64077    fn drop(&mut self) {
64078        self.control_handle.shutdown();
64079        // Safety: drops once, never accessed again
64080        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64081    }
64082}
64083
64084impl fidl::endpoints::Responder for StreamSocketSetIpv6MulticastInterfaceResponder {
64085    type ControlHandle = StreamSocketControlHandle;
64086
64087    fn control_handle(&self) -> &StreamSocketControlHandle {
64088        &self.control_handle
64089    }
64090
64091    fn drop_without_shutdown(mut self) {
64092        // Safety: drops once, never accessed again due to mem::forget
64093        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64094        // Prevent Drop from running (which would shut down the channel)
64095        std::mem::forget(self);
64096    }
64097}
64098
64099impl StreamSocketSetIpv6MulticastInterfaceResponder {
64100    /// Sends a response to the FIDL transaction.
64101    ///
64102    /// Sets the channel to shutdown if an error occurs.
64103    pub fn send(
64104        self,
64105        mut result: Result<(), fidl_fuchsia_posix::Errno>,
64106    ) -> Result<(), fidl::Error> {
64107        let _result = self.send_raw(result);
64108        if _result.is_err() {
64109            self.control_handle.shutdown();
64110        }
64111        self.drop_without_shutdown();
64112        _result
64113    }
64114
64115    /// Similar to "send" but does not shutdown the channel if an error occurs.
64116    pub fn send_no_shutdown_on_err(
64117        self,
64118        mut result: Result<(), fidl_fuchsia_posix::Errno>,
64119    ) -> Result<(), fidl::Error> {
64120        let _result = self.send_raw(result);
64121        self.drop_without_shutdown();
64122        _result
64123    }
64124
64125    fn send_raw(
64126        &self,
64127        mut result: Result<(), fidl_fuchsia_posix::Errno>,
64128    ) -> Result<(), fidl::Error> {
64129        self.control_handle.inner.send::<fidl::encoding::ResultType<
64130            fidl::encoding::EmptyStruct,
64131            fidl_fuchsia_posix::Errno,
64132        >>(
64133            result,
64134            self.tx_id,
64135            0x135f76db3774ab3b,
64136            fidl::encoding::DynamicFlags::empty(),
64137        )
64138    }
64139}
64140
64141#[must_use = "FIDL methods require a response to be sent"]
64142#[derive(Debug)]
64143pub struct StreamSocketGetIpv6MulticastInterfaceResponder {
64144    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
64145    tx_id: u32,
64146}
64147
64148/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
64149/// if the responder is dropped without sending a response, so that the client
64150/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
64151impl std::ops::Drop for StreamSocketGetIpv6MulticastInterfaceResponder {
64152    fn drop(&mut self) {
64153        self.control_handle.shutdown();
64154        // Safety: drops once, never accessed again
64155        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64156    }
64157}
64158
64159impl fidl::endpoints::Responder for StreamSocketGetIpv6MulticastInterfaceResponder {
64160    type ControlHandle = StreamSocketControlHandle;
64161
64162    fn control_handle(&self) -> &StreamSocketControlHandle {
64163        &self.control_handle
64164    }
64165
64166    fn drop_without_shutdown(mut self) {
64167        // Safety: drops once, never accessed again due to mem::forget
64168        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64169        // Prevent Drop from running (which would shut down the channel)
64170        std::mem::forget(self);
64171    }
64172}
64173
64174impl StreamSocketGetIpv6MulticastInterfaceResponder {
64175    /// Sends a response to the FIDL transaction.
64176    ///
64177    /// Sets the channel to shutdown if an error occurs.
64178    pub fn send(
64179        self,
64180        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
64181    ) -> Result<(), fidl::Error> {
64182        let _result = self.send_raw(result);
64183        if _result.is_err() {
64184            self.control_handle.shutdown();
64185        }
64186        self.drop_without_shutdown();
64187        _result
64188    }
64189
64190    /// Similar to "send" but does not shutdown the channel if an error occurs.
64191    pub fn send_no_shutdown_on_err(
64192        self,
64193        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
64194    ) -> Result<(), fidl::Error> {
64195        let _result = self.send_raw(result);
64196        self.drop_without_shutdown();
64197        _result
64198    }
64199
64200    fn send_raw(
64201        &self,
64202        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
64203    ) -> Result<(), fidl::Error> {
64204        self.control_handle.inner.send::<fidl::encoding::ResultType<
64205            BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
64206            fidl_fuchsia_posix::Errno,
64207        >>(
64208            result.map(|value| (value,)),
64209            self.tx_id,
64210            0x1f26fcdd348f1882,
64211            fidl::encoding::DynamicFlags::empty(),
64212        )
64213    }
64214}
64215
64216#[must_use = "FIDL methods require a response to be sent"]
64217#[derive(Debug)]
64218pub struct StreamSocketSetIpv6UnicastHopsResponder {
64219    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
64220    tx_id: u32,
64221}
64222
64223/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
64224/// if the responder is dropped without sending a response, so that the client
64225/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
64226impl std::ops::Drop for StreamSocketSetIpv6UnicastHopsResponder {
64227    fn drop(&mut self) {
64228        self.control_handle.shutdown();
64229        // Safety: drops once, never accessed again
64230        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64231    }
64232}
64233
64234impl fidl::endpoints::Responder for StreamSocketSetIpv6UnicastHopsResponder {
64235    type ControlHandle = StreamSocketControlHandle;
64236
64237    fn control_handle(&self) -> &StreamSocketControlHandle {
64238        &self.control_handle
64239    }
64240
64241    fn drop_without_shutdown(mut self) {
64242        // Safety: drops once, never accessed again due to mem::forget
64243        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64244        // Prevent Drop from running (which would shut down the channel)
64245        std::mem::forget(self);
64246    }
64247}
64248
64249impl StreamSocketSetIpv6UnicastHopsResponder {
64250    /// Sends a response to the FIDL transaction.
64251    ///
64252    /// Sets the channel to shutdown if an error occurs.
64253    pub fn send(
64254        self,
64255        mut result: Result<(), fidl_fuchsia_posix::Errno>,
64256    ) -> Result<(), fidl::Error> {
64257        let _result = self.send_raw(result);
64258        if _result.is_err() {
64259            self.control_handle.shutdown();
64260        }
64261        self.drop_without_shutdown();
64262        _result
64263    }
64264
64265    /// Similar to "send" but does not shutdown the channel if an error occurs.
64266    pub fn send_no_shutdown_on_err(
64267        self,
64268        mut result: Result<(), fidl_fuchsia_posix::Errno>,
64269    ) -> Result<(), fidl::Error> {
64270        let _result = self.send_raw(result);
64271        self.drop_without_shutdown();
64272        _result
64273    }
64274
64275    fn send_raw(
64276        &self,
64277        mut result: Result<(), fidl_fuchsia_posix::Errno>,
64278    ) -> Result<(), fidl::Error> {
64279        self.control_handle.inner.send::<fidl::encoding::ResultType<
64280            fidl::encoding::EmptyStruct,
64281            fidl_fuchsia_posix::Errno,
64282        >>(
64283            result,
64284            self.tx_id,
64285            0x157d51e98f462859,
64286            fidl::encoding::DynamicFlags::empty(),
64287        )
64288    }
64289}
64290
64291#[must_use = "FIDL methods require a response to be sent"]
64292#[derive(Debug)]
64293pub struct StreamSocketGetIpv6UnicastHopsResponder {
64294    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
64295    tx_id: u32,
64296}
64297
64298/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
64299/// if the responder is dropped without sending a response, so that the client
64300/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
64301impl std::ops::Drop for StreamSocketGetIpv6UnicastHopsResponder {
64302    fn drop(&mut self) {
64303        self.control_handle.shutdown();
64304        // Safety: drops once, never accessed again
64305        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64306    }
64307}
64308
64309impl fidl::endpoints::Responder for StreamSocketGetIpv6UnicastHopsResponder {
64310    type ControlHandle = StreamSocketControlHandle;
64311
64312    fn control_handle(&self) -> &StreamSocketControlHandle {
64313        &self.control_handle
64314    }
64315
64316    fn drop_without_shutdown(mut self) {
64317        // Safety: drops once, never accessed again due to mem::forget
64318        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64319        // Prevent Drop from running (which would shut down the channel)
64320        std::mem::forget(self);
64321    }
64322}
64323
64324impl StreamSocketGetIpv6UnicastHopsResponder {
64325    /// Sends a response to the FIDL transaction.
64326    ///
64327    /// Sets the channel to shutdown if an error occurs.
64328    pub fn send(
64329        self,
64330        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
64331    ) -> Result<(), fidl::Error> {
64332        let _result = self.send_raw(result);
64333        if _result.is_err() {
64334            self.control_handle.shutdown();
64335        }
64336        self.drop_without_shutdown();
64337        _result
64338    }
64339
64340    /// Similar to "send" but does not shutdown the channel if an error occurs.
64341    pub fn send_no_shutdown_on_err(
64342        self,
64343        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
64344    ) -> Result<(), fidl::Error> {
64345        let _result = self.send_raw(result);
64346        self.drop_without_shutdown();
64347        _result
64348    }
64349
64350    fn send_raw(
64351        &self,
64352        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
64353    ) -> Result<(), fidl::Error> {
64354        self.control_handle.inner.send::<fidl::encoding::ResultType<
64355            BaseNetworkSocketGetIpv6UnicastHopsResponse,
64356            fidl_fuchsia_posix::Errno,
64357        >>(
64358            result.map(|value| (value,)),
64359            self.tx_id,
64360            0x21f4641cad8bd8d2,
64361            fidl::encoding::DynamicFlags::empty(),
64362        )
64363    }
64364}
64365
64366#[must_use = "FIDL methods require a response to be sent"]
64367#[derive(Debug)]
64368pub struct StreamSocketSetIpv6ReceiveHopLimitResponder {
64369    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
64370    tx_id: u32,
64371}
64372
64373/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
64374/// if the responder is dropped without sending a response, so that the client
64375/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
64376impl std::ops::Drop for StreamSocketSetIpv6ReceiveHopLimitResponder {
64377    fn drop(&mut self) {
64378        self.control_handle.shutdown();
64379        // Safety: drops once, never accessed again
64380        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64381    }
64382}
64383
64384impl fidl::endpoints::Responder for StreamSocketSetIpv6ReceiveHopLimitResponder {
64385    type ControlHandle = StreamSocketControlHandle;
64386
64387    fn control_handle(&self) -> &StreamSocketControlHandle {
64388        &self.control_handle
64389    }
64390
64391    fn drop_without_shutdown(mut self) {
64392        // Safety: drops once, never accessed again due to mem::forget
64393        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64394        // Prevent Drop from running (which would shut down the channel)
64395        std::mem::forget(self);
64396    }
64397}
64398
64399impl StreamSocketSetIpv6ReceiveHopLimitResponder {
64400    /// Sends a response to the FIDL transaction.
64401    ///
64402    /// Sets the channel to shutdown if an error occurs.
64403    pub fn send(
64404        self,
64405        mut result: Result<(), fidl_fuchsia_posix::Errno>,
64406    ) -> Result<(), fidl::Error> {
64407        let _result = self.send_raw(result);
64408        if _result.is_err() {
64409            self.control_handle.shutdown();
64410        }
64411        self.drop_without_shutdown();
64412        _result
64413    }
64414
64415    /// Similar to "send" but does not shutdown the channel if an error occurs.
64416    pub fn send_no_shutdown_on_err(
64417        self,
64418        mut result: Result<(), fidl_fuchsia_posix::Errno>,
64419    ) -> Result<(), fidl::Error> {
64420        let _result = self.send_raw(result);
64421        self.drop_without_shutdown();
64422        _result
64423    }
64424
64425    fn send_raw(
64426        &self,
64427        mut result: Result<(), fidl_fuchsia_posix::Errno>,
64428    ) -> Result<(), fidl::Error> {
64429        self.control_handle.inner.send::<fidl::encoding::ResultType<
64430            fidl::encoding::EmptyStruct,
64431            fidl_fuchsia_posix::Errno,
64432        >>(
64433            result,
64434            self.tx_id,
64435            0x5c24808ed2e84a1e,
64436            fidl::encoding::DynamicFlags::empty(),
64437        )
64438    }
64439}
64440
64441#[must_use = "FIDL methods require a response to be sent"]
64442#[derive(Debug)]
64443pub struct StreamSocketGetIpv6ReceiveHopLimitResponder {
64444    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
64445    tx_id: u32,
64446}
64447
64448/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
64449/// if the responder is dropped without sending a response, so that the client
64450/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
64451impl std::ops::Drop for StreamSocketGetIpv6ReceiveHopLimitResponder {
64452    fn drop(&mut self) {
64453        self.control_handle.shutdown();
64454        // Safety: drops once, never accessed again
64455        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64456    }
64457}
64458
64459impl fidl::endpoints::Responder for StreamSocketGetIpv6ReceiveHopLimitResponder {
64460    type ControlHandle = StreamSocketControlHandle;
64461
64462    fn control_handle(&self) -> &StreamSocketControlHandle {
64463        &self.control_handle
64464    }
64465
64466    fn drop_without_shutdown(mut self) {
64467        // Safety: drops once, never accessed again due to mem::forget
64468        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64469        // Prevent Drop from running (which would shut down the channel)
64470        std::mem::forget(self);
64471    }
64472}
64473
64474impl StreamSocketGetIpv6ReceiveHopLimitResponder {
64475    /// Sends a response to the FIDL transaction.
64476    ///
64477    /// Sets the channel to shutdown if an error occurs.
64478    pub fn send(
64479        self,
64480        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
64481    ) -> Result<(), fidl::Error> {
64482        let _result = self.send_raw(result);
64483        if _result.is_err() {
64484            self.control_handle.shutdown();
64485        }
64486        self.drop_without_shutdown();
64487        _result
64488    }
64489
64490    /// Similar to "send" but does not shutdown the channel if an error occurs.
64491    pub fn send_no_shutdown_on_err(
64492        self,
64493        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
64494    ) -> Result<(), fidl::Error> {
64495        let _result = self.send_raw(result);
64496        self.drop_without_shutdown();
64497        _result
64498    }
64499
64500    fn send_raw(
64501        &self,
64502        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
64503    ) -> Result<(), fidl::Error> {
64504        self.control_handle.inner.send::<fidl::encoding::ResultType<
64505            BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
64506            fidl_fuchsia_posix::Errno,
64507        >>(
64508            result.map(|value| (value,)),
64509            self.tx_id,
64510            0x341e06689885b4c0,
64511            fidl::encoding::DynamicFlags::empty(),
64512        )
64513    }
64514}
64515
64516#[must_use = "FIDL methods require a response to be sent"]
64517#[derive(Debug)]
64518pub struct StreamSocketSetIpv6MulticastHopsResponder {
64519    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
64520    tx_id: u32,
64521}
64522
64523/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
64524/// if the responder is dropped without sending a response, so that the client
64525/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
64526impl std::ops::Drop for StreamSocketSetIpv6MulticastHopsResponder {
64527    fn drop(&mut self) {
64528        self.control_handle.shutdown();
64529        // Safety: drops once, never accessed again
64530        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64531    }
64532}
64533
64534impl fidl::endpoints::Responder for StreamSocketSetIpv6MulticastHopsResponder {
64535    type ControlHandle = StreamSocketControlHandle;
64536
64537    fn control_handle(&self) -> &StreamSocketControlHandle {
64538        &self.control_handle
64539    }
64540
64541    fn drop_without_shutdown(mut self) {
64542        // Safety: drops once, never accessed again due to mem::forget
64543        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64544        // Prevent Drop from running (which would shut down the channel)
64545        std::mem::forget(self);
64546    }
64547}
64548
64549impl StreamSocketSetIpv6MulticastHopsResponder {
64550    /// Sends a response to the FIDL transaction.
64551    ///
64552    /// Sets the channel to shutdown if an error occurs.
64553    pub fn send(
64554        self,
64555        mut result: Result<(), fidl_fuchsia_posix::Errno>,
64556    ) -> Result<(), fidl::Error> {
64557        let _result = self.send_raw(result);
64558        if _result.is_err() {
64559            self.control_handle.shutdown();
64560        }
64561        self.drop_without_shutdown();
64562        _result
64563    }
64564
64565    /// Similar to "send" but does not shutdown the channel if an error occurs.
64566    pub fn send_no_shutdown_on_err(
64567        self,
64568        mut result: Result<(), fidl_fuchsia_posix::Errno>,
64569    ) -> Result<(), fidl::Error> {
64570        let _result = self.send_raw(result);
64571        self.drop_without_shutdown();
64572        _result
64573    }
64574
64575    fn send_raw(
64576        &self,
64577        mut result: Result<(), fidl_fuchsia_posix::Errno>,
64578    ) -> Result<(), fidl::Error> {
64579        self.control_handle.inner.send::<fidl::encoding::ResultType<
64580            fidl::encoding::EmptyStruct,
64581            fidl_fuchsia_posix::Errno,
64582        >>(
64583            result,
64584            self.tx_id,
64585            0x25b9cd4d181f82c1,
64586            fidl::encoding::DynamicFlags::empty(),
64587        )
64588    }
64589}
64590
64591#[must_use = "FIDL methods require a response to be sent"]
64592#[derive(Debug)]
64593pub struct StreamSocketGetIpv6MulticastHopsResponder {
64594    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
64595    tx_id: u32,
64596}
64597
64598/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
64599/// if the responder is dropped without sending a response, so that the client
64600/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
64601impl std::ops::Drop for StreamSocketGetIpv6MulticastHopsResponder {
64602    fn drop(&mut self) {
64603        self.control_handle.shutdown();
64604        // Safety: drops once, never accessed again
64605        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64606    }
64607}
64608
64609impl fidl::endpoints::Responder for StreamSocketGetIpv6MulticastHopsResponder {
64610    type ControlHandle = StreamSocketControlHandle;
64611
64612    fn control_handle(&self) -> &StreamSocketControlHandle {
64613        &self.control_handle
64614    }
64615
64616    fn drop_without_shutdown(mut self) {
64617        // Safety: drops once, never accessed again due to mem::forget
64618        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64619        // Prevent Drop from running (which would shut down the channel)
64620        std::mem::forget(self);
64621    }
64622}
64623
64624impl StreamSocketGetIpv6MulticastHopsResponder {
64625    /// Sends a response to the FIDL transaction.
64626    ///
64627    /// Sets the channel to shutdown if an error occurs.
64628    pub fn send(
64629        self,
64630        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
64631    ) -> Result<(), fidl::Error> {
64632        let _result = self.send_raw(result);
64633        if _result.is_err() {
64634            self.control_handle.shutdown();
64635        }
64636        self.drop_without_shutdown();
64637        _result
64638    }
64639
64640    /// Similar to "send" but does not shutdown the channel if an error occurs.
64641    pub fn send_no_shutdown_on_err(
64642        self,
64643        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
64644    ) -> Result<(), fidl::Error> {
64645        let _result = self.send_raw(result);
64646        self.drop_without_shutdown();
64647        _result
64648    }
64649
64650    fn send_raw(
64651        &self,
64652        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
64653    ) -> Result<(), fidl::Error> {
64654        self.control_handle.inner.send::<fidl::encoding::ResultType<
64655            BaseNetworkSocketGetIpv6MulticastHopsResponse,
64656            fidl_fuchsia_posix::Errno,
64657        >>(
64658            result.map(|value| (value,)),
64659            self.tx_id,
64660            0x52916948a365012a,
64661            fidl::encoding::DynamicFlags::empty(),
64662        )
64663    }
64664}
64665
64666#[must_use = "FIDL methods require a response to be sent"]
64667#[derive(Debug)]
64668pub struct StreamSocketSetIpv6MulticastLoopbackResponder {
64669    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
64670    tx_id: u32,
64671}
64672
64673/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
64674/// if the responder is dropped without sending a response, so that the client
64675/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
64676impl std::ops::Drop for StreamSocketSetIpv6MulticastLoopbackResponder {
64677    fn drop(&mut self) {
64678        self.control_handle.shutdown();
64679        // Safety: drops once, never accessed again
64680        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64681    }
64682}
64683
64684impl fidl::endpoints::Responder for StreamSocketSetIpv6MulticastLoopbackResponder {
64685    type ControlHandle = StreamSocketControlHandle;
64686
64687    fn control_handle(&self) -> &StreamSocketControlHandle {
64688        &self.control_handle
64689    }
64690
64691    fn drop_without_shutdown(mut self) {
64692        // Safety: drops once, never accessed again due to mem::forget
64693        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64694        // Prevent Drop from running (which would shut down the channel)
64695        std::mem::forget(self);
64696    }
64697}
64698
64699impl StreamSocketSetIpv6MulticastLoopbackResponder {
64700    /// Sends a response to the FIDL transaction.
64701    ///
64702    /// Sets the channel to shutdown if an error occurs.
64703    pub fn send(
64704        self,
64705        mut result: Result<(), fidl_fuchsia_posix::Errno>,
64706    ) -> Result<(), fidl::Error> {
64707        let _result = self.send_raw(result);
64708        if _result.is_err() {
64709            self.control_handle.shutdown();
64710        }
64711        self.drop_without_shutdown();
64712        _result
64713    }
64714
64715    /// Similar to "send" but does not shutdown the channel if an error occurs.
64716    pub fn send_no_shutdown_on_err(
64717        self,
64718        mut result: Result<(), fidl_fuchsia_posix::Errno>,
64719    ) -> Result<(), fidl::Error> {
64720        let _result = self.send_raw(result);
64721        self.drop_without_shutdown();
64722        _result
64723    }
64724
64725    fn send_raw(
64726        &self,
64727        mut result: Result<(), fidl_fuchsia_posix::Errno>,
64728    ) -> Result<(), fidl::Error> {
64729        self.control_handle.inner.send::<fidl::encoding::ResultType<
64730            fidl::encoding::EmptyStruct,
64731            fidl_fuchsia_posix::Errno,
64732        >>(
64733            result,
64734            self.tx_id,
64735            0x55701c409ff41b40,
64736            fidl::encoding::DynamicFlags::empty(),
64737        )
64738    }
64739}
64740
64741#[must_use = "FIDL methods require a response to be sent"]
64742#[derive(Debug)]
64743pub struct StreamSocketGetIpv6MulticastLoopbackResponder {
64744    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
64745    tx_id: u32,
64746}
64747
64748/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
64749/// if the responder is dropped without sending a response, so that the client
64750/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
64751impl std::ops::Drop for StreamSocketGetIpv6MulticastLoopbackResponder {
64752    fn drop(&mut self) {
64753        self.control_handle.shutdown();
64754        // Safety: drops once, never accessed again
64755        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64756    }
64757}
64758
64759impl fidl::endpoints::Responder for StreamSocketGetIpv6MulticastLoopbackResponder {
64760    type ControlHandle = StreamSocketControlHandle;
64761
64762    fn control_handle(&self) -> &StreamSocketControlHandle {
64763        &self.control_handle
64764    }
64765
64766    fn drop_without_shutdown(mut self) {
64767        // Safety: drops once, never accessed again due to mem::forget
64768        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64769        // Prevent Drop from running (which would shut down the channel)
64770        std::mem::forget(self);
64771    }
64772}
64773
64774impl StreamSocketGetIpv6MulticastLoopbackResponder {
64775    /// Sends a response to the FIDL transaction.
64776    ///
64777    /// Sets the channel to shutdown if an error occurs.
64778    pub fn send(
64779        self,
64780        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
64781    ) -> Result<(), fidl::Error> {
64782        let _result = self.send_raw(result);
64783        if _result.is_err() {
64784            self.control_handle.shutdown();
64785        }
64786        self.drop_without_shutdown();
64787        _result
64788    }
64789
64790    /// Similar to "send" but does not shutdown the channel if an error occurs.
64791    pub fn send_no_shutdown_on_err(
64792        self,
64793        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
64794    ) -> Result<(), fidl::Error> {
64795        let _result = self.send_raw(result);
64796        self.drop_without_shutdown();
64797        _result
64798    }
64799
64800    fn send_raw(
64801        &self,
64802        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
64803    ) -> Result<(), fidl::Error> {
64804        self.control_handle.inner.send::<fidl::encoding::ResultType<
64805            BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
64806            fidl_fuchsia_posix::Errno,
64807        >>(
64808            result.map(|value| (value,)),
64809            self.tx_id,
64810            0x4415b701fde319c3,
64811            fidl::encoding::DynamicFlags::empty(),
64812        )
64813    }
64814}
64815
64816#[must_use = "FIDL methods require a response to be sent"]
64817#[derive(Debug)]
64818pub struct StreamSocketSetIpv6OnlyResponder {
64819    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
64820    tx_id: u32,
64821}
64822
64823/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
64824/// if the responder is dropped without sending a response, so that the client
64825/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
64826impl std::ops::Drop for StreamSocketSetIpv6OnlyResponder {
64827    fn drop(&mut self) {
64828        self.control_handle.shutdown();
64829        // Safety: drops once, never accessed again
64830        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64831    }
64832}
64833
64834impl fidl::endpoints::Responder for StreamSocketSetIpv6OnlyResponder {
64835    type ControlHandle = StreamSocketControlHandle;
64836
64837    fn control_handle(&self) -> &StreamSocketControlHandle {
64838        &self.control_handle
64839    }
64840
64841    fn drop_without_shutdown(mut self) {
64842        // Safety: drops once, never accessed again due to mem::forget
64843        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64844        // Prevent Drop from running (which would shut down the channel)
64845        std::mem::forget(self);
64846    }
64847}
64848
64849impl StreamSocketSetIpv6OnlyResponder {
64850    /// Sends a response to the FIDL transaction.
64851    ///
64852    /// Sets the channel to shutdown if an error occurs.
64853    pub fn send(
64854        self,
64855        mut result: Result<(), fidl_fuchsia_posix::Errno>,
64856    ) -> Result<(), fidl::Error> {
64857        let _result = self.send_raw(result);
64858        if _result.is_err() {
64859            self.control_handle.shutdown();
64860        }
64861        self.drop_without_shutdown();
64862        _result
64863    }
64864
64865    /// Similar to "send" but does not shutdown the channel if an error occurs.
64866    pub fn send_no_shutdown_on_err(
64867        self,
64868        mut result: Result<(), fidl_fuchsia_posix::Errno>,
64869    ) -> Result<(), fidl::Error> {
64870        let _result = self.send_raw(result);
64871        self.drop_without_shutdown();
64872        _result
64873    }
64874
64875    fn send_raw(
64876        &self,
64877        mut result: Result<(), fidl_fuchsia_posix::Errno>,
64878    ) -> Result<(), fidl::Error> {
64879        self.control_handle.inner.send::<fidl::encoding::ResultType<
64880            fidl::encoding::EmptyStruct,
64881            fidl_fuchsia_posix::Errno,
64882        >>(
64883            result,
64884            self.tx_id,
64885            0x4873f1364758cbba,
64886            fidl::encoding::DynamicFlags::empty(),
64887        )
64888    }
64889}
64890
64891#[must_use = "FIDL methods require a response to be sent"]
64892#[derive(Debug)]
64893pub struct StreamSocketGetIpv6OnlyResponder {
64894    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
64895    tx_id: u32,
64896}
64897
64898/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
64899/// if the responder is dropped without sending a response, so that the client
64900/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
64901impl std::ops::Drop for StreamSocketGetIpv6OnlyResponder {
64902    fn drop(&mut self) {
64903        self.control_handle.shutdown();
64904        // Safety: drops once, never accessed again
64905        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64906    }
64907}
64908
64909impl fidl::endpoints::Responder for StreamSocketGetIpv6OnlyResponder {
64910    type ControlHandle = StreamSocketControlHandle;
64911
64912    fn control_handle(&self) -> &StreamSocketControlHandle {
64913        &self.control_handle
64914    }
64915
64916    fn drop_without_shutdown(mut self) {
64917        // Safety: drops once, never accessed again due to mem::forget
64918        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64919        // Prevent Drop from running (which would shut down the channel)
64920        std::mem::forget(self);
64921    }
64922}
64923
64924impl StreamSocketGetIpv6OnlyResponder {
64925    /// Sends a response to the FIDL transaction.
64926    ///
64927    /// Sets the channel to shutdown if an error occurs.
64928    pub fn send(
64929        self,
64930        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
64931    ) -> Result<(), fidl::Error> {
64932        let _result = self.send_raw(result);
64933        if _result.is_err() {
64934            self.control_handle.shutdown();
64935        }
64936        self.drop_without_shutdown();
64937        _result
64938    }
64939
64940    /// Similar to "send" but does not shutdown the channel if an error occurs.
64941    pub fn send_no_shutdown_on_err(
64942        self,
64943        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
64944    ) -> Result<(), fidl::Error> {
64945        let _result = self.send_raw(result);
64946        self.drop_without_shutdown();
64947        _result
64948    }
64949
64950    fn send_raw(
64951        &self,
64952        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
64953    ) -> Result<(), fidl::Error> {
64954        self.control_handle.inner.send::<fidl::encoding::ResultType<
64955            BaseNetworkSocketGetIpv6OnlyResponse,
64956            fidl_fuchsia_posix::Errno,
64957        >>(
64958            result.map(|value| (value,)),
64959            self.tx_id,
64960            0x4aa3340a1a26b89c,
64961            fidl::encoding::DynamicFlags::empty(),
64962        )
64963    }
64964}
64965
64966#[must_use = "FIDL methods require a response to be sent"]
64967#[derive(Debug)]
64968pub struct StreamSocketSetIpv6ReceiveTrafficClassResponder {
64969    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
64970    tx_id: u32,
64971}
64972
64973/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
64974/// if the responder is dropped without sending a response, so that the client
64975/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
64976impl std::ops::Drop for StreamSocketSetIpv6ReceiveTrafficClassResponder {
64977    fn drop(&mut self) {
64978        self.control_handle.shutdown();
64979        // Safety: drops once, never accessed again
64980        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64981    }
64982}
64983
64984impl fidl::endpoints::Responder for StreamSocketSetIpv6ReceiveTrafficClassResponder {
64985    type ControlHandle = StreamSocketControlHandle;
64986
64987    fn control_handle(&self) -> &StreamSocketControlHandle {
64988        &self.control_handle
64989    }
64990
64991    fn drop_without_shutdown(mut self) {
64992        // Safety: drops once, never accessed again due to mem::forget
64993        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
64994        // Prevent Drop from running (which would shut down the channel)
64995        std::mem::forget(self);
64996    }
64997}
64998
64999impl StreamSocketSetIpv6ReceiveTrafficClassResponder {
65000    /// Sends a response to the FIDL transaction.
65001    ///
65002    /// Sets the channel to shutdown if an error occurs.
65003    pub fn send(
65004        self,
65005        mut result: Result<(), fidl_fuchsia_posix::Errno>,
65006    ) -> Result<(), fidl::Error> {
65007        let _result = self.send_raw(result);
65008        if _result.is_err() {
65009            self.control_handle.shutdown();
65010        }
65011        self.drop_without_shutdown();
65012        _result
65013    }
65014
65015    /// Similar to "send" but does not shutdown the channel if an error occurs.
65016    pub fn send_no_shutdown_on_err(
65017        self,
65018        mut result: Result<(), fidl_fuchsia_posix::Errno>,
65019    ) -> Result<(), fidl::Error> {
65020        let _result = self.send_raw(result);
65021        self.drop_without_shutdown();
65022        _result
65023    }
65024
65025    fn send_raw(
65026        &self,
65027        mut result: Result<(), fidl_fuchsia_posix::Errno>,
65028    ) -> Result<(), fidl::Error> {
65029        self.control_handle.inner.send::<fidl::encoding::ResultType<
65030            fidl::encoding::EmptyStruct,
65031            fidl_fuchsia_posix::Errno,
65032        >>(
65033            result,
65034            self.tx_id,
65035            0x58f07c8788d099a0,
65036            fidl::encoding::DynamicFlags::empty(),
65037        )
65038    }
65039}
65040
65041#[must_use = "FIDL methods require a response to be sent"]
65042#[derive(Debug)]
65043pub struct StreamSocketGetIpv6ReceiveTrafficClassResponder {
65044    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
65045    tx_id: u32,
65046}
65047
65048/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
65049/// if the responder is dropped without sending a response, so that the client
65050/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
65051impl std::ops::Drop for StreamSocketGetIpv6ReceiveTrafficClassResponder {
65052    fn drop(&mut self) {
65053        self.control_handle.shutdown();
65054        // Safety: drops once, never accessed again
65055        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65056    }
65057}
65058
65059impl fidl::endpoints::Responder for StreamSocketGetIpv6ReceiveTrafficClassResponder {
65060    type ControlHandle = StreamSocketControlHandle;
65061
65062    fn control_handle(&self) -> &StreamSocketControlHandle {
65063        &self.control_handle
65064    }
65065
65066    fn drop_without_shutdown(mut self) {
65067        // Safety: drops once, never accessed again due to mem::forget
65068        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65069        // Prevent Drop from running (which would shut down the channel)
65070        std::mem::forget(self);
65071    }
65072}
65073
65074impl StreamSocketGetIpv6ReceiveTrafficClassResponder {
65075    /// Sends a response to the FIDL transaction.
65076    ///
65077    /// Sets the channel to shutdown if an error occurs.
65078    pub fn send(
65079        self,
65080        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
65081    ) -> Result<(), fidl::Error> {
65082        let _result = self.send_raw(result);
65083        if _result.is_err() {
65084            self.control_handle.shutdown();
65085        }
65086        self.drop_without_shutdown();
65087        _result
65088    }
65089
65090    /// Similar to "send" but does not shutdown the channel if an error occurs.
65091    pub fn send_no_shutdown_on_err(
65092        self,
65093        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
65094    ) -> Result<(), fidl::Error> {
65095        let _result = self.send_raw(result);
65096        self.drop_without_shutdown();
65097        _result
65098    }
65099
65100    fn send_raw(
65101        &self,
65102        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
65103    ) -> Result<(), fidl::Error> {
65104        self.control_handle.inner.send::<fidl::encoding::ResultType<
65105            BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
65106            fidl_fuchsia_posix::Errno,
65107        >>(
65108            result.map(|value| (value,)),
65109            self.tx_id,
65110            0x2e334df1da553ffa,
65111            fidl::encoding::DynamicFlags::empty(),
65112        )
65113    }
65114}
65115
65116#[must_use = "FIDL methods require a response to be sent"]
65117#[derive(Debug)]
65118pub struct StreamSocketSetIpv6TrafficClassResponder {
65119    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
65120    tx_id: u32,
65121}
65122
65123/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
65124/// if the responder is dropped without sending a response, so that the client
65125/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
65126impl std::ops::Drop for StreamSocketSetIpv6TrafficClassResponder {
65127    fn drop(&mut self) {
65128        self.control_handle.shutdown();
65129        // Safety: drops once, never accessed again
65130        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65131    }
65132}
65133
65134impl fidl::endpoints::Responder for StreamSocketSetIpv6TrafficClassResponder {
65135    type ControlHandle = StreamSocketControlHandle;
65136
65137    fn control_handle(&self) -> &StreamSocketControlHandle {
65138        &self.control_handle
65139    }
65140
65141    fn drop_without_shutdown(mut self) {
65142        // Safety: drops once, never accessed again due to mem::forget
65143        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65144        // Prevent Drop from running (which would shut down the channel)
65145        std::mem::forget(self);
65146    }
65147}
65148
65149impl StreamSocketSetIpv6TrafficClassResponder {
65150    /// Sends a response to the FIDL transaction.
65151    ///
65152    /// Sets the channel to shutdown if an error occurs.
65153    pub fn send(
65154        self,
65155        mut result: Result<(), fidl_fuchsia_posix::Errno>,
65156    ) -> Result<(), fidl::Error> {
65157        let _result = self.send_raw(result);
65158        if _result.is_err() {
65159            self.control_handle.shutdown();
65160        }
65161        self.drop_without_shutdown();
65162        _result
65163    }
65164
65165    /// Similar to "send" but does not shutdown the channel if an error occurs.
65166    pub fn send_no_shutdown_on_err(
65167        self,
65168        mut result: Result<(), fidl_fuchsia_posix::Errno>,
65169    ) -> Result<(), fidl::Error> {
65170        let _result = self.send_raw(result);
65171        self.drop_without_shutdown();
65172        _result
65173    }
65174
65175    fn send_raw(
65176        &self,
65177        mut result: Result<(), fidl_fuchsia_posix::Errno>,
65178    ) -> Result<(), fidl::Error> {
65179        self.control_handle.inner.send::<fidl::encoding::ResultType<
65180            fidl::encoding::EmptyStruct,
65181            fidl_fuchsia_posix::Errno,
65182        >>(
65183            result,
65184            self.tx_id,
65185            0x6af077800c5a0b4f,
65186            fidl::encoding::DynamicFlags::empty(),
65187        )
65188    }
65189}
65190
65191#[must_use = "FIDL methods require a response to be sent"]
65192#[derive(Debug)]
65193pub struct StreamSocketGetIpv6TrafficClassResponder {
65194    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
65195    tx_id: u32,
65196}
65197
65198/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
65199/// if the responder is dropped without sending a response, so that the client
65200/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
65201impl std::ops::Drop for StreamSocketGetIpv6TrafficClassResponder {
65202    fn drop(&mut self) {
65203        self.control_handle.shutdown();
65204        // Safety: drops once, never accessed again
65205        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65206    }
65207}
65208
65209impl fidl::endpoints::Responder for StreamSocketGetIpv6TrafficClassResponder {
65210    type ControlHandle = StreamSocketControlHandle;
65211
65212    fn control_handle(&self) -> &StreamSocketControlHandle {
65213        &self.control_handle
65214    }
65215
65216    fn drop_without_shutdown(mut self) {
65217        // Safety: drops once, never accessed again due to mem::forget
65218        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65219        // Prevent Drop from running (which would shut down the channel)
65220        std::mem::forget(self);
65221    }
65222}
65223
65224impl StreamSocketGetIpv6TrafficClassResponder {
65225    /// Sends a response to the FIDL transaction.
65226    ///
65227    /// Sets the channel to shutdown if an error occurs.
65228    pub fn send(
65229        self,
65230        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
65231    ) -> Result<(), fidl::Error> {
65232        let _result = self.send_raw(result);
65233        if _result.is_err() {
65234            self.control_handle.shutdown();
65235        }
65236        self.drop_without_shutdown();
65237        _result
65238    }
65239
65240    /// Similar to "send" but does not shutdown the channel if an error occurs.
65241    pub fn send_no_shutdown_on_err(
65242        self,
65243        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
65244    ) -> Result<(), fidl::Error> {
65245        let _result = self.send_raw(result);
65246        self.drop_without_shutdown();
65247        _result
65248    }
65249
65250    fn send_raw(
65251        &self,
65252        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
65253    ) -> Result<(), fidl::Error> {
65254        self.control_handle.inner.send::<fidl::encoding::ResultType<
65255            BaseNetworkSocketGetIpv6TrafficClassResponse,
65256            fidl_fuchsia_posix::Errno,
65257        >>(
65258            result.map(|value| (value,)),
65259            self.tx_id,
65260            0x6baf6eed8fc2f04,
65261            fidl::encoding::DynamicFlags::empty(),
65262        )
65263    }
65264}
65265
65266#[must_use = "FIDL methods require a response to be sent"]
65267#[derive(Debug)]
65268pub struct StreamSocketSetIpv6ReceivePacketInfoResponder {
65269    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
65270    tx_id: u32,
65271}
65272
65273/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
65274/// if the responder is dropped without sending a response, so that the client
65275/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
65276impl std::ops::Drop for StreamSocketSetIpv6ReceivePacketInfoResponder {
65277    fn drop(&mut self) {
65278        self.control_handle.shutdown();
65279        // Safety: drops once, never accessed again
65280        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65281    }
65282}
65283
65284impl fidl::endpoints::Responder for StreamSocketSetIpv6ReceivePacketInfoResponder {
65285    type ControlHandle = StreamSocketControlHandle;
65286
65287    fn control_handle(&self) -> &StreamSocketControlHandle {
65288        &self.control_handle
65289    }
65290
65291    fn drop_without_shutdown(mut self) {
65292        // Safety: drops once, never accessed again due to mem::forget
65293        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65294        // Prevent Drop from running (which would shut down the channel)
65295        std::mem::forget(self);
65296    }
65297}
65298
65299impl StreamSocketSetIpv6ReceivePacketInfoResponder {
65300    /// Sends a response to the FIDL transaction.
65301    ///
65302    /// Sets the channel to shutdown if an error occurs.
65303    pub fn send(
65304        self,
65305        mut result: Result<(), fidl_fuchsia_posix::Errno>,
65306    ) -> Result<(), fidl::Error> {
65307        let _result = self.send_raw(result);
65308        if _result.is_err() {
65309            self.control_handle.shutdown();
65310        }
65311        self.drop_without_shutdown();
65312        _result
65313    }
65314
65315    /// Similar to "send" but does not shutdown the channel if an error occurs.
65316    pub fn send_no_shutdown_on_err(
65317        self,
65318        mut result: Result<(), fidl_fuchsia_posix::Errno>,
65319    ) -> Result<(), fidl::Error> {
65320        let _result = self.send_raw(result);
65321        self.drop_without_shutdown();
65322        _result
65323    }
65324
65325    fn send_raw(
65326        &self,
65327        mut result: Result<(), fidl_fuchsia_posix::Errno>,
65328    ) -> Result<(), fidl::Error> {
65329        self.control_handle.inner.send::<fidl::encoding::ResultType<
65330            fidl::encoding::EmptyStruct,
65331            fidl_fuchsia_posix::Errno,
65332        >>(
65333            result,
65334            self.tx_id,
65335            0x19259775b1a92768,
65336            fidl::encoding::DynamicFlags::empty(),
65337        )
65338    }
65339}
65340
65341#[must_use = "FIDL methods require a response to be sent"]
65342#[derive(Debug)]
65343pub struct StreamSocketGetIpv6ReceivePacketInfoResponder {
65344    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
65345    tx_id: u32,
65346}
65347
65348/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
65349/// if the responder is dropped without sending a response, so that the client
65350/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
65351impl std::ops::Drop for StreamSocketGetIpv6ReceivePacketInfoResponder {
65352    fn drop(&mut self) {
65353        self.control_handle.shutdown();
65354        // Safety: drops once, never accessed again
65355        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65356    }
65357}
65358
65359impl fidl::endpoints::Responder for StreamSocketGetIpv6ReceivePacketInfoResponder {
65360    type ControlHandle = StreamSocketControlHandle;
65361
65362    fn control_handle(&self) -> &StreamSocketControlHandle {
65363        &self.control_handle
65364    }
65365
65366    fn drop_without_shutdown(mut self) {
65367        // Safety: drops once, never accessed again due to mem::forget
65368        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65369        // Prevent Drop from running (which would shut down the channel)
65370        std::mem::forget(self);
65371    }
65372}
65373
65374impl StreamSocketGetIpv6ReceivePacketInfoResponder {
65375    /// Sends a response to the FIDL transaction.
65376    ///
65377    /// Sets the channel to shutdown if an error occurs.
65378    pub fn send(
65379        self,
65380        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
65381    ) -> Result<(), fidl::Error> {
65382        let _result = self.send_raw(result);
65383        if _result.is_err() {
65384            self.control_handle.shutdown();
65385        }
65386        self.drop_without_shutdown();
65387        _result
65388    }
65389
65390    /// Similar to "send" but does not shutdown the channel if an error occurs.
65391    pub fn send_no_shutdown_on_err(
65392        self,
65393        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
65394    ) -> Result<(), fidl::Error> {
65395        let _result = self.send_raw(result);
65396        self.drop_without_shutdown();
65397        _result
65398    }
65399
65400    fn send_raw(
65401        &self,
65402        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
65403    ) -> Result<(), fidl::Error> {
65404        self.control_handle.inner.send::<fidl::encoding::ResultType<
65405            BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
65406            fidl_fuchsia_posix::Errno,
65407        >>(
65408            result.map(|value| (value,)),
65409            self.tx_id,
65410            0x7acd4a2775baec75,
65411            fidl::encoding::DynamicFlags::empty(),
65412        )
65413    }
65414}
65415
65416#[must_use = "FIDL methods require a response to be sent"]
65417#[derive(Debug)]
65418pub struct StreamSocketGetOriginalDestinationResponder {
65419    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
65420    tx_id: u32,
65421}
65422
65423/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
65424/// if the responder is dropped without sending a response, so that the client
65425/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
65426impl std::ops::Drop for StreamSocketGetOriginalDestinationResponder {
65427    fn drop(&mut self) {
65428        self.control_handle.shutdown();
65429        // Safety: drops once, never accessed again
65430        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65431    }
65432}
65433
65434impl fidl::endpoints::Responder for StreamSocketGetOriginalDestinationResponder {
65435    type ControlHandle = StreamSocketControlHandle;
65436
65437    fn control_handle(&self) -> &StreamSocketControlHandle {
65438        &self.control_handle
65439    }
65440
65441    fn drop_without_shutdown(mut self) {
65442        // Safety: drops once, never accessed again due to mem::forget
65443        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65444        // Prevent Drop from running (which would shut down the channel)
65445        std::mem::forget(self);
65446    }
65447}
65448
65449impl StreamSocketGetOriginalDestinationResponder {
65450    /// Sends a response to the FIDL transaction.
65451    ///
65452    /// Sets the channel to shutdown if an error occurs.
65453    pub fn send(
65454        self,
65455        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
65456    ) -> Result<(), fidl::Error> {
65457        let _result = self.send_raw(result);
65458        if _result.is_err() {
65459            self.control_handle.shutdown();
65460        }
65461        self.drop_without_shutdown();
65462        _result
65463    }
65464
65465    /// Similar to "send" but does not shutdown the channel if an error occurs.
65466    pub fn send_no_shutdown_on_err(
65467        self,
65468        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
65469    ) -> Result<(), fidl::Error> {
65470        let _result = self.send_raw(result);
65471        self.drop_without_shutdown();
65472        _result
65473    }
65474
65475    fn send_raw(
65476        &self,
65477        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
65478    ) -> Result<(), fidl::Error> {
65479        self.control_handle.inner.send::<fidl::encoding::ResultType<
65480            BaseNetworkSocketGetOriginalDestinationResponse,
65481            fidl_fuchsia_posix::Errno,
65482        >>(
65483            result.map(|value| (value,)),
65484            self.tx_id,
65485            0x38bf28f0dafdbac0,
65486            fidl::encoding::DynamicFlags::empty(),
65487        )
65488    }
65489}
65490
65491#[must_use = "FIDL methods require a response to be sent"]
65492#[derive(Debug)]
65493pub struct StreamSocketDescribeResponder {
65494    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
65495    tx_id: u32,
65496}
65497
65498/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
65499/// if the responder is dropped without sending a response, so that the client
65500/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
65501impl std::ops::Drop for StreamSocketDescribeResponder {
65502    fn drop(&mut self) {
65503        self.control_handle.shutdown();
65504        // Safety: drops once, never accessed again
65505        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65506    }
65507}
65508
65509impl fidl::endpoints::Responder for StreamSocketDescribeResponder {
65510    type ControlHandle = StreamSocketControlHandle;
65511
65512    fn control_handle(&self) -> &StreamSocketControlHandle {
65513        &self.control_handle
65514    }
65515
65516    fn drop_without_shutdown(mut self) {
65517        // Safety: drops once, never accessed again due to mem::forget
65518        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65519        // Prevent Drop from running (which would shut down the channel)
65520        std::mem::forget(self);
65521    }
65522}
65523
65524impl StreamSocketDescribeResponder {
65525    /// Sends a response to the FIDL transaction.
65526    ///
65527    /// Sets the channel to shutdown if an error occurs.
65528    pub fn send(self, mut payload: StreamSocketDescribeResponse) -> Result<(), fidl::Error> {
65529        let _result = self.send_raw(payload);
65530        if _result.is_err() {
65531            self.control_handle.shutdown();
65532        }
65533        self.drop_without_shutdown();
65534        _result
65535    }
65536
65537    /// Similar to "send" but does not shutdown the channel if an error occurs.
65538    pub fn send_no_shutdown_on_err(
65539        self,
65540        mut payload: StreamSocketDescribeResponse,
65541    ) -> Result<(), fidl::Error> {
65542        let _result = self.send_raw(payload);
65543        self.drop_without_shutdown();
65544        _result
65545    }
65546
65547    fn send_raw(&self, mut payload: StreamSocketDescribeResponse) -> Result<(), fidl::Error> {
65548        self.control_handle.inner.send::<StreamSocketDescribeResponse>(
65549            &mut payload,
65550            self.tx_id,
65551            0x29e22969a7dadc32,
65552            fidl::encoding::DynamicFlags::empty(),
65553        )
65554    }
65555}
65556
65557#[must_use = "FIDL methods require a response to be sent"]
65558#[derive(Debug)]
65559pub struct StreamSocketListenResponder {
65560    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
65561    tx_id: u32,
65562}
65563
65564/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
65565/// if the responder is dropped without sending a response, so that the client
65566/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
65567impl std::ops::Drop for StreamSocketListenResponder {
65568    fn drop(&mut self) {
65569        self.control_handle.shutdown();
65570        // Safety: drops once, never accessed again
65571        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65572    }
65573}
65574
65575impl fidl::endpoints::Responder for StreamSocketListenResponder {
65576    type ControlHandle = StreamSocketControlHandle;
65577
65578    fn control_handle(&self) -> &StreamSocketControlHandle {
65579        &self.control_handle
65580    }
65581
65582    fn drop_without_shutdown(mut self) {
65583        // Safety: drops once, never accessed again due to mem::forget
65584        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65585        // Prevent Drop from running (which would shut down the channel)
65586        std::mem::forget(self);
65587    }
65588}
65589
65590impl StreamSocketListenResponder {
65591    /// Sends a response to the FIDL transaction.
65592    ///
65593    /// Sets the channel to shutdown if an error occurs.
65594    pub fn send(
65595        self,
65596        mut result: Result<(), fidl_fuchsia_posix::Errno>,
65597    ) -> Result<(), fidl::Error> {
65598        let _result = self.send_raw(result);
65599        if _result.is_err() {
65600            self.control_handle.shutdown();
65601        }
65602        self.drop_without_shutdown();
65603        _result
65604    }
65605
65606    /// Similar to "send" but does not shutdown the channel if an error occurs.
65607    pub fn send_no_shutdown_on_err(
65608        self,
65609        mut result: Result<(), fidl_fuchsia_posix::Errno>,
65610    ) -> Result<(), fidl::Error> {
65611        let _result = self.send_raw(result);
65612        self.drop_without_shutdown();
65613        _result
65614    }
65615
65616    fn send_raw(
65617        &self,
65618        mut result: Result<(), fidl_fuchsia_posix::Errno>,
65619    ) -> Result<(), fidl::Error> {
65620        self.control_handle.inner.send::<fidl::encoding::ResultType<
65621            fidl::encoding::EmptyStruct,
65622            fidl_fuchsia_posix::Errno,
65623        >>(
65624            result,
65625            self.tx_id,
65626            0x3d0a65ced3d10108,
65627            fidl::encoding::DynamicFlags::empty(),
65628        )
65629    }
65630}
65631
65632#[must_use = "FIDL methods require a response to be sent"]
65633#[derive(Debug)]
65634pub struct StreamSocketAcceptResponder {
65635    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
65636    tx_id: u32,
65637}
65638
65639/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
65640/// if the responder is dropped without sending a response, so that the client
65641/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
65642impl std::ops::Drop for StreamSocketAcceptResponder {
65643    fn drop(&mut self) {
65644        self.control_handle.shutdown();
65645        // Safety: drops once, never accessed again
65646        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65647    }
65648}
65649
65650impl fidl::endpoints::Responder for StreamSocketAcceptResponder {
65651    type ControlHandle = StreamSocketControlHandle;
65652
65653    fn control_handle(&self) -> &StreamSocketControlHandle {
65654        &self.control_handle
65655    }
65656
65657    fn drop_without_shutdown(mut self) {
65658        // Safety: drops once, never accessed again due to mem::forget
65659        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65660        // Prevent Drop from running (which would shut down the channel)
65661        std::mem::forget(self);
65662    }
65663}
65664
65665impl StreamSocketAcceptResponder {
65666    /// Sends a response to the FIDL transaction.
65667    ///
65668    /// Sets the channel to shutdown if an error occurs.
65669    pub fn send(
65670        self,
65671        mut result: Result<
65672            (
65673                Option<&fidl_fuchsia_net::SocketAddress>,
65674                fidl::endpoints::ClientEnd<StreamSocketMarker>,
65675            ),
65676            fidl_fuchsia_posix::Errno,
65677        >,
65678    ) -> Result<(), fidl::Error> {
65679        let _result = self.send_raw(result);
65680        if _result.is_err() {
65681            self.control_handle.shutdown();
65682        }
65683        self.drop_without_shutdown();
65684        _result
65685    }
65686
65687    /// Similar to "send" but does not shutdown the channel if an error occurs.
65688    pub fn send_no_shutdown_on_err(
65689        self,
65690        mut result: Result<
65691            (
65692                Option<&fidl_fuchsia_net::SocketAddress>,
65693                fidl::endpoints::ClientEnd<StreamSocketMarker>,
65694            ),
65695            fidl_fuchsia_posix::Errno,
65696        >,
65697    ) -> Result<(), fidl::Error> {
65698        let _result = self.send_raw(result);
65699        self.drop_without_shutdown();
65700        _result
65701    }
65702
65703    fn send_raw(
65704        &self,
65705        mut result: Result<
65706            (
65707                Option<&fidl_fuchsia_net::SocketAddress>,
65708                fidl::endpoints::ClientEnd<StreamSocketMarker>,
65709            ),
65710            fidl_fuchsia_posix::Errno,
65711        >,
65712    ) -> Result<(), fidl::Error> {
65713        self.control_handle.inner.send::<fidl::encoding::ResultType<
65714            StreamSocketAcceptResponse,
65715            fidl_fuchsia_posix::Errno,
65716        >>(
65717            result,
65718            self.tx_id,
65719            0x5ab7ad620424c163,
65720            fidl::encoding::DynamicFlags::empty(),
65721        )
65722    }
65723}
65724
65725#[must_use = "FIDL methods require a response to be sent"]
65726#[derive(Debug)]
65727pub struct StreamSocketGetInfoResponder {
65728    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
65729    tx_id: u32,
65730}
65731
65732/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
65733/// if the responder is dropped without sending a response, so that the client
65734/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
65735impl std::ops::Drop for StreamSocketGetInfoResponder {
65736    fn drop(&mut self) {
65737        self.control_handle.shutdown();
65738        // Safety: drops once, never accessed again
65739        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65740    }
65741}
65742
65743impl fidl::endpoints::Responder for StreamSocketGetInfoResponder {
65744    type ControlHandle = StreamSocketControlHandle;
65745
65746    fn control_handle(&self) -> &StreamSocketControlHandle {
65747        &self.control_handle
65748    }
65749
65750    fn drop_without_shutdown(mut self) {
65751        // Safety: drops once, never accessed again due to mem::forget
65752        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65753        // Prevent Drop from running (which would shut down the channel)
65754        std::mem::forget(self);
65755    }
65756}
65757
65758impl StreamSocketGetInfoResponder {
65759    /// Sends a response to the FIDL transaction.
65760    ///
65761    /// Sets the channel to shutdown if an error occurs.
65762    pub fn send(
65763        self,
65764        mut result: Result<(Domain, StreamSocketProtocol), fidl_fuchsia_posix::Errno>,
65765    ) -> Result<(), fidl::Error> {
65766        let _result = self.send_raw(result);
65767        if _result.is_err() {
65768            self.control_handle.shutdown();
65769        }
65770        self.drop_without_shutdown();
65771        _result
65772    }
65773
65774    /// Similar to "send" but does not shutdown the channel if an error occurs.
65775    pub fn send_no_shutdown_on_err(
65776        self,
65777        mut result: Result<(Domain, StreamSocketProtocol), fidl_fuchsia_posix::Errno>,
65778    ) -> Result<(), fidl::Error> {
65779        let _result = self.send_raw(result);
65780        self.drop_without_shutdown();
65781        _result
65782    }
65783
65784    fn send_raw(
65785        &self,
65786        mut result: Result<(Domain, StreamSocketProtocol), fidl_fuchsia_posix::Errno>,
65787    ) -> Result<(), fidl::Error> {
65788        self.control_handle.inner.send::<fidl::encoding::ResultType<
65789            StreamSocketGetInfoResponse,
65790            fidl_fuchsia_posix::Errno,
65791        >>(
65792            result,
65793            self.tx_id,
65794            0x87cfa55d19f878f,
65795            fidl::encoding::DynamicFlags::empty(),
65796        )
65797    }
65798}
65799
65800#[must_use = "FIDL methods require a response to be sent"]
65801#[derive(Debug)]
65802pub struct StreamSocketSetTcpNoDelayResponder {
65803    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
65804    tx_id: u32,
65805}
65806
65807/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
65808/// if the responder is dropped without sending a response, so that the client
65809/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
65810impl std::ops::Drop for StreamSocketSetTcpNoDelayResponder {
65811    fn drop(&mut self) {
65812        self.control_handle.shutdown();
65813        // Safety: drops once, never accessed again
65814        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65815    }
65816}
65817
65818impl fidl::endpoints::Responder for StreamSocketSetTcpNoDelayResponder {
65819    type ControlHandle = StreamSocketControlHandle;
65820
65821    fn control_handle(&self) -> &StreamSocketControlHandle {
65822        &self.control_handle
65823    }
65824
65825    fn drop_without_shutdown(mut self) {
65826        // Safety: drops once, never accessed again due to mem::forget
65827        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65828        // Prevent Drop from running (which would shut down the channel)
65829        std::mem::forget(self);
65830    }
65831}
65832
65833impl StreamSocketSetTcpNoDelayResponder {
65834    /// Sends a response to the FIDL transaction.
65835    ///
65836    /// Sets the channel to shutdown if an error occurs.
65837    pub fn send(
65838        self,
65839        mut result: Result<(), fidl_fuchsia_posix::Errno>,
65840    ) -> Result<(), fidl::Error> {
65841        let _result = self.send_raw(result);
65842        if _result.is_err() {
65843            self.control_handle.shutdown();
65844        }
65845        self.drop_without_shutdown();
65846        _result
65847    }
65848
65849    /// Similar to "send" but does not shutdown the channel if an error occurs.
65850    pub fn send_no_shutdown_on_err(
65851        self,
65852        mut result: Result<(), fidl_fuchsia_posix::Errno>,
65853    ) -> Result<(), fidl::Error> {
65854        let _result = self.send_raw(result);
65855        self.drop_without_shutdown();
65856        _result
65857    }
65858
65859    fn send_raw(
65860        &self,
65861        mut result: Result<(), fidl_fuchsia_posix::Errno>,
65862    ) -> Result<(), fidl::Error> {
65863        self.control_handle.inner.send::<fidl::encoding::ResultType<
65864            fidl::encoding::EmptyStruct,
65865            fidl_fuchsia_posix::Errno,
65866        >>(
65867            result,
65868            self.tx_id,
65869            0x5a59b778f7333ada,
65870            fidl::encoding::DynamicFlags::empty(),
65871        )
65872    }
65873}
65874
65875#[must_use = "FIDL methods require a response to be sent"]
65876#[derive(Debug)]
65877pub struct StreamSocketGetTcpNoDelayResponder {
65878    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
65879    tx_id: u32,
65880}
65881
65882/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
65883/// if the responder is dropped without sending a response, so that the client
65884/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
65885impl std::ops::Drop for StreamSocketGetTcpNoDelayResponder {
65886    fn drop(&mut self) {
65887        self.control_handle.shutdown();
65888        // Safety: drops once, never accessed again
65889        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65890    }
65891}
65892
65893impl fidl::endpoints::Responder for StreamSocketGetTcpNoDelayResponder {
65894    type ControlHandle = StreamSocketControlHandle;
65895
65896    fn control_handle(&self) -> &StreamSocketControlHandle {
65897        &self.control_handle
65898    }
65899
65900    fn drop_without_shutdown(mut self) {
65901        // Safety: drops once, never accessed again due to mem::forget
65902        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65903        // Prevent Drop from running (which would shut down the channel)
65904        std::mem::forget(self);
65905    }
65906}
65907
65908impl StreamSocketGetTcpNoDelayResponder {
65909    /// Sends a response to the FIDL transaction.
65910    ///
65911    /// Sets the channel to shutdown if an error occurs.
65912    pub fn send(
65913        self,
65914        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
65915    ) -> Result<(), fidl::Error> {
65916        let _result = self.send_raw(result);
65917        if _result.is_err() {
65918            self.control_handle.shutdown();
65919        }
65920        self.drop_without_shutdown();
65921        _result
65922    }
65923
65924    /// Similar to "send" but does not shutdown the channel if an error occurs.
65925    pub fn send_no_shutdown_on_err(
65926        self,
65927        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
65928    ) -> Result<(), fidl::Error> {
65929        let _result = self.send_raw(result);
65930        self.drop_without_shutdown();
65931        _result
65932    }
65933
65934    fn send_raw(
65935        &self,
65936        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
65937    ) -> Result<(), fidl::Error> {
65938        self.control_handle.inner.send::<fidl::encoding::ResultType<
65939            StreamSocketGetTcpNoDelayResponse,
65940            fidl_fuchsia_posix::Errno,
65941        >>(
65942            result.map(|value| (value,)),
65943            self.tx_id,
65944            0xac219a3218b0799,
65945            fidl::encoding::DynamicFlags::empty(),
65946        )
65947    }
65948}
65949
65950#[must_use = "FIDL methods require a response to be sent"]
65951#[derive(Debug)]
65952pub struct StreamSocketSetTcpMaxSegmentResponder {
65953    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
65954    tx_id: u32,
65955}
65956
65957/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
65958/// if the responder is dropped without sending a response, so that the client
65959/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
65960impl std::ops::Drop for StreamSocketSetTcpMaxSegmentResponder {
65961    fn drop(&mut self) {
65962        self.control_handle.shutdown();
65963        // Safety: drops once, never accessed again
65964        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65965    }
65966}
65967
65968impl fidl::endpoints::Responder for StreamSocketSetTcpMaxSegmentResponder {
65969    type ControlHandle = StreamSocketControlHandle;
65970
65971    fn control_handle(&self) -> &StreamSocketControlHandle {
65972        &self.control_handle
65973    }
65974
65975    fn drop_without_shutdown(mut self) {
65976        // Safety: drops once, never accessed again due to mem::forget
65977        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
65978        // Prevent Drop from running (which would shut down the channel)
65979        std::mem::forget(self);
65980    }
65981}
65982
65983impl StreamSocketSetTcpMaxSegmentResponder {
65984    /// Sends a response to the FIDL transaction.
65985    ///
65986    /// Sets the channel to shutdown if an error occurs.
65987    pub fn send(
65988        self,
65989        mut result: Result<(), fidl_fuchsia_posix::Errno>,
65990    ) -> Result<(), fidl::Error> {
65991        let _result = self.send_raw(result);
65992        if _result.is_err() {
65993            self.control_handle.shutdown();
65994        }
65995        self.drop_without_shutdown();
65996        _result
65997    }
65998
65999    /// Similar to "send" but does not shutdown the channel if an error occurs.
66000    pub fn send_no_shutdown_on_err(
66001        self,
66002        mut result: Result<(), fidl_fuchsia_posix::Errno>,
66003    ) -> Result<(), fidl::Error> {
66004        let _result = self.send_raw(result);
66005        self.drop_without_shutdown();
66006        _result
66007    }
66008
66009    fn send_raw(
66010        &self,
66011        mut result: Result<(), fidl_fuchsia_posix::Errno>,
66012    ) -> Result<(), fidl::Error> {
66013        self.control_handle.inner.send::<fidl::encoding::ResultType<
66014            fidl::encoding::EmptyStruct,
66015            fidl_fuchsia_posix::Errno,
66016        >>(
66017            result,
66018            self.tx_id,
66019            0xb3d30c498266d18,
66020            fidl::encoding::DynamicFlags::empty(),
66021        )
66022    }
66023}
66024
66025#[must_use = "FIDL methods require a response to be sent"]
66026#[derive(Debug)]
66027pub struct StreamSocketGetTcpMaxSegmentResponder {
66028    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
66029    tx_id: u32,
66030}
66031
66032/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
66033/// if the responder is dropped without sending a response, so that the client
66034/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
66035impl std::ops::Drop for StreamSocketGetTcpMaxSegmentResponder {
66036    fn drop(&mut self) {
66037        self.control_handle.shutdown();
66038        // Safety: drops once, never accessed again
66039        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66040    }
66041}
66042
66043impl fidl::endpoints::Responder for StreamSocketGetTcpMaxSegmentResponder {
66044    type ControlHandle = StreamSocketControlHandle;
66045
66046    fn control_handle(&self) -> &StreamSocketControlHandle {
66047        &self.control_handle
66048    }
66049
66050    fn drop_without_shutdown(mut self) {
66051        // Safety: drops once, never accessed again due to mem::forget
66052        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66053        // Prevent Drop from running (which would shut down the channel)
66054        std::mem::forget(self);
66055    }
66056}
66057
66058impl StreamSocketGetTcpMaxSegmentResponder {
66059    /// Sends a response to the FIDL transaction.
66060    ///
66061    /// Sets the channel to shutdown if an error occurs.
66062    pub fn send(
66063        self,
66064        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
66065    ) -> Result<(), fidl::Error> {
66066        let _result = self.send_raw(result);
66067        if _result.is_err() {
66068            self.control_handle.shutdown();
66069        }
66070        self.drop_without_shutdown();
66071        _result
66072    }
66073
66074    /// Similar to "send" but does not shutdown the channel if an error occurs.
66075    pub fn send_no_shutdown_on_err(
66076        self,
66077        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
66078    ) -> Result<(), fidl::Error> {
66079        let _result = self.send_raw(result);
66080        self.drop_without_shutdown();
66081        _result
66082    }
66083
66084    fn send_raw(
66085        &self,
66086        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
66087    ) -> Result<(), fidl::Error> {
66088        self.control_handle.inner.send::<fidl::encoding::ResultType<
66089            StreamSocketGetTcpMaxSegmentResponse,
66090            fidl_fuchsia_posix::Errno,
66091        >>(
66092            result.map(|value_bytes| (value_bytes,)),
66093            self.tx_id,
66094            0x637404d1b4b9982c,
66095            fidl::encoding::DynamicFlags::empty(),
66096        )
66097    }
66098}
66099
66100#[must_use = "FIDL methods require a response to be sent"]
66101#[derive(Debug)]
66102pub struct StreamSocketSetTcpCorkResponder {
66103    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
66104    tx_id: u32,
66105}
66106
66107/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
66108/// if the responder is dropped without sending a response, so that the client
66109/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
66110impl std::ops::Drop for StreamSocketSetTcpCorkResponder {
66111    fn drop(&mut self) {
66112        self.control_handle.shutdown();
66113        // Safety: drops once, never accessed again
66114        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66115    }
66116}
66117
66118impl fidl::endpoints::Responder for StreamSocketSetTcpCorkResponder {
66119    type ControlHandle = StreamSocketControlHandle;
66120
66121    fn control_handle(&self) -> &StreamSocketControlHandle {
66122        &self.control_handle
66123    }
66124
66125    fn drop_without_shutdown(mut self) {
66126        // Safety: drops once, never accessed again due to mem::forget
66127        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66128        // Prevent Drop from running (which would shut down the channel)
66129        std::mem::forget(self);
66130    }
66131}
66132
66133impl StreamSocketSetTcpCorkResponder {
66134    /// Sends a response to the FIDL transaction.
66135    ///
66136    /// Sets the channel to shutdown if an error occurs.
66137    pub fn send(
66138        self,
66139        mut result: Result<(), fidl_fuchsia_posix::Errno>,
66140    ) -> Result<(), fidl::Error> {
66141        let _result = self.send_raw(result);
66142        if _result.is_err() {
66143            self.control_handle.shutdown();
66144        }
66145        self.drop_without_shutdown();
66146        _result
66147    }
66148
66149    /// Similar to "send" but does not shutdown the channel if an error occurs.
66150    pub fn send_no_shutdown_on_err(
66151        self,
66152        mut result: Result<(), fidl_fuchsia_posix::Errno>,
66153    ) -> Result<(), fidl::Error> {
66154        let _result = self.send_raw(result);
66155        self.drop_without_shutdown();
66156        _result
66157    }
66158
66159    fn send_raw(
66160        &self,
66161        mut result: Result<(), fidl_fuchsia_posix::Errno>,
66162    ) -> Result<(), fidl::Error> {
66163        self.control_handle.inner.send::<fidl::encoding::ResultType<
66164            fidl::encoding::EmptyStruct,
66165            fidl_fuchsia_posix::Errno,
66166        >>(
66167            result,
66168            self.tx_id,
66169            0x62e26891541143a0,
66170            fidl::encoding::DynamicFlags::empty(),
66171        )
66172    }
66173}
66174
66175#[must_use = "FIDL methods require a response to be sent"]
66176#[derive(Debug)]
66177pub struct StreamSocketGetTcpCorkResponder {
66178    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
66179    tx_id: u32,
66180}
66181
66182/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
66183/// if the responder is dropped without sending a response, so that the client
66184/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
66185impl std::ops::Drop for StreamSocketGetTcpCorkResponder {
66186    fn drop(&mut self) {
66187        self.control_handle.shutdown();
66188        // Safety: drops once, never accessed again
66189        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66190    }
66191}
66192
66193impl fidl::endpoints::Responder for StreamSocketGetTcpCorkResponder {
66194    type ControlHandle = StreamSocketControlHandle;
66195
66196    fn control_handle(&self) -> &StreamSocketControlHandle {
66197        &self.control_handle
66198    }
66199
66200    fn drop_without_shutdown(mut self) {
66201        // Safety: drops once, never accessed again due to mem::forget
66202        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66203        // Prevent Drop from running (which would shut down the channel)
66204        std::mem::forget(self);
66205    }
66206}
66207
66208impl StreamSocketGetTcpCorkResponder {
66209    /// Sends a response to the FIDL transaction.
66210    ///
66211    /// Sets the channel to shutdown if an error occurs.
66212    pub fn send(
66213        self,
66214        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
66215    ) -> Result<(), fidl::Error> {
66216        let _result = self.send_raw(result);
66217        if _result.is_err() {
66218            self.control_handle.shutdown();
66219        }
66220        self.drop_without_shutdown();
66221        _result
66222    }
66223
66224    /// Similar to "send" but does not shutdown the channel if an error occurs.
66225    pub fn send_no_shutdown_on_err(
66226        self,
66227        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
66228    ) -> Result<(), fidl::Error> {
66229        let _result = self.send_raw(result);
66230        self.drop_without_shutdown();
66231        _result
66232    }
66233
66234    fn send_raw(
66235        &self,
66236        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
66237    ) -> Result<(), fidl::Error> {
66238        self.control_handle.inner.send::<fidl::encoding::ResultType<
66239            StreamSocketGetTcpCorkResponse,
66240            fidl_fuchsia_posix::Errno,
66241        >>(
66242            result.map(|value| (value,)),
66243            self.tx_id,
66244            0x435bb232e0e74f32,
66245            fidl::encoding::DynamicFlags::empty(),
66246        )
66247    }
66248}
66249
66250#[must_use = "FIDL methods require a response to be sent"]
66251#[derive(Debug)]
66252pub struct StreamSocketSetTcpKeepAliveIdleResponder {
66253    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
66254    tx_id: u32,
66255}
66256
66257/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
66258/// if the responder is dropped without sending a response, so that the client
66259/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
66260impl std::ops::Drop for StreamSocketSetTcpKeepAliveIdleResponder {
66261    fn drop(&mut self) {
66262        self.control_handle.shutdown();
66263        // Safety: drops once, never accessed again
66264        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66265    }
66266}
66267
66268impl fidl::endpoints::Responder for StreamSocketSetTcpKeepAliveIdleResponder {
66269    type ControlHandle = StreamSocketControlHandle;
66270
66271    fn control_handle(&self) -> &StreamSocketControlHandle {
66272        &self.control_handle
66273    }
66274
66275    fn drop_without_shutdown(mut self) {
66276        // Safety: drops once, never accessed again due to mem::forget
66277        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66278        // Prevent Drop from running (which would shut down the channel)
66279        std::mem::forget(self);
66280    }
66281}
66282
66283impl StreamSocketSetTcpKeepAliveIdleResponder {
66284    /// Sends a response to the FIDL transaction.
66285    ///
66286    /// Sets the channel to shutdown if an error occurs.
66287    pub fn send(
66288        self,
66289        mut result: Result<(), fidl_fuchsia_posix::Errno>,
66290    ) -> Result<(), fidl::Error> {
66291        let _result = self.send_raw(result);
66292        if _result.is_err() {
66293            self.control_handle.shutdown();
66294        }
66295        self.drop_without_shutdown();
66296        _result
66297    }
66298
66299    /// Similar to "send" but does not shutdown the channel if an error occurs.
66300    pub fn send_no_shutdown_on_err(
66301        self,
66302        mut result: Result<(), fidl_fuchsia_posix::Errno>,
66303    ) -> Result<(), fidl::Error> {
66304        let _result = self.send_raw(result);
66305        self.drop_without_shutdown();
66306        _result
66307    }
66308
66309    fn send_raw(
66310        &self,
66311        mut result: Result<(), fidl_fuchsia_posix::Errno>,
66312    ) -> Result<(), fidl::Error> {
66313        self.control_handle.inner.send::<fidl::encoding::ResultType<
66314            fidl::encoding::EmptyStruct,
66315            fidl_fuchsia_posix::Errno,
66316        >>(
66317            result,
66318            self.tx_id,
66319            0x196d053d8363c42,
66320            fidl::encoding::DynamicFlags::empty(),
66321        )
66322    }
66323}
66324
66325#[must_use = "FIDL methods require a response to be sent"]
66326#[derive(Debug)]
66327pub struct StreamSocketGetTcpKeepAliveIdleResponder {
66328    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
66329    tx_id: u32,
66330}
66331
66332/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
66333/// if the responder is dropped without sending a response, so that the client
66334/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
66335impl std::ops::Drop for StreamSocketGetTcpKeepAliveIdleResponder {
66336    fn drop(&mut self) {
66337        self.control_handle.shutdown();
66338        // Safety: drops once, never accessed again
66339        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66340    }
66341}
66342
66343impl fidl::endpoints::Responder for StreamSocketGetTcpKeepAliveIdleResponder {
66344    type ControlHandle = StreamSocketControlHandle;
66345
66346    fn control_handle(&self) -> &StreamSocketControlHandle {
66347        &self.control_handle
66348    }
66349
66350    fn drop_without_shutdown(mut self) {
66351        // Safety: drops once, never accessed again due to mem::forget
66352        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66353        // Prevent Drop from running (which would shut down the channel)
66354        std::mem::forget(self);
66355    }
66356}
66357
66358impl StreamSocketGetTcpKeepAliveIdleResponder {
66359    /// Sends a response to the FIDL transaction.
66360    ///
66361    /// Sets the channel to shutdown if an error occurs.
66362    pub fn send(
66363        self,
66364        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
66365    ) -> Result<(), fidl::Error> {
66366        let _result = self.send_raw(result);
66367        if _result.is_err() {
66368            self.control_handle.shutdown();
66369        }
66370        self.drop_without_shutdown();
66371        _result
66372    }
66373
66374    /// Similar to "send" but does not shutdown the channel if an error occurs.
66375    pub fn send_no_shutdown_on_err(
66376        self,
66377        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
66378    ) -> Result<(), fidl::Error> {
66379        let _result = self.send_raw(result);
66380        self.drop_without_shutdown();
66381        _result
66382    }
66383
66384    fn send_raw(
66385        &self,
66386        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
66387    ) -> Result<(), fidl::Error> {
66388        self.control_handle.inner.send::<fidl::encoding::ResultType<
66389            StreamSocketGetTcpKeepAliveIdleResponse,
66390            fidl_fuchsia_posix::Errno,
66391        >>(
66392            result.map(|value_secs| (value_secs,)),
66393            self.tx_id,
66394            0x35ec58564879dac,
66395            fidl::encoding::DynamicFlags::empty(),
66396        )
66397    }
66398}
66399
66400#[must_use = "FIDL methods require a response to be sent"]
66401#[derive(Debug)]
66402pub struct StreamSocketSetTcpKeepAliveIntervalResponder {
66403    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
66404    tx_id: u32,
66405}
66406
66407/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
66408/// if the responder is dropped without sending a response, so that the client
66409/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
66410impl std::ops::Drop for StreamSocketSetTcpKeepAliveIntervalResponder {
66411    fn drop(&mut self) {
66412        self.control_handle.shutdown();
66413        // Safety: drops once, never accessed again
66414        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66415    }
66416}
66417
66418impl fidl::endpoints::Responder for StreamSocketSetTcpKeepAliveIntervalResponder {
66419    type ControlHandle = StreamSocketControlHandle;
66420
66421    fn control_handle(&self) -> &StreamSocketControlHandle {
66422        &self.control_handle
66423    }
66424
66425    fn drop_without_shutdown(mut self) {
66426        // Safety: drops once, never accessed again due to mem::forget
66427        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66428        // Prevent Drop from running (which would shut down the channel)
66429        std::mem::forget(self);
66430    }
66431}
66432
66433impl StreamSocketSetTcpKeepAliveIntervalResponder {
66434    /// Sends a response to the FIDL transaction.
66435    ///
66436    /// Sets the channel to shutdown if an error occurs.
66437    pub fn send(
66438        self,
66439        mut result: Result<(), fidl_fuchsia_posix::Errno>,
66440    ) -> Result<(), fidl::Error> {
66441        let _result = self.send_raw(result);
66442        if _result.is_err() {
66443            self.control_handle.shutdown();
66444        }
66445        self.drop_without_shutdown();
66446        _result
66447    }
66448
66449    /// Similar to "send" but does not shutdown the channel if an error occurs.
66450    pub fn send_no_shutdown_on_err(
66451        self,
66452        mut result: Result<(), fidl_fuchsia_posix::Errno>,
66453    ) -> Result<(), fidl::Error> {
66454        let _result = self.send_raw(result);
66455        self.drop_without_shutdown();
66456        _result
66457    }
66458
66459    fn send_raw(
66460        &self,
66461        mut result: Result<(), fidl_fuchsia_posix::Errno>,
66462    ) -> Result<(), fidl::Error> {
66463        self.control_handle.inner.send::<fidl::encoding::ResultType<
66464            fidl::encoding::EmptyStruct,
66465            fidl_fuchsia_posix::Errno,
66466        >>(
66467            result,
66468            self.tx_id,
66469            0x485ffbc2da1243f2,
66470            fidl::encoding::DynamicFlags::empty(),
66471        )
66472    }
66473}
66474
66475#[must_use = "FIDL methods require a response to be sent"]
66476#[derive(Debug)]
66477pub struct StreamSocketGetTcpKeepAliveIntervalResponder {
66478    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
66479    tx_id: u32,
66480}
66481
66482/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
66483/// if the responder is dropped without sending a response, so that the client
66484/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
66485impl std::ops::Drop for StreamSocketGetTcpKeepAliveIntervalResponder {
66486    fn drop(&mut self) {
66487        self.control_handle.shutdown();
66488        // Safety: drops once, never accessed again
66489        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66490    }
66491}
66492
66493impl fidl::endpoints::Responder for StreamSocketGetTcpKeepAliveIntervalResponder {
66494    type ControlHandle = StreamSocketControlHandle;
66495
66496    fn control_handle(&self) -> &StreamSocketControlHandle {
66497        &self.control_handle
66498    }
66499
66500    fn drop_without_shutdown(mut self) {
66501        // Safety: drops once, never accessed again due to mem::forget
66502        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66503        // Prevent Drop from running (which would shut down the channel)
66504        std::mem::forget(self);
66505    }
66506}
66507
66508impl StreamSocketGetTcpKeepAliveIntervalResponder {
66509    /// Sends a response to the FIDL transaction.
66510    ///
66511    /// Sets the channel to shutdown if an error occurs.
66512    pub fn send(
66513        self,
66514        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
66515    ) -> Result<(), fidl::Error> {
66516        let _result = self.send_raw(result);
66517        if _result.is_err() {
66518            self.control_handle.shutdown();
66519        }
66520        self.drop_without_shutdown();
66521        _result
66522    }
66523
66524    /// Similar to "send" but does not shutdown the channel if an error occurs.
66525    pub fn send_no_shutdown_on_err(
66526        self,
66527        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
66528    ) -> Result<(), fidl::Error> {
66529        let _result = self.send_raw(result);
66530        self.drop_without_shutdown();
66531        _result
66532    }
66533
66534    fn send_raw(
66535        &self,
66536        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
66537    ) -> Result<(), fidl::Error> {
66538        self.control_handle.inner.send::<fidl::encoding::ResultType<
66539            StreamSocketGetTcpKeepAliveIntervalResponse,
66540            fidl_fuchsia_posix::Errno,
66541        >>(
66542            result.map(|value_secs| (value_secs,)),
66543            self.tx_id,
66544            0x264eaf46306b284,
66545            fidl::encoding::DynamicFlags::empty(),
66546        )
66547    }
66548}
66549
66550#[must_use = "FIDL methods require a response to be sent"]
66551#[derive(Debug)]
66552pub struct StreamSocketSetTcpKeepAliveCountResponder {
66553    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
66554    tx_id: u32,
66555}
66556
66557/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
66558/// if the responder is dropped without sending a response, so that the client
66559/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
66560impl std::ops::Drop for StreamSocketSetTcpKeepAliveCountResponder {
66561    fn drop(&mut self) {
66562        self.control_handle.shutdown();
66563        // Safety: drops once, never accessed again
66564        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66565    }
66566}
66567
66568impl fidl::endpoints::Responder for StreamSocketSetTcpKeepAliveCountResponder {
66569    type ControlHandle = StreamSocketControlHandle;
66570
66571    fn control_handle(&self) -> &StreamSocketControlHandle {
66572        &self.control_handle
66573    }
66574
66575    fn drop_without_shutdown(mut self) {
66576        // Safety: drops once, never accessed again due to mem::forget
66577        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66578        // Prevent Drop from running (which would shut down the channel)
66579        std::mem::forget(self);
66580    }
66581}
66582
66583impl StreamSocketSetTcpKeepAliveCountResponder {
66584    /// Sends a response to the FIDL transaction.
66585    ///
66586    /// Sets the channel to shutdown if an error occurs.
66587    pub fn send(
66588        self,
66589        mut result: Result<(), fidl_fuchsia_posix::Errno>,
66590    ) -> Result<(), fidl::Error> {
66591        let _result = self.send_raw(result);
66592        if _result.is_err() {
66593            self.control_handle.shutdown();
66594        }
66595        self.drop_without_shutdown();
66596        _result
66597    }
66598
66599    /// Similar to "send" but does not shutdown the channel if an error occurs.
66600    pub fn send_no_shutdown_on_err(
66601        self,
66602        mut result: Result<(), fidl_fuchsia_posix::Errno>,
66603    ) -> Result<(), fidl::Error> {
66604        let _result = self.send_raw(result);
66605        self.drop_without_shutdown();
66606        _result
66607    }
66608
66609    fn send_raw(
66610        &self,
66611        mut result: Result<(), fidl_fuchsia_posix::Errno>,
66612    ) -> Result<(), fidl::Error> {
66613        self.control_handle.inner.send::<fidl::encoding::ResultType<
66614            fidl::encoding::EmptyStruct,
66615            fidl_fuchsia_posix::Errno,
66616        >>(
66617            result,
66618            self.tx_id,
66619            0x2ab2e8c111708421,
66620            fidl::encoding::DynamicFlags::empty(),
66621        )
66622    }
66623}
66624
66625#[must_use = "FIDL methods require a response to be sent"]
66626#[derive(Debug)]
66627pub struct StreamSocketGetTcpKeepAliveCountResponder {
66628    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
66629    tx_id: u32,
66630}
66631
66632/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
66633/// if the responder is dropped without sending a response, so that the client
66634/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
66635impl std::ops::Drop for StreamSocketGetTcpKeepAliveCountResponder {
66636    fn drop(&mut self) {
66637        self.control_handle.shutdown();
66638        // Safety: drops once, never accessed again
66639        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66640    }
66641}
66642
66643impl fidl::endpoints::Responder for StreamSocketGetTcpKeepAliveCountResponder {
66644    type ControlHandle = StreamSocketControlHandle;
66645
66646    fn control_handle(&self) -> &StreamSocketControlHandle {
66647        &self.control_handle
66648    }
66649
66650    fn drop_without_shutdown(mut self) {
66651        // Safety: drops once, never accessed again due to mem::forget
66652        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66653        // Prevent Drop from running (which would shut down the channel)
66654        std::mem::forget(self);
66655    }
66656}
66657
66658impl StreamSocketGetTcpKeepAliveCountResponder {
66659    /// Sends a response to the FIDL transaction.
66660    ///
66661    /// Sets the channel to shutdown if an error occurs.
66662    pub fn send(
66663        self,
66664        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
66665    ) -> Result<(), fidl::Error> {
66666        let _result = self.send_raw(result);
66667        if _result.is_err() {
66668            self.control_handle.shutdown();
66669        }
66670        self.drop_without_shutdown();
66671        _result
66672    }
66673
66674    /// Similar to "send" but does not shutdown the channel if an error occurs.
66675    pub fn send_no_shutdown_on_err(
66676        self,
66677        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
66678    ) -> Result<(), fidl::Error> {
66679        let _result = self.send_raw(result);
66680        self.drop_without_shutdown();
66681        _result
66682    }
66683
66684    fn send_raw(
66685        &self,
66686        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
66687    ) -> Result<(), fidl::Error> {
66688        self.control_handle.inner.send::<fidl::encoding::ResultType<
66689            StreamSocketGetTcpKeepAliveCountResponse,
66690            fidl_fuchsia_posix::Errno,
66691        >>(
66692            result.map(|value| (value,)),
66693            self.tx_id,
66694            0x2f176ae271fe7a09,
66695            fidl::encoding::DynamicFlags::empty(),
66696        )
66697    }
66698}
66699
66700#[must_use = "FIDL methods require a response to be sent"]
66701#[derive(Debug)]
66702pub struct StreamSocketSetTcpSynCountResponder {
66703    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
66704    tx_id: u32,
66705}
66706
66707/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
66708/// if the responder is dropped without sending a response, so that the client
66709/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
66710impl std::ops::Drop for StreamSocketSetTcpSynCountResponder {
66711    fn drop(&mut self) {
66712        self.control_handle.shutdown();
66713        // Safety: drops once, never accessed again
66714        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66715    }
66716}
66717
66718impl fidl::endpoints::Responder for StreamSocketSetTcpSynCountResponder {
66719    type ControlHandle = StreamSocketControlHandle;
66720
66721    fn control_handle(&self) -> &StreamSocketControlHandle {
66722        &self.control_handle
66723    }
66724
66725    fn drop_without_shutdown(mut self) {
66726        // Safety: drops once, never accessed again due to mem::forget
66727        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66728        // Prevent Drop from running (which would shut down the channel)
66729        std::mem::forget(self);
66730    }
66731}
66732
66733impl StreamSocketSetTcpSynCountResponder {
66734    /// Sends a response to the FIDL transaction.
66735    ///
66736    /// Sets the channel to shutdown if an error occurs.
66737    pub fn send(
66738        self,
66739        mut result: Result<(), fidl_fuchsia_posix::Errno>,
66740    ) -> Result<(), fidl::Error> {
66741        let _result = self.send_raw(result);
66742        if _result.is_err() {
66743            self.control_handle.shutdown();
66744        }
66745        self.drop_without_shutdown();
66746        _result
66747    }
66748
66749    /// Similar to "send" but does not shutdown the channel if an error occurs.
66750    pub fn send_no_shutdown_on_err(
66751        self,
66752        mut result: Result<(), fidl_fuchsia_posix::Errno>,
66753    ) -> Result<(), fidl::Error> {
66754        let _result = self.send_raw(result);
66755        self.drop_without_shutdown();
66756        _result
66757    }
66758
66759    fn send_raw(
66760        &self,
66761        mut result: Result<(), fidl_fuchsia_posix::Errno>,
66762    ) -> Result<(), fidl::Error> {
66763        self.control_handle.inner.send::<fidl::encoding::ResultType<
66764            fidl::encoding::EmptyStruct,
66765            fidl_fuchsia_posix::Errno,
66766        >>(
66767            result,
66768            self.tx_id,
66769            0x4dcd6ab5573c1eb3,
66770            fidl::encoding::DynamicFlags::empty(),
66771        )
66772    }
66773}
66774
66775#[must_use = "FIDL methods require a response to be sent"]
66776#[derive(Debug)]
66777pub struct StreamSocketGetTcpSynCountResponder {
66778    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
66779    tx_id: u32,
66780}
66781
66782/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
66783/// if the responder is dropped without sending a response, so that the client
66784/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
66785impl std::ops::Drop for StreamSocketGetTcpSynCountResponder {
66786    fn drop(&mut self) {
66787        self.control_handle.shutdown();
66788        // Safety: drops once, never accessed again
66789        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66790    }
66791}
66792
66793impl fidl::endpoints::Responder for StreamSocketGetTcpSynCountResponder {
66794    type ControlHandle = StreamSocketControlHandle;
66795
66796    fn control_handle(&self) -> &StreamSocketControlHandle {
66797        &self.control_handle
66798    }
66799
66800    fn drop_without_shutdown(mut self) {
66801        // Safety: drops once, never accessed again due to mem::forget
66802        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66803        // Prevent Drop from running (which would shut down the channel)
66804        std::mem::forget(self);
66805    }
66806}
66807
66808impl StreamSocketGetTcpSynCountResponder {
66809    /// Sends a response to the FIDL transaction.
66810    ///
66811    /// Sets the channel to shutdown if an error occurs.
66812    pub fn send(
66813        self,
66814        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
66815    ) -> Result<(), fidl::Error> {
66816        let _result = self.send_raw(result);
66817        if _result.is_err() {
66818            self.control_handle.shutdown();
66819        }
66820        self.drop_without_shutdown();
66821        _result
66822    }
66823
66824    /// Similar to "send" but does not shutdown the channel if an error occurs.
66825    pub fn send_no_shutdown_on_err(
66826        self,
66827        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
66828    ) -> Result<(), fidl::Error> {
66829        let _result = self.send_raw(result);
66830        self.drop_without_shutdown();
66831        _result
66832    }
66833
66834    fn send_raw(
66835        &self,
66836        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
66837    ) -> Result<(), fidl::Error> {
66838        self.control_handle.inner.send::<fidl::encoding::ResultType<
66839            StreamSocketGetTcpSynCountResponse,
66840            fidl_fuchsia_posix::Errno,
66841        >>(
66842            result.map(|value| (value,)),
66843            self.tx_id,
66844            0x7d457cba8f5f3ee6,
66845            fidl::encoding::DynamicFlags::empty(),
66846        )
66847    }
66848}
66849
66850#[must_use = "FIDL methods require a response to be sent"]
66851#[derive(Debug)]
66852pub struct StreamSocketSetTcpLingerResponder {
66853    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
66854    tx_id: u32,
66855}
66856
66857/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
66858/// if the responder is dropped without sending a response, so that the client
66859/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
66860impl std::ops::Drop for StreamSocketSetTcpLingerResponder {
66861    fn drop(&mut self) {
66862        self.control_handle.shutdown();
66863        // Safety: drops once, never accessed again
66864        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66865    }
66866}
66867
66868impl fidl::endpoints::Responder for StreamSocketSetTcpLingerResponder {
66869    type ControlHandle = StreamSocketControlHandle;
66870
66871    fn control_handle(&self) -> &StreamSocketControlHandle {
66872        &self.control_handle
66873    }
66874
66875    fn drop_without_shutdown(mut self) {
66876        // Safety: drops once, never accessed again due to mem::forget
66877        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66878        // Prevent Drop from running (which would shut down the channel)
66879        std::mem::forget(self);
66880    }
66881}
66882
66883impl StreamSocketSetTcpLingerResponder {
66884    /// Sends a response to the FIDL transaction.
66885    ///
66886    /// Sets the channel to shutdown if an error occurs.
66887    pub fn send(
66888        self,
66889        mut result: Result<(), fidl_fuchsia_posix::Errno>,
66890    ) -> Result<(), fidl::Error> {
66891        let _result = self.send_raw(result);
66892        if _result.is_err() {
66893            self.control_handle.shutdown();
66894        }
66895        self.drop_without_shutdown();
66896        _result
66897    }
66898
66899    /// Similar to "send" but does not shutdown the channel if an error occurs.
66900    pub fn send_no_shutdown_on_err(
66901        self,
66902        mut result: Result<(), fidl_fuchsia_posix::Errno>,
66903    ) -> Result<(), fidl::Error> {
66904        let _result = self.send_raw(result);
66905        self.drop_without_shutdown();
66906        _result
66907    }
66908
66909    fn send_raw(
66910        &self,
66911        mut result: Result<(), fidl_fuchsia_posix::Errno>,
66912    ) -> Result<(), fidl::Error> {
66913        self.control_handle.inner.send::<fidl::encoding::ResultType<
66914            fidl::encoding::EmptyStruct,
66915            fidl_fuchsia_posix::Errno,
66916        >>(
66917            result,
66918            self.tx_id,
66919            0xd5cc1e8654d36e4,
66920            fidl::encoding::DynamicFlags::empty(),
66921        )
66922    }
66923}
66924
66925#[must_use = "FIDL methods require a response to be sent"]
66926#[derive(Debug)]
66927pub struct StreamSocketGetTcpLingerResponder {
66928    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
66929    tx_id: u32,
66930}
66931
66932/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
66933/// if the responder is dropped without sending a response, so that the client
66934/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
66935impl std::ops::Drop for StreamSocketGetTcpLingerResponder {
66936    fn drop(&mut self) {
66937        self.control_handle.shutdown();
66938        // Safety: drops once, never accessed again
66939        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66940    }
66941}
66942
66943impl fidl::endpoints::Responder for StreamSocketGetTcpLingerResponder {
66944    type ControlHandle = StreamSocketControlHandle;
66945
66946    fn control_handle(&self) -> &StreamSocketControlHandle {
66947        &self.control_handle
66948    }
66949
66950    fn drop_without_shutdown(mut self) {
66951        // Safety: drops once, never accessed again due to mem::forget
66952        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
66953        // Prevent Drop from running (which would shut down the channel)
66954        std::mem::forget(self);
66955    }
66956}
66957
66958impl StreamSocketGetTcpLingerResponder {
66959    /// Sends a response to the FIDL transaction.
66960    ///
66961    /// Sets the channel to shutdown if an error occurs.
66962    pub fn send(
66963        self,
66964        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
66965    ) -> Result<(), fidl::Error> {
66966        let _result = self.send_raw(result);
66967        if _result.is_err() {
66968            self.control_handle.shutdown();
66969        }
66970        self.drop_without_shutdown();
66971        _result
66972    }
66973
66974    /// Similar to "send" but does not shutdown the channel if an error occurs.
66975    pub fn send_no_shutdown_on_err(
66976        self,
66977        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
66978    ) -> Result<(), fidl::Error> {
66979        let _result = self.send_raw(result);
66980        self.drop_without_shutdown();
66981        _result
66982    }
66983
66984    fn send_raw(
66985        &self,
66986        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
66987    ) -> Result<(), fidl::Error> {
66988        self.control_handle.inner.send::<fidl::encoding::ResultType<
66989            StreamSocketGetTcpLingerResponse,
66990            fidl_fuchsia_posix::Errno,
66991        >>(
66992            result.map(|value_secs| (value_secs,)),
66993            self.tx_id,
66994            0xad870d311cf30eb,
66995            fidl::encoding::DynamicFlags::empty(),
66996        )
66997    }
66998}
66999
67000#[must_use = "FIDL methods require a response to be sent"]
67001#[derive(Debug)]
67002pub struct StreamSocketSetTcpDeferAcceptResponder {
67003    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
67004    tx_id: u32,
67005}
67006
67007/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
67008/// if the responder is dropped without sending a response, so that the client
67009/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
67010impl std::ops::Drop for StreamSocketSetTcpDeferAcceptResponder {
67011    fn drop(&mut self) {
67012        self.control_handle.shutdown();
67013        // Safety: drops once, never accessed again
67014        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67015    }
67016}
67017
67018impl fidl::endpoints::Responder for StreamSocketSetTcpDeferAcceptResponder {
67019    type ControlHandle = StreamSocketControlHandle;
67020
67021    fn control_handle(&self) -> &StreamSocketControlHandle {
67022        &self.control_handle
67023    }
67024
67025    fn drop_without_shutdown(mut self) {
67026        // Safety: drops once, never accessed again due to mem::forget
67027        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67028        // Prevent Drop from running (which would shut down the channel)
67029        std::mem::forget(self);
67030    }
67031}
67032
67033impl StreamSocketSetTcpDeferAcceptResponder {
67034    /// Sends a response to the FIDL transaction.
67035    ///
67036    /// Sets the channel to shutdown if an error occurs.
67037    pub fn send(
67038        self,
67039        mut result: Result<(), fidl_fuchsia_posix::Errno>,
67040    ) -> Result<(), fidl::Error> {
67041        let _result = self.send_raw(result);
67042        if _result.is_err() {
67043            self.control_handle.shutdown();
67044        }
67045        self.drop_without_shutdown();
67046        _result
67047    }
67048
67049    /// Similar to "send" but does not shutdown the channel if an error occurs.
67050    pub fn send_no_shutdown_on_err(
67051        self,
67052        mut result: Result<(), fidl_fuchsia_posix::Errno>,
67053    ) -> Result<(), fidl::Error> {
67054        let _result = self.send_raw(result);
67055        self.drop_without_shutdown();
67056        _result
67057    }
67058
67059    fn send_raw(
67060        &self,
67061        mut result: Result<(), fidl_fuchsia_posix::Errno>,
67062    ) -> Result<(), fidl::Error> {
67063        self.control_handle.inner.send::<fidl::encoding::ResultType<
67064            fidl::encoding::EmptyStruct,
67065            fidl_fuchsia_posix::Errno,
67066        >>(
67067            result,
67068            self.tx_id,
67069            0x15092f181e57c404,
67070            fidl::encoding::DynamicFlags::empty(),
67071        )
67072    }
67073}
67074
67075#[must_use = "FIDL methods require a response to be sent"]
67076#[derive(Debug)]
67077pub struct StreamSocketGetTcpDeferAcceptResponder {
67078    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
67079    tx_id: u32,
67080}
67081
67082/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
67083/// if the responder is dropped without sending a response, so that the client
67084/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
67085impl std::ops::Drop for StreamSocketGetTcpDeferAcceptResponder {
67086    fn drop(&mut self) {
67087        self.control_handle.shutdown();
67088        // Safety: drops once, never accessed again
67089        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67090    }
67091}
67092
67093impl fidl::endpoints::Responder for StreamSocketGetTcpDeferAcceptResponder {
67094    type ControlHandle = StreamSocketControlHandle;
67095
67096    fn control_handle(&self) -> &StreamSocketControlHandle {
67097        &self.control_handle
67098    }
67099
67100    fn drop_without_shutdown(mut self) {
67101        // Safety: drops once, never accessed again due to mem::forget
67102        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67103        // Prevent Drop from running (which would shut down the channel)
67104        std::mem::forget(self);
67105    }
67106}
67107
67108impl StreamSocketGetTcpDeferAcceptResponder {
67109    /// Sends a response to the FIDL transaction.
67110    ///
67111    /// Sets the channel to shutdown if an error occurs.
67112    pub fn send(
67113        self,
67114        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
67115    ) -> Result<(), fidl::Error> {
67116        let _result = self.send_raw(result);
67117        if _result.is_err() {
67118            self.control_handle.shutdown();
67119        }
67120        self.drop_without_shutdown();
67121        _result
67122    }
67123
67124    /// Similar to "send" but does not shutdown the channel if an error occurs.
67125    pub fn send_no_shutdown_on_err(
67126        self,
67127        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
67128    ) -> Result<(), fidl::Error> {
67129        let _result = self.send_raw(result);
67130        self.drop_without_shutdown();
67131        _result
67132    }
67133
67134    fn send_raw(
67135        &self,
67136        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
67137    ) -> Result<(), fidl::Error> {
67138        self.control_handle.inner.send::<fidl::encoding::ResultType<
67139            StreamSocketGetTcpDeferAcceptResponse,
67140            fidl_fuchsia_posix::Errno,
67141        >>(
67142            result.map(|value_secs| (value_secs,)),
67143            self.tx_id,
67144            0x64589790842cb7c6,
67145            fidl::encoding::DynamicFlags::empty(),
67146        )
67147    }
67148}
67149
67150#[must_use = "FIDL methods require a response to be sent"]
67151#[derive(Debug)]
67152pub struct StreamSocketSetTcpWindowClampResponder {
67153    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
67154    tx_id: u32,
67155}
67156
67157/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
67158/// if the responder is dropped without sending a response, so that the client
67159/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
67160impl std::ops::Drop for StreamSocketSetTcpWindowClampResponder {
67161    fn drop(&mut self) {
67162        self.control_handle.shutdown();
67163        // Safety: drops once, never accessed again
67164        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67165    }
67166}
67167
67168impl fidl::endpoints::Responder for StreamSocketSetTcpWindowClampResponder {
67169    type ControlHandle = StreamSocketControlHandle;
67170
67171    fn control_handle(&self) -> &StreamSocketControlHandle {
67172        &self.control_handle
67173    }
67174
67175    fn drop_without_shutdown(mut self) {
67176        // Safety: drops once, never accessed again due to mem::forget
67177        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67178        // Prevent Drop from running (which would shut down the channel)
67179        std::mem::forget(self);
67180    }
67181}
67182
67183impl StreamSocketSetTcpWindowClampResponder {
67184    /// Sends a response to the FIDL transaction.
67185    ///
67186    /// Sets the channel to shutdown if an error occurs.
67187    pub fn send(
67188        self,
67189        mut result: Result<(), fidl_fuchsia_posix::Errno>,
67190    ) -> Result<(), fidl::Error> {
67191        let _result = self.send_raw(result);
67192        if _result.is_err() {
67193            self.control_handle.shutdown();
67194        }
67195        self.drop_without_shutdown();
67196        _result
67197    }
67198
67199    /// Similar to "send" but does not shutdown the channel if an error occurs.
67200    pub fn send_no_shutdown_on_err(
67201        self,
67202        mut result: Result<(), fidl_fuchsia_posix::Errno>,
67203    ) -> Result<(), fidl::Error> {
67204        let _result = self.send_raw(result);
67205        self.drop_without_shutdown();
67206        _result
67207    }
67208
67209    fn send_raw(
67210        &self,
67211        mut result: Result<(), fidl_fuchsia_posix::Errno>,
67212    ) -> Result<(), fidl::Error> {
67213        self.control_handle.inner.send::<fidl::encoding::ResultType<
67214            fidl::encoding::EmptyStruct,
67215            fidl_fuchsia_posix::Errno,
67216        >>(
67217            result,
67218            self.tx_id,
67219            0x4a26ce07d847f1c6,
67220            fidl::encoding::DynamicFlags::empty(),
67221        )
67222    }
67223}
67224
67225#[must_use = "FIDL methods require a response to be sent"]
67226#[derive(Debug)]
67227pub struct StreamSocketGetTcpWindowClampResponder {
67228    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
67229    tx_id: u32,
67230}
67231
67232/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
67233/// if the responder is dropped without sending a response, so that the client
67234/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
67235impl std::ops::Drop for StreamSocketGetTcpWindowClampResponder {
67236    fn drop(&mut self) {
67237        self.control_handle.shutdown();
67238        // Safety: drops once, never accessed again
67239        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67240    }
67241}
67242
67243impl fidl::endpoints::Responder for StreamSocketGetTcpWindowClampResponder {
67244    type ControlHandle = StreamSocketControlHandle;
67245
67246    fn control_handle(&self) -> &StreamSocketControlHandle {
67247        &self.control_handle
67248    }
67249
67250    fn drop_without_shutdown(mut self) {
67251        // Safety: drops once, never accessed again due to mem::forget
67252        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67253        // Prevent Drop from running (which would shut down the channel)
67254        std::mem::forget(self);
67255    }
67256}
67257
67258impl StreamSocketGetTcpWindowClampResponder {
67259    /// Sends a response to the FIDL transaction.
67260    ///
67261    /// Sets the channel to shutdown if an error occurs.
67262    pub fn send(
67263        self,
67264        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
67265    ) -> Result<(), fidl::Error> {
67266        let _result = self.send_raw(result);
67267        if _result.is_err() {
67268            self.control_handle.shutdown();
67269        }
67270        self.drop_without_shutdown();
67271        _result
67272    }
67273
67274    /// Similar to "send" but does not shutdown the channel if an error occurs.
67275    pub fn send_no_shutdown_on_err(
67276        self,
67277        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
67278    ) -> Result<(), fidl::Error> {
67279        let _result = self.send_raw(result);
67280        self.drop_without_shutdown();
67281        _result
67282    }
67283
67284    fn send_raw(
67285        &self,
67286        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
67287    ) -> Result<(), fidl::Error> {
67288        self.control_handle.inner.send::<fidl::encoding::ResultType<
67289            StreamSocketGetTcpWindowClampResponse,
67290            fidl_fuchsia_posix::Errno,
67291        >>(
67292            result.map(|value| (value,)),
67293            self.tx_id,
67294            0x2df6b636bf0a6a4e,
67295            fidl::encoding::DynamicFlags::empty(),
67296        )
67297    }
67298}
67299
67300#[must_use = "FIDL methods require a response to be sent"]
67301#[derive(Debug)]
67302pub struct StreamSocketGetTcpInfoResponder {
67303    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
67304    tx_id: u32,
67305}
67306
67307/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
67308/// if the responder is dropped without sending a response, so that the client
67309/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
67310impl std::ops::Drop for StreamSocketGetTcpInfoResponder {
67311    fn drop(&mut self) {
67312        self.control_handle.shutdown();
67313        // Safety: drops once, never accessed again
67314        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67315    }
67316}
67317
67318impl fidl::endpoints::Responder for StreamSocketGetTcpInfoResponder {
67319    type ControlHandle = StreamSocketControlHandle;
67320
67321    fn control_handle(&self) -> &StreamSocketControlHandle {
67322        &self.control_handle
67323    }
67324
67325    fn drop_without_shutdown(mut self) {
67326        // Safety: drops once, never accessed again due to mem::forget
67327        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67328        // Prevent Drop from running (which would shut down the channel)
67329        std::mem::forget(self);
67330    }
67331}
67332
67333impl StreamSocketGetTcpInfoResponder {
67334    /// Sends a response to the FIDL transaction.
67335    ///
67336    /// Sets the channel to shutdown if an error occurs.
67337    pub fn send(
67338        self,
67339        mut result: Result<&TcpInfo, fidl_fuchsia_posix::Errno>,
67340    ) -> Result<(), fidl::Error> {
67341        let _result = self.send_raw(result);
67342        if _result.is_err() {
67343            self.control_handle.shutdown();
67344        }
67345        self.drop_without_shutdown();
67346        _result
67347    }
67348
67349    /// Similar to "send" but does not shutdown the channel if an error occurs.
67350    pub fn send_no_shutdown_on_err(
67351        self,
67352        mut result: Result<&TcpInfo, fidl_fuchsia_posix::Errno>,
67353    ) -> Result<(), fidl::Error> {
67354        let _result = self.send_raw(result);
67355        self.drop_without_shutdown();
67356        _result
67357    }
67358
67359    fn send_raw(
67360        &self,
67361        mut result: Result<&TcpInfo, fidl_fuchsia_posix::Errno>,
67362    ) -> Result<(), fidl::Error> {
67363        self.control_handle.inner.send::<fidl::encoding::ResultType<
67364            StreamSocketGetTcpInfoResponse,
67365            fidl_fuchsia_posix::Errno,
67366        >>(
67367            result.map(|info| (info,)),
67368            self.tx_id,
67369            0x1ffb123d9f03ead2,
67370            fidl::encoding::DynamicFlags::empty(),
67371        )
67372    }
67373}
67374
67375#[must_use = "FIDL methods require a response to be sent"]
67376#[derive(Debug)]
67377pub struct StreamSocketSetTcpQuickAckResponder {
67378    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
67379    tx_id: u32,
67380}
67381
67382/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
67383/// if the responder is dropped without sending a response, so that the client
67384/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
67385impl std::ops::Drop for StreamSocketSetTcpQuickAckResponder {
67386    fn drop(&mut self) {
67387        self.control_handle.shutdown();
67388        // Safety: drops once, never accessed again
67389        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67390    }
67391}
67392
67393impl fidl::endpoints::Responder for StreamSocketSetTcpQuickAckResponder {
67394    type ControlHandle = StreamSocketControlHandle;
67395
67396    fn control_handle(&self) -> &StreamSocketControlHandle {
67397        &self.control_handle
67398    }
67399
67400    fn drop_without_shutdown(mut self) {
67401        // Safety: drops once, never accessed again due to mem::forget
67402        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67403        // Prevent Drop from running (which would shut down the channel)
67404        std::mem::forget(self);
67405    }
67406}
67407
67408impl StreamSocketSetTcpQuickAckResponder {
67409    /// Sends a response to the FIDL transaction.
67410    ///
67411    /// Sets the channel to shutdown if an error occurs.
67412    pub fn send(
67413        self,
67414        mut result: Result<(), fidl_fuchsia_posix::Errno>,
67415    ) -> Result<(), fidl::Error> {
67416        let _result = self.send_raw(result);
67417        if _result.is_err() {
67418            self.control_handle.shutdown();
67419        }
67420        self.drop_without_shutdown();
67421        _result
67422    }
67423
67424    /// Similar to "send" but does not shutdown the channel if an error occurs.
67425    pub fn send_no_shutdown_on_err(
67426        self,
67427        mut result: Result<(), fidl_fuchsia_posix::Errno>,
67428    ) -> Result<(), fidl::Error> {
67429        let _result = self.send_raw(result);
67430        self.drop_without_shutdown();
67431        _result
67432    }
67433
67434    fn send_raw(
67435        &self,
67436        mut result: Result<(), fidl_fuchsia_posix::Errno>,
67437    ) -> Result<(), fidl::Error> {
67438        self.control_handle.inner.send::<fidl::encoding::ResultType<
67439            fidl::encoding::EmptyStruct,
67440            fidl_fuchsia_posix::Errno,
67441        >>(
67442            result,
67443            self.tx_id,
67444            0x6fa811be8fde7457,
67445            fidl::encoding::DynamicFlags::empty(),
67446        )
67447    }
67448}
67449
67450#[must_use = "FIDL methods require a response to be sent"]
67451#[derive(Debug)]
67452pub struct StreamSocketGetTcpQuickAckResponder {
67453    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
67454    tx_id: u32,
67455}
67456
67457/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
67458/// if the responder is dropped without sending a response, so that the client
67459/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
67460impl std::ops::Drop for StreamSocketGetTcpQuickAckResponder {
67461    fn drop(&mut self) {
67462        self.control_handle.shutdown();
67463        // Safety: drops once, never accessed again
67464        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67465    }
67466}
67467
67468impl fidl::endpoints::Responder for StreamSocketGetTcpQuickAckResponder {
67469    type ControlHandle = StreamSocketControlHandle;
67470
67471    fn control_handle(&self) -> &StreamSocketControlHandle {
67472        &self.control_handle
67473    }
67474
67475    fn drop_without_shutdown(mut self) {
67476        // Safety: drops once, never accessed again due to mem::forget
67477        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67478        // Prevent Drop from running (which would shut down the channel)
67479        std::mem::forget(self);
67480    }
67481}
67482
67483impl StreamSocketGetTcpQuickAckResponder {
67484    /// Sends a response to the FIDL transaction.
67485    ///
67486    /// Sets the channel to shutdown if an error occurs.
67487    pub fn send(
67488        self,
67489        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
67490    ) -> Result<(), fidl::Error> {
67491        let _result = self.send_raw(result);
67492        if _result.is_err() {
67493            self.control_handle.shutdown();
67494        }
67495        self.drop_without_shutdown();
67496        _result
67497    }
67498
67499    /// Similar to "send" but does not shutdown the channel if an error occurs.
67500    pub fn send_no_shutdown_on_err(
67501        self,
67502        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
67503    ) -> Result<(), fidl::Error> {
67504        let _result = self.send_raw(result);
67505        self.drop_without_shutdown();
67506        _result
67507    }
67508
67509    fn send_raw(
67510        &self,
67511        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
67512    ) -> Result<(), fidl::Error> {
67513        self.control_handle.inner.send::<fidl::encoding::ResultType<
67514            StreamSocketGetTcpQuickAckResponse,
67515            fidl_fuchsia_posix::Errno,
67516        >>(
67517            result.map(|value| (value,)),
67518            self.tx_id,
67519            0x7356a949bef2df32,
67520            fidl::encoding::DynamicFlags::empty(),
67521        )
67522    }
67523}
67524
67525#[must_use = "FIDL methods require a response to be sent"]
67526#[derive(Debug)]
67527pub struct StreamSocketSetTcpCongestionResponder {
67528    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
67529    tx_id: u32,
67530}
67531
67532/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
67533/// if the responder is dropped without sending a response, so that the client
67534/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
67535impl std::ops::Drop for StreamSocketSetTcpCongestionResponder {
67536    fn drop(&mut self) {
67537        self.control_handle.shutdown();
67538        // Safety: drops once, never accessed again
67539        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67540    }
67541}
67542
67543impl fidl::endpoints::Responder for StreamSocketSetTcpCongestionResponder {
67544    type ControlHandle = StreamSocketControlHandle;
67545
67546    fn control_handle(&self) -> &StreamSocketControlHandle {
67547        &self.control_handle
67548    }
67549
67550    fn drop_without_shutdown(mut self) {
67551        // Safety: drops once, never accessed again due to mem::forget
67552        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67553        // Prevent Drop from running (which would shut down the channel)
67554        std::mem::forget(self);
67555    }
67556}
67557
67558impl StreamSocketSetTcpCongestionResponder {
67559    /// Sends a response to the FIDL transaction.
67560    ///
67561    /// Sets the channel to shutdown if an error occurs.
67562    pub fn send(
67563        self,
67564        mut result: Result<(), fidl_fuchsia_posix::Errno>,
67565    ) -> Result<(), fidl::Error> {
67566        let _result = self.send_raw(result);
67567        if _result.is_err() {
67568            self.control_handle.shutdown();
67569        }
67570        self.drop_without_shutdown();
67571        _result
67572    }
67573
67574    /// Similar to "send" but does not shutdown the channel if an error occurs.
67575    pub fn send_no_shutdown_on_err(
67576        self,
67577        mut result: Result<(), fidl_fuchsia_posix::Errno>,
67578    ) -> Result<(), fidl::Error> {
67579        let _result = self.send_raw(result);
67580        self.drop_without_shutdown();
67581        _result
67582    }
67583
67584    fn send_raw(
67585        &self,
67586        mut result: Result<(), fidl_fuchsia_posix::Errno>,
67587    ) -> Result<(), fidl::Error> {
67588        self.control_handle.inner.send::<fidl::encoding::ResultType<
67589            fidl::encoding::EmptyStruct,
67590            fidl_fuchsia_posix::Errno,
67591        >>(
67592            result,
67593            self.tx_id,
67594            0x7924c6eabde7819e,
67595            fidl::encoding::DynamicFlags::empty(),
67596        )
67597    }
67598}
67599
67600#[must_use = "FIDL methods require a response to be sent"]
67601#[derive(Debug)]
67602pub struct StreamSocketGetTcpCongestionResponder {
67603    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
67604    tx_id: u32,
67605}
67606
67607/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
67608/// if the responder is dropped without sending a response, so that the client
67609/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
67610impl std::ops::Drop for StreamSocketGetTcpCongestionResponder {
67611    fn drop(&mut self) {
67612        self.control_handle.shutdown();
67613        // Safety: drops once, never accessed again
67614        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67615    }
67616}
67617
67618impl fidl::endpoints::Responder for StreamSocketGetTcpCongestionResponder {
67619    type ControlHandle = StreamSocketControlHandle;
67620
67621    fn control_handle(&self) -> &StreamSocketControlHandle {
67622        &self.control_handle
67623    }
67624
67625    fn drop_without_shutdown(mut self) {
67626        // Safety: drops once, never accessed again due to mem::forget
67627        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67628        // Prevent Drop from running (which would shut down the channel)
67629        std::mem::forget(self);
67630    }
67631}
67632
67633impl StreamSocketGetTcpCongestionResponder {
67634    /// Sends a response to the FIDL transaction.
67635    ///
67636    /// Sets the channel to shutdown if an error occurs.
67637    pub fn send(
67638        self,
67639        mut result: Result<TcpCongestionControl, fidl_fuchsia_posix::Errno>,
67640    ) -> Result<(), fidl::Error> {
67641        let _result = self.send_raw(result);
67642        if _result.is_err() {
67643            self.control_handle.shutdown();
67644        }
67645        self.drop_without_shutdown();
67646        _result
67647    }
67648
67649    /// Similar to "send" but does not shutdown the channel if an error occurs.
67650    pub fn send_no_shutdown_on_err(
67651        self,
67652        mut result: Result<TcpCongestionControl, fidl_fuchsia_posix::Errno>,
67653    ) -> Result<(), fidl::Error> {
67654        let _result = self.send_raw(result);
67655        self.drop_without_shutdown();
67656        _result
67657    }
67658
67659    fn send_raw(
67660        &self,
67661        mut result: Result<TcpCongestionControl, fidl_fuchsia_posix::Errno>,
67662    ) -> Result<(), fidl::Error> {
67663        self.control_handle.inner.send::<fidl::encoding::ResultType<
67664            StreamSocketGetTcpCongestionResponse,
67665            fidl_fuchsia_posix::Errno,
67666        >>(
67667            result.map(|value| (value,)),
67668            self.tx_id,
67669            0x11e16397e1b72a47,
67670            fidl::encoding::DynamicFlags::empty(),
67671        )
67672    }
67673}
67674
67675#[must_use = "FIDL methods require a response to be sent"]
67676#[derive(Debug)]
67677pub struct StreamSocketSetTcpUserTimeoutResponder {
67678    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
67679    tx_id: u32,
67680}
67681
67682/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
67683/// if the responder is dropped without sending a response, so that the client
67684/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
67685impl std::ops::Drop for StreamSocketSetTcpUserTimeoutResponder {
67686    fn drop(&mut self) {
67687        self.control_handle.shutdown();
67688        // Safety: drops once, never accessed again
67689        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67690    }
67691}
67692
67693impl fidl::endpoints::Responder for StreamSocketSetTcpUserTimeoutResponder {
67694    type ControlHandle = StreamSocketControlHandle;
67695
67696    fn control_handle(&self) -> &StreamSocketControlHandle {
67697        &self.control_handle
67698    }
67699
67700    fn drop_without_shutdown(mut self) {
67701        // Safety: drops once, never accessed again due to mem::forget
67702        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67703        // Prevent Drop from running (which would shut down the channel)
67704        std::mem::forget(self);
67705    }
67706}
67707
67708impl StreamSocketSetTcpUserTimeoutResponder {
67709    /// Sends a response to the FIDL transaction.
67710    ///
67711    /// Sets the channel to shutdown if an error occurs.
67712    pub fn send(
67713        self,
67714        mut result: Result<(), fidl_fuchsia_posix::Errno>,
67715    ) -> Result<(), fidl::Error> {
67716        let _result = self.send_raw(result);
67717        if _result.is_err() {
67718            self.control_handle.shutdown();
67719        }
67720        self.drop_without_shutdown();
67721        _result
67722    }
67723
67724    /// Similar to "send" but does not shutdown the channel if an error occurs.
67725    pub fn send_no_shutdown_on_err(
67726        self,
67727        mut result: Result<(), fidl_fuchsia_posix::Errno>,
67728    ) -> Result<(), fidl::Error> {
67729        let _result = self.send_raw(result);
67730        self.drop_without_shutdown();
67731        _result
67732    }
67733
67734    fn send_raw(
67735        &self,
67736        mut result: Result<(), fidl_fuchsia_posix::Errno>,
67737    ) -> Result<(), fidl::Error> {
67738        self.control_handle.inner.send::<fidl::encoding::ResultType<
67739            fidl::encoding::EmptyStruct,
67740            fidl_fuchsia_posix::Errno,
67741        >>(
67742            result,
67743            self.tx_id,
67744            0x6b459e81c3741a60,
67745            fidl::encoding::DynamicFlags::empty(),
67746        )
67747    }
67748}
67749
67750#[must_use = "FIDL methods require a response to be sent"]
67751#[derive(Debug)]
67752pub struct StreamSocketGetTcpUserTimeoutResponder {
67753    control_handle: std::mem::ManuallyDrop<StreamSocketControlHandle>,
67754    tx_id: u32,
67755}
67756
67757/// Set the the channel to be shutdown (see [`StreamSocketControlHandle::shutdown`])
67758/// if the responder is dropped without sending a response, so that the client
67759/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
67760impl std::ops::Drop for StreamSocketGetTcpUserTimeoutResponder {
67761    fn drop(&mut self) {
67762        self.control_handle.shutdown();
67763        // Safety: drops once, never accessed again
67764        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67765    }
67766}
67767
67768impl fidl::endpoints::Responder for StreamSocketGetTcpUserTimeoutResponder {
67769    type ControlHandle = StreamSocketControlHandle;
67770
67771    fn control_handle(&self) -> &StreamSocketControlHandle {
67772        &self.control_handle
67773    }
67774
67775    fn drop_without_shutdown(mut self) {
67776        // Safety: drops once, never accessed again due to mem::forget
67777        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
67778        // Prevent Drop from running (which would shut down the channel)
67779        std::mem::forget(self);
67780    }
67781}
67782
67783impl StreamSocketGetTcpUserTimeoutResponder {
67784    /// Sends a response to the FIDL transaction.
67785    ///
67786    /// Sets the channel to shutdown if an error occurs.
67787    pub fn send(
67788        self,
67789        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
67790    ) -> Result<(), fidl::Error> {
67791        let _result = self.send_raw(result);
67792        if _result.is_err() {
67793            self.control_handle.shutdown();
67794        }
67795        self.drop_without_shutdown();
67796        _result
67797    }
67798
67799    /// Similar to "send" but does not shutdown the channel if an error occurs.
67800    pub fn send_no_shutdown_on_err(
67801        self,
67802        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
67803    ) -> Result<(), fidl::Error> {
67804        let _result = self.send_raw(result);
67805        self.drop_without_shutdown();
67806        _result
67807    }
67808
67809    fn send_raw(
67810        &self,
67811        mut result: Result<u32, fidl_fuchsia_posix::Errno>,
67812    ) -> Result<(), fidl::Error> {
67813        self.control_handle.inner.send::<fidl::encoding::ResultType<
67814            StreamSocketGetTcpUserTimeoutResponse,
67815            fidl_fuchsia_posix::Errno,
67816        >>(
67817            result.map(|value_millis| (value_millis,)),
67818            self.tx_id,
67819            0x24bbd5858ad8c380,
67820            fidl::encoding::DynamicFlags::empty(),
67821        )
67822    }
67823}
67824
67825#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
67826pub struct SynchronousDatagramSocketMarker;
67827
67828impl fidl::endpoints::ProtocolMarker for SynchronousDatagramSocketMarker {
67829    type Proxy = SynchronousDatagramSocketProxy;
67830    type RequestStream = SynchronousDatagramSocketRequestStream;
67831    #[cfg(target_os = "fuchsia")]
67832    type SynchronousProxy = SynchronousDatagramSocketSynchronousProxy;
67833
67834    const DEBUG_NAME: &'static str = "fuchsia.posix.socket.SynchronousDatagramSocket";
67835}
67836impl fidl::endpoints::DiscoverableProtocolMarker for SynchronousDatagramSocketMarker {}
67837pub type SynchronousDatagramSocketRecvMsgResult = Result<
67838    (Option<Box<fidl_fuchsia_net::SocketAddress>>, Vec<u8>, DatagramSocketRecvControlData, u32),
67839    fidl_fuchsia_posix::Errno,
67840>;
67841pub type SynchronousDatagramSocketSendMsgResult = Result<i64, fidl_fuchsia_posix::Errno>;
67842
67843pub trait SynchronousDatagramSocketProxyInterface: Send + Sync {
67844    fn r#clone(
67845        &self,
67846        request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
67847    ) -> Result<(), fidl::Error>;
67848    type CloseResponseFut: std::future::Future<
67849            Output = Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error>,
67850        > + Send;
67851    fn r#close(&self) -> Self::CloseResponseFut;
67852    type QueryResponseFut: std::future::Future<Output = Result<Vec<u8>, fidl::Error>> + Send;
67853    fn r#query(&self) -> Self::QueryResponseFut;
67854    type SetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketSetReuseAddressResult, fidl::Error>>
67855        + Send;
67856    fn r#set_reuse_address(&self, value: bool) -> Self::SetReuseAddressResponseFut;
67857    type GetReuseAddressResponseFut: std::future::Future<Output = Result<BaseSocketGetReuseAddressResult, fidl::Error>>
67858        + Send;
67859    fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut;
67860    type GetErrorResponseFut: std::future::Future<Output = Result<BaseSocketGetErrorResult, fidl::Error>>
67861        + Send;
67862    fn r#get_error(&self) -> Self::GetErrorResponseFut;
67863    type SetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketSetBroadcastResult, fidl::Error>>
67864        + Send;
67865    fn r#set_broadcast(&self, value: bool) -> Self::SetBroadcastResponseFut;
67866    type GetBroadcastResponseFut: std::future::Future<Output = Result<BaseSocketGetBroadcastResult, fidl::Error>>
67867        + Send;
67868    fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut;
67869    type SetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetSendBufferResult, fidl::Error>>
67870        + Send;
67871    fn r#set_send_buffer(&self, value_bytes: u64) -> Self::SetSendBufferResponseFut;
67872    type GetSendBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetSendBufferResult, fidl::Error>>
67873        + Send;
67874    fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut;
67875    type SetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketSetReceiveBufferResult, fidl::Error>>
67876        + Send;
67877    fn r#set_receive_buffer(&self, value_bytes: u64) -> Self::SetReceiveBufferResponseFut;
67878    type GetReceiveBufferResponseFut: std::future::Future<Output = Result<BaseSocketGetReceiveBufferResult, fidl::Error>>
67879        + Send;
67880    fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut;
67881    type SetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketSetKeepAliveResult, fidl::Error>>
67882        + Send;
67883    fn r#set_keep_alive(&self, value: bool) -> Self::SetKeepAliveResponseFut;
67884    type GetKeepAliveResponseFut: std::future::Future<Output = Result<BaseSocketGetKeepAliveResult, fidl::Error>>
67885        + Send;
67886    fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut;
67887    type SetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketSetOutOfBandInlineResult, fidl::Error>>
67888        + Send;
67889    fn r#set_out_of_band_inline(&self, value: bool) -> Self::SetOutOfBandInlineResponseFut;
67890    type GetOutOfBandInlineResponseFut: std::future::Future<Output = Result<BaseSocketGetOutOfBandInlineResult, fidl::Error>>
67891        + Send;
67892    fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut;
67893    type SetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketSetNoCheckResult, fidl::Error>>
67894        + Send;
67895    fn r#set_no_check(&self, value: bool) -> Self::SetNoCheckResponseFut;
67896    type GetNoCheckResponseFut: std::future::Future<Output = Result<BaseSocketGetNoCheckResult, fidl::Error>>
67897        + Send;
67898    fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut;
67899    type SetLingerResponseFut: std::future::Future<Output = Result<BaseSocketSetLingerResult, fidl::Error>>
67900        + Send;
67901    fn r#set_linger(&self, linger: bool, length_secs: u32) -> Self::SetLingerResponseFut;
67902    type GetLingerResponseFut: std::future::Future<Output = Result<BaseSocketGetLingerResult, fidl::Error>>
67903        + Send;
67904    fn r#get_linger(&self) -> Self::GetLingerResponseFut;
67905    type SetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketSetReusePortResult, fidl::Error>>
67906        + Send;
67907    fn r#set_reuse_port(&self, value: bool) -> Self::SetReusePortResponseFut;
67908    type GetReusePortResponseFut: std::future::Future<Output = Result<BaseSocketGetReusePortResult, fidl::Error>>
67909        + Send;
67910    fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut;
67911    type GetAcceptConnResponseFut: std::future::Future<Output = Result<BaseSocketGetAcceptConnResult, fidl::Error>>
67912        + Send;
67913    fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut;
67914    type SetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToDeviceResult, fidl::Error>>
67915        + Send;
67916    fn r#set_bind_to_device(&self, value: &str) -> Self::SetBindToDeviceResponseFut;
67917    type GetBindToDeviceResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToDeviceResult, fidl::Error>>
67918        + Send;
67919    fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut;
67920    type SetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error>>
67921        + Send;
67922    fn r#set_bind_to_interface_index(&self, value: u64)
67923        -> Self::SetBindToInterfaceIndexResponseFut;
67924    type GetBindToInterfaceIndexResponseFut: std::future::Future<Output = Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error>>
67925        + Send;
67926    fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut;
67927    type SetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketSetTimestampResult, fidl::Error>>
67928        + Send;
67929    fn r#set_timestamp(&self, value: TimestampOption) -> Self::SetTimestampResponseFut;
67930    type GetTimestampResponseFut: std::future::Future<Output = Result<BaseSocketGetTimestampResult, fidl::Error>>
67931        + Send;
67932    fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut;
67933    type SetMarkResponseFut: std::future::Future<Output = Result<BaseSocketSetMarkResult, fidl::Error>>
67934        + Send;
67935    fn r#set_mark(
67936        &self,
67937        domain: fidl_fuchsia_net::MarkDomain,
67938        mark: &OptionalUint32,
67939    ) -> Self::SetMarkResponseFut;
67940    type GetMarkResponseFut: std::future::Future<Output = Result<BaseSocketGetMarkResult, fidl::Error>>
67941        + Send;
67942    fn r#get_mark(&self, domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut;
67943    type BindResponseFut: std::future::Future<Output = Result<BaseNetworkSocketBindResult, fidl::Error>>
67944        + Send;
67945    fn r#bind(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut;
67946    type ConnectResponseFut: std::future::Future<Output = Result<BaseNetworkSocketConnectResult, fidl::Error>>
67947        + Send;
67948    fn r#connect(&self, addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut;
67949    type DisconnectResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDisconnectResult, fidl::Error>>
67950        + Send;
67951    fn r#disconnect(&self) -> Self::DisconnectResponseFut;
67952    type GetSockNameResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetSockNameResult, fidl::Error>>
67953        + Send;
67954    fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut;
67955    type GetPeerNameResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetPeerNameResult, fidl::Error>>
67956        + Send;
67957    fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut;
67958    type ShutdownResponseFut: std::future::Future<Output = Result<BaseNetworkSocketShutdownResult, fidl::Error>>
67959        + Send;
67960    fn r#shutdown(&self, mode: ShutdownMode) -> Self::ShutdownResponseFut;
67961    type SetIpTypeOfServiceResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error>>
67962        + Send;
67963    fn r#set_ip_type_of_service(&self, value: u8) -> Self::SetIpTypeOfServiceResponseFut;
67964    type GetIpTypeOfServiceResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error>>
67965        + Send;
67966    fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut;
67967    type SetIpTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTtlResult, fidl::Error>>
67968        + Send;
67969    fn r#set_ip_ttl(&self, value: &OptionalUint8) -> Self::SetIpTtlResponseFut;
67970    type GetIpTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTtlResult, fidl::Error>>
67971        + Send;
67972    fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut;
67973    type SetIpPacketInfoResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error>>
67974        + Send;
67975    fn r#set_ip_packet_info(&self, value: bool) -> Self::SetIpPacketInfoResponseFut;
67976    type GetIpPacketInfoResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error>>
67977        + Send;
67978    fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut;
67979    type SetIpReceiveTypeOfServiceResponseFut: std::future::Future<
67980            Output = Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error>,
67981        > + Send;
67982    fn r#set_ip_receive_type_of_service(
67983        &self,
67984        value: bool,
67985    ) -> Self::SetIpReceiveTypeOfServiceResponseFut;
67986    type GetIpReceiveTypeOfServiceResponseFut: std::future::Future<
67987            Output = Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error>,
67988        > + Send;
67989    fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut;
67990    type SetIpReceiveTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error>>
67991        + Send;
67992    fn r#set_ip_receive_ttl(&self, value: bool) -> Self::SetIpReceiveTtlResponseFut;
67993    type GetIpReceiveTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error>>
67994        + Send;
67995    fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut;
67996    type SetIpMulticastInterfaceResponseFut: std::future::Future<
67997            Output = Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error>,
67998        > + Send;
67999    fn r#set_ip_multicast_interface(
68000        &self,
68001        iface: u64,
68002        address: &fidl_fuchsia_net::Ipv4Address,
68003    ) -> Self::SetIpMulticastInterfaceResponseFut;
68004    type GetIpMulticastInterfaceResponseFut: std::future::Future<
68005            Output = Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error>,
68006        > + Send;
68007    fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut;
68008    type SetIpMulticastTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error>>
68009        + Send;
68010    fn r#set_ip_multicast_ttl(&self, value: &OptionalUint8) -> Self::SetIpMulticastTtlResponseFut;
68011    type GetIpMulticastTtlResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error>>
68012        + Send;
68013    fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut;
68014    type SetIpMulticastLoopbackResponseFut: std::future::Future<
68015            Output = Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error>,
68016        > + Send;
68017    fn r#set_ip_multicast_loopback(&self, value: bool) -> Self::SetIpMulticastLoopbackResponseFut;
68018    type GetIpMulticastLoopbackResponseFut: std::future::Future<
68019            Output = Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error>,
68020        > + Send;
68021    fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut;
68022    type AddIpMembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error>>
68023        + Send;
68024    fn r#add_ip_membership(
68025        &self,
68026        membership: &IpMulticastMembership,
68027    ) -> Self::AddIpMembershipResponseFut;
68028    type DropIpMembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error>>
68029        + Send;
68030    fn r#drop_ip_membership(
68031        &self,
68032        membership: &IpMulticastMembership,
68033    ) -> Self::DropIpMembershipResponseFut;
68034    type SetIpTransparentResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error>>
68035        + Send;
68036    fn r#set_ip_transparent(&self, value: bool) -> Self::SetIpTransparentResponseFut;
68037    type GetIpTransparentResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error>>
68038        + Send;
68039    fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut;
68040    type SetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<
68041            Output = Result<
68042                BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
68043                fidl::Error,
68044            >,
68045        > + Send;
68046    fn r#set_ip_receive_original_destination_address(
68047        &self,
68048        value: bool,
68049    ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut;
68050    type GetIpReceiveOriginalDestinationAddressResponseFut: std::future::Future<
68051            Output = Result<
68052                BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
68053                fidl::Error,
68054            >,
68055        > + Send;
68056    fn r#get_ip_receive_original_destination_address(
68057        &self,
68058    ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut;
68059    type AddIpv6MembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error>>
68060        + Send;
68061    fn r#add_ipv6_membership(
68062        &self,
68063        membership: &Ipv6MulticastMembership,
68064    ) -> Self::AddIpv6MembershipResponseFut;
68065    type DropIpv6MembershipResponseFut: std::future::Future<Output = Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error>>
68066        + Send;
68067    fn r#drop_ipv6_membership(
68068        &self,
68069        membership: &Ipv6MulticastMembership,
68070    ) -> Self::DropIpv6MembershipResponseFut;
68071    type SetIpv6MulticastInterfaceResponseFut: std::future::Future<
68072            Output = Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error>,
68073        > + Send;
68074    fn r#set_ipv6_multicast_interface(
68075        &self,
68076        value: u64,
68077    ) -> Self::SetIpv6MulticastInterfaceResponseFut;
68078    type GetIpv6MulticastInterfaceResponseFut: std::future::Future<
68079            Output = Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error>,
68080        > + Send;
68081    fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut;
68082    type SetIpv6UnicastHopsResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error>>
68083        + Send;
68084    fn r#set_ipv6_unicast_hops(&self, value: &OptionalUint8)
68085        -> Self::SetIpv6UnicastHopsResponseFut;
68086    type GetIpv6UnicastHopsResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error>>
68087        + Send;
68088    fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut;
68089    type SetIpv6ReceiveHopLimitResponseFut: std::future::Future<
68090            Output = Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error>,
68091        > + Send;
68092    fn r#set_ipv6_receive_hop_limit(&self, value: bool) -> Self::SetIpv6ReceiveHopLimitResponseFut;
68093    type GetIpv6ReceiveHopLimitResponseFut: std::future::Future<
68094            Output = Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error>,
68095        > + Send;
68096    fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut;
68097    type SetIpv6MulticastHopsResponseFut: std::future::Future<
68098            Output = Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error>,
68099        > + Send;
68100    fn r#set_ipv6_multicast_hops(
68101        &self,
68102        value: &OptionalUint8,
68103    ) -> Self::SetIpv6MulticastHopsResponseFut;
68104    type GetIpv6MulticastHopsResponseFut: std::future::Future<
68105            Output = Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error>,
68106        > + Send;
68107    fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut;
68108    type SetIpv6MulticastLoopbackResponseFut: std::future::Future<
68109            Output = Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error>,
68110        > + Send;
68111    fn r#set_ipv6_multicast_loopback(
68112        &self,
68113        value: bool,
68114    ) -> Self::SetIpv6MulticastLoopbackResponseFut;
68115    type GetIpv6MulticastLoopbackResponseFut: std::future::Future<
68116            Output = Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error>,
68117        > + Send;
68118    fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut;
68119    type SetIpv6OnlyResponseFut: std::future::Future<Output = Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error>>
68120        + Send;
68121    fn r#set_ipv6_only(&self, value: bool) -> Self::SetIpv6OnlyResponseFut;
68122    type GetIpv6OnlyResponseFut: std::future::Future<Output = Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error>>
68123        + Send;
68124    fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut;
68125    type SetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
68126            Output = Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error>,
68127        > + Send;
68128    fn r#set_ipv6_receive_traffic_class(
68129        &self,
68130        value: bool,
68131    ) -> Self::SetIpv6ReceiveTrafficClassResponseFut;
68132    type GetIpv6ReceiveTrafficClassResponseFut: std::future::Future<
68133            Output = Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error>,
68134        > + Send;
68135    fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut;
68136    type SetIpv6TrafficClassResponseFut: std::future::Future<
68137            Output = Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error>,
68138        > + Send;
68139    fn r#set_ipv6_traffic_class(
68140        &self,
68141        value: &OptionalUint8,
68142    ) -> Self::SetIpv6TrafficClassResponseFut;
68143    type GetIpv6TrafficClassResponseFut: std::future::Future<
68144            Output = Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error>,
68145        > + Send;
68146    fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut;
68147    type SetIpv6ReceivePacketInfoResponseFut: std::future::Future<
68148            Output = Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error>,
68149        > + Send;
68150    fn r#set_ipv6_receive_packet_info(
68151        &self,
68152        value: bool,
68153    ) -> Self::SetIpv6ReceivePacketInfoResponseFut;
68154    type GetIpv6ReceivePacketInfoResponseFut: std::future::Future<
68155            Output = Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error>,
68156        > + Send;
68157    fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut;
68158    type GetOriginalDestinationResponseFut: std::future::Future<
68159            Output = Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error>,
68160        > + Send;
68161    fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut;
68162    type GetInfoResponseFut: std::future::Future<Output = Result<BaseDatagramSocketGetInfoResult, fidl::Error>>
68163        + Send;
68164    fn r#get_info(&self) -> Self::GetInfoResponseFut;
68165    type DescribeResponseFut: std::future::Future<Output = Result<SynchronousDatagramSocketDescribeResponse, fidl::Error>>
68166        + Send;
68167    fn r#describe(&self) -> Self::DescribeResponseFut;
68168    type RecvMsgResponseFut: std::future::Future<Output = Result<SynchronousDatagramSocketRecvMsgResult, fidl::Error>>
68169        + Send;
68170    fn r#recv_msg(
68171        &self,
68172        want_addr: bool,
68173        data_len: u32,
68174        want_control: bool,
68175        flags: RecvMsgFlags,
68176    ) -> Self::RecvMsgResponseFut;
68177    type SendMsgResponseFut: std::future::Future<Output = Result<SynchronousDatagramSocketSendMsgResult, fidl::Error>>
68178        + Send;
68179    fn r#send_msg(
68180        &self,
68181        addr: Option<&fidl_fuchsia_net::SocketAddress>,
68182        data: &[u8],
68183        control: &DatagramSocketSendControlData,
68184        flags: SendMsgFlags,
68185    ) -> Self::SendMsgResponseFut;
68186}
68187#[derive(Debug)]
68188#[cfg(target_os = "fuchsia")]
68189pub struct SynchronousDatagramSocketSynchronousProxy {
68190    client: fidl::client::sync::Client,
68191}
68192
68193#[cfg(target_os = "fuchsia")]
68194impl fidl::endpoints::SynchronousProxy for SynchronousDatagramSocketSynchronousProxy {
68195    type Proxy = SynchronousDatagramSocketProxy;
68196    type Protocol = SynchronousDatagramSocketMarker;
68197
68198    fn from_channel(inner: fidl::Channel) -> Self {
68199        Self::new(inner)
68200    }
68201
68202    fn into_channel(self) -> fidl::Channel {
68203        self.client.into_channel()
68204    }
68205
68206    fn as_channel(&self) -> &fidl::Channel {
68207        self.client.as_channel()
68208    }
68209}
68210
68211#[cfg(target_os = "fuchsia")]
68212impl SynchronousDatagramSocketSynchronousProxy {
68213    pub fn new(channel: fidl::Channel) -> Self {
68214        let protocol_name =
68215            <SynchronousDatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
68216        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
68217    }
68218
68219    pub fn into_channel(self) -> fidl::Channel {
68220        self.client.into_channel()
68221    }
68222
68223    /// Waits until an event arrives and returns it. It is safe for other
68224    /// threads to make concurrent requests while waiting for an event.
68225    pub fn wait_for_event(
68226        &self,
68227        deadline: zx::MonotonicInstant,
68228    ) -> Result<SynchronousDatagramSocketEvent, fidl::Error> {
68229        SynchronousDatagramSocketEvent::decode(self.client.wait_for_event(deadline)?)
68230    }
68231
68232    pub fn r#clone(
68233        &self,
68234        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
68235    ) -> Result<(), fidl::Error> {
68236        self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
68237            (request,),
68238            0x20d8a7aba2168a79,
68239            fidl::encoding::DynamicFlags::empty(),
68240        )
68241    }
68242
68243    /// Terminates the connection.
68244    ///
68245    /// After calling `Close`, the client must not send any other requests.
68246    ///
68247    /// Servers, after sending the status response, should close the connection
68248    /// regardless of status and without sending an epitaph.
68249    ///
68250    /// Closing the client end of the channel should be semantically equivalent
68251    /// to calling `Close` without knowing when the close has completed or its
68252    /// status.
68253    pub fn r#close(
68254        &self,
68255        ___deadline: zx::MonotonicInstant,
68256    ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
68257        let _response = self.client.send_query::<
68258            fidl::encoding::EmptyPayload,
68259            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
68260        >(
68261            (),
68262            0x5ac5d459ad7f657e,
68263            fidl::encoding::DynamicFlags::empty(),
68264            ___deadline,
68265        )?;
68266        Ok(_response.map(|x| x))
68267    }
68268
68269    pub fn r#query(&self, ___deadline: zx::MonotonicInstant) -> Result<Vec<u8>, fidl::Error> {
68270        let _response = self.client.send_query::<
68271            fidl::encoding::EmptyPayload,
68272            fidl_fuchsia_unknown::QueryableQueryResponse,
68273        >(
68274            (),
68275            0x2658edee9decfc06,
68276            fidl::encoding::DynamicFlags::empty(),
68277            ___deadline,
68278        )?;
68279        Ok(_response.protocol)
68280    }
68281
68282    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
68283    pub fn r#set_reuse_address(
68284        &self,
68285        mut value: bool,
68286        ___deadline: zx::MonotonicInstant,
68287    ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
68288        let _response =
68289            self.client.send_query::<BaseSocketSetReuseAddressRequest, fidl::encoding::ResultType<
68290                fidl::encoding::EmptyStruct,
68291                fidl_fuchsia_posix::Errno,
68292            >>(
68293                (value,),
68294                0x1fd74ee8b9a4a876,
68295                fidl::encoding::DynamicFlags::empty(),
68296                ___deadline,
68297            )?;
68298        Ok(_response.map(|x| x))
68299    }
68300
68301    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
68302    pub fn r#get_reuse_address(
68303        &self,
68304        ___deadline: zx::MonotonicInstant,
68305    ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
68306        let _response = self
68307            .client
68308            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68309                BaseSocketGetReuseAddressResponse,
68310                fidl_fuchsia_posix::Errno,
68311            >>(
68312                (), 0x67b7206b8d1bc0a5, fidl::encoding::DynamicFlags::empty(), ___deadline
68313            )?;
68314        Ok(_response.map(|x| x.value))
68315    }
68316
68317    /// Get `SOL_SOCKET` -> `SO_ERROR`.
68318    /// Returns the last error if there is an error set on the socket.
68319    pub fn r#get_error(
68320        &self,
68321        ___deadline: zx::MonotonicInstant,
68322    ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
68323        let _response =
68324            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68325                fidl::encoding::EmptyStruct,
68326                fidl_fuchsia_posix::Errno,
68327            >>(
68328                (),
68329                0x5aad39b33e5f6ebb,
68330                fidl::encoding::DynamicFlags::empty(),
68331                ___deadline,
68332            )?;
68333        Ok(_response.map(|x| x))
68334    }
68335
68336    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
68337    pub fn r#set_broadcast(
68338        &self,
68339        mut value: bool,
68340        ___deadline: zx::MonotonicInstant,
68341    ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
68342        let _response =
68343            self.client.send_query::<BaseSocketSetBroadcastRequest, fidl::encoding::ResultType<
68344                fidl::encoding::EmptyStruct,
68345                fidl_fuchsia_posix::Errno,
68346            >>(
68347                (value,),
68348                0x6023e081ce3cd947,
68349                fidl::encoding::DynamicFlags::empty(),
68350                ___deadline,
68351            )?;
68352        Ok(_response.map(|x| x))
68353    }
68354
68355    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
68356    pub fn r#get_broadcast(
68357        &self,
68358        ___deadline: zx::MonotonicInstant,
68359    ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
68360        let _response =
68361            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68362                BaseSocketGetBroadcastResponse,
68363                fidl_fuchsia_posix::Errno,
68364            >>(
68365                (),
68366                0x68796fc556f9780d,
68367                fidl::encoding::DynamicFlags::empty(),
68368                ___deadline,
68369            )?;
68370        Ok(_response.map(|x| x.value))
68371    }
68372
68373    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
68374    pub fn r#set_send_buffer(
68375        &self,
68376        mut value_bytes: u64,
68377        ___deadline: zx::MonotonicInstant,
68378    ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
68379        let _response =
68380            self.client.send_query::<BaseSocketSetSendBufferRequest, fidl::encoding::ResultType<
68381                fidl::encoding::EmptyStruct,
68382                fidl_fuchsia_posix::Errno,
68383            >>(
68384                (value_bytes,),
68385                0x756eac32d73a7a70,
68386                fidl::encoding::DynamicFlags::empty(),
68387                ___deadline,
68388            )?;
68389        Ok(_response.map(|x| x))
68390    }
68391
68392    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
68393    pub fn r#get_send_buffer(
68394        &self,
68395        ___deadline: zx::MonotonicInstant,
68396    ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
68397        let _response = self
68398            .client
68399            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68400                BaseSocketGetSendBufferResponse,
68401                fidl_fuchsia_posix::Errno,
68402            >>(
68403                (), 0x78a52fd9c7b2410b, fidl::encoding::DynamicFlags::empty(), ___deadline
68404            )?;
68405        Ok(_response.map(|x| x.value_bytes))
68406    }
68407
68408    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
68409    pub fn r#set_receive_buffer(
68410        &self,
68411        mut value_bytes: u64,
68412        ___deadline: zx::MonotonicInstant,
68413    ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
68414        let _response =
68415            self.client
68416                .send_query::<BaseSocketSetReceiveBufferRequest, fidl::encoding::ResultType<
68417                    fidl::encoding::EmptyStruct,
68418                    fidl_fuchsia_posix::Errno,
68419                >>(
68420                    (value_bytes,),
68421                    0x6b0cf2f1919c7001,
68422                    fidl::encoding::DynamicFlags::empty(),
68423                    ___deadline,
68424                )?;
68425        Ok(_response.map(|x| x))
68426    }
68427
68428    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
68429    pub fn r#get_receive_buffer(
68430        &self,
68431        ___deadline: zx::MonotonicInstant,
68432    ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
68433        let _response = self
68434            .client
68435            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68436                BaseSocketGetReceiveBufferResponse,
68437                fidl_fuchsia_posix::Errno,
68438            >>(
68439                (), 0x14c1a4b64f709e5c, fidl::encoding::DynamicFlags::empty(), ___deadline
68440            )?;
68441        Ok(_response.map(|x| x.value_bytes))
68442    }
68443
68444    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
68445    pub fn r#set_keep_alive(
68446        &self,
68447        mut value: bool,
68448        ___deadline: zx::MonotonicInstant,
68449    ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
68450        let _response =
68451            self.client.send_query::<BaseSocketSetKeepAliveRequest, fidl::encoding::ResultType<
68452                fidl::encoding::EmptyStruct,
68453                fidl_fuchsia_posix::Errno,
68454            >>(
68455                (value,),
68456                0x572df8f0b920d2c7,
68457                fidl::encoding::DynamicFlags::empty(),
68458                ___deadline,
68459            )?;
68460        Ok(_response.map(|x| x))
68461    }
68462
68463    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
68464    pub fn r#get_keep_alive(
68465        &self,
68466        ___deadline: zx::MonotonicInstant,
68467    ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
68468        let _response =
68469            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68470                BaseSocketGetKeepAliveResponse,
68471                fidl_fuchsia_posix::Errno,
68472            >>(
68473                (),
68474                0x2dd29d3215f2c9d2,
68475                fidl::encoding::DynamicFlags::empty(),
68476                ___deadline,
68477            )?;
68478        Ok(_response.map(|x| x.value))
68479    }
68480
68481    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
68482    pub fn r#set_out_of_band_inline(
68483        &self,
68484        mut value: bool,
68485        ___deadline: zx::MonotonicInstant,
68486    ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
68487        let _response =
68488            self.client
68489                .send_query::<BaseSocketSetOutOfBandInlineRequest, fidl::encoding::ResultType<
68490                    fidl::encoding::EmptyStruct,
68491                    fidl_fuchsia_posix::Errno,
68492                >>(
68493                    (value,),
68494                    0x3ecb49968bee439,
68495                    fidl::encoding::DynamicFlags::empty(),
68496                    ___deadline,
68497                )?;
68498        Ok(_response.map(|x| x))
68499    }
68500
68501    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
68502    pub fn r#get_out_of_band_inline(
68503        &self,
68504        ___deadline: zx::MonotonicInstant,
68505    ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
68506        let _response = self
68507            .client
68508            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68509                BaseSocketGetOutOfBandInlineResponse,
68510                fidl_fuchsia_posix::Errno,
68511            >>(
68512                (), 0x348c1ab3aeca1745, fidl::encoding::DynamicFlags::empty(), ___deadline
68513            )?;
68514        Ok(_response.map(|x| x.value))
68515    }
68516
68517    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
68518    pub fn r#set_no_check(
68519        &self,
68520        mut value: bool,
68521        ___deadline: zx::MonotonicInstant,
68522    ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
68523        let _response =
68524            self.client.send_query::<BaseSocketSetNoCheckRequest, fidl::encoding::ResultType<
68525                fidl::encoding::EmptyStruct,
68526                fidl_fuchsia_posix::Errno,
68527            >>(
68528                (value,),
68529                0x6bbf00c53a4c78c2,
68530                fidl::encoding::DynamicFlags::empty(),
68531                ___deadline,
68532            )?;
68533        Ok(_response.map(|x| x))
68534    }
68535
68536    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
68537    pub fn r#get_no_check(
68538        &self,
68539        ___deadline: zx::MonotonicInstant,
68540    ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
68541        let _response =
68542            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68543                BaseSocketGetNoCheckResponse,
68544                fidl_fuchsia_posix::Errno,
68545            >>(
68546                (),
68547                0x2cd4249286417694,
68548                fidl::encoding::DynamicFlags::empty(),
68549                ___deadline,
68550            )?;
68551        Ok(_response.map(|x| x.value))
68552    }
68553
68554    /// Set `SOL_SOCKET` -> `SO_LINGER`.
68555    pub fn r#set_linger(
68556        &self,
68557        mut linger: bool,
68558        mut length_secs: u32,
68559        ___deadline: zx::MonotonicInstant,
68560    ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
68561        let _response =
68562            self.client.send_query::<BaseSocketSetLingerRequest, fidl::encoding::ResultType<
68563                fidl::encoding::EmptyStruct,
68564                fidl_fuchsia_posix::Errno,
68565            >>(
68566                (linger, length_secs),
68567                0x45386351246e998e,
68568                fidl::encoding::DynamicFlags::empty(),
68569                ___deadline,
68570            )?;
68571        Ok(_response.map(|x| x))
68572    }
68573
68574    /// Get `SOL_SOCKET` -> `SO_LINGER`.
68575    pub fn r#get_linger(
68576        &self,
68577        ___deadline: zx::MonotonicInstant,
68578    ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
68579        let _response =
68580            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68581                BaseSocketGetLingerResponse,
68582                fidl_fuchsia_posix::Errno,
68583            >>(
68584                (),
68585                0x48eb20fc5ccb0e45,
68586                fidl::encoding::DynamicFlags::empty(),
68587                ___deadline,
68588            )?;
68589        Ok(_response.map(|x| (x.linger, x.length_secs)))
68590    }
68591
68592    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
68593    pub fn r#set_reuse_port(
68594        &self,
68595        mut value: bool,
68596        ___deadline: zx::MonotonicInstant,
68597    ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
68598        let _response =
68599            self.client.send_query::<BaseSocketSetReusePortRequest, fidl::encoding::ResultType<
68600                fidl::encoding::EmptyStruct,
68601                fidl_fuchsia_posix::Errno,
68602            >>(
68603                (value,),
68604                0x24dd3e5cb36d9ccb,
68605                fidl::encoding::DynamicFlags::empty(),
68606                ___deadline,
68607            )?;
68608        Ok(_response.map(|x| x))
68609    }
68610
68611    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
68612    pub fn r#get_reuse_port(
68613        &self,
68614        ___deadline: zx::MonotonicInstant,
68615    ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
68616        let _response =
68617            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68618                BaseSocketGetReusePortResponse,
68619                fidl_fuchsia_posix::Errno,
68620            >>(
68621                (),
68622                0x7a112c1ab54ff828,
68623                fidl::encoding::DynamicFlags::empty(),
68624                ___deadline,
68625            )?;
68626        Ok(_response.map(|x| x.value))
68627    }
68628
68629    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
68630    pub fn r#get_accept_conn(
68631        &self,
68632        ___deadline: zx::MonotonicInstant,
68633    ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
68634        let _response = self
68635            .client
68636            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68637                BaseSocketGetAcceptConnResponse,
68638                fidl_fuchsia_posix::Errno,
68639            >>(
68640                (), 0x67ce6db6c2ec8966, fidl::encoding::DynamicFlags::empty(), ___deadline
68641            )?;
68642        Ok(_response.map(|x| x.value))
68643    }
68644
68645    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
68646    pub fn r#set_bind_to_device(
68647        &self,
68648        mut value: &str,
68649        ___deadline: zx::MonotonicInstant,
68650    ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
68651        let _response =
68652            self.client.send_query::<BaseSocketSetBindToDeviceRequest, fidl::encoding::ResultType<
68653                fidl::encoding::EmptyStruct,
68654                fidl_fuchsia_posix::Errno,
68655            >>(
68656                (value,),
68657                0x2118b483f28aafc4,
68658                fidl::encoding::DynamicFlags::empty(),
68659                ___deadline,
68660            )?;
68661        Ok(_response.map(|x| x))
68662    }
68663
68664    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
68665    pub fn r#get_bind_to_device(
68666        &self,
68667        ___deadline: zx::MonotonicInstant,
68668    ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
68669        let _response = self
68670            .client
68671            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68672                BaseSocketGetBindToDeviceResponse,
68673                fidl_fuchsia_posix::Errno,
68674            >>(
68675                (), 0x1ab1fbf0ef7906c8, fidl::encoding::DynamicFlags::empty(), ___deadline
68676            )?;
68677        Ok(_response.map(|x| x.value))
68678    }
68679
68680    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
68681    /// If `value` is 0, this clears the bound interface.
68682    pub fn r#set_bind_to_interface_index(
68683        &self,
68684        mut value: u64,
68685        ___deadline: zx::MonotonicInstant,
68686    ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
68687        let _response =
68688            self.client
68689                .send_query::<BaseSocketSetBindToInterfaceIndexRequest, fidl::encoding::ResultType<
68690                    fidl::encoding::EmptyStruct,
68691                    fidl_fuchsia_posix::Errno,
68692                >>(
68693                    (value,),
68694                    0x6e387a0def00821,
68695                    fidl::encoding::DynamicFlags::empty(),
68696                    ___deadline,
68697                )?;
68698        Ok(_response.map(|x| x))
68699    }
68700
68701    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
68702    pub fn r#get_bind_to_interface_index(
68703        &self,
68704        ___deadline: zx::MonotonicInstant,
68705    ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
68706        let _response = self
68707            .client
68708            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68709                BaseSocketGetBindToInterfaceIndexResponse,
68710                fidl_fuchsia_posix::Errno,
68711            >>(
68712                (), 0x59c31dd3e3078295, fidl::encoding::DynamicFlags::empty(), ___deadline
68713            )?;
68714        Ok(_response.map(|x| x.value))
68715    }
68716
68717    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
68718    pub fn r#set_timestamp(
68719        &self,
68720        mut value: TimestampOption,
68721        ___deadline: zx::MonotonicInstant,
68722    ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
68723        let _response =
68724            self.client.send_query::<BaseSocketSetTimestampRequest, fidl::encoding::ResultType<
68725                fidl::encoding::EmptyStruct,
68726                fidl_fuchsia_posix::Errno,
68727            >>(
68728                (value,),
68729                0x285d6516c263d839,
68730                fidl::encoding::DynamicFlags::empty(),
68731                ___deadline,
68732            )?;
68733        Ok(_response.map(|x| x))
68734    }
68735
68736    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
68737    pub fn r#get_timestamp(
68738        &self,
68739        ___deadline: zx::MonotonicInstant,
68740    ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
68741        let _response =
68742            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68743                BaseSocketGetTimestampResponse,
68744                fidl_fuchsia_posix::Errno,
68745            >>(
68746                (),
68747                0x49f2fffbbcc2bd27,
68748                fidl::encoding::DynamicFlags::empty(),
68749                ___deadline,
68750            )?;
68751        Ok(_response.map(|x| x.value))
68752    }
68753
68754    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
68755    /// unlike the standard SO_MARK, this API has multiple mark domains and each
68756    /// mark can be set independently in each domain.
68757    pub fn r#set_mark(
68758        &self,
68759        mut domain: fidl_fuchsia_net::MarkDomain,
68760        mut mark: &OptionalUint32,
68761        ___deadline: zx::MonotonicInstant,
68762    ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
68763        let _response =
68764            self.client.send_query::<BaseSocketSetMarkRequest, fidl::encoding::ResultType<
68765                fidl::encoding::EmptyStruct,
68766                fidl_fuchsia_posix::Errno,
68767            >>(
68768                (domain, mark),
68769                0x6ead6de09f653236,
68770                fidl::encoding::DynamicFlags::empty(),
68771                ___deadline,
68772            )?;
68773        Ok(_response.map(|x| x))
68774    }
68775
68776    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
68777    /// unlike the standard SO_MARK, this API has multiple mark domains and each
68778    /// mark can be retrieved independently in each domain.
68779    pub fn r#get_mark(
68780        &self,
68781        mut domain: fidl_fuchsia_net::MarkDomain,
68782        ___deadline: zx::MonotonicInstant,
68783    ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
68784        let _response =
68785            self.client.send_query::<BaseSocketGetMarkRequest, fidl::encoding::ResultType<
68786                BaseSocketGetMarkResponse,
68787                fidl_fuchsia_posix::Errno,
68788            >>(
68789                (domain,),
68790                0x57a2752c61d93d47,
68791                fidl::encoding::DynamicFlags::empty(),
68792                ___deadline,
68793            )?;
68794        Ok(_response.map(|x| x.mark))
68795    }
68796
68797    /// Sets the local address used for the socket.
68798    pub fn r#bind(
68799        &self,
68800        mut addr: &fidl_fuchsia_net::SocketAddress,
68801        ___deadline: zx::MonotonicInstant,
68802    ) -> Result<BaseNetworkSocketBindResult, fidl::Error> {
68803        let _response =
68804            self.client.send_query::<BaseNetworkSocketBindRequest, fidl::encoding::ResultType<
68805                fidl::encoding::EmptyStruct,
68806                fidl_fuchsia_posix::Errno,
68807            >>(
68808                (addr,),
68809                0x4bc6400ae92125d,
68810                fidl::encoding::DynamicFlags::empty(),
68811                ___deadline,
68812            )?;
68813        Ok(_response.map(|x| x))
68814    }
68815
68816    /// Initiates a connection to a remote address.
68817    pub fn r#connect(
68818        &self,
68819        mut addr: &fidl_fuchsia_net::SocketAddress,
68820        ___deadline: zx::MonotonicInstant,
68821    ) -> Result<BaseNetworkSocketConnectResult, fidl::Error> {
68822        let _response =
68823            self.client.send_query::<BaseNetworkSocketConnectRequest, fidl::encoding::ResultType<
68824                fidl::encoding::EmptyStruct,
68825                fidl_fuchsia_posix::Errno,
68826            >>(
68827                (addr,),
68828                0x5f05f19bfdd38871,
68829                fidl::encoding::DynamicFlags::empty(),
68830                ___deadline,
68831            )?;
68832        Ok(_response.map(|x| x))
68833    }
68834
68835    /// Clears connection information from this socket.
68836    pub fn r#disconnect(
68837        &self,
68838        ___deadline: zx::MonotonicInstant,
68839    ) -> Result<BaseNetworkSocketDisconnectResult, fidl::Error> {
68840        let _response =
68841            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68842                fidl::encoding::EmptyStruct,
68843                fidl_fuchsia_posix::Errno,
68844            >>(
68845                (),
68846                0x74e63b91f7b29b2,
68847                fidl::encoding::DynamicFlags::empty(),
68848                ___deadline,
68849            )?;
68850        Ok(_response.map(|x| x))
68851    }
68852
68853    /// Retrieves the local socket address.
68854    pub fn r#get_sock_name(
68855        &self,
68856        ___deadline: zx::MonotonicInstant,
68857    ) -> Result<BaseNetworkSocketGetSockNameResult, fidl::Error> {
68858        let _response = self
68859            .client
68860            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68861                BaseNetworkSocketGetSockNameResponse,
68862                fidl_fuchsia_posix::Errno,
68863            >>(
68864                (), 0x475f23f84a1a4f85, fidl::encoding::DynamicFlags::empty(), ___deadline
68865            )?;
68866        Ok(_response.map(|x| x.addr))
68867    }
68868
68869    /// Retrieves the remote socket address.
68870    pub fn r#get_peer_name(
68871        &self,
68872        ___deadline: zx::MonotonicInstant,
68873    ) -> Result<BaseNetworkSocketGetPeerNameResult, fidl::Error> {
68874        let _response = self
68875            .client
68876            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68877                BaseNetworkSocketGetPeerNameResponse,
68878                fidl_fuchsia_posix::Errno,
68879            >>(
68880                (), 0x1ffecf4bd5b6432e, fidl::encoding::DynamicFlags::empty(), ___deadline
68881            )?;
68882        Ok(_response.map(|x| x.addr))
68883    }
68884
68885    /// Shuts down part of the socket.
68886    pub fn r#shutdown(
68887        &self,
68888        mut mode: ShutdownMode,
68889        ___deadline: zx::MonotonicInstant,
68890    ) -> Result<BaseNetworkSocketShutdownResult, fidl::Error> {
68891        let _response =
68892            self.client.send_query::<BaseNetworkSocketShutdownRequest, fidl::encoding::ResultType<
68893                fidl::encoding::EmptyStruct,
68894                fidl_fuchsia_posix::Errno,
68895            >>(
68896                (mode,),
68897                0x247f38b6db68c336,
68898                fidl::encoding::DynamicFlags::empty(),
68899                ___deadline,
68900            )?;
68901        Ok(_response.map(|x| x))
68902    }
68903
68904    /// Set `SOL_IP` -> `IP_TOS`.
68905    pub fn r#set_ip_type_of_service(
68906        &self,
68907        mut value: u8,
68908        ___deadline: zx::MonotonicInstant,
68909    ) -> Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error> {
68910        let _response = self.client.send_query::<
68911            BaseNetworkSocketSetIpTypeOfServiceRequest,
68912            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
68913        >(
68914            (value,),
68915            0x995c600475b6d46,
68916            fidl::encoding::DynamicFlags::empty(),
68917            ___deadline,
68918        )?;
68919        Ok(_response.map(|x| x))
68920    }
68921
68922    /// Get `SOL_IP` -> `IP_TOS`.
68923    pub fn r#get_ip_type_of_service(
68924        &self,
68925        ___deadline: zx::MonotonicInstant,
68926    ) -> Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error> {
68927        let _response = self
68928            .client
68929            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68930                BaseNetworkSocketGetIpTypeOfServiceResponse,
68931                fidl_fuchsia_posix::Errno,
68932            >>(
68933                (), 0x3814a04259f75fcb, fidl::encoding::DynamicFlags::empty(), ___deadline
68934            )?;
68935        Ok(_response.map(|x| x.value))
68936    }
68937
68938    /// Set `SOL_IP` -> `IP_TTL`.
68939    pub fn r#set_ip_ttl(
68940        &self,
68941        mut value: &OptionalUint8,
68942        ___deadline: zx::MonotonicInstant,
68943    ) -> Result<BaseNetworkSocketSetIpTtlResult, fidl::Error> {
68944        let _response =
68945            self.client.send_query::<BaseNetworkSocketSetIpTtlRequest, fidl::encoding::ResultType<
68946                fidl::encoding::EmptyStruct,
68947                fidl_fuchsia_posix::Errno,
68948            >>(
68949                (value,),
68950                0x29e2424b433ae1ef,
68951                fidl::encoding::DynamicFlags::empty(),
68952                ___deadline,
68953            )?;
68954        Ok(_response.map(|x| x))
68955    }
68956
68957    /// Get `SOL_IP` -> `IP_TTL`.
68958    pub fn r#get_ip_ttl(
68959        &self,
68960        ___deadline: zx::MonotonicInstant,
68961    ) -> Result<BaseNetworkSocketGetIpTtlResult, fidl::Error> {
68962        let _response = self
68963            .client
68964            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
68965                BaseNetworkSocketGetIpTtlResponse,
68966                fidl_fuchsia_posix::Errno,
68967            >>(
68968                (), 0x47e47fa1f24da471, fidl::encoding::DynamicFlags::empty(), ___deadline
68969            )?;
68970        Ok(_response.map(|x| x.value))
68971    }
68972
68973    /// Set `SOL_IP` -> `IP_PKTINFO`.
68974    pub fn r#set_ip_packet_info(
68975        &self,
68976        mut value: bool,
68977        ___deadline: zx::MonotonicInstant,
68978    ) -> Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error> {
68979        let _response =
68980            self.client
68981                .send_query::<BaseNetworkSocketSetIpPacketInfoRequest, fidl::encoding::ResultType<
68982                    fidl::encoding::EmptyStruct,
68983                    fidl_fuchsia_posix::Errno,
68984                >>(
68985                    (value,),
68986                    0x392d16bee20c0e16,
68987                    fidl::encoding::DynamicFlags::empty(),
68988                    ___deadline,
68989                )?;
68990        Ok(_response.map(|x| x))
68991    }
68992
68993    /// Get `SOL_IP` -> `IP_PKTINFO`.
68994    pub fn r#get_ip_packet_info(
68995        &self,
68996        ___deadline: zx::MonotonicInstant,
68997    ) -> Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error> {
68998        let _response = self
68999            .client
69000            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69001                BaseNetworkSocketGetIpPacketInfoResponse,
69002                fidl_fuchsia_posix::Errno,
69003            >>(
69004                (), 0x54b505f242280740, fidl::encoding::DynamicFlags::empty(), ___deadline
69005            )?;
69006        Ok(_response.map(|x| x.value))
69007    }
69008
69009    /// Set `SOL_IP` -> `IP_RECVTOS`.
69010    pub fn r#set_ip_receive_type_of_service(
69011        &self,
69012        mut value: bool,
69013        ___deadline: zx::MonotonicInstant,
69014    ) -> Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error> {
69015        let _response = self.client.send_query::<
69016            BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
69017            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
69018        >(
69019            (value,),
69020            0x6c4f6714995f84ef,
69021            fidl::encoding::DynamicFlags::empty(),
69022            ___deadline,
69023        )?;
69024        Ok(_response.map(|x| x))
69025    }
69026
69027    /// Get `SOL_IP` -> `IP_RECVTOS`.
69028    pub fn r#get_ip_receive_type_of_service(
69029        &self,
69030        ___deadline: zx::MonotonicInstant,
69031    ) -> Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error> {
69032        let _response = self
69033            .client
69034            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69035                BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
69036                fidl_fuchsia_posix::Errno,
69037            >>(
69038                (), 0x4158ba7dc2795960, fidl::encoding::DynamicFlags::empty(), ___deadline
69039            )?;
69040        Ok(_response.map(|x| x.value))
69041    }
69042
69043    /// Set `SOL_IP` -> `IP_RECVTTL`.
69044    pub fn r#set_ip_receive_ttl(
69045        &self,
69046        mut value: bool,
69047        ___deadline: zx::MonotonicInstant,
69048    ) -> Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error> {
69049        let _response =
69050            self.client
69051                .send_query::<BaseNetworkSocketSetIpReceiveTtlRequest, fidl::encoding::ResultType<
69052                    fidl::encoding::EmptyStruct,
69053                    fidl_fuchsia_posix::Errno,
69054                >>(
69055                    (value,),
69056                    0x46f15be0ce0ab82b,
69057                    fidl::encoding::DynamicFlags::empty(),
69058                    ___deadline,
69059                )?;
69060        Ok(_response.map(|x| x))
69061    }
69062
69063    /// Get `SOL_IP` -> `IP_RECVTTL`.
69064    pub fn r#get_ip_receive_ttl(
69065        &self,
69066        ___deadline: zx::MonotonicInstant,
69067    ) -> Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error> {
69068        let _response = self
69069            .client
69070            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69071                BaseNetworkSocketGetIpReceiveTtlResponse,
69072                fidl_fuchsia_posix::Errno,
69073            >>(
69074                (), 0x678ddd5a5dfa2eb5, fidl::encoding::DynamicFlags::empty(), ___deadline
69075            )?;
69076        Ok(_response.map(|x| x.value))
69077    }
69078
69079    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
69080    pub fn r#set_ip_multicast_interface(
69081        &self,
69082        mut iface: u64,
69083        mut address: &fidl_fuchsia_net::Ipv4Address,
69084        ___deadline: zx::MonotonicInstant,
69085    ) -> Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error> {
69086        let _response = self.client.send_query::<
69087            BaseNetworkSocketSetIpMulticastInterfaceRequest,
69088            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
69089        >(
69090            (iface, address,),
69091            0x752fbfa9b12befe,
69092            fidl::encoding::DynamicFlags::empty(),
69093            ___deadline,
69094        )?;
69095        Ok(_response.map(|x| x))
69096    }
69097
69098    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
69099    pub fn r#get_ip_multicast_interface(
69100        &self,
69101        ___deadline: zx::MonotonicInstant,
69102    ) -> Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error> {
69103        let _response = self
69104            .client
69105            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69106                BaseNetworkSocketGetIpMulticastInterfaceResponse,
69107                fidl_fuchsia_posix::Errno,
69108            >>(
69109                (), 0x320bd14c4df046c4, fidl::encoding::DynamicFlags::empty(), ___deadline
69110            )?;
69111        Ok(_response.map(|x| x.value))
69112    }
69113
69114    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
69115    pub fn r#set_ip_multicast_ttl(
69116        &self,
69117        mut value: &OptionalUint8,
69118        ___deadline: zx::MonotonicInstant,
69119    ) -> Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error> {
69120        let _response =
69121            self.client
69122                .send_query::<BaseNetworkSocketSetIpMulticastTtlRequest, fidl::encoding::ResultType<
69123                    fidl::encoding::EmptyStruct,
69124                    fidl_fuchsia_posix::Errno,
69125                >>(
69126                    (value,),
69127                    0x63134d53772916a1,
69128                    fidl::encoding::DynamicFlags::empty(),
69129                    ___deadline,
69130                )?;
69131        Ok(_response.map(|x| x))
69132    }
69133
69134    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
69135    pub fn r#get_ip_multicast_ttl(
69136        &self,
69137        ___deadline: zx::MonotonicInstant,
69138    ) -> Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error> {
69139        let _response = self
69140            .client
69141            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69142                BaseNetworkSocketGetIpMulticastTtlResponse,
69143                fidl_fuchsia_posix::Errno,
69144            >>(
69145                (), 0x4665cd378f39e1a, fidl::encoding::DynamicFlags::empty(), ___deadline
69146            )?;
69147        Ok(_response.map(|x| x.value))
69148    }
69149
69150    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
69151    pub fn r#set_ip_multicast_loopback(
69152        &self,
69153        mut value: bool,
69154        ___deadline: zx::MonotonicInstant,
69155    ) -> Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error> {
69156        let _response = self.client.send_query::<
69157            BaseNetworkSocketSetIpMulticastLoopbackRequest,
69158            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
69159        >(
69160            (value,),
69161            0x20c55c11f00943ea,
69162            fidl::encoding::DynamicFlags::empty(),
69163            ___deadline,
69164        )?;
69165        Ok(_response.map(|x| x))
69166    }
69167
69168    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
69169    pub fn r#get_ip_multicast_loopback(
69170        &self,
69171        ___deadline: zx::MonotonicInstant,
69172    ) -> Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error> {
69173        let _response = self
69174            .client
69175            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69176                BaseNetworkSocketGetIpMulticastLoopbackResponse,
69177                fidl_fuchsia_posix::Errno,
69178            >>(
69179                (), 0x3b6b26ff558298f2, fidl::encoding::DynamicFlags::empty(), ___deadline
69180            )?;
69181        Ok(_response.map(|x| x.value))
69182    }
69183
69184    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
69185    pub fn r#add_ip_membership(
69186        &self,
69187        mut membership: &IpMulticastMembership,
69188        ___deadline: zx::MonotonicInstant,
69189    ) -> Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error> {
69190        let _response =
69191            self.client
69192                .send_query::<BaseNetworkSocketAddIpMembershipRequest, fidl::encoding::ResultType<
69193                    fidl::encoding::EmptyStruct,
69194                    fidl_fuchsia_posix::Errno,
69195                >>(
69196                    (membership,),
69197                    0x76bc7df115a3b4d0,
69198                    fidl::encoding::DynamicFlags::empty(),
69199                    ___deadline,
69200                )?;
69201        Ok(_response.map(|x| x))
69202    }
69203
69204    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
69205    pub fn r#drop_ip_membership(
69206        &self,
69207        mut membership: &IpMulticastMembership,
69208        ___deadline: zx::MonotonicInstant,
69209    ) -> Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error> {
69210        let _response =
69211            self.client
69212                .send_query::<BaseNetworkSocketDropIpMembershipRequest, fidl::encoding::ResultType<
69213                    fidl::encoding::EmptyStruct,
69214                    fidl_fuchsia_posix::Errno,
69215                >>(
69216                    (membership,),
69217                    0x2888f3099188d03,
69218                    fidl::encoding::DynamicFlags::empty(),
69219                    ___deadline,
69220                )?;
69221        Ok(_response.map(|x| x))
69222    }
69223
69224    /// Set `SOL_IP` -> `IP_TRANSPARENT`
69225    pub fn r#set_ip_transparent(
69226        &self,
69227        mut value: bool,
69228        ___deadline: zx::MonotonicInstant,
69229    ) -> Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error> {
69230        let _response =
69231            self.client
69232                .send_query::<BaseNetworkSocketSetIpTransparentRequest, fidl::encoding::ResultType<
69233                    fidl::encoding::EmptyStruct,
69234                    fidl_fuchsia_posix::Errno,
69235                >>(
69236                    (value,),
69237                    0x1ae532b0c066e3a0,
69238                    fidl::encoding::DynamicFlags::empty(),
69239                    ___deadline,
69240                )?;
69241        Ok(_response.map(|x| x))
69242    }
69243
69244    /// Get `SOL_IP` -> `IP_TRANSPARENT`
69245    pub fn r#get_ip_transparent(
69246        &self,
69247        ___deadline: zx::MonotonicInstant,
69248    ) -> Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error> {
69249        let _response = self
69250            .client
69251            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69252                BaseNetworkSocketGetIpTransparentResponse,
69253                fidl_fuchsia_posix::Errno,
69254            >>(
69255                (), 0x51d43695962ebfb5, fidl::encoding::DynamicFlags::empty(), ___deadline
69256            )?;
69257        Ok(_response.map(|x| x.value))
69258    }
69259
69260    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
69261    pub fn r#set_ip_receive_original_destination_address(
69262        &self,
69263        mut value: bool,
69264        ___deadline: zx::MonotonicInstant,
69265    ) -> Result<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error> {
69266        let _response = self.client.send_query::<
69267            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
69268            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
69269        >(
69270            (value,),
69271            0x4722b4ce52f7840,
69272            fidl::encoding::DynamicFlags::empty(),
69273            ___deadline,
69274        )?;
69275        Ok(_response.map(|x| x))
69276    }
69277
69278    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
69279    pub fn r#get_ip_receive_original_destination_address(
69280        &self,
69281        ___deadline: zx::MonotonicInstant,
69282    ) -> Result<BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error> {
69283        let _response = self
69284            .client
69285            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69286                BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
69287                fidl_fuchsia_posix::Errno,
69288            >>(
69289                (), 0x2a0e7dc5d6bfdfe9, fidl::encoding::DynamicFlags::empty(), ___deadline
69290            )?;
69291        Ok(_response.map(|x| x.value))
69292    }
69293
69294    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
69295    pub fn r#add_ipv6_membership(
69296        &self,
69297        mut membership: &Ipv6MulticastMembership,
69298        ___deadline: zx::MonotonicInstant,
69299    ) -> Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error> {
69300        let _response =
69301            self.client
69302                .send_query::<BaseNetworkSocketAddIpv6MembershipRequest, fidl::encoding::ResultType<
69303                    fidl::encoding::EmptyStruct,
69304                    fidl_fuchsia_posix::Errno,
69305                >>(
69306                    (membership,),
69307                    0x7c94727acb4ea4b3,
69308                    fidl::encoding::DynamicFlags::empty(),
69309                    ___deadline,
69310                )?;
69311        Ok(_response.map(|x| x))
69312    }
69313
69314    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
69315    pub fn r#drop_ipv6_membership(
69316        &self,
69317        mut membership: &Ipv6MulticastMembership,
69318        ___deadline: zx::MonotonicInstant,
69319    ) -> Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error> {
69320        let _response = self.client.send_query::<
69321            BaseNetworkSocketDropIpv6MembershipRequest,
69322            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
69323        >(
69324            (membership,),
69325            0x42104c70ccaba304,
69326            fidl::encoding::DynamicFlags::empty(),
69327            ___deadline,
69328        )?;
69329        Ok(_response.map(|x| x))
69330    }
69331
69332    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
69333    pub fn r#set_ipv6_multicast_interface(
69334        &self,
69335        mut value: u64,
69336        ___deadline: zx::MonotonicInstant,
69337    ) -> Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error> {
69338        let _response = self.client.send_query::<
69339            BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
69340            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
69341        >(
69342            (value,),
69343            0x135f76db3774ab3b,
69344            fidl::encoding::DynamicFlags::empty(),
69345            ___deadline,
69346        )?;
69347        Ok(_response.map(|x| x))
69348    }
69349
69350    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
69351    pub fn r#get_ipv6_multicast_interface(
69352        &self,
69353        ___deadline: zx::MonotonicInstant,
69354    ) -> Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error> {
69355        let _response = self
69356            .client
69357            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69358                BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
69359                fidl_fuchsia_posix::Errno,
69360            >>(
69361                (), 0x1f26fcdd348f1882, fidl::encoding::DynamicFlags::empty(), ___deadline
69362            )?;
69363        Ok(_response.map(|x| x.value))
69364    }
69365
69366    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
69367    pub fn r#set_ipv6_unicast_hops(
69368        &self,
69369        mut value: &OptionalUint8,
69370        ___deadline: zx::MonotonicInstant,
69371    ) -> Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error> {
69372        let _response = self.client.send_query::<
69373            BaseNetworkSocketSetIpv6UnicastHopsRequest,
69374            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
69375        >(
69376            (value,),
69377            0x157d51e98f462859,
69378            fidl::encoding::DynamicFlags::empty(),
69379            ___deadline,
69380        )?;
69381        Ok(_response.map(|x| x))
69382    }
69383
69384    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
69385    pub fn r#get_ipv6_unicast_hops(
69386        &self,
69387        ___deadline: zx::MonotonicInstant,
69388    ) -> Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error> {
69389        let _response = self
69390            .client
69391            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69392                BaseNetworkSocketGetIpv6UnicastHopsResponse,
69393                fidl_fuchsia_posix::Errno,
69394            >>(
69395                (), 0x21f4641cad8bd8d2, fidl::encoding::DynamicFlags::empty(), ___deadline
69396            )?;
69397        Ok(_response.map(|x| x.value))
69398    }
69399
69400    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
69401    pub fn r#set_ipv6_receive_hop_limit(
69402        &self,
69403        mut value: bool,
69404        ___deadline: zx::MonotonicInstant,
69405    ) -> Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error> {
69406        let _response = self.client.send_query::<
69407            BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
69408            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
69409        >(
69410            (value,),
69411            0x5c24808ed2e84a1e,
69412            fidl::encoding::DynamicFlags::empty(),
69413            ___deadline,
69414        )?;
69415        Ok(_response.map(|x| x))
69416    }
69417
69418    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
69419    pub fn r#get_ipv6_receive_hop_limit(
69420        &self,
69421        ___deadline: zx::MonotonicInstant,
69422    ) -> Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error> {
69423        let _response = self
69424            .client
69425            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69426                BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
69427                fidl_fuchsia_posix::Errno,
69428            >>(
69429                (), 0x341e06689885b4c0, fidl::encoding::DynamicFlags::empty(), ___deadline
69430            )?;
69431        Ok(_response.map(|x| x.value))
69432    }
69433
69434    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
69435    pub fn r#set_ipv6_multicast_hops(
69436        &self,
69437        mut value: &OptionalUint8,
69438        ___deadline: zx::MonotonicInstant,
69439    ) -> Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error> {
69440        let _response = self.client.send_query::<
69441            BaseNetworkSocketSetIpv6MulticastHopsRequest,
69442            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
69443        >(
69444            (value,),
69445            0x25b9cd4d181f82c1,
69446            fidl::encoding::DynamicFlags::empty(),
69447            ___deadline,
69448        )?;
69449        Ok(_response.map(|x| x))
69450    }
69451
69452    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
69453    pub fn r#get_ipv6_multicast_hops(
69454        &self,
69455        ___deadline: zx::MonotonicInstant,
69456    ) -> Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error> {
69457        let _response = self
69458            .client
69459            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69460                BaseNetworkSocketGetIpv6MulticastHopsResponse,
69461                fidl_fuchsia_posix::Errno,
69462            >>(
69463                (), 0x52916948a365012a, fidl::encoding::DynamicFlags::empty(), ___deadline
69464            )?;
69465        Ok(_response.map(|x| x.value))
69466    }
69467
69468    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
69469    pub fn r#set_ipv6_multicast_loopback(
69470        &self,
69471        mut value: bool,
69472        ___deadline: zx::MonotonicInstant,
69473    ) -> Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error> {
69474        let _response = self.client.send_query::<
69475            BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
69476            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
69477        >(
69478            (value,),
69479            0x55701c409ff41b40,
69480            fidl::encoding::DynamicFlags::empty(),
69481            ___deadline,
69482        )?;
69483        Ok(_response.map(|x| x))
69484    }
69485
69486    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
69487    pub fn r#get_ipv6_multicast_loopback(
69488        &self,
69489        ___deadline: zx::MonotonicInstant,
69490    ) -> Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error> {
69491        let _response = self
69492            .client
69493            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69494                BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
69495                fidl_fuchsia_posix::Errno,
69496            >>(
69497                (), 0x4415b701fde319c3, fidl::encoding::DynamicFlags::empty(), ___deadline
69498            )?;
69499        Ok(_response.map(|x| x.value))
69500    }
69501
69502    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
69503    pub fn r#set_ipv6_only(
69504        &self,
69505        mut value: bool,
69506        ___deadline: zx::MonotonicInstant,
69507    ) -> Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
69508        let _response =
69509            self.client
69510                .send_query::<BaseNetworkSocketSetIpv6OnlyRequest, fidl::encoding::ResultType<
69511                    fidl::encoding::EmptyStruct,
69512                    fidl_fuchsia_posix::Errno,
69513                >>(
69514                    (value,),
69515                    0x4873f1364758cbba,
69516                    fidl::encoding::DynamicFlags::empty(),
69517                    ___deadline,
69518                )?;
69519        Ok(_response.map(|x| x))
69520    }
69521
69522    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
69523    pub fn r#get_ipv6_only(
69524        &self,
69525        ___deadline: zx::MonotonicInstant,
69526    ) -> Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
69527        let _response = self
69528            .client
69529            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69530                BaseNetworkSocketGetIpv6OnlyResponse,
69531                fidl_fuchsia_posix::Errno,
69532            >>(
69533                (), 0x4aa3340a1a26b89c, fidl::encoding::DynamicFlags::empty(), ___deadline
69534            )?;
69535        Ok(_response.map(|x| x.value))
69536    }
69537
69538    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
69539    pub fn r#set_ipv6_receive_traffic_class(
69540        &self,
69541        mut value: bool,
69542        ___deadline: zx::MonotonicInstant,
69543    ) -> Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error> {
69544        let _response = self.client.send_query::<
69545            BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
69546            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
69547        >(
69548            (value,),
69549            0x58f07c8788d099a0,
69550            fidl::encoding::DynamicFlags::empty(),
69551            ___deadline,
69552        )?;
69553        Ok(_response.map(|x| x))
69554    }
69555
69556    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
69557    pub fn r#get_ipv6_receive_traffic_class(
69558        &self,
69559        ___deadline: zx::MonotonicInstant,
69560    ) -> Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error> {
69561        let _response = self
69562            .client
69563            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69564                BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
69565                fidl_fuchsia_posix::Errno,
69566            >>(
69567                (), 0x2e334df1da553ffa, fidl::encoding::DynamicFlags::empty(), ___deadline
69568            )?;
69569        Ok(_response.map(|x| x.value))
69570    }
69571
69572    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
69573    pub fn r#set_ipv6_traffic_class(
69574        &self,
69575        mut value: &OptionalUint8,
69576        ___deadline: zx::MonotonicInstant,
69577    ) -> Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error> {
69578        let _response = self.client.send_query::<
69579            BaseNetworkSocketSetIpv6TrafficClassRequest,
69580            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
69581        >(
69582            (value,),
69583            0x6af077800c5a0b4f,
69584            fidl::encoding::DynamicFlags::empty(),
69585            ___deadline,
69586        )?;
69587        Ok(_response.map(|x| x))
69588    }
69589
69590    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
69591    pub fn r#get_ipv6_traffic_class(
69592        &self,
69593        ___deadline: zx::MonotonicInstant,
69594    ) -> Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error> {
69595        let _response = self
69596            .client
69597            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69598                BaseNetworkSocketGetIpv6TrafficClassResponse,
69599                fidl_fuchsia_posix::Errno,
69600            >>(
69601                (), 0x6baf6eed8fc2f04, fidl::encoding::DynamicFlags::empty(), ___deadline
69602            )?;
69603        Ok(_response.map(|x| x.value))
69604    }
69605
69606    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
69607    pub fn r#set_ipv6_receive_packet_info(
69608        &self,
69609        mut value: bool,
69610        ___deadline: zx::MonotonicInstant,
69611    ) -> Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error> {
69612        let _response = self.client.send_query::<
69613            BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
69614            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
69615        >(
69616            (value,),
69617            0x19259775b1a92768,
69618            fidl::encoding::DynamicFlags::empty(),
69619            ___deadline,
69620        )?;
69621        Ok(_response.map(|x| x))
69622    }
69623
69624    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
69625    pub fn r#get_ipv6_receive_packet_info(
69626        &self,
69627        ___deadline: zx::MonotonicInstant,
69628    ) -> Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error> {
69629        let _response = self
69630            .client
69631            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69632                BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
69633                fidl_fuchsia_posix::Errno,
69634            >>(
69635                (), 0x7acd4a2775baec75, fidl::encoding::DynamicFlags::empty(), ___deadline
69636            )?;
69637        Ok(_response.map(|x| x.value))
69638    }
69639
69640    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
69641    pub fn r#get_original_destination(
69642        &self,
69643        ___deadline: zx::MonotonicInstant,
69644    ) -> Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error> {
69645        let _response = self
69646            .client
69647            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69648                BaseNetworkSocketGetOriginalDestinationResponse,
69649                fidl_fuchsia_posix::Errno,
69650            >>(
69651                (), 0x38bf28f0dafdbac0, fidl::encoding::DynamicFlags::empty(), ___deadline
69652            )?;
69653        Ok(_response.map(|x| x.value))
69654    }
69655
69656    /// Retrieves creation information from the socket.
69657    ///
69658    /// - response `domain` the socket's associated domain.
69659    /// - response `proto` the socket's associated protocol.
69660    pub fn r#get_info(
69661        &self,
69662        ___deadline: zx::MonotonicInstant,
69663    ) -> Result<BaseDatagramSocketGetInfoResult, fidl::Error> {
69664        let _response = self
69665            .client
69666            .send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
69667                BaseDatagramSocketGetInfoResponse,
69668                fidl_fuchsia_posix::Errno,
69669            >>(
69670                (), 0x48aa0a1f6a32d2ed, fidl::encoding::DynamicFlags::empty(), ___deadline
69671            )?;
69672        Ok(_response.map(|x| (x.domain, x.proto)))
69673    }
69674
69675    pub fn r#describe(
69676        &self,
69677        ___deadline: zx::MonotonicInstant,
69678    ) -> Result<SynchronousDatagramSocketDescribeResponse, fidl::Error> {
69679        let _response = self
69680            .client
69681            .send_query::<fidl::encoding::EmptyPayload, SynchronousDatagramSocketDescribeResponse>(
69682                (),
69683                0x585f20b73631070d,
69684                fidl::encoding::DynamicFlags::empty(),
69685                ___deadline,
69686            )?;
69687        Ok(_response)
69688    }
69689
69690    /// Receives a message from the socket.
69691    ///
69692    /// + request `want_addr` request message's source address information to
69693    ///   be returned.
69694    /// + request `data_len` the maximum allowed length of the response data
69695    ///   buffer.
69696    /// + request `want_control` request ancillary data to be returned.
69697    /// + request `flags` flags for the receive request.
69698    /// - response `addr` the message's source address information, if
69699    ///   requested.
69700    /// - response `data` the message.
69701    /// - response `control` control messages, if requested.
69702    /// - response `truncated` indicates whether or not the returned message
69703    ///   was truncated.
69704    pub fn r#recv_msg(
69705        &self,
69706        mut want_addr: bool,
69707        mut data_len: u32,
69708        mut want_control: bool,
69709        mut flags: RecvMsgFlags,
69710        ___deadline: zx::MonotonicInstant,
69711    ) -> Result<SynchronousDatagramSocketRecvMsgResult, fidl::Error> {
69712        let _response = self
69713            .client
69714            .send_query::<SynchronousDatagramSocketRecvMsgRequest, fidl::encoding::ResultType<
69715                SynchronousDatagramSocketRecvMsgResponse,
69716                fidl_fuchsia_posix::Errno,
69717            >>(
69718                (want_addr, data_len, want_control, flags),
69719                0x28e494e48fb5dbf3,
69720                fidl::encoding::DynamicFlags::empty(),
69721                ___deadline,
69722            )?;
69723        Ok(_response.map(|x| (x.addr, x.data, x.control, x.truncated)))
69724    }
69725
69726    /// Sends a message on the socket.
69727    ///
69728    /// + request `addr` the address to send the message to. If unset, will send
69729    ///   to the connected peer.
69730    /// + request `data` the message.
69731    /// + request `control` ancillary data.
69732    /// + request `flags` flags for the send request.
69733    /// - response `len` the number of bytes sent.
69734    pub fn r#send_msg(
69735        &self,
69736        mut addr: Option<&fidl_fuchsia_net::SocketAddress>,
69737        mut data: &[u8],
69738        mut control: &DatagramSocketSendControlData,
69739        mut flags: SendMsgFlags,
69740        ___deadline: zx::MonotonicInstant,
69741    ) -> Result<SynchronousDatagramSocketSendMsgResult, fidl::Error> {
69742        let _response = self
69743            .client
69744            .send_query::<SynchronousDatagramSocketSendMsgRequest, fidl::encoding::ResultType<
69745                SynchronousDatagramSocketSendMsgResponse,
69746                fidl_fuchsia_posix::Errno,
69747            >>(
69748                (addr, data, control, flags),
69749                0x12dc2fceab6cefaa,
69750                fidl::encoding::DynamicFlags::empty(),
69751                ___deadline,
69752            )?;
69753        Ok(_response.map(|x| x.len))
69754    }
69755}
69756
69757#[cfg(target_os = "fuchsia")]
69758impl From<SynchronousDatagramSocketSynchronousProxy> for zx::Handle {
69759    fn from(value: SynchronousDatagramSocketSynchronousProxy) -> Self {
69760        value.into_channel().into()
69761    }
69762}
69763
69764#[cfg(target_os = "fuchsia")]
69765impl From<fidl::Channel> for SynchronousDatagramSocketSynchronousProxy {
69766    fn from(value: fidl::Channel) -> Self {
69767        Self::new(value)
69768    }
69769}
69770
69771#[derive(Debug, Clone)]
69772pub struct SynchronousDatagramSocketProxy {
69773    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
69774}
69775
69776impl fidl::endpoints::Proxy for SynchronousDatagramSocketProxy {
69777    type Protocol = SynchronousDatagramSocketMarker;
69778
69779    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
69780        Self::new(inner)
69781    }
69782
69783    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
69784        self.client.into_channel().map_err(|client| Self { client })
69785    }
69786
69787    fn as_channel(&self) -> &::fidl::AsyncChannel {
69788        self.client.as_channel()
69789    }
69790}
69791
69792impl SynchronousDatagramSocketProxy {
69793    /// Create a new Proxy for fuchsia.posix.socket/SynchronousDatagramSocket.
69794    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
69795        let protocol_name =
69796            <SynchronousDatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
69797        Self { client: fidl::client::Client::new(channel, protocol_name) }
69798    }
69799
69800    /// Get a Stream of events from the remote end of the protocol.
69801    ///
69802    /// # Panics
69803    ///
69804    /// Panics if the event stream was already taken.
69805    pub fn take_event_stream(&self) -> SynchronousDatagramSocketEventStream {
69806        SynchronousDatagramSocketEventStream { event_receiver: self.client.take_event_receiver() }
69807    }
69808
69809    pub fn r#clone(
69810        &self,
69811        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
69812    ) -> Result<(), fidl::Error> {
69813        SynchronousDatagramSocketProxyInterface::r#clone(self, request)
69814    }
69815
69816    /// Terminates the connection.
69817    ///
69818    /// After calling `Close`, the client must not send any other requests.
69819    ///
69820    /// Servers, after sending the status response, should close the connection
69821    /// regardless of status and without sending an epitaph.
69822    ///
69823    /// Closing the client end of the channel should be semantically equivalent
69824    /// to calling `Close` without knowing when the close has completed or its
69825    /// status.
69826    pub fn r#close(
69827        &self,
69828    ) -> fidl::client::QueryResponseFut<
69829        fidl_fuchsia_unknown::CloseableCloseResult,
69830        fidl::encoding::DefaultFuchsiaResourceDialect,
69831    > {
69832        SynchronousDatagramSocketProxyInterface::r#close(self)
69833    }
69834
69835    pub fn r#query(
69836        &self,
69837    ) -> fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>
69838    {
69839        SynchronousDatagramSocketProxyInterface::r#query(self)
69840    }
69841
69842    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
69843    pub fn r#set_reuse_address(
69844        &self,
69845        mut value: bool,
69846    ) -> fidl::client::QueryResponseFut<
69847        BaseSocketSetReuseAddressResult,
69848        fidl::encoding::DefaultFuchsiaResourceDialect,
69849    > {
69850        SynchronousDatagramSocketProxyInterface::r#set_reuse_address(self, value)
69851    }
69852
69853    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
69854    pub fn r#get_reuse_address(
69855        &self,
69856    ) -> fidl::client::QueryResponseFut<
69857        BaseSocketGetReuseAddressResult,
69858        fidl::encoding::DefaultFuchsiaResourceDialect,
69859    > {
69860        SynchronousDatagramSocketProxyInterface::r#get_reuse_address(self)
69861    }
69862
69863    /// Get `SOL_SOCKET` -> `SO_ERROR`.
69864    /// Returns the last error if there is an error set on the socket.
69865    pub fn r#get_error(
69866        &self,
69867    ) -> fidl::client::QueryResponseFut<
69868        BaseSocketGetErrorResult,
69869        fidl::encoding::DefaultFuchsiaResourceDialect,
69870    > {
69871        SynchronousDatagramSocketProxyInterface::r#get_error(self)
69872    }
69873
69874    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
69875    pub fn r#set_broadcast(
69876        &self,
69877        mut value: bool,
69878    ) -> fidl::client::QueryResponseFut<
69879        BaseSocketSetBroadcastResult,
69880        fidl::encoding::DefaultFuchsiaResourceDialect,
69881    > {
69882        SynchronousDatagramSocketProxyInterface::r#set_broadcast(self, value)
69883    }
69884
69885    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
69886    pub fn r#get_broadcast(
69887        &self,
69888    ) -> fidl::client::QueryResponseFut<
69889        BaseSocketGetBroadcastResult,
69890        fidl::encoding::DefaultFuchsiaResourceDialect,
69891    > {
69892        SynchronousDatagramSocketProxyInterface::r#get_broadcast(self)
69893    }
69894
69895    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
69896    pub fn r#set_send_buffer(
69897        &self,
69898        mut value_bytes: u64,
69899    ) -> fidl::client::QueryResponseFut<
69900        BaseSocketSetSendBufferResult,
69901        fidl::encoding::DefaultFuchsiaResourceDialect,
69902    > {
69903        SynchronousDatagramSocketProxyInterface::r#set_send_buffer(self, value_bytes)
69904    }
69905
69906    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
69907    pub fn r#get_send_buffer(
69908        &self,
69909    ) -> fidl::client::QueryResponseFut<
69910        BaseSocketGetSendBufferResult,
69911        fidl::encoding::DefaultFuchsiaResourceDialect,
69912    > {
69913        SynchronousDatagramSocketProxyInterface::r#get_send_buffer(self)
69914    }
69915
69916    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
69917    pub fn r#set_receive_buffer(
69918        &self,
69919        mut value_bytes: u64,
69920    ) -> fidl::client::QueryResponseFut<
69921        BaseSocketSetReceiveBufferResult,
69922        fidl::encoding::DefaultFuchsiaResourceDialect,
69923    > {
69924        SynchronousDatagramSocketProxyInterface::r#set_receive_buffer(self, value_bytes)
69925    }
69926
69927    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
69928    pub fn r#get_receive_buffer(
69929        &self,
69930    ) -> fidl::client::QueryResponseFut<
69931        BaseSocketGetReceiveBufferResult,
69932        fidl::encoding::DefaultFuchsiaResourceDialect,
69933    > {
69934        SynchronousDatagramSocketProxyInterface::r#get_receive_buffer(self)
69935    }
69936
69937    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
69938    pub fn r#set_keep_alive(
69939        &self,
69940        mut value: bool,
69941    ) -> fidl::client::QueryResponseFut<
69942        BaseSocketSetKeepAliveResult,
69943        fidl::encoding::DefaultFuchsiaResourceDialect,
69944    > {
69945        SynchronousDatagramSocketProxyInterface::r#set_keep_alive(self, value)
69946    }
69947
69948    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
69949    pub fn r#get_keep_alive(
69950        &self,
69951    ) -> fidl::client::QueryResponseFut<
69952        BaseSocketGetKeepAliveResult,
69953        fidl::encoding::DefaultFuchsiaResourceDialect,
69954    > {
69955        SynchronousDatagramSocketProxyInterface::r#get_keep_alive(self)
69956    }
69957
69958    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
69959    pub fn r#set_out_of_band_inline(
69960        &self,
69961        mut value: bool,
69962    ) -> fidl::client::QueryResponseFut<
69963        BaseSocketSetOutOfBandInlineResult,
69964        fidl::encoding::DefaultFuchsiaResourceDialect,
69965    > {
69966        SynchronousDatagramSocketProxyInterface::r#set_out_of_band_inline(self, value)
69967    }
69968
69969    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
69970    pub fn r#get_out_of_band_inline(
69971        &self,
69972    ) -> fidl::client::QueryResponseFut<
69973        BaseSocketGetOutOfBandInlineResult,
69974        fidl::encoding::DefaultFuchsiaResourceDialect,
69975    > {
69976        SynchronousDatagramSocketProxyInterface::r#get_out_of_band_inline(self)
69977    }
69978
69979    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
69980    pub fn r#set_no_check(
69981        &self,
69982        mut value: bool,
69983    ) -> fidl::client::QueryResponseFut<
69984        BaseSocketSetNoCheckResult,
69985        fidl::encoding::DefaultFuchsiaResourceDialect,
69986    > {
69987        SynchronousDatagramSocketProxyInterface::r#set_no_check(self, value)
69988    }
69989
69990    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
69991    pub fn r#get_no_check(
69992        &self,
69993    ) -> fidl::client::QueryResponseFut<
69994        BaseSocketGetNoCheckResult,
69995        fidl::encoding::DefaultFuchsiaResourceDialect,
69996    > {
69997        SynchronousDatagramSocketProxyInterface::r#get_no_check(self)
69998    }
69999
70000    /// Set `SOL_SOCKET` -> `SO_LINGER`.
70001    pub fn r#set_linger(
70002        &self,
70003        mut linger: bool,
70004        mut length_secs: u32,
70005    ) -> fidl::client::QueryResponseFut<
70006        BaseSocketSetLingerResult,
70007        fidl::encoding::DefaultFuchsiaResourceDialect,
70008    > {
70009        SynchronousDatagramSocketProxyInterface::r#set_linger(self, linger, length_secs)
70010    }
70011
70012    /// Get `SOL_SOCKET` -> `SO_LINGER`.
70013    pub fn r#get_linger(
70014        &self,
70015    ) -> fidl::client::QueryResponseFut<
70016        BaseSocketGetLingerResult,
70017        fidl::encoding::DefaultFuchsiaResourceDialect,
70018    > {
70019        SynchronousDatagramSocketProxyInterface::r#get_linger(self)
70020    }
70021
70022    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
70023    pub fn r#set_reuse_port(
70024        &self,
70025        mut value: bool,
70026    ) -> fidl::client::QueryResponseFut<
70027        BaseSocketSetReusePortResult,
70028        fidl::encoding::DefaultFuchsiaResourceDialect,
70029    > {
70030        SynchronousDatagramSocketProxyInterface::r#set_reuse_port(self, value)
70031    }
70032
70033    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
70034    pub fn r#get_reuse_port(
70035        &self,
70036    ) -> fidl::client::QueryResponseFut<
70037        BaseSocketGetReusePortResult,
70038        fidl::encoding::DefaultFuchsiaResourceDialect,
70039    > {
70040        SynchronousDatagramSocketProxyInterface::r#get_reuse_port(self)
70041    }
70042
70043    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
70044    pub fn r#get_accept_conn(
70045        &self,
70046    ) -> fidl::client::QueryResponseFut<
70047        BaseSocketGetAcceptConnResult,
70048        fidl::encoding::DefaultFuchsiaResourceDialect,
70049    > {
70050        SynchronousDatagramSocketProxyInterface::r#get_accept_conn(self)
70051    }
70052
70053    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
70054    pub fn r#set_bind_to_device(
70055        &self,
70056        mut value: &str,
70057    ) -> fidl::client::QueryResponseFut<
70058        BaseSocketSetBindToDeviceResult,
70059        fidl::encoding::DefaultFuchsiaResourceDialect,
70060    > {
70061        SynchronousDatagramSocketProxyInterface::r#set_bind_to_device(self, value)
70062    }
70063
70064    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
70065    pub fn r#get_bind_to_device(
70066        &self,
70067    ) -> fidl::client::QueryResponseFut<
70068        BaseSocketGetBindToDeviceResult,
70069        fidl::encoding::DefaultFuchsiaResourceDialect,
70070    > {
70071        SynchronousDatagramSocketProxyInterface::r#get_bind_to_device(self)
70072    }
70073
70074    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
70075    /// If `value` is 0, this clears the bound interface.
70076    pub fn r#set_bind_to_interface_index(
70077        &self,
70078        mut value: u64,
70079    ) -> fidl::client::QueryResponseFut<
70080        BaseSocketSetBindToInterfaceIndexResult,
70081        fidl::encoding::DefaultFuchsiaResourceDialect,
70082    > {
70083        SynchronousDatagramSocketProxyInterface::r#set_bind_to_interface_index(self, value)
70084    }
70085
70086    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
70087    pub fn r#get_bind_to_interface_index(
70088        &self,
70089    ) -> fidl::client::QueryResponseFut<
70090        BaseSocketGetBindToInterfaceIndexResult,
70091        fidl::encoding::DefaultFuchsiaResourceDialect,
70092    > {
70093        SynchronousDatagramSocketProxyInterface::r#get_bind_to_interface_index(self)
70094    }
70095
70096    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
70097    pub fn r#set_timestamp(
70098        &self,
70099        mut value: TimestampOption,
70100    ) -> fidl::client::QueryResponseFut<
70101        BaseSocketSetTimestampResult,
70102        fidl::encoding::DefaultFuchsiaResourceDialect,
70103    > {
70104        SynchronousDatagramSocketProxyInterface::r#set_timestamp(self, value)
70105    }
70106
70107    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
70108    pub fn r#get_timestamp(
70109        &self,
70110    ) -> fidl::client::QueryResponseFut<
70111        BaseSocketGetTimestampResult,
70112        fidl::encoding::DefaultFuchsiaResourceDialect,
70113    > {
70114        SynchronousDatagramSocketProxyInterface::r#get_timestamp(self)
70115    }
70116
70117    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
70118    /// unlike the standard SO_MARK, this API has multiple mark domains and each
70119    /// mark can be set independently in each domain.
70120    pub fn r#set_mark(
70121        &self,
70122        mut domain: fidl_fuchsia_net::MarkDomain,
70123        mut mark: &OptionalUint32,
70124    ) -> fidl::client::QueryResponseFut<
70125        BaseSocketSetMarkResult,
70126        fidl::encoding::DefaultFuchsiaResourceDialect,
70127    > {
70128        SynchronousDatagramSocketProxyInterface::r#set_mark(self, domain, mark)
70129    }
70130
70131    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
70132    /// unlike the standard SO_MARK, this API has multiple mark domains and each
70133    /// mark can be retrieved independently in each domain.
70134    pub fn r#get_mark(
70135        &self,
70136        mut domain: fidl_fuchsia_net::MarkDomain,
70137    ) -> fidl::client::QueryResponseFut<
70138        BaseSocketGetMarkResult,
70139        fidl::encoding::DefaultFuchsiaResourceDialect,
70140    > {
70141        SynchronousDatagramSocketProxyInterface::r#get_mark(self, domain)
70142    }
70143
70144    /// Sets the local address used for the socket.
70145    pub fn r#bind(
70146        &self,
70147        mut addr: &fidl_fuchsia_net::SocketAddress,
70148    ) -> fidl::client::QueryResponseFut<
70149        BaseNetworkSocketBindResult,
70150        fidl::encoding::DefaultFuchsiaResourceDialect,
70151    > {
70152        SynchronousDatagramSocketProxyInterface::r#bind(self, addr)
70153    }
70154
70155    /// Initiates a connection to a remote address.
70156    pub fn r#connect(
70157        &self,
70158        mut addr: &fidl_fuchsia_net::SocketAddress,
70159    ) -> fidl::client::QueryResponseFut<
70160        BaseNetworkSocketConnectResult,
70161        fidl::encoding::DefaultFuchsiaResourceDialect,
70162    > {
70163        SynchronousDatagramSocketProxyInterface::r#connect(self, addr)
70164    }
70165
70166    /// Clears connection information from this socket.
70167    pub fn r#disconnect(
70168        &self,
70169    ) -> fidl::client::QueryResponseFut<
70170        BaseNetworkSocketDisconnectResult,
70171        fidl::encoding::DefaultFuchsiaResourceDialect,
70172    > {
70173        SynchronousDatagramSocketProxyInterface::r#disconnect(self)
70174    }
70175
70176    /// Retrieves the local socket address.
70177    pub fn r#get_sock_name(
70178        &self,
70179    ) -> fidl::client::QueryResponseFut<
70180        BaseNetworkSocketGetSockNameResult,
70181        fidl::encoding::DefaultFuchsiaResourceDialect,
70182    > {
70183        SynchronousDatagramSocketProxyInterface::r#get_sock_name(self)
70184    }
70185
70186    /// Retrieves the remote socket address.
70187    pub fn r#get_peer_name(
70188        &self,
70189    ) -> fidl::client::QueryResponseFut<
70190        BaseNetworkSocketGetPeerNameResult,
70191        fidl::encoding::DefaultFuchsiaResourceDialect,
70192    > {
70193        SynchronousDatagramSocketProxyInterface::r#get_peer_name(self)
70194    }
70195
70196    /// Shuts down part of the socket.
70197    pub fn r#shutdown(
70198        &self,
70199        mut mode: ShutdownMode,
70200    ) -> fidl::client::QueryResponseFut<
70201        BaseNetworkSocketShutdownResult,
70202        fidl::encoding::DefaultFuchsiaResourceDialect,
70203    > {
70204        SynchronousDatagramSocketProxyInterface::r#shutdown(self, mode)
70205    }
70206
70207    /// Set `SOL_IP` -> `IP_TOS`.
70208    pub fn r#set_ip_type_of_service(
70209        &self,
70210        mut value: u8,
70211    ) -> fidl::client::QueryResponseFut<
70212        BaseNetworkSocketSetIpTypeOfServiceResult,
70213        fidl::encoding::DefaultFuchsiaResourceDialect,
70214    > {
70215        SynchronousDatagramSocketProxyInterface::r#set_ip_type_of_service(self, value)
70216    }
70217
70218    /// Get `SOL_IP` -> `IP_TOS`.
70219    pub fn r#get_ip_type_of_service(
70220        &self,
70221    ) -> fidl::client::QueryResponseFut<
70222        BaseNetworkSocketGetIpTypeOfServiceResult,
70223        fidl::encoding::DefaultFuchsiaResourceDialect,
70224    > {
70225        SynchronousDatagramSocketProxyInterface::r#get_ip_type_of_service(self)
70226    }
70227
70228    /// Set `SOL_IP` -> `IP_TTL`.
70229    pub fn r#set_ip_ttl(
70230        &self,
70231        mut value: &OptionalUint8,
70232    ) -> fidl::client::QueryResponseFut<
70233        BaseNetworkSocketSetIpTtlResult,
70234        fidl::encoding::DefaultFuchsiaResourceDialect,
70235    > {
70236        SynchronousDatagramSocketProxyInterface::r#set_ip_ttl(self, value)
70237    }
70238
70239    /// Get `SOL_IP` -> `IP_TTL`.
70240    pub fn r#get_ip_ttl(
70241        &self,
70242    ) -> fidl::client::QueryResponseFut<
70243        BaseNetworkSocketGetIpTtlResult,
70244        fidl::encoding::DefaultFuchsiaResourceDialect,
70245    > {
70246        SynchronousDatagramSocketProxyInterface::r#get_ip_ttl(self)
70247    }
70248
70249    /// Set `SOL_IP` -> `IP_PKTINFO`.
70250    pub fn r#set_ip_packet_info(
70251        &self,
70252        mut value: bool,
70253    ) -> fidl::client::QueryResponseFut<
70254        BaseNetworkSocketSetIpPacketInfoResult,
70255        fidl::encoding::DefaultFuchsiaResourceDialect,
70256    > {
70257        SynchronousDatagramSocketProxyInterface::r#set_ip_packet_info(self, value)
70258    }
70259
70260    /// Get `SOL_IP` -> `IP_PKTINFO`.
70261    pub fn r#get_ip_packet_info(
70262        &self,
70263    ) -> fidl::client::QueryResponseFut<
70264        BaseNetworkSocketGetIpPacketInfoResult,
70265        fidl::encoding::DefaultFuchsiaResourceDialect,
70266    > {
70267        SynchronousDatagramSocketProxyInterface::r#get_ip_packet_info(self)
70268    }
70269
70270    /// Set `SOL_IP` -> `IP_RECVTOS`.
70271    pub fn r#set_ip_receive_type_of_service(
70272        &self,
70273        mut value: bool,
70274    ) -> fidl::client::QueryResponseFut<
70275        BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
70276        fidl::encoding::DefaultFuchsiaResourceDialect,
70277    > {
70278        SynchronousDatagramSocketProxyInterface::r#set_ip_receive_type_of_service(self, value)
70279    }
70280
70281    /// Get `SOL_IP` -> `IP_RECVTOS`.
70282    pub fn r#get_ip_receive_type_of_service(
70283        &self,
70284    ) -> fidl::client::QueryResponseFut<
70285        BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
70286        fidl::encoding::DefaultFuchsiaResourceDialect,
70287    > {
70288        SynchronousDatagramSocketProxyInterface::r#get_ip_receive_type_of_service(self)
70289    }
70290
70291    /// Set `SOL_IP` -> `IP_RECVTTL`.
70292    pub fn r#set_ip_receive_ttl(
70293        &self,
70294        mut value: bool,
70295    ) -> fidl::client::QueryResponseFut<
70296        BaseNetworkSocketSetIpReceiveTtlResult,
70297        fidl::encoding::DefaultFuchsiaResourceDialect,
70298    > {
70299        SynchronousDatagramSocketProxyInterface::r#set_ip_receive_ttl(self, value)
70300    }
70301
70302    /// Get `SOL_IP` -> `IP_RECVTTL`.
70303    pub fn r#get_ip_receive_ttl(
70304        &self,
70305    ) -> fidl::client::QueryResponseFut<
70306        BaseNetworkSocketGetIpReceiveTtlResult,
70307        fidl::encoding::DefaultFuchsiaResourceDialect,
70308    > {
70309        SynchronousDatagramSocketProxyInterface::r#get_ip_receive_ttl(self)
70310    }
70311
70312    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
70313    pub fn r#set_ip_multicast_interface(
70314        &self,
70315        mut iface: u64,
70316        mut address: &fidl_fuchsia_net::Ipv4Address,
70317    ) -> fidl::client::QueryResponseFut<
70318        BaseNetworkSocketSetIpMulticastInterfaceResult,
70319        fidl::encoding::DefaultFuchsiaResourceDialect,
70320    > {
70321        SynchronousDatagramSocketProxyInterface::r#set_ip_multicast_interface(self, iface, address)
70322    }
70323
70324    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
70325    pub fn r#get_ip_multicast_interface(
70326        &self,
70327    ) -> fidl::client::QueryResponseFut<
70328        BaseNetworkSocketGetIpMulticastInterfaceResult,
70329        fidl::encoding::DefaultFuchsiaResourceDialect,
70330    > {
70331        SynchronousDatagramSocketProxyInterface::r#get_ip_multicast_interface(self)
70332    }
70333
70334    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
70335    pub fn r#set_ip_multicast_ttl(
70336        &self,
70337        mut value: &OptionalUint8,
70338    ) -> fidl::client::QueryResponseFut<
70339        BaseNetworkSocketSetIpMulticastTtlResult,
70340        fidl::encoding::DefaultFuchsiaResourceDialect,
70341    > {
70342        SynchronousDatagramSocketProxyInterface::r#set_ip_multicast_ttl(self, value)
70343    }
70344
70345    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
70346    pub fn r#get_ip_multicast_ttl(
70347        &self,
70348    ) -> fidl::client::QueryResponseFut<
70349        BaseNetworkSocketGetIpMulticastTtlResult,
70350        fidl::encoding::DefaultFuchsiaResourceDialect,
70351    > {
70352        SynchronousDatagramSocketProxyInterface::r#get_ip_multicast_ttl(self)
70353    }
70354
70355    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
70356    pub fn r#set_ip_multicast_loopback(
70357        &self,
70358        mut value: bool,
70359    ) -> fidl::client::QueryResponseFut<
70360        BaseNetworkSocketSetIpMulticastLoopbackResult,
70361        fidl::encoding::DefaultFuchsiaResourceDialect,
70362    > {
70363        SynchronousDatagramSocketProxyInterface::r#set_ip_multicast_loopback(self, value)
70364    }
70365
70366    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
70367    pub fn r#get_ip_multicast_loopback(
70368        &self,
70369    ) -> fidl::client::QueryResponseFut<
70370        BaseNetworkSocketGetIpMulticastLoopbackResult,
70371        fidl::encoding::DefaultFuchsiaResourceDialect,
70372    > {
70373        SynchronousDatagramSocketProxyInterface::r#get_ip_multicast_loopback(self)
70374    }
70375
70376    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
70377    pub fn r#add_ip_membership(
70378        &self,
70379        mut membership: &IpMulticastMembership,
70380    ) -> fidl::client::QueryResponseFut<
70381        BaseNetworkSocketAddIpMembershipResult,
70382        fidl::encoding::DefaultFuchsiaResourceDialect,
70383    > {
70384        SynchronousDatagramSocketProxyInterface::r#add_ip_membership(self, membership)
70385    }
70386
70387    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
70388    pub fn r#drop_ip_membership(
70389        &self,
70390        mut membership: &IpMulticastMembership,
70391    ) -> fidl::client::QueryResponseFut<
70392        BaseNetworkSocketDropIpMembershipResult,
70393        fidl::encoding::DefaultFuchsiaResourceDialect,
70394    > {
70395        SynchronousDatagramSocketProxyInterface::r#drop_ip_membership(self, membership)
70396    }
70397
70398    /// Set `SOL_IP` -> `IP_TRANSPARENT`
70399    pub fn r#set_ip_transparent(
70400        &self,
70401        mut value: bool,
70402    ) -> fidl::client::QueryResponseFut<
70403        BaseNetworkSocketSetIpTransparentResult,
70404        fidl::encoding::DefaultFuchsiaResourceDialect,
70405    > {
70406        SynchronousDatagramSocketProxyInterface::r#set_ip_transparent(self, value)
70407    }
70408
70409    /// Get `SOL_IP` -> `IP_TRANSPARENT`
70410    pub fn r#get_ip_transparent(
70411        &self,
70412    ) -> fidl::client::QueryResponseFut<
70413        BaseNetworkSocketGetIpTransparentResult,
70414        fidl::encoding::DefaultFuchsiaResourceDialect,
70415    > {
70416        SynchronousDatagramSocketProxyInterface::r#get_ip_transparent(self)
70417    }
70418
70419    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
70420    pub fn r#set_ip_receive_original_destination_address(
70421        &self,
70422        mut value: bool,
70423    ) -> fidl::client::QueryResponseFut<
70424        BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
70425        fidl::encoding::DefaultFuchsiaResourceDialect,
70426    > {
70427        SynchronousDatagramSocketProxyInterface::r#set_ip_receive_original_destination_address(
70428            self, value,
70429        )
70430    }
70431
70432    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
70433    pub fn r#get_ip_receive_original_destination_address(
70434        &self,
70435    ) -> fidl::client::QueryResponseFut<
70436        BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
70437        fidl::encoding::DefaultFuchsiaResourceDialect,
70438    > {
70439        SynchronousDatagramSocketProxyInterface::r#get_ip_receive_original_destination_address(self)
70440    }
70441
70442    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
70443    pub fn r#add_ipv6_membership(
70444        &self,
70445        mut membership: &Ipv6MulticastMembership,
70446    ) -> fidl::client::QueryResponseFut<
70447        BaseNetworkSocketAddIpv6MembershipResult,
70448        fidl::encoding::DefaultFuchsiaResourceDialect,
70449    > {
70450        SynchronousDatagramSocketProxyInterface::r#add_ipv6_membership(self, membership)
70451    }
70452
70453    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
70454    pub fn r#drop_ipv6_membership(
70455        &self,
70456        mut membership: &Ipv6MulticastMembership,
70457    ) -> fidl::client::QueryResponseFut<
70458        BaseNetworkSocketDropIpv6MembershipResult,
70459        fidl::encoding::DefaultFuchsiaResourceDialect,
70460    > {
70461        SynchronousDatagramSocketProxyInterface::r#drop_ipv6_membership(self, membership)
70462    }
70463
70464    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
70465    pub fn r#set_ipv6_multicast_interface(
70466        &self,
70467        mut value: u64,
70468    ) -> fidl::client::QueryResponseFut<
70469        BaseNetworkSocketSetIpv6MulticastInterfaceResult,
70470        fidl::encoding::DefaultFuchsiaResourceDialect,
70471    > {
70472        SynchronousDatagramSocketProxyInterface::r#set_ipv6_multicast_interface(self, value)
70473    }
70474
70475    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
70476    pub fn r#get_ipv6_multicast_interface(
70477        &self,
70478    ) -> fidl::client::QueryResponseFut<
70479        BaseNetworkSocketGetIpv6MulticastInterfaceResult,
70480        fidl::encoding::DefaultFuchsiaResourceDialect,
70481    > {
70482        SynchronousDatagramSocketProxyInterface::r#get_ipv6_multicast_interface(self)
70483    }
70484
70485    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
70486    pub fn r#set_ipv6_unicast_hops(
70487        &self,
70488        mut value: &OptionalUint8,
70489    ) -> fidl::client::QueryResponseFut<
70490        BaseNetworkSocketSetIpv6UnicastHopsResult,
70491        fidl::encoding::DefaultFuchsiaResourceDialect,
70492    > {
70493        SynchronousDatagramSocketProxyInterface::r#set_ipv6_unicast_hops(self, value)
70494    }
70495
70496    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
70497    pub fn r#get_ipv6_unicast_hops(
70498        &self,
70499    ) -> fidl::client::QueryResponseFut<
70500        BaseNetworkSocketGetIpv6UnicastHopsResult,
70501        fidl::encoding::DefaultFuchsiaResourceDialect,
70502    > {
70503        SynchronousDatagramSocketProxyInterface::r#get_ipv6_unicast_hops(self)
70504    }
70505
70506    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
70507    pub fn r#set_ipv6_receive_hop_limit(
70508        &self,
70509        mut value: bool,
70510    ) -> fidl::client::QueryResponseFut<
70511        BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
70512        fidl::encoding::DefaultFuchsiaResourceDialect,
70513    > {
70514        SynchronousDatagramSocketProxyInterface::r#set_ipv6_receive_hop_limit(self, value)
70515    }
70516
70517    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
70518    pub fn r#get_ipv6_receive_hop_limit(
70519        &self,
70520    ) -> fidl::client::QueryResponseFut<
70521        BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
70522        fidl::encoding::DefaultFuchsiaResourceDialect,
70523    > {
70524        SynchronousDatagramSocketProxyInterface::r#get_ipv6_receive_hop_limit(self)
70525    }
70526
70527    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
70528    pub fn r#set_ipv6_multicast_hops(
70529        &self,
70530        mut value: &OptionalUint8,
70531    ) -> fidl::client::QueryResponseFut<
70532        BaseNetworkSocketSetIpv6MulticastHopsResult,
70533        fidl::encoding::DefaultFuchsiaResourceDialect,
70534    > {
70535        SynchronousDatagramSocketProxyInterface::r#set_ipv6_multicast_hops(self, value)
70536    }
70537
70538    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
70539    pub fn r#get_ipv6_multicast_hops(
70540        &self,
70541    ) -> fidl::client::QueryResponseFut<
70542        BaseNetworkSocketGetIpv6MulticastHopsResult,
70543        fidl::encoding::DefaultFuchsiaResourceDialect,
70544    > {
70545        SynchronousDatagramSocketProxyInterface::r#get_ipv6_multicast_hops(self)
70546    }
70547
70548    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
70549    pub fn r#set_ipv6_multicast_loopback(
70550        &self,
70551        mut value: bool,
70552    ) -> fidl::client::QueryResponseFut<
70553        BaseNetworkSocketSetIpv6MulticastLoopbackResult,
70554        fidl::encoding::DefaultFuchsiaResourceDialect,
70555    > {
70556        SynchronousDatagramSocketProxyInterface::r#set_ipv6_multicast_loopback(self, value)
70557    }
70558
70559    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
70560    pub fn r#get_ipv6_multicast_loopback(
70561        &self,
70562    ) -> fidl::client::QueryResponseFut<
70563        BaseNetworkSocketGetIpv6MulticastLoopbackResult,
70564        fidl::encoding::DefaultFuchsiaResourceDialect,
70565    > {
70566        SynchronousDatagramSocketProxyInterface::r#get_ipv6_multicast_loopback(self)
70567    }
70568
70569    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
70570    pub fn r#set_ipv6_only(
70571        &self,
70572        mut value: bool,
70573    ) -> fidl::client::QueryResponseFut<
70574        BaseNetworkSocketSetIpv6OnlyResult,
70575        fidl::encoding::DefaultFuchsiaResourceDialect,
70576    > {
70577        SynchronousDatagramSocketProxyInterface::r#set_ipv6_only(self, value)
70578    }
70579
70580    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
70581    pub fn r#get_ipv6_only(
70582        &self,
70583    ) -> fidl::client::QueryResponseFut<
70584        BaseNetworkSocketGetIpv6OnlyResult,
70585        fidl::encoding::DefaultFuchsiaResourceDialect,
70586    > {
70587        SynchronousDatagramSocketProxyInterface::r#get_ipv6_only(self)
70588    }
70589
70590    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
70591    pub fn r#set_ipv6_receive_traffic_class(
70592        &self,
70593        mut value: bool,
70594    ) -> fidl::client::QueryResponseFut<
70595        BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
70596        fidl::encoding::DefaultFuchsiaResourceDialect,
70597    > {
70598        SynchronousDatagramSocketProxyInterface::r#set_ipv6_receive_traffic_class(self, value)
70599    }
70600
70601    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
70602    pub fn r#get_ipv6_receive_traffic_class(
70603        &self,
70604    ) -> fidl::client::QueryResponseFut<
70605        BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
70606        fidl::encoding::DefaultFuchsiaResourceDialect,
70607    > {
70608        SynchronousDatagramSocketProxyInterface::r#get_ipv6_receive_traffic_class(self)
70609    }
70610
70611    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
70612    pub fn r#set_ipv6_traffic_class(
70613        &self,
70614        mut value: &OptionalUint8,
70615    ) -> fidl::client::QueryResponseFut<
70616        BaseNetworkSocketSetIpv6TrafficClassResult,
70617        fidl::encoding::DefaultFuchsiaResourceDialect,
70618    > {
70619        SynchronousDatagramSocketProxyInterface::r#set_ipv6_traffic_class(self, value)
70620    }
70621
70622    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
70623    pub fn r#get_ipv6_traffic_class(
70624        &self,
70625    ) -> fidl::client::QueryResponseFut<
70626        BaseNetworkSocketGetIpv6TrafficClassResult,
70627        fidl::encoding::DefaultFuchsiaResourceDialect,
70628    > {
70629        SynchronousDatagramSocketProxyInterface::r#get_ipv6_traffic_class(self)
70630    }
70631
70632    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
70633    pub fn r#set_ipv6_receive_packet_info(
70634        &self,
70635        mut value: bool,
70636    ) -> fidl::client::QueryResponseFut<
70637        BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
70638        fidl::encoding::DefaultFuchsiaResourceDialect,
70639    > {
70640        SynchronousDatagramSocketProxyInterface::r#set_ipv6_receive_packet_info(self, value)
70641    }
70642
70643    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
70644    pub fn r#get_ipv6_receive_packet_info(
70645        &self,
70646    ) -> fidl::client::QueryResponseFut<
70647        BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
70648        fidl::encoding::DefaultFuchsiaResourceDialect,
70649    > {
70650        SynchronousDatagramSocketProxyInterface::r#get_ipv6_receive_packet_info(self)
70651    }
70652
70653    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
70654    pub fn r#get_original_destination(
70655        &self,
70656    ) -> fidl::client::QueryResponseFut<
70657        BaseNetworkSocketGetOriginalDestinationResult,
70658        fidl::encoding::DefaultFuchsiaResourceDialect,
70659    > {
70660        SynchronousDatagramSocketProxyInterface::r#get_original_destination(self)
70661    }
70662
70663    /// Retrieves creation information from the socket.
70664    ///
70665    /// - response `domain` the socket's associated domain.
70666    /// - response `proto` the socket's associated protocol.
70667    pub fn r#get_info(
70668        &self,
70669    ) -> fidl::client::QueryResponseFut<
70670        BaseDatagramSocketGetInfoResult,
70671        fidl::encoding::DefaultFuchsiaResourceDialect,
70672    > {
70673        SynchronousDatagramSocketProxyInterface::r#get_info(self)
70674    }
70675
70676    pub fn r#describe(
70677        &self,
70678    ) -> fidl::client::QueryResponseFut<
70679        SynchronousDatagramSocketDescribeResponse,
70680        fidl::encoding::DefaultFuchsiaResourceDialect,
70681    > {
70682        SynchronousDatagramSocketProxyInterface::r#describe(self)
70683    }
70684
70685    /// Receives a message from the socket.
70686    ///
70687    /// + request `want_addr` request message's source address information to
70688    ///   be returned.
70689    /// + request `data_len` the maximum allowed length of the response data
70690    ///   buffer.
70691    /// + request `want_control` request ancillary data to be returned.
70692    /// + request `flags` flags for the receive request.
70693    /// - response `addr` the message's source address information, if
70694    ///   requested.
70695    /// - response `data` the message.
70696    /// - response `control` control messages, if requested.
70697    /// - response `truncated` indicates whether or not the returned message
70698    ///   was truncated.
70699    pub fn r#recv_msg(
70700        &self,
70701        mut want_addr: bool,
70702        mut data_len: u32,
70703        mut want_control: bool,
70704        mut flags: RecvMsgFlags,
70705    ) -> fidl::client::QueryResponseFut<
70706        SynchronousDatagramSocketRecvMsgResult,
70707        fidl::encoding::DefaultFuchsiaResourceDialect,
70708    > {
70709        SynchronousDatagramSocketProxyInterface::r#recv_msg(
70710            self,
70711            want_addr,
70712            data_len,
70713            want_control,
70714            flags,
70715        )
70716    }
70717
70718    /// Sends a message on the socket.
70719    ///
70720    /// + request `addr` the address to send the message to. If unset, will send
70721    ///   to the connected peer.
70722    /// + request `data` the message.
70723    /// + request `control` ancillary data.
70724    /// + request `flags` flags for the send request.
70725    /// - response `len` the number of bytes sent.
70726    pub fn r#send_msg(
70727        &self,
70728        mut addr: Option<&fidl_fuchsia_net::SocketAddress>,
70729        mut data: &[u8],
70730        mut control: &DatagramSocketSendControlData,
70731        mut flags: SendMsgFlags,
70732    ) -> fidl::client::QueryResponseFut<
70733        SynchronousDatagramSocketSendMsgResult,
70734        fidl::encoding::DefaultFuchsiaResourceDialect,
70735    > {
70736        SynchronousDatagramSocketProxyInterface::r#send_msg(self, addr, data, control, flags)
70737    }
70738}
70739
70740impl SynchronousDatagramSocketProxyInterface for SynchronousDatagramSocketProxy {
70741    fn r#clone(
70742        &self,
70743        mut request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
70744    ) -> Result<(), fidl::Error> {
70745        self.client.send::<fidl_fuchsia_unknown::CloneableCloneRequest>(
70746            (request,),
70747            0x20d8a7aba2168a79,
70748            fidl::encoding::DynamicFlags::empty(),
70749        )
70750    }
70751
70752    type CloseResponseFut = fidl::client::QueryResponseFut<
70753        fidl_fuchsia_unknown::CloseableCloseResult,
70754        fidl::encoding::DefaultFuchsiaResourceDialect,
70755    >;
70756    fn r#close(&self) -> Self::CloseResponseFut {
70757        fn _decode(
70758            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
70759        ) -> Result<fidl_fuchsia_unknown::CloseableCloseResult, fidl::Error> {
70760            let _response = fidl::client::decode_transaction_body::<
70761                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>,
70762                fidl::encoding::DefaultFuchsiaResourceDialect,
70763                0x5ac5d459ad7f657e,
70764            >(_buf?)?;
70765            Ok(_response.map(|x| x))
70766        }
70767        self.client.send_query_and_decode::<
70768            fidl::encoding::EmptyPayload,
70769            fidl_fuchsia_unknown::CloseableCloseResult,
70770        >(
70771            (),
70772            0x5ac5d459ad7f657e,
70773            fidl::encoding::DynamicFlags::empty(),
70774            _decode,
70775        )
70776    }
70777
70778    type QueryResponseFut =
70779        fidl::client::QueryResponseFut<Vec<u8>, fidl::encoding::DefaultFuchsiaResourceDialect>;
70780    fn r#query(&self) -> Self::QueryResponseFut {
70781        fn _decode(
70782            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
70783        ) -> Result<Vec<u8>, fidl::Error> {
70784            let _response = fidl::client::decode_transaction_body::<
70785                fidl_fuchsia_unknown::QueryableQueryResponse,
70786                fidl::encoding::DefaultFuchsiaResourceDialect,
70787                0x2658edee9decfc06,
70788            >(_buf?)?;
70789            Ok(_response.protocol)
70790        }
70791        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<u8>>(
70792            (),
70793            0x2658edee9decfc06,
70794            fidl::encoding::DynamicFlags::empty(),
70795            _decode,
70796        )
70797    }
70798
70799    type SetReuseAddressResponseFut = fidl::client::QueryResponseFut<
70800        BaseSocketSetReuseAddressResult,
70801        fidl::encoding::DefaultFuchsiaResourceDialect,
70802    >;
70803    fn r#set_reuse_address(&self, mut value: bool) -> Self::SetReuseAddressResponseFut {
70804        fn _decode(
70805            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
70806        ) -> Result<BaseSocketSetReuseAddressResult, fidl::Error> {
70807            let _response = fidl::client::decode_transaction_body::<
70808                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
70809                fidl::encoding::DefaultFuchsiaResourceDialect,
70810                0x1fd74ee8b9a4a876,
70811            >(_buf?)?;
70812            Ok(_response.map(|x| x))
70813        }
70814        self.client.send_query_and_decode::<
70815            BaseSocketSetReuseAddressRequest,
70816            BaseSocketSetReuseAddressResult,
70817        >(
70818            (value,),
70819            0x1fd74ee8b9a4a876,
70820            fidl::encoding::DynamicFlags::empty(),
70821            _decode,
70822        )
70823    }
70824
70825    type GetReuseAddressResponseFut = fidl::client::QueryResponseFut<
70826        BaseSocketGetReuseAddressResult,
70827        fidl::encoding::DefaultFuchsiaResourceDialect,
70828    >;
70829    fn r#get_reuse_address(&self) -> Self::GetReuseAddressResponseFut {
70830        fn _decode(
70831            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
70832        ) -> Result<BaseSocketGetReuseAddressResult, fidl::Error> {
70833            let _response = fidl::client::decode_transaction_body::<
70834                fidl::encoding::ResultType<
70835                    BaseSocketGetReuseAddressResponse,
70836                    fidl_fuchsia_posix::Errno,
70837                >,
70838                fidl::encoding::DefaultFuchsiaResourceDialect,
70839                0x67b7206b8d1bc0a5,
70840            >(_buf?)?;
70841            Ok(_response.map(|x| x.value))
70842        }
70843        self.client
70844            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReuseAddressResult>(
70845                (),
70846                0x67b7206b8d1bc0a5,
70847                fidl::encoding::DynamicFlags::empty(),
70848                _decode,
70849            )
70850    }
70851
70852    type GetErrorResponseFut = fidl::client::QueryResponseFut<
70853        BaseSocketGetErrorResult,
70854        fidl::encoding::DefaultFuchsiaResourceDialect,
70855    >;
70856    fn r#get_error(&self) -> Self::GetErrorResponseFut {
70857        fn _decode(
70858            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
70859        ) -> Result<BaseSocketGetErrorResult, fidl::Error> {
70860            let _response = fidl::client::decode_transaction_body::<
70861                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
70862                fidl::encoding::DefaultFuchsiaResourceDialect,
70863                0x5aad39b33e5f6ebb,
70864            >(_buf?)?;
70865            Ok(_response.map(|x| x))
70866        }
70867        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetErrorResult>(
70868            (),
70869            0x5aad39b33e5f6ebb,
70870            fidl::encoding::DynamicFlags::empty(),
70871            _decode,
70872        )
70873    }
70874
70875    type SetBroadcastResponseFut = fidl::client::QueryResponseFut<
70876        BaseSocketSetBroadcastResult,
70877        fidl::encoding::DefaultFuchsiaResourceDialect,
70878    >;
70879    fn r#set_broadcast(&self, mut value: bool) -> Self::SetBroadcastResponseFut {
70880        fn _decode(
70881            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
70882        ) -> Result<BaseSocketSetBroadcastResult, fidl::Error> {
70883            let _response = fidl::client::decode_transaction_body::<
70884                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
70885                fidl::encoding::DefaultFuchsiaResourceDialect,
70886                0x6023e081ce3cd947,
70887            >(_buf?)?;
70888            Ok(_response.map(|x| x))
70889        }
70890        self.client
70891            .send_query_and_decode::<BaseSocketSetBroadcastRequest, BaseSocketSetBroadcastResult>(
70892                (value,),
70893                0x6023e081ce3cd947,
70894                fidl::encoding::DynamicFlags::empty(),
70895                _decode,
70896            )
70897    }
70898
70899    type GetBroadcastResponseFut = fidl::client::QueryResponseFut<
70900        BaseSocketGetBroadcastResult,
70901        fidl::encoding::DefaultFuchsiaResourceDialect,
70902    >;
70903    fn r#get_broadcast(&self) -> Self::GetBroadcastResponseFut {
70904        fn _decode(
70905            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
70906        ) -> Result<BaseSocketGetBroadcastResult, fidl::Error> {
70907            let _response = fidl::client::decode_transaction_body::<
70908                fidl::encoding::ResultType<
70909                    BaseSocketGetBroadcastResponse,
70910                    fidl_fuchsia_posix::Errno,
70911                >,
70912                fidl::encoding::DefaultFuchsiaResourceDialect,
70913                0x68796fc556f9780d,
70914            >(_buf?)?;
70915            Ok(_response.map(|x| x.value))
70916        }
70917        self.client
70918            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBroadcastResult>(
70919                (),
70920                0x68796fc556f9780d,
70921                fidl::encoding::DynamicFlags::empty(),
70922                _decode,
70923            )
70924    }
70925
70926    type SetSendBufferResponseFut = fidl::client::QueryResponseFut<
70927        BaseSocketSetSendBufferResult,
70928        fidl::encoding::DefaultFuchsiaResourceDialect,
70929    >;
70930    fn r#set_send_buffer(&self, mut value_bytes: u64) -> Self::SetSendBufferResponseFut {
70931        fn _decode(
70932            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
70933        ) -> Result<BaseSocketSetSendBufferResult, fidl::Error> {
70934            let _response = fidl::client::decode_transaction_body::<
70935                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
70936                fidl::encoding::DefaultFuchsiaResourceDialect,
70937                0x756eac32d73a7a70,
70938            >(_buf?)?;
70939            Ok(_response.map(|x| x))
70940        }
70941        self.client
70942            .send_query_and_decode::<BaseSocketSetSendBufferRequest, BaseSocketSetSendBufferResult>(
70943                (value_bytes,),
70944                0x756eac32d73a7a70,
70945                fidl::encoding::DynamicFlags::empty(),
70946                _decode,
70947            )
70948    }
70949
70950    type GetSendBufferResponseFut = fidl::client::QueryResponseFut<
70951        BaseSocketGetSendBufferResult,
70952        fidl::encoding::DefaultFuchsiaResourceDialect,
70953    >;
70954    fn r#get_send_buffer(&self) -> Self::GetSendBufferResponseFut {
70955        fn _decode(
70956            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
70957        ) -> Result<BaseSocketGetSendBufferResult, fidl::Error> {
70958            let _response = fidl::client::decode_transaction_body::<
70959                fidl::encoding::ResultType<
70960                    BaseSocketGetSendBufferResponse,
70961                    fidl_fuchsia_posix::Errno,
70962                >,
70963                fidl::encoding::DefaultFuchsiaResourceDialect,
70964                0x78a52fd9c7b2410b,
70965            >(_buf?)?;
70966            Ok(_response.map(|x| x.value_bytes))
70967        }
70968        self.client
70969            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetSendBufferResult>(
70970                (),
70971                0x78a52fd9c7b2410b,
70972                fidl::encoding::DynamicFlags::empty(),
70973                _decode,
70974            )
70975    }
70976
70977    type SetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
70978        BaseSocketSetReceiveBufferResult,
70979        fidl::encoding::DefaultFuchsiaResourceDialect,
70980    >;
70981    fn r#set_receive_buffer(&self, mut value_bytes: u64) -> Self::SetReceiveBufferResponseFut {
70982        fn _decode(
70983            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
70984        ) -> Result<BaseSocketSetReceiveBufferResult, fidl::Error> {
70985            let _response = fidl::client::decode_transaction_body::<
70986                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
70987                fidl::encoding::DefaultFuchsiaResourceDialect,
70988                0x6b0cf2f1919c7001,
70989            >(_buf?)?;
70990            Ok(_response.map(|x| x))
70991        }
70992        self.client.send_query_and_decode::<
70993            BaseSocketSetReceiveBufferRequest,
70994            BaseSocketSetReceiveBufferResult,
70995        >(
70996            (value_bytes,),
70997            0x6b0cf2f1919c7001,
70998            fidl::encoding::DynamicFlags::empty(),
70999            _decode,
71000        )
71001    }
71002
71003    type GetReceiveBufferResponseFut = fidl::client::QueryResponseFut<
71004        BaseSocketGetReceiveBufferResult,
71005        fidl::encoding::DefaultFuchsiaResourceDialect,
71006    >;
71007    fn r#get_receive_buffer(&self) -> Self::GetReceiveBufferResponseFut {
71008        fn _decode(
71009            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71010        ) -> Result<BaseSocketGetReceiveBufferResult, fidl::Error> {
71011            let _response = fidl::client::decode_transaction_body::<
71012                fidl::encoding::ResultType<
71013                    BaseSocketGetReceiveBufferResponse,
71014                    fidl_fuchsia_posix::Errno,
71015                >,
71016                fidl::encoding::DefaultFuchsiaResourceDialect,
71017                0x14c1a4b64f709e5c,
71018            >(_buf?)?;
71019            Ok(_response.map(|x| x.value_bytes))
71020        }
71021        self.client.send_query_and_decode::<
71022            fidl::encoding::EmptyPayload,
71023            BaseSocketGetReceiveBufferResult,
71024        >(
71025            (),
71026            0x14c1a4b64f709e5c,
71027            fidl::encoding::DynamicFlags::empty(),
71028            _decode,
71029        )
71030    }
71031
71032    type SetKeepAliveResponseFut = fidl::client::QueryResponseFut<
71033        BaseSocketSetKeepAliveResult,
71034        fidl::encoding::DefaultFuchsiaResourceDialect,
71035    >;
71036    fn r#set_keep_alive(&self, mut value: bool) -> Self::SetKeepAliveResponseFut {
71037        fn _decode(
71038            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71039        ) -> Result<BaseSocketSetKeepAliveResult, fidl::Error> {
71040            let _response = fidl::client::decode_transaction_body::<
71041                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71042                fidl::encoding::DefaultFuchsiaResourceDialect,
71043                0x572df8f0b920d2c7,
71044            >(_buf?)?;
71045            Ok(_response.map(|x| x))
71046        }
71047        self.client
71048            .send_query_and_decode::<BaseSocketSetKeepAliveRequest, BaseSocketSetKeepAliveResult>(
71049                (value,),
71050                0x572df8f0b920d2c7,
71051                fidl::encoding::DynamicFlags::empty(),
71052                _decode,
71053            )
71054    }
71055
71056    type GetKeepAliveResponseFut = fidl::client::QueryResponseFut<
71057        BaseSocketGetKeepAliveResult,
71058        fidl::encoding::DefaultFuchsiaResourceDialect,
71059    >;
71060    fn r#get_keep_alive(&self) -> Self::GetKeepAliveResponseFut {
71061        fn _decode(
71062            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71063        ) -> Result<BaseSocketGetKeepAliveResult, fidl::Error> {
71064            let _response = fidl::client::decode_transaction_body::<
71065                fidl::encoding::ResultType<
71066                    BaseSocketGetKeepAliveResponse,
71067                    fidl_fuchsia_posix::Errno,
71068                >,
71069                fidl::encoding::DefaultFuchsiaResourceDialect,
71070                0x2dd29d3215f2c9d2,
71071            >(_buf?)?;
71072            Ok(_response.map(|x| x.value))
71073        }
71074        self.client
71075            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetKeepAliveResult>(
71076                (),
71077                0x2dd29d3215f2c9d2,
71078                fidl::encoding::DynamicFlags::empty(),
71079                _decode,
71080            )
71081    }
71082
71083    type SetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
71084        BaseSocketSetOutOfBandInlineResult,
71085        fidl::encoding::DefaultFuchsiaResourceDialect,
71086    >;
71087    fn r#set_out_of_band_inline(&self, mut value: bool) -> Self::SetOutOfBandInlineResponseFut {
71088        fn _decode(
71089            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71090        ) -> Result<BaseSocketSetOutOfBandInlineResult, fidl::Error> {
71091            let _response = fidl::client::decode_transaction_body::<
71092                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71093                fidl::encoding::DefaultFuchsiaResourceDialect,
71094                0x3ecb49968bee439,
71095            >(_buf?)?;
71096            Ok(_response.map(|x| x))
71097        }
71098        self.client.send_query_and_decode::<
71099            BaseSocketSetOutOfBandInlineRequest,
71100            BaseSocketSetOutOfBandInlineResult,
71101        >(
71102            (value,),
71103            0x3ecb49968bee439,
71104            fidl::encoding::DynamicFlags::empty(),
71105            _decode,
71106        )
71107    }
71108
71109    type GetOutOfBandInlineResponseFut = fidl::client::QueryResponseFut<
71110        BaseSocketGetOutOfBandInlineResult,
71111        fidl::encoding::DefaultFuchsiaResourceDialect,
71112    >;
71113    fn r#get_out_of_band_inline(&self) -> Self::GetOutOfBandInlineResponseFut {
71114        fn _decode(
71115            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71116        ) -> Result<BaseSocketGetOutOfBandInlineResult, fidl::Error> {
71117            let _response = fidl::client::decode_transaction_body::<
71118                fidl::encoding::ResultType<
71119                    BaseSocketGetOutOfBandInlineResponse,
71120                    fidl_fuchsia_posix::Errno,
71121                >,
71122                fidl::encoding::DefaultFuchsiaResourceDialect,
71123                0x348c1ab3aeca1745,
71124            >(_buf?)?;
71125            Ok(_response.map(|x| x.value))
71126        }
71127        self.client.send_query_and_decode::<
71128            fidl::encoding::EmptyPayload,
71129            BaseSocketGetOutOfBandInlineResult,
71130        >(
71131            (),
71132            0x348c1ab3aeca1745,
71133            fidl::encoding::DynamicFlags::empty(),
71134            _decode,
71135        )
71136    }
71137
71138    type SetNoCheckResponseFut = fidl::client::QueryResponseFut<
71139        BaseSocketSetNoCheckResult,
71140        fidl::encoding::DefaultFuchsiaResourceDialect,
71141    >;
71142    fn r#set_no_check(&self, mut value: bool) -> Self::SetNoCheckResponseFut {
71143        fn _decode(
71144            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71145        ) -> Result<BaseSocketSetNoCheckResult, fidl::Error> {
71146            let _response = fidl::client::decode_transaction_body::<
71147                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71148                fidl::encoding::DefaultFuchsiaResourceDialect,
71149                0x6bbf00c53a4c78c2,
71150            >(_buf?)?;
71151            Ok(_response.map(|x| x))
71152        }
71153        self.client
71154            .send_query_and_decode::<BaseSocketSetNoCheckRequest, BaseSocketSetNoCheckResult>(
71155                (value,),
71156                0x6bbf00c53a4c78c2,
71157                fidl::encoding::DynamicFlags::empty(),
71158                _decode,
71159            )
71160    }
71161
71162    type GetNoCheckResponseFut = fidl::client::QueryResponseFut<
71163        BaseSocketGetNoCheckResult,
71164        fidl::encoding::DefaultFuchsiaResourceDialect,
71165    >;
71166    fn r#get_no_check(&self) -> Self::GetNoCheckResponseFut {
71167        fn _decode(
71168            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71169        ) -> Result<BaseSocketGetNoCheckResult, fidl::Error> {
71170            let _response = fidl::client::decode_transaction_body::<
71171                fidl::encoding::ResultType<BaseSocketGetNoCheckResponse, fidl_fuchsia_posix::Errno>,
71172                fidl::encoding::DefaultFuchsiaResourceDialect,
71173                0x2cd4249286417694,
71174            >(_buf?)?;
71175            Ok(_response.map(|x| x.value))
71176        }
71177        self.client
71178            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetNoCheckResult>(
71179                (),
71180                0x2cd4249286417694,
71181                fidl::encoding::DynamicFlags::empty(),
71182                _decode,
71183            )
71184    }
71185
71186    type SetLingerResponseFut = fidl::client::QueryResponseFut<
71187        BaseSocketSetLingerResult,
71188        fidl::encoding::DefaultFuchsiaResourceDialect,
71189    >;
71190    fn r#set_linger(&self, mut linger: bool, mut length_secs: u32) -> Self::SetLingerResponseFut {
71191        fn _decode(
71192            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71193        ) -> Result<BaseSocketSetLingerResult, fidl::Error> {
71194            let _response = fidl::client::decode_transaction_body::<
71195                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71196                fidl::encoding::DefaultFuchsiaResourceDialect,
71197                0x45386351246e998e,
71198            >(_buf?)?;
71199            Ok(_response.map(|x| x))
71200        }
71201        self.client.send_query_and_decode::<BaseSocketSetLingerRequest, BaseSocketSetLingerResult>(
71202            (linger, length_secs),
71203            0x45386351246e998e,
71204            fidl::encoding::DynamicFlags::empty(),
71205            _decode,
71206        )
71207    }
71208
71209    type GetLingerResponseFut = fidl::client::QueryResponseFut<
71210        BaseSocketGetLingerResult,
71211        fidl::encoding::DefaultFuchsiaResourceDialect,
71212    >;
71213    fn r#get_linger(&self) -> Self::GetLingerResponseFut {
71214        fn _decode(
71215            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71216        ) -> Result<BaseSocketGetLingerResult, fidl::Error> {
71217            let _response = fidl::client::decode_transaction_body::<
71218                fidl::encoding::ResultType<BaseSocketGetLingerResponse, fidl_fuchsia_posix::Errno>,
71219                fidl::encoding::DefaultFuchsiaResourceDialect,
71220                0x48eb20fc5ccb0e45,
71221            >(_buf?)?;
71222            Ok(_response.map(|x| (x.linger, x.length_secs)))
71223        }
71224        self.client
71225            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetLingerResult>(
71226                (),
71227                0x48eb20fc5ccb0e45,
71228                fidl::encoding::DynamicFlags::empty(),
71229                _decode,
71230            )
71231    }
71232
71233    type SetReusePortResponseFut = fidl::client::QueryResponseFut<
71234        BaseSocketSetReusePortResult,
71235        fidl::encoding::DefaultFuchsiaResourceDialect,
71236    >;
71237    fn r#set_reuse_port(&self, mut value: bool) -> Self::SetReusePortResponseFut {
71238        fn _decode(
71239            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71240        ) -> Result<BaseSocketSetReusePortResult, fidl::Error> {
71241            let _response = fidl::client::decode_transaction_body::<
71242                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71243                fidl::encoding::DefaultFuchsiaResourceDialect,
71244                0x24dd3e5cb36d9ccb,
71245            >(_buf?)?;
71246            Ok(_response.map(|x| x))
71247        }
71248        self.client
71249            .send_query_and_decode::<BaseSocketSetReusePortRequest, BaseSocketSetReusePortResult>(
71250                (value,),
71251                0x24dd3e5cb36d9ccb,
71252                fidl::encoding::DynamicFlags::empty(),
71253                _decode,
71254            )
71255    }
71256
71257    type GetReusePortResponseFut = fidl::client::QueryResponseFut<
71258        BaseSocketGetReusePortResult,
71259        fidl::encoding::DefaultFuchsiaResourceDialect,
71260    >;
71261    fn r#get_reuse_port(&self) -> Self::GetReusePortResponseFut {
71262        fn _decode(
71263            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71264        ) -> Result<BaseSocketGetReusePortResult, fidl::Error> {
71265            let _response = fidl::client::decode_transaction_body::<
71266                fidl::encoding::ResultType<
71267                    BaseSocketGetReusePortResponse,
71268                    fidl_fuchsia_posix::Errno,
71269                >,
71270                fidl::encoding::DefaultFuchsiaResourceDialect,
71271                0x7a112c1ab54ff828,
71272            >(_buf?)?;
71273            Ok(_response.map(|x| x.value))
71274        }
71275        self.client
71276            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetReusePortResult>(
71277                (),
71278                0x7a112c1ab54ff828,
71279                fidl::encoding::DynamicFlags::empty(),
71280                _decode,
71281            )
71282    }
71283
71284    type GetAcceptConnResponseFut = fidl::client::QueryResponseFut<
71285        BaseSocketGetAcceptConnResult,
71286        fidl::encoding::DefaultFuchsiaResourceDialect,
71287    >;
71288    fn r#get_accept_conn(&self) -> Self::GetAcceptConnResponseFut {
71289        fn _decode(
71290            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71291        ) -> Result<BaseSocketGetAcceptConnResult, fidl::Error> {
71292            let _response = fidl::client::decode_transaction_body::<
71293                fidl::encoding::ResultType<
71294                    BaseSocketGetAcceptConnResponse,
71295                    fidl_fuchsia_posix::Errno,
71296                >,
71297                fidl::encoding::DefaultFuchsiaResourceDialect,
71298                0x67ce6db6c2ec8966,
71299            >(_buf?)?;
71300            Ok(_response.map(|x| x.value))
71301        }
71302        self.client
71303            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetAcceptConnResult>(
71304                (),
71305                0x67ce6db6c2ec8966,
71306                fidl::encoding::DynamicFlags::empty(),
71307                _decode,
71308            )
71309    }
71310
71311    type SetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
71312        BaseSocketSetBindToDeviceResult,
71313        fidl::encoding::DefaultFuchsiaResourceDialect,
71314    >;
71315    fn r#set_bind_to_device(&self, mut value: &str) -> Self::SetBindToDeviceResponseFut {
71316        fn _decode(
71317            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71318        ) -> Result<BaseSocketSetBindToDeviceResult, fidl::Error> {
71319            let _response = fidl::client::decode_transaction_body::<
71320                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71321                fidl::encoding::DefaultFuchsiaResourceDialect,
71322                0x2118b483f28aafc4,
71323            >(_buf?)?;
71324            Ok(_response.map(|x| x))
71325        }
71326        self.client.send_query_and_decode::<
71327            BaseSocketSetBindToDeviceRequest,
71328            BaseSocketSetBindToDeviceResult,
71329        >(
71330            (value,),
71331            0x2118b483f28aafc4,
71332            fidl::encoding::DynamicFlags::empty(),
71333            _decode,
71334        )
71335    }
71336
71337    type GetBindToDeviceResponseFut = fidl::client::QueryResponseFut<
71338        BaseSocketGetBindToDeviceResult,
71339        fidl::encoding::DefaultFuchsiaResourceDialect,
71340    >;
71341    fn r#get_bind_to_device(&self) -> Self::GetBindToDeviceResponseFut {
71342        fn _decode(
71343            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71344        ) -> Result<BaseSocketGetBindToDeviceResult, fidl::Error> {
71345            let _response = fidl::client::decode_transaction_body::<
71346                fidl::encoding::ResultType<
71347                    BaseSocketGetBindToDeviceResponse,
71348                    fidl_fuchsia_posix::Errno,
71349                >,
71350                fidl::encoding::DefaultFuchsiaResourceDialect,
71351                0x1ab1fbf0ef7906c8,
71352            >(_buf?)?;
71353            Ok(_response.map(|x| x.value))
71354        }
71355        self.client
71356            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetBindToDeviceResult>(
71357                (),
71358                0x1ab1fbf0ef7906c8,
71359                fidl::encoding::DynamicFlags::empty(),
71360                _decode,
71361            )
71362    }
71363
71364    type SetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
71365        BaseSocketSetBindToInterfaceIndexResult,
71366        fidl::encoding::DefaultFuchsiaResourceDialect,
71367    >;
71368    fn r#set_bind_to_interface_index(
71369        &self,
71370        mut value: u64,
71371    ) -> Self::SetBindToInterfaceIndexResponseFut {
71372        fn _decode(
71373            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71374        ) -> Result<BaseSocketSetBindToInterfaceIndexResult, fidl::Error> {
71375            let _response = fidl::client::decode_transaction_body::<
71376                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71377                fidl::encoding::DefaultFuchsiaResourceDialect,
71378                0x6e387a0def00821,
71379            >(_buf?)?;
71380            Ok(_response.map(|x| x))
71381        }
71382        self.client.send_query_and_decode::<
71383            BaseSocketSetBindToInterfaceIndexRequest,
71384            BaseSocketSetBindToInterfaceIndexResult,
71385        >(
71386            (value,),
71387            0x6e387a0def00821,
71388            fidl::encoding::DynamicFlags::empty(),
71389            _decode,
71390        )
71391    }
71392
71393    type GetBindToInterfaceIndexResponseFut = fidl::client::QueryResponseFut<
71394        BaseSocketGetBindToInterfaceIndexResult,
71395        fidl::encoding::DefaultFuchsiaResourceDialect,
71396    >;
71397    fn r#get_bind_to_interface_index(&self) -> Self::GetBindToInterfaceIndexResponseFut {
71398        fn _decode(
71399            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71400        ) -> Result<BaseSocketGetBindToInterfaceIndexResult, fidl::Error> {
71401            let _response = fidl::client::decode_transaction_body::<
71402                fidl::encoding::ResultType<
71403                    BaseSocketGetBindToInterfaceIndexResponse,
71404                    fidl_fuchsia_posix::Errno,
71405                >,
71406                fidl::encoding::DefaultFuchsiaResourceDialect,
71407                0x59c31dd3e3078295,
71408            >(_buf?)?;
71409            Ok(_response.map(|x| x.value))
71410        }
71411        self.client.send_query_and_decode::<
71412            fidl::encoding::EmptyPayload,
71413            BaseSocketGetBindToInterfaceIndexResult,
71414        >(
71415            (),
71416            0x59c31dd3e3078295,
71417            fidl::encoding::DynamicFlags::empty(),
71418            _decode,
71419        )
71420    }
71421
71422    type SetTimestampResponseFut = fidl::client::QueryResponseFut<
71423        BaseSocketSetTimestampResult,
71424        fidl::encoding::DefaultFuchsiaResourceDialect,
71425    >;
71426    fn r#set_timestamp(&self, mut value: TimestampOption) -> Self::SetTimestampResponseFut {
71427        fn _decode(
71428            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71429        ) -> Result<BaseSocketSetTimestampResult, fidl::Error> {
71430            let _response = fidl::client::decode_transaction_body::<
71431                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71432                fidl::encoding::DefaultFuchsiaResourceDialect,
71433                0x285d6516c263d839,
71434            >(_buf?)?;
71435            Ok(_response.map(|x| x))
71436        }
71437        self.client
71438            .send_query_and_decode::<BaseSocketSetTimestampRequest, BaseSocketSetTimestampResult>(
71439                (value,),
71440                0x285d6516c263d839,
71441                fidl::encoding::DynamicFlags::empty(),
71442                _decode,
71443            )
71444    }
71445
71446    type GetTimestampResponseFut = fidl::client::QueryResponseFut<
71447        BaseSocketGetTimestampResult,
71448        fidl::encoding::DefaultFuchsiaResourceDialect,
71449    >;
71450    fn r#get_timestamp(&self) -> Self::GetTimestampResponseFut {
71451        fn _decode(
71452            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71453        ) -> Result<BaseSocketGetTimestampResult, fidl::Error> {
71454            let _response = fidl::client::decode_transaction_body::<
71455                fidl::encoding::ResultType<
71456                    BaseSocketGetTimestampResponse,
71457                    fidl_fuchsia_posix::Errno,
71458                >,
71459                fidl::encoding::DefaultFuchsiaResourceDialect,
71460                0x49f2fffbbcc2bd27,
71461            >(_buf?)?;
71462            Ok(_response.map(|x| x.value))
71463        }
71464        self.client
71465            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseSocketGetTimestampResult>(
71466                (),
71467                0x49f2fffbbcc2bd27,
71468                fidl::encoding::DynamicFlags::empty(),
71469                _decode,
71470            )
71471    }
71472
71473    type SetMarkResponseFut = fidl::client::QueryResponseFut<
71474        BaseSocketSetMarkResult,
71475        fidl::encoding::DefaultFuchsiaResourceDialect,
71476    >;
71477    fn r#set_mark(
71478        &self,
71479        mut domain: fidl_fuchsia_net::MarkDomain,
71480        mut mark: &OptionalUint32,
71481    ) -> Self::SetMarkResponseFut {
71482        fn _decode(
71483            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71484        ) -> Result<BaseSocketSetMarkResult, fidl::Error> {
71485            let _response = fidl::client::decode_transaction_body::<
71486                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71487                fidl::encoding::DefaultFuchsiaResourceDialect,
71488                0x6ead6de09f653236,
71489            >(_buf?)?;
71490            Ok(_response.map(|x| x))
71491        }
71492        self.client.send_query_and_decode::<BaseSocketSetMarkRequest, BaseSocketSetMarkResult>(
71493            (domain, mark),
71494            0x6ead6de09f653236,
71495            fidl::encoding::DynamicFlags::empty(),
71496            _decode,
71497        )
71498    }
71499
71500    type GetMarkResponseFut = fidl::client::QueryResponseFut<
71501        BaseSocketGetMarkResult,
71502        fidl::encoding::DefaultFuchsiaResourceDialect,
71503    >;
71504    fn r#get_mark(&self, mut domain: fidl_fuchsia_net::MarkDomain) -> Self::GetMarkResponseFut {
71505        fn _decode(
71506            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71507        ) -> Result<BaseSocketGetMarkResult, fidl::Error> {
71508            let _response = fidl::client::decode_transaction_body::<
71509                fidl::encoding::ResultType<BaseSocketGetMarkResponse, fidl_fuchsia_posix::Errno>,
71510                fidl::encoding::DefaultFuchsiaResourceDialect,
71511                0x57a2752c61d93d47,
71512            >(_buf?)?;
71513            Ok(_response.map(|x| x.mark))
71514        }
71515        self.client.send_query_and_decode::<BaseSocketGetMarkRequest, BaseSocketGetMarkResult>(
71516            (domain,),
71517            0x57a2752c61d93d47,
71518            fidl::encoding::DynamicFlags::empty(),
71519            _decode,
71520        )
71521    }
71522
71523    type BindResponseFut = fidl::client::QueryResponseFut<
71524        BaseNetworkSocketBindResult,
71525        fidl::encoding::DefaultFuchsiaResourceDialect,
71526    >;
71527    fn r#bind(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::BindResponseFut {
71528        fn _decode(
71529            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71530        ) -> Result<BaseNetworkSocketBindResult, fidl::Error> {
71531            let _response = fidl::client::decode_transaction_body::<
71532                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71533                fidl::encoding::DefaultFuchsiaResourceDialect,
71534                0x4bc6400ae92125d,
71535            >(_buf?)?;
71536            Ok(_response.map(|x| x))
71537        }
71538        self.client
71539            .send_query_and_decode::<BaseNetworkSocketBindRequest, BaseNetworkSocketBindResult>(
71540                (addr,),
71541                0x4bc6400ae92125d,
71542                fidl::encoding::DynamicFlags::empty(),
71543                _decode,
71544            )
71545    }
71546
71547    type ConnectResponseFut = fidl::client::QueryResponseFut<
71548        BaseNetworkSocketConnectResult,
71549        fidl::encoding::DefaultFuchsiaResourceDialect,
71550    >;
71551    fn r#connect(&self, mut addr: &fidl_fuchsia_net::SocketAddress) -> Self::ConnectResponseFut {
71552        fn _decode(
71553            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71554        ) -> Result<BaseNetworkSocketConnectResult, fidl::Error> {
71555            let _response = fidl::client::decode_transaction_body::<
71556                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71557                fidl::encoding::DefaultFuchsiaResourceDialect,
71558                0x5f05f19bfdd38871,
71559            >(_buf?)?;
71560            Ok(_response.map(|x| x))
71561        }
71562        self.client.send_query_and_decode::<
71563            BaseNetworkSocketConnectRequest,
71564            BaseNetworkSocketConnectResult,
71565        >(
71566            (addr,),
71567            0x5f05f19bfdd38871,
71568            fidl::encoding::DynamicFlags::empty(),
71569            _decode,
71570        )
71571    }
71572
71573    type DisconnectResponseFut = fidl::client::QueryResponseFut<
71574        BaseNetworkSocketDisconnectResult,
71575        fidl::encoding::DefaultFuchsiaResourceDialect,
71576    >;
71577    fn r#disconnect(&self) -> Self::DisconnectResponseFut {
71578        fn _decode(
71579            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71580        ) -> Result<BaseNetworkSocketDisconnectResult, fidl::Error> {
71581            let _response = fidl::client::decode_transaction_body::<
71582                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71583                fidl::encoding::DefaultFuchsiaResourceDialect,
71584                0x74e63b91f7b29b2,
71585            >(_buf?)?;
71586            Ok(_response.map(|x| x))
71587        }
71588        self.client.send_query_and_decode::<
71589            fidl::encoding::EmptyPayload,
71590            BaseNetworkSocketDisconnectResult,
71591        >(
71592            (),
71593            0x74e63b91f7b29b2,
71594            fidl::encoding::DynamicFlags::empty(),
71595            _decode,
71596        )
71597    }
71598
71599    type GetSockNameResponseFut = fidl::client::QueryResponseFut<
71600        BaseNetworkSocketGetSockNameResult,
71601        fidl::encoding::DefaultFuchsiaResourceDialect,
71602    >;
71603    fn r#get_sock_name(&self) -> Self::GetSockNameResponseFut {
71604        fn _decode(
71605            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71606        ) -> Result<BaseNetworkSocketGetSockNameResult, fidl::Error> {
71607            let _response = fidl::client::decode_transaction_body::<
71608                fidl::encoding::ResultType<
71609                    BaseNetworkSocketGetSockNameResponse,
71610                    fidl_fuchsia_posix::Errno,
71611                >,
71612                fidl::encoding::DefaultFuchsiaResourceDialect,
71613                0x475f23f84a1a4f85,
71614            >(_buf?)?;
71615            Ok(_response.map(|x| x.addr))
71616        }
71617        self.client.send_query_and_decode::<
71618            fidl::encoding::EmptyPayload,
71619            BaseNetworkSocketGetSockNameResult,
71620        >(
71621            (),
71622            0x475f23f84a1a4f85,
71623            fidl::encoding::DynamicFlags::empty(),
71624            _decode,
71625        )
71626    }
71627
71628    type GetPeerNameResponseFut = fidl::client::QueryResponseFut<
71629        BaseNetworkSocketGetPeerNameResult,
71630        fidl::encoding::DefaultFuchsiaResourceDialect,
71631    >;
71632    fn r#get_peer_name(&self) -> Self::GetPeerNameResponseFut {
71633        fn _decode(
71634            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71635        ) -> Result<BaseNetworkSocketGetPeerNameResult, fidl::Error> {
71636            let _response = fidl::client::decode_transaction_body::<
71637                fidl::encoding::ResultType<
71638                    BaseNetworkSocketGetPeerNameResponse,
71639                    fidl_fuchsia_posix::Errno,
71640                >,
71641                fidl::encoding::DefaultFuchsiaResourceDialect,
71642                0x1ffecf4bd5b6432e,
71643            >(_buf?)?;
71644            Ok(_response.map(|x| x.addr))
71645        }
71646        self.client.send_query_and_decode::<
71647            fidl::encoding::EmptyPayload,
71648            BaseNetworkSocketGetPeerNameResult,
71649        >(
71650            (),
71651            0x1ffecf4bd5b6432e,
71652            fidl::encoding::DynamicFlags::empty(),
71653            _decode,
71654        )
71655    }
71656
71657    type ShutdownResponseFut = fidl::client::QueryResponseFut<
71658        BaseNetworkSocketShutdownResult,
71659        fidl::encoding::DefaultFuchsiaResourceDialect,
71660    >;
71661    fn r#shutdown(&self, mut mode: ShutdownMode) -> Self::ShutdownResponseFut {
71662        fn _decode(
71663            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71664        ) -> Result<BaseNetworkSocketShutdownResult, fidl::Error> {
71665            let _response = fidl::client::decode_transaction_body::<
71666                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71667                fidl::encoding::DefaultFuchsiaResourceDialect,
71668                0x247f38b6db68c336,
71669            >(_buf?)?;
71670            Ok(_response.map(|x| x))
71671        }
71672        self.client.send_query_and_decode::<
71673            BaseNetworkSocketShutdownRequest,
71674            BaseNetworkSocketShutdownResult,
71675        >(
71676            (mode,),
71677            0x247f38b6db68c336,
71678            fidl::encoding::DynamicFlags::empty(),
71679            _decode,
71680        )
71681    }
71682
71683    type SetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
71684        BaseNetworkSocketSetIpTypeOfServiceResult,
71685        fidl::encoding::DefaultFuchsiaResourceDialect,
71686    >;
71687    fn r#set_ip_type_of_service(&self, mut value: u8) -> Self::SetIpTypeOfServiceResponseFut {
71688        fn _decode(
71689            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71690        ) -> Result<BaseNetworkSocketSetIpTypeOfServiceResult, fidl::Error> {
71691            let _response = fidl::client::decode_transaction_body::<
71692                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71693                fidl::encoding::DefaultFuchsiaResourceDialect,
71694                0x995c600475b6d46,
71695            >(_buf?)?;
71696            Ok(_response.map(|x| x))
71697        }
71698        self.client.send_query_and_decode::<
71699            BaseNetworkSocketSetIpTypeOfServiceRequest,
71700            BaseNetworkSocketSetIpTypeOfServiceResult,
71701        >(
71702            (value,),
71703            0x995c600475b6d46,
71704            fidl::encoding::DynamicFlags::empty(),
71705            _decode,
71706        )
71707    }
71708
71709    type GetIpTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
71710        BaseNetworkSocketGetIpTypeOfServiceResult,
71711        fidl::encoding::DefaultFuchsiaResourceDialect,
71712    >;
71713    fn r#get_ip_type_of_service(&self) -> Self::GetIpTypeOfServiceResponseFut {
71714        fn _decode(
71715            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71716        ) -> Result<BaseNetworkSocketGetIpTypeOfServiceResult, fidl::Error> {
71717            let _response = fidl::client::decode_transaction_body::<
71718                fidl::encoding::ResultType<
71719                    BaseNetworkSocketGetIpTypeOfServiceResponse,
71720                    fidl_fuchsia_posix::Errno,
71721                >,
71722                fidl::encoding::DefaultFuchsiaResourceDialect,
71723                0x3814a04259f75fcb,
71724            >(_buf?)?;
71725            Ok(_response.map(|x| x.value))
71726        }
71727        self.client.send_query_and_decode::<
71728            fidl::encoding::EmptyPayload,
71729            BaseNetworkSocketGetIpTypeOfServiceResult,
71730        >(
71731            (),
71732            0x3814a04259f75fcb,
71733            fidl::encoding::DynamicFlags::empty(),
71734            _decode,
71735        )
71736    }
71737
71738    type SetIpTtlResponseFut = fidl::client::QueryResponseFut<
71739        BaseNetworkSocketSetIpTtlResult,
71740        fidl::encoding::DefaultFuchsiaResourceDialect,
71741    >;
71742    fn r#set_ip_ttl(&self, mut value: &OptionalUint8) -> Self::SetIpTtlResponseFut {
71743        fn _decode(
71744            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71745        ) -> Result<BaseNetworkSocketSetIpTtlResult, fidl::Error> {
71746            let _response = fidl::client::decode_transaction_body::<
71747                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71748                fidl::encoding::DefaultFuchsiaResourceDialect,
71749                0x29e2424b433ae1ef,
71750            >(_buf?)?;
71751            Ok(_response.map(|x| x))
71752        }
71753        self.client.send_query_and_decode::<
71754            BaseNetworkSocketSetIpTtlRequest,
71755            BaseNetworkSocketSetIpTtlResult,
71756        >(
71757            (value,),
71758            0x29e2424b433ae1ef,
71759            fidl::encoding::DynamicFlags::empty(),
71760            _decode,
71761        )
71762    }
71763
71764    type GetIpTtlResponseFut = fidl::client::QueryResponseFut<
71765        BaseNetworkSocketGetIpTtlResult,
71766        fidl::encoding::DefaultFuchsiaResourceDialect,
71767    >;
71768    fn r#get_ip_ttl(&self) -> Self::GetIpTtlResponseFut {
71769        fn _decode(
71770            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71771        ) -> Result<BaseNetworkSocketGetIpTtlResult, fidl::Error> {
71772            let _response = fidl::client::decode_transaction_body::<
71773                fidl::encoding::ResultType<
71774                    BaseNetworkSocketGetIpTtlResponse,
71775                    fidl_fuchsia_posix::Errno,
71776                >,
71777                fidl::encoding::DefaultFuchsiaResourceDialect,
71778                0x47e47fa1f24da471,
71779            >(_buf?)?;
71780            Ok(_response.map(|x| x.value))
71781        }
71782        self.client
71783            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseNetworkSocketGetIpTtlResult>(
71784                (),
71785                0x47e47fa1f24da471,
71786                fidl::encoding::DynamicFlags::empty(),
71787                _decode,
71788            )
71789    }
71790
71791    type SetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
71792        BaseNetworkSocketSetIpPacketInfoResult,
71793        fidl::encoding::DefaultFuchsiaResourceDialect,
71794    >;
71795    fn r#set_ip_packet_info(&self, mut value: bool) -> Self::SetIpPacketInfoResponseFut {
71796        fn _decode(
71797            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71798        ) -> Result<BaseNetworkSocketSetIpPacketInfoResult, fidl::Error> {
71799            let _response = fidl::client::decode_transaction_body::<
71800                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71801                fidl::encoding::DefaultFuchsiaResourceDialect,
71802                0x392d16bee20c0e16,
71803            >(_buf?)?;
71804            Ok(_response.map(|x| x))
71805        }
71806        self.client.send_query_and_decode::<
71807            BaseNetworkSocketSetIpPacketInfoRequest,
71808            BaseNetworkSocketSetIpPacketInfoResult,
71809        >(
71810            (value,),
71811            0x392d16bee20c0e16,
71812            fidl::encoding::DynamicFlags::empty(),
71813            _decode,
71814        )
71815    }
71816
71817    type GetIpPacketInfoResponseFut = fidl::client::QueryResponseFut<
71818        BaseNetworkSocketGetIpPacketInfoResult,
71819        fidl::encoding::DefaultFuchsiaResourceDialect,
71820    >;
71821    fn r#get_ip_packet_info(&self) -> Self::GetIpPacketInfoResponseFut {
71822        fn _decode(
71823            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71824        ) -> Result<BaseNetworkSocketGetIpPacketInfoResult, fidl::Error> {
71825            let _response = fidl::client::decode_transaction_body::<
71826                fidl::encoding::ResultType<
71827                    BaseNetworkSocketGetIpPacketInfoResponse,
71828                    fidl_fuchsia_posix::Errno,
71829                >,
71830                fidl::encoding::DefaultFuchsiaResourceDialect,
71831                0x54b505f242280740,
71832            >(_buf?)?;
71833            Ok(_response.map(|x| x.value))
71834        }
71835        self.client.send_query_and_decode::<
71836            fidl::encoding::EmptyPayload,
71837            BaseNetworkSocketGetIpPacketInfoResult,
71838        >(
71839            (),
71840            0x54b505f242280740,
71841            fidl::encoding::DynamicFlags::empty(),
71842            _decode,
71843        )
71844    }
71845
71846    type SetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
71847        BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
71848        fidl::encoding::DefaultFuchsiaResourceDialect,
71849    >;
71850    fn r#set_ip_receive_type_of_service(
71851        &self,
71852        mut value: bool,
71853    ) -> Self::SetIpReceiveTypeOfServiceResponseFut {
71854        fn _decode(
71855            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71856        ) -> Result<BaseNetworkSocketSetIpReceiveTypeOfServiceResult, fidl::Error> {
71857            let _response = fidl::client::decode_transaction_body::<
71858                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71859                fidl::encoding::DefaultFuchsiaResourceDialect,
71860                0x6c4f6714995f84ef,
71861            >(_buf?)?;
71862            Ok(_response.map(|x| x))
71863        }
71864        self.client.send_query_and_decode::<
71865            BaseNetworkSocketSetIpReceiveTypeOfServiceRequest,
71866            BaseNetworkSocketSetIpReceiveTypeOfServiceResult,
71867        >(
71868            (value,),
71869            0x6c4f6714995f84ef,
71870            fidl::encoding::DynamicFlags::empty(),
71871            _decode,
71872        )
71873    }
71874
71875    type GetIpReceiveTypeOfServiceResponseFut = fidl::client::QueryResponseFut<
71876        BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
71877        fidl::encoding::DefaultFuchsiaResourceDialect,
71878    >;
71879    fn r#get_ip_receive_type_of_service(&self) -> Self::GetIpReceiveTypeOfServiceResponseFut {
71880        fn _decode(
71881            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71882        ) -> Result<BaseNetworkSocketGetIpReceiveTypeOfServiceResult, fidl::Error> {
71883            let _response = fidl::client::decode_transaction_body::<
71884                fidl::encoding::ResultType<
71885                    BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
71886                    fidl_fuchsia_posix::Errno,
71887                >,
71888                fidl::encoding::DefaultFuchsiaResourceDialect,
71889                0x4158ba7dc2795960,
71890            >(_buf?)?;
71891            Ok(_response.map(|x| x.value))
71892        }
71893        self.client.send_query_and_decode::<
71894            fidl::encoding::EmptyPayload,
71895            BaseNetworkSocketGetIpReceiveTypeOfServiceResult,
71896        >(
71897            (),
71898            0x4158ba7dc2795960,
71899            fidl::encoding::DynamicFlags::empty(),
71900            _decode,
71901        )
71902    }
71903
71904    type SetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
71905        BaseNetworkSocketSetIpReceiveTtlResult,
71906        fidl::encoding::DefaultFuchsiaResourceDialect,
71907    >;
71908    fn r#set_ip_receive_ttl(&self, mut value: bool) -> Self::SetIpReceiveTtlResponseFut {
71909        fn _decode(
71910            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71911        ) -> Result<BaseNetworkSocketSetIpReceiveTtlResult, fidl::Error> {
71912            let _response = fidl::client::decode_transaction_body::<
71913                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71914                fidl::encoding::DefaultFuchsiaResourceDialect,
71915                0x46f15be0ce0ab82b,
71916            >(_buf?)?;
71917            Ok(_response.map(|x| x))
71918        }
71919        self.client.send_query_and_decode::<
71920            BaseNetworkSocketSetIpReceiveTtlRequest,
71921            BaseNetworkSocketSetIpReceiveTtlResult,
71922        >(
71923            (value,),
71924            0x46f15be0ce0ab82b,
71925            fidl::encoding::DynamicFlags::empty(),
71926            _decode,
71927        )
71928    }
71929
71930    type GetIpReceiveTtlResponseFut = fidl::client::QueryResponseFut<
71931        BaseNetworkSocketGetIpReceiveTtlResult,
71932        fidl::encoding::DefaultFuchsiaResourceDialect,
71933    >;
71934    fn r#get_ip_receive_ttl(&self) -> Self::GetIpReceiveTtlResponseFut {
71935        fn _decode(
71936            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71937        ) -> Result<BaseNetworkSocketGetIpReceiveTtlResult, fidl::Error> {
71938            let _response = fidl::client::decode_transaction_body::<
71939                fidl::encoding::ResultType<
71940                    BaseNetworkSocketGetIpReceiveTtlResponse,
71941                    fidl_fuchsia_posix::Errno,
71942                >,
71943                fidl::encoding::DefaultFuchsiaResourceDialect,
71944                0x678ddd5a5dfa2eb5,
71945            >(_buf?)?;
71946            Ok(_response.map(|x| x.value))
71947        }
71948        self.client.send_query_and_decode::<
71949            fidl::encoding::EmptyPayload,
71950            BaseNetworkSocketGetIpReceiveTtlResult,
71951        >(
71952            (),
71953            0x678ddd5a5dfa2eb5,
71954            fidl::encoding::DynamicFlags::empty(),
71955            _decode,
71956        )
71957    }
71958
71959    type SetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
71960        BaseNetworkSocketSetIpMulticastInterfaceResult,
71961        fidl::encoding::DefaultFuchsiaResourceDialect,
71962    >;
71963    fn r#set_ip_multicast_interface(
71964        &self,
71965        mut iface: u64,
71966        mut address: &fidl_fuchsia_net::Ipv4Address,
71967    ) -> Self::SetIpMulticastInterfaceResponseFut {
71968        fn _decode(
71969            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71970        ) -> Result<BaseNetworkSocketSetIpMulticastInterfaceResult, fidl::Error> {
71971            let _response = fidl::client::decode_transaction_body::<
71972                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
71973                fidl::encoding::DefaultFuchsiaResourceDialect,
71974                0x752fbfa9b12befe,
71975            >(_buf?)?;
71976            Ok(_response.map(|x| x))
71977        }
71978        self.client.send_query_and_decode::<
71979            BaseNetworkSocketSetIpMulticastInterfaceRequest,
71980            BaseNetworkSocketSetIpMulticastInterfaceResult,
71981        >(
71982            (iface, address,),
71983            0x752fbfa9b12befe,
71984            fidl::encoding::DynamicFlags::empty(),
71985            _decode,
71986        )
71987    }
71988
71989    type GetIpMulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
71990        BaseNetworkSocketGetIpMulticastInterfaceResult,
71991        fidl::encoding::DefaultFuchsiaResourceDialect,
71992    >;
71993    fn r#get_ip_multicast_interface(&self) -> Self::GetIpMulticastInterfaceResponseFut {
71994        fn _decode(
71995            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
71996        ) -> Result<BaseNetworkSocketGetIpMulticastInterfaceResult, fidl::Error> {
71997            let _response = fidl::client::decode_transaction_body::<
71998                fidl::encoding::ResultType<
71999                    BaseNetworkSocketGetIpMulticastInterfaceResponse,
72000                    fidl_fuchsia_posix::Errno,
72001                >,
72002                fidl::encoding::DefaultFuchsiaResourceDialect,
72003                0x320bd14c4df046c4,
72004            >(_buf?)?;
72005            Ok(_response.map(|x| x.value))
72006        }
72007        self.client.send_query_and_decode::<
72008            fidl::encoding::EmptyPayload,
72009            BaseNetworkSocketGetIpMulticastInterfaceResult,
72010        >(
72011            (),
72012            0x320bd14c4df046c4,
72013            fidl::encoding::DynamicFlags::empty(),
72014            _decode,
72015        )
72016    }
72017
72018    type SetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
72019        BaseNetworkSocketSetIpMulticastTtlResult,
72020        fidl::encoding::DefaultFuchsiaResourceDialect,
72021    >;
72022    fn r#set_ip_multicast_ttl(
72023        &self,
72024        mut value: &OptionalUint8,
72025    ) -> Self::SetIpMulticastTtlResponseFut {
72026        fn _decode(
72027            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72028        ) -> Result<BaseNetworkSocketSetIpMulticastTtlResult, fidl::Error> {
72029            let _response = fidl::client::decode_transaction_body::<
72030                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72031                fidl::encoding::DefaultFuchsiaResourceDialect,
72032                0x63134d53772916a1,
72033            >(_buf?)?;
72034            Ok(_response.map(|x| x))
72035        }
72036        self.client.send_query_and_decode::<
72037            BaseNetworkSocketSetIpMulticastTtlRequest,
72038            BaseNetworkSocketSetIpMulticastTtlResult,
72039        >(
72040            (value,),
72041            0x63134d53772916a1,
72042            fidl::encoding::DynamicFlags::empty(),
72043            _decode,
72044        )
72045    }
72046
72047    type GetIpMulticastTtlResponseFut = fidl::client::QueryResponseFut<
72048        BaseNetworkSocketGetIpMulticastTtlResult,
72049        fidl::encoding::DefaultFuchsiaResourceDialect,
72050    >;
72051    fn r#get_ip_multicast_ttl(&self) -> Self::GetIpMulticastTtlResponseFut {
72052        fn _decode(
72053            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72054        ) -> Result<BaseNetworkSocketGetIpMulticastTtlResult, fidl::Error> {
72055            let _response = fidl::client::decode_transaction_body::<
72056                fidl::encoding::ResultType<
72057                    BaseNetworkSocketGetIpMulticastTtlResponse,
72058                    fidl_fuchsia_posix::Errno,
72059                >,
72060                fidl::encoding::DefaultFuchsiaResourceDialect,
72061                0x4665cd378f39e1a,
72062            >(_buf?)?;
72063            Ok(_response.map(|x| x.value))
72064        }
72065        self.client.send_query_and_decode::<
72066            fidl::encoding::EmptyPayload,
72067            BaseNetworkSocketGetIpMulticastTtlResult,
72068        >(
72069            (),
72070            0x4665cd378f39e1a,
72071            fidl::encoding::DynamicFlags::empty(),
72072            _decode,
72073        )
72074    }
72075
72076    type SetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
72077        BaseNetworkSocketSetIpMulticastLoopbackResult,
72078        fidl::encoding::DefaultFuchsiaResourceDialect,
72079    >;
72080    fn r#set_ip_multicast_loopback(
72081        &self,
72082        mut value: bool,
72083    ) -> Self::SetIpMulticastLoopbackResponseFut {
72084        fn _decode(
72085            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72086        ) -> Result<BaseNetworkSocketSetIpMulticastLoopbackResult, fidl::Error> {
72087            let _response = fidl::client::decode_transaction_body::<
72088                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72089                fidl::encoding::DefaultFuchsiaResourceDialect,
72090                0x20c55c11f00943ea,
72091            >(_buf?)?;
72092            Ok(_response.map(|x| x))
72093        }
72094        self.client.send_query_and_decode::<
72095            BaseNetworkSocketSetIpMulticastLoopbackRequest,
72096            BaseNetworkSocketSetIpMulticastLoopbackResult,
72097        >(
72098            (value,),
72099            0x20c55c11f00943ea,
72100            fidl::encoding::DynamicFlags::empty(),
72101            _decode,
72102        )
72103    }
72104
72105    type GetIpMulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
72106        BaseNetworkSocketGetIpMulticastLoopbackResult,
72107        fidl::encoding::DefaultFuchsiaResourceDialect,
72108    >;
72109    fn r#get_ip_multicast_loopback(&self) -> Self::GetIpMulticastLoopbackResponseFut {
72110        fn _decode(
72111            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72112        ) -> Result<BaseNetworkSocketGetIpMulticastLoopbackResult, fidl::Error> {
72113            let _response = fidl::client::decode_transaction_body::<
72114                fidl::encoding::ResultType<
72115                    BaseNetworkSocketGetIpMulticastLoopbackResponse,
72116                    fidl_fuchsia_posix::Errno,
72117                >,
72118                fidl::encoding::DefaultFuchsiaResourceDialect,
72119                0x3b6b26ff558298f2,
72120            >(_buf?)?;
72121            Ok(_response.map(|x| x.value))
72122        }
72123        self.client.send_query_and_decode::<
72124            fidl::encoding::EmptyPayload,
72125            BaseNetworkSocketGetIpMulticastLoopbackResult,
72126        >(
72127            (),
72128            0x3b6b26ff558298f2,
72129            fidl::encoding::DynamicFlags::empty(),
72130            _decode,
72131        )
72132    }
72133
72134    type AddIpMembershipResponseFut = fidl::client::QueryResponseFut<
72135        BaseNetworkSocketAddIpMembershipResult,
72136        fidl::encoding::DefaultFuchsiaResourceDialect,
72137    >;
72138    fn r#add_ip_membership(
72139        &self,
72140        mut membership: &IpMulticastMembership,
72141    ) -> Self::AddIpMembershipResponseFut {
72142        fn _decode(
72143            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72144        ) -> Result<BaseNetworkSocketAddIpMembershipResult, fidl::Error> {
72145            let _response = fidl::client::decode_transaction_body::<
72146                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72147                fidl::encoding::DefaultFuchsiaResourceDialect,
72148                0x76bc7df115a3b4d0,
72149            >(_buf?)?;
72150            Ok(_response.map(|x| x))
72151        }
72152        self.client.send_query_and_decode::<
72153            BaseNetworkSocketAddIpMembershipRequest,
72154            BaseNetworkSocketAddIpMembershipResult,
72155        >(
72156            (membership,),
72157            0x76bc7df115a3b4d0,
72158            fidl::encoding::DynamicFlags::empty(),
72159            _decode,
72160        )
72161    }
72162
72163    type DropIpMembershipResponseFut = fidl::client::QueryResponseFut<
72164        BaseNetworkSocketDropIpMembershipResult,
72165        fidl::encoding::DefaultFuchsiaResourceDialect,
72166    >;
72167    fn r#drop_ip_membership(
72168        &self,
72169        mut membership: &IpMulticastMembership,
72170    ) -> Self::DropIpMembershipResponseFut {
72171        fn _decode(
72172            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72173        ) -> Result<BaseNetworkSocketDropIpMembershipResult, fidl::Error> {
72174            let _response = fidl::client::decode_transaction_body::<
72175                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72176                fidl::encoding::DefaultFuchsiaResourceDialect,
72177                0x2888f3099188d03,
72178            >(_buf?)?;
72179            Ok(_response.map(|x| x))
72180        }
72181        self.client.send_query_and_decode::<
72182            BaseNetworkSocketDropIpMembershipRequest,
72183            BaseNetworkSocketDropIpMembershipResult,
72184        >(
72185            (membership,),
72186            0x2888f3099188d03,
72187            fidl::encoding::DynamicFlags::empty(),
72188            _decode,
72189        )
72190    }
72191
72192    type SetIpTransparentResponseFut = fidl::client::QueryResponseFut<
72193        BaseNetworkSocketSetIpTransparentResult,
72194        fidl::encoding::DefaultFuchsiaResourceDialect,
72195    >;
72196    fn r#set_ip_transparent(&self, mut value: bool) -> Self::SetIpTransparentResponseFut {
72197        fn _decode(
72198            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72199        ) -> Result<BaseNetworkSocketSetIpTransparentResult, fidl::Error> {
72200            let _response = fidl::client::decode_transaction_body::<
72201                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72202                fidl::encoding::DefaultFuchsiaResourceDialect,
72203                0x1ae532b0c066e3a0,
72204            >(_buf?)?;
72205            Ok(_response.map(|x| x))
72206        }
72207        self.client.send_query_and_decode::<
72208            BaseNetworkSocketSetIpTransparentRequest,
72209            BaseNetworkSocketSetIpTransparentResult,
72210        >(
72211            (value,),
72212            0x1ae532b0c066e3a0,
72213            fidl::encoding::DynamicFlags::empty(),
72214            _decode,
72215        )
72216    }
72217
72218    type GetIpTransparentResponseFut = fidl::client::QueryResponseFut<
72219        BaseNetworkSocketGetIpTransparentResult,
72220        fidl::encoding::DefaultFuchsiaResourceDialect,
72221    >;
72222    fn r#get_ip_transparent(&self) -> Self::GetIpTransparentResponseFut {
72223        fn _decode(
72224            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72225        ) -> Result<BaseNetworkSocketGetIpTransparentResult, fidl::Error> {
72226            let _response = fidl::client::decode_transaction_body::<
72227                fidl::encoding::ResultType<
72228                    BaseNetworkSocketGetIpTransparentResponse,
72229                    fidl_fuchsia_posix::Errno,
72230                >,
72231                fidl::encoding::DefaultFuchsiaResourceDialect,
72232                0x51d43695962ebfb5,
72233            >(_buf?)?;
72234            Ok(_response.map(|x| x.value))
72235        }
72236        self.client.send_query_and_decode::<
72237            fidl::encoding::EmptyPayload,
72238            BaseNetworkSocketGetIpTransparentResult,
72239        >(
72240            (),
72241            0x51d43695962ebfb5,
72242            fidl::encoding::DynamicFlags::empty(),
72243            _decode,
72244        )
72245    }
72246
72247    type SetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
72248        BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
72249        fidl::encoding::DefaultFuchsiaResourceDialect,
72250    >;
72251    fn r#set_ip_receive_original_destination_address(
72252        &self,
72253        mut value: bool,
72254    ) -> Self::SetIpReceiveOriginalDestinationAddressResponseFut {
72255        fn _decode(
72256            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72257        ) -> Result<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult, fidl::Error>
72258        {
72259            let _response = fidl::client::decode_transaction_body::<
72260                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72261                fidl::encoding::DefaultFuchsiaResourceDialect,
72262                0x4722b4ce52f7840,
72263            >(_buf?)?;
72264            Ok(_response.map(|x| x))
72265        }
72266        self.client.send_query_and_decode::<
72267            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest,
72268            BaseNetworkSocketSetIpReceiveOriginalDestinationAddressResult,
72269        >(
72270            (value,),
72271            0x4722b4ce52f7840,
72272            fidl::encoding::DynamicFlags::empty(),
72273            _decode,
72274        )
72275    }
72276
72277    type GetIpReceiveOriginalDestinationAddressResponseFut = fidl::client::QueryResponseFut<
72278        BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
72279        fidl::encoding::DefaultFuchsiaResourceDialect,
72280    >;
72281    fn r#get_ip_receive_original_destination_address(
72282        &self,
72283    ) -> Self::GetIpReceiveOriginalDestinationAddressResponseFut {
72284        fn _decode(
72285            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72286        ) -> Result<BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult, fidl::Error>
72287        {
72288            let _response = fidl::client::decode_transaction_body::<
72289                fidl::encoding::ResultType<
72290                    BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
72291                    fidl_fuchsia_posix::Errno,
72292                >,
72293                fidl::encoding::DefaultFuchsiaResourceDialect,
72294                0x2a0e7dc5d6bfdfe9,
72295            >(_buf?)?;
72296            Ok(_response.map(|x| x.value))
72297        }
72298        self.client.send_query_and_decode::<
72299            fidl::encoding::EmptyPayload,
72300            BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResult,
72301        >(
72302            (),
72303            0x2a0e7dc5d6bfdfe9,
72304            fidl::encoding::DynamicFlags::empty(),
72305            _decode,
72306        )
72307    }
72308
72309    type AddIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
72310        BaseNetworkSocketAddIpv6MembershipResult,
72311        fidl::encoding::DefaultFuchsiaResourceDialect,
72312    >;
72313    fn r#add_ipv6_membership(
72314        &self,
72315        mut membership: &Ipv6MulticastMembership,
72316    ) -> Self::AddIpv6MembershipResponseFut {
72317        fn _decode(
72318            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72319        ) -> Result<BaseNetworkSocketAddIpv6MembershipResult, fidl::Error> {
72320            let _response = fidl::client::decode_transaction_body::<
72321                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72322                fidl::encoding::DefaultFuchsiaResourceDialect,
72323                0x7c94727acb4ea4b3,
72324            >(_buf?)?;
72325            Ok(_response.map(|x| x))
72326        }
72327        self.client.send_query_and_decode::<
72328            BaseNetworkSocketAddIpv6MembershipRequest,
72329            BaseNetworkSocketAddIpv6MembershipResult,
72330        >(
72331            (membership,),
72332            0x7c94727acb4ea4b3,
72333            fidl::encoding::DynamicFlags::empty(),
72334            _decode,
72335        )
72336    }
72337
72338    type DropIpv6MembershipResponseFut = fidl::client::QueryResponseFut<
72339        BaseNetworkSocketDropIpv6MembershipResult,
72340        fidl::encoding::DefaultFuchsiaResourceDialect,
72341    >;
72342    fn r#drop_ipv6_membership(
72343        &self,
72344        mut membership: &Ipv6MulticastMembership,
72345    ) -> Self::DropIpv6MembershipResponseFut {
72346        fn _decode(
72347            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72348        ) -> Result<BaseNetworkSocketDropIpv6MembershipResult, fidl::Error> {
72349            let _response = fidl::client::decode_transaction_body::<
72350                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72351                fidl::encoding::DefaultFuchsiaResourceDialect,
72352                0x42104c70ccaba304,
72353            >(_buf?)?;
72354            Ok(_response.map(|x| x))
72355        }
72356        self.client.send_query_and_decode::<
72357            BaseNetworkSocketDropIpv6MembershipRequest,
72358            BaseNetworkSocketDropIpv6MembershipResult,
72359        >(
72360            (membership,),
72361            0x42104c70ccaba304,
72362            fidl::encoding::DynamicFlags::empty(),
72363            _decode,
72364        )
72365    }
72366
72367    type SetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
72368        BaseNetworkSocketSetIpv6MulticastInterfaceResult,
72369        fidl::encoding::DefaultFuchsiaResourceDialect,
72370    >;
72371    fn r#set_ipv6_multicast_interface(
72372        &self,
72373        mut value: u64,
72374    ) -> Self::SetIpv6MulticastInterfaceResponseFut {
72375        fn _decode(
72376            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72377        ) -> Result<BaseNetworkSocketSetIpv6MulticastInterfaceResult, fidl::Error> {
72378            let _response = fidl::client::decode_transaction_body::<
72379                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72380                fidl::encoding::DefaultFuchsiaResourceDialect,
72381                0x135f76db3774ab3b,
72382            >(_buf?)?;
72383            Ok(_response.map(|x| x))
72384        }
72385        self.client.send_query_and_decode::<
72386            BaseNetworkSocketSetIpv6MulticastInterfaceRequest,
72387            BaseNetworkSocketSetIpv6MulticastInterfaceResult,
72388        >(
72389            (value,),
72390            0x135f76db3774ab3b,
72391            fidl::encoding::DynamicFlags::empty(),
72392            _decode,
72393        )
72394    }
72395
72396    type GetIpv6MulticastInterfaceResponseFut = fidl::client::QueryResponseFut<
72397        BaseNetworkSocketGetIpv6MulticastInterfaceResult,
72398        fidl::encoding::DefaultFuchsiaResourceDialect,
72399    >;
72400    fn r#get_ipv6_multicast_interface(&self) -> Self::GetIpv6MulticastInterfaceResponseFut {
72401        fn _decode(
72402            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72403        ) -> Result<BaseNetworkSocketGetIpv6MulticastInterfaceResult, fidl::Error> {
72404            let _response = fidl::client::decode_transaction_body::<
72405                fidl::encoding::ResultType<
72406                    BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
72407                    fidl_fuchsia_posix::Errno,
72408                >,
72409                fidl::encoding::DefaultFuchsiaResourceDialect,
72410                0x1f26fcdd348f1882,
72411            >(_buf?)?;
72412            Ok(_response.map(|x| x.value))
72413        }
72414        self.client.send_query_and_decode::<
72415            fidl::encoding::EmptyPayload,
72416            BaseNetworkSocketGetIpv6MulticastInterfaceResult,
72417        >(
72418            (),
72419            0x1f26fcdd348f1882,
72420            fidl::encoding::DynamicFlags::empty(),
72421            _decode,
72422        )
72423    }
72424
72425    type SetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
72426        BaseNetworkSocketSetIpv6UnicastHopsResult,
72427        fidl::encoding::DefaultFuchsiaResourceDialect,
72428    >;
72429    fn r#set_ipv6_unicast_hops(
72430        &self,
72431        mut value: &OptionalUint8,
72432    ) -> Self::SetIpv6UnicastHopsResponseFut {
72433        fn _decode(
72434            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72435        ) -> Result<BaseNetworkSocketSetIpv6UnicastHopsResult, fidl::Error> {
72436            let _response = fidl::client::decode_transaction_body::<
72437                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72438                fidl::encoding::DefaultFuchsiaResourceDialect,
72439                0x157d51e98f462859,
72440            >(_buf?)?;
72441            Ok(_response.map(|x| x))
72442        }
72443        self.client.send_query_and_decode::<
72444            BaseNetworkSocketSetIpv6UnicastHopsRequest,
72445            BaseNetworkSocketSetIpv6UnicastHopsResult,
72446        >(
72447            (value,),
72448            0x157d51e98f462859,
72449            fidl::encoding::DynamicFlags::empty(),
72450            _decode,
72451        )
72452    }
72453
72454    type GetIpv6UnicastHopsResponseFut = fidl::client::QueryResponseFut<
72455        BaseNetworkSocketGetIpv6UnicastHopsResult,
72456        fidl::encoding::DefaultFuchsiaResourceDialect,
72457    >;
72458    fn r#get_ipv6_unicast_hops(&self) -> Self::GetIpv6UnicastHopsResponseFut {
72459        fn _decode(
72460            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72461        ) -> Result<BaseNetworkSocketGetIpv6UnicastHopsResult, fidl::Error> {
72462            let _response = fidl::client::decode_transaction_body::<
72463                fidl::encoding::ResultType<
72464                    BaseNetworkSocketGetIpv6UnicastHopsResponse,
72465                    fidl_fuchsia_posix::Errno,
72466                >,
72467                fidl::encoding::DefaultFuchsiaResourceDialect,
72468                0x21f4641cad8bd8d2,
72469            >(_buf?)?;
72470            Ok(_response.map(|x| x.value))
72471        }
72472        self.client.send_query_and_decode::<
72473            fidl::encoding::EmptyPayload,
72474            BaseNetworkSocketGetIpv6UnicastHopsResult,
72475        >(
72476            (),
72477            0x21f4641cad8bd8d2,
72478            fidl::encoding::DynamicFlags::empty(),
72479            _decode,
72480        )
72481    }
72482
72483    type SetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
72484        BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
72485        fidl::encoding::DefaultFuchsiaResourceDialect,
72486    >;
72487    fn r#set_ipv6_receive_hop_limit(
72488        &self,
72489        mut value: bool,
72490    ) -> Self::SetIpv6ReceiveHopLimitResponseFut {
72491        fn _decode(
72492            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72493        ) -> Result<BaseNetworkSocketSetIpv6ReceiveHopLimitResult, fidl::Error> {
72494            let _response = fidl::client::decode_transaction_body::<
72495                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72496                fidl::encoding::DefaultFuchsiaResourceDialect,
72497                0x5c24808ed2e84a1e,
72498            >(_buf?)?;
72499            Ok(_response.map(|x| x))
72500        }
72501        self.client.send_query_and_decode::<
72502            BaseNetworkSocketSetIpv6ReceiveHopLimitRequest,
72503            BaseNetworkSocketSetIpv6ReceiveHopLimitResult,
72504        >(
72505            (value,),
72506            0x5c24808ed2e84a1e,
72507            fidl::encoding::DynamicFlags::empty(),
72508            _decode,
72509        )
72510    }
72511
72512    type GetIpv6ReceiveHopLimitResponseFut = fidl::client::QueryResponseFut<
72513        BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
72514        fidl::encoding::DefaultFuchsiaResourceDialect,
72515    >;
72516    fn r#get_ipv6_receive_hop_limit(&self) -> Self::GetIpv6ReceiveHopLimitResponseFut {
72517        fn _decode(
72518            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72519        ) -> Result<BaseNetworkSocketGetIpv6ReceiveHopLimitResult, fidl::Error> {
72520            let _response = fidl::client::decode_transaction_body::<
72521                fidl::encoding::ResultType<
72522                    BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
72523                    fidl_fuchsia_posix::Errno,
72524                >,
72525                fidl::encoding::DefaultFuchsiaResourceDialect,
72526                0x341e06689885b4c0,
72527            >(_buf?)?;
72528            Ok(_response.map(|x| x.value))
72529        }
72530        self.client.send_query_and_decode::<
72531            fidl::encoding::EmptyPayload,
72532            BaseNetworkSocketGetIpv6ReceiveHopLimitResult,
72533        >(
72534            (),
72535            0x341e06689885b4c0,
72536            fidl::encoding::DynamicFlags::empty(),
72537            _decode,
72538        )
72539    }
72540
72541    type SetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
72542        BaseNetworkSocketSetIpv6MulticastHopsResult,
72543        fidl::encoding::DefaultFuchsiaResourceDialect,
72544    >;
72545    fn r#set_ipv6_multicast_hops(
72546        &self,
72547        mut value: &OptionalUint8,
72548    ) -> Self::SetIpv6MulticastHopsResponseFut {
72549        fn _decode(
72550            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72551        ) -> Result<BaseNetworkSocketSetIpv6MulticastHopsResult, fidl::Error> {
72552            let _response = fidl::client::decode_transaction_body::<
72553                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72554                fidl::encoding::DefaultFuchsiaResourceDialect,
72555                0x25b9cd4d181f82c1,
72556            >(_buf?)?;
72557            Ok(_response.map(|x| x))
72558        }
72559        self.client.send_query_and_decode::<
72560            BaseNetworkSocketSetIpv6MulticastHopsRequest,
72561            BaseNetworkSocketSetIpv6MulticastHopsResult,
72562        >(
72563            (value,),
72564            0x25b9cd4d181f82c1,
72565            fidl::encoding::DynamicFlags::empty(),
72566            _decode,
72567        )
72568    }
72569
72570    type GetIpv6MulticastHopsResponseFut = fidl::client::QueryResponseFut<
72571        BaseNetworkSocketGetIpv6MulticastHopsResult,
72572        fidl::encoding::DefaultFuchsiaResourceDialect,
72573    >;
72574    fn r#get_ipv6_multicast_hops(&self) -> Self::GetIpv6MulticastHopsResponseFut {
72575        fn _decode(
72576            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72577        ) -> Result<BaseNetworkSocketGetIpv6MulticastHopsResult, fidl::Error> {
72578            let _response = fidl::client::decode_transaction_body::<
72579                fidl::encoding::ResultType<
72580                    BaseNetworkSocketGetIpv6MulticastHopsResponse,
72581                    fidl_fuchsia_posix::Errno,
72582                >,
72583                fidl::encoding::DefaultFuchsiaResourceDialect,
72584                0x52916948a365012a,
72585            >(_buf?)?;
72586            Ok(_response.map(|x| x.value))
72587        }
72588        self.client.send_query_and_decode::<
72589            fidl::encoding::EmptyPayload,
72590            BaseNetworkSocketGetIpv6MulticastHopsResult,
72591        >(
72592            (),
72593            0x52916948a365012a,
72594            fidl::encoding::DynamicFlags::empty(),
72595            _decode,
72596        )
72597    }
72598
72599    type SetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
72600        BaseNetworkSocketSetIpv6MulticastLoopbackResult,
72601        fidl::encoding::DefaultFuchsiaResourceDialect,
72602    >;
72603    fn r#set_ipv6_multicast_loopback(
72604        &self,
72605        mut value: bool,
72606    ) -> Self::SetIpv6MulticastLoopbackResponseFut {
72607        fn _decode(
72608            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72609        ) -> Result<BaseNetworkSocketSetIpv6MulticastLoopbackResult, fidl::Error> {
72610            let _response = fidl::client::decode_transaction_body::<
72611                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72612                fidl::encoding::DefaultFuchsiaResourceDialect,
72613                0x55701c409ff41b40,
72614            >(_buf?)?;
72615            Ok(_response.map(|x| x))
72616        }
72617        self.client.send_query_and_decode::<
72618            BaseNetworkSocketSetIpv6MulticastLoopbackRequest,
72619            BaseNetworkSocketSetIpv6MulticastLoopbackResult,
72620        >(
72621            (value,),
72622            0x55701c409ff41b40,
72623            fidl::encoding::DynamicFlags::empty(),
72624            _decode,
72625        )
72626    }
72627
72628    type GetIpv6MulticastLoopbackResponseFut = fidl::client::QueryResponseFut<
72629        BaseNetworkSocketGetIpv6MulticastLoopbackResult,
72630        fidl::encoding::DefaultFuchsiaResourceDialect,
72631    >;
72632    fn r#get_ipv6_multicast_loopback(&self) -> Self::GetIpv6MulticastLoopbackResponseFut {
72633        fn _decode(
72634            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72635        ) -> Result<BaseNetworkSocketGetIpv6MulticastLoopbackResult, fidl::Error> {
72636            let _response = fidl::client::decode_transaction_body::<
72637                fidl::encoding::ResultType<
72638                    BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
72639                    fidl_fuchsia_posix::Errno,
72640                >,
72641                fidl::encoding::DefaultFuchsiaResourceDialect,
72642                0x4415b701fde319c3,
72643            >(_buf?)?;
72644            Ok(_response.map(|x| x.value))
72645        }
72646        self.client.send_query_and_decode::<
72647            fidl::encoding::EmptyPayload,
72648            BaseNetworkSocketGetIpv6MulticastLoopbackResult,
72649        >(
72650            (),
72651            0x4415b701fde319c3,
72652            fidl::encoding::DynamicFlags::empty(),
72653            _decode,
72654        )
72655    }
72656
72657    type SetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
72658        BaseNetworkSocketSetIpv6OnlyResult,
72659        fidl::encoding::DefaultFuchsiaResourceDialect,
72660    >;
72661    fn r#set_ipv6_only(&self, mut value: bool) -> Self::SetIpv6OnlyResponseFut {
72662        fn _decode(
72663            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72664        ) -> Result<BaseNetworkSocketSetIpv6OnlyResult, fidl::Error> {
72665            let _response = fidl::client::decode_transaction_body::<
72666                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72667                fidl::encoding::DefaultFuchsiaResourceDialect,
72668                0x4873f1364758cbba,
72669            >(_buf?)?;
72670            Ok(_response.map(|x| x))
72671        }
72672        self.client.send_query_and_decode::<
72673            BaseNetworkSocketSetIpv6OnlyRequest,
72674            BaseNetworkSocketSetIpv6OnlyResult,
72675        >(
72676            (value,),
72677            0x4873f1364758cbba,
72678            fidl::encoding::DynamicFlags::empty(),
72679            _decode,
72680        )
72681    }
72682
72683    type GetIpv6OnlyResponseFut = fidl::client::QueryResponseFut<
72684        BaseNetworkSocketGetIpv6OnlyResult,
72685        fidl::encoding::DefaultFuchsiaResourceDialect,
72686    >;
72687    fn r#get_ipv6_only(&self) -> Self::GetIpv6OnlyResponseFut {
72688        fn _decode(
72689            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72690        ) -> Result<BaseNetworkSocketGetIpv6OnlyResult, fidl::Error> {
72691            let _response = fidl::client::decode_transaction_body::<
72692                fidl::encoding::ResultType<
72693                    BaseNetworkSocketGetIpv6OnlyResponse,
72694                    fidl_fuchsia_posix::Errno,
72695                >,
72696                fidl::encoding::DefaultFuchsiaResourceDialect,
72697                0x4aa3340a1a26b89c,
72698            >(_buf?)?;
72699            Ok(_response.map(|x| x.value))
72700        }
72701        self.client.send_query_and_decode::<
72702            fidl::encoding::EmptyPayload,
72703            BaseNetworkSocketGetIpv6OnlyResult,
72704        >(
72705            (),
72706            0x4aa3340a1a26b89c,
72707            fidl::encoding::DynamicFlags::empty(),
72708            _decode,
72709        )
72710    }
72711
72712    type SetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
72713        BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
72714        fidl::encoding::DefaultFuchsiaResourceDialect,
72715    >;
72716    fn r#set_ipv6_receive_traffic_class(
72717        &self,
72718        mut value: bool,
72719    ) -> Self::SetIpv6ReceiveTrafficClassResponseFut {
72720        fn _decode(
72721            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72722        ) -> Result<BaseNetworkSocketSetIpv6ReceiveTrafficClassResult, fidl::Error> {
72723            let _response = fidl::client::decode_transaction_body::<
72724                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72725                fidl::encoding::DefaultFuchsiaResourceDialect,
72726                0x58f07c8788d099a0,
72727            >(_buf?)?;
72728            Ok(_response.map(|x| x))
72729        }
72730        self.client.send_query_and_decode::<
72731            BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest,
72732            BaseNetworkSocketSetIpv6ReceiveTrafficClassResult,
72733        >(
72734            (value,),
72735            0x58f07c8788d099a0,
72736            fidl::encoding::DynamicFlags::empty(),
72737            _decode,
72738        )
72739    }
72740
72741    type GetIpv6ReceiveTrafficClassResponseFut = fidl::client::QueryResponseFut<
72742        BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
72743        fidl::encoding::DefaultFuchsiaResourceDialect,
72744    >;
72745    fn r#get_ipv6_receive_traffic_class(&self) -> Self::GetIpv6ReceiveTrafficClassResponseFut {
72746        fn _decode(
72747            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72748        ) -> Result<BaseNetworkSocketGetIpv6ReceiveTrafficClassResult, fidl::Error> {
72749            let _response = fidl::client::decode_transaction_body::<
72750                fidl::encoding::ResultType<
72751                    BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
72752                    fidl_fuchsia_posix::Errno,
72753                >,
72754                fidl::encoding::DefaultFuchsiaResourceDialect,
72755                0x2e334df1da553ffa,
72756            >(_buf?)?;
72757            Ok(_response.map(|x| x.value))
72758        }
72759        self.client.send_query_and_decode::<
72760            fidl::encoding::EmptyPayload,
72761            BaseNetworkSocketGetIpv6ReceiveTrafficClassResult,
72762        >(
72763            (),
72764            0x2e334df1da553ffa,
72765            fidl::encoding::DynamicFlags::empty(),
72766            _decode,
72767        )
72768    }
72769
72770    type SetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
72771        BaseNetworkSocketSetIpv6TrafficClassResult,
72772        fidl::encoding::DefaultFuchsiaResourceDialect,
72773    >;
72774    fn r#set_ipv6_traffic_class(
72775        &self,
72776        mut value: &OptionalUint8,
72777    ) -> Self::SetIpv6TrafficClassResponseFut {
72778        fn _decode(
72779            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72780        ) -> Result<BaseNetworkSocketSetIpv6TrafficClassResult, fidl::Error> {
72781            let _response = fidl::client::decode_transaction_body::<
72782                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72783                fidl::encoding::DefaultFuchsiaResourceDialect,
72784                0x6af077800c5a0b4f,
72785            >(_buf?)?;
72786            Ok(_response.map(|x| x))
72787        }
72788        self.client.send_query_and_decode::<
72789            BaseNetworkSocketSetIpv6TrafficClassRequest,
72790            BaseNetworkSocketSetIpv6TrafficClassResult,
72791        >(
72792            (value,),
72793            0x6af077800c5a0b4f,
72794            fidl::encoding::DynamicFlags::empty(),
72795            _decode,
72796        )
72797    }
72798
72799    type GetIpv6TrafficClassResponseFut = fidl::client::QueryResponseFut<
72800        BaseNetworkSocketGetIpv6TrafficClassResult,
72801        fidl::encoding::DefaultFuchsiaResourceDialect,
72802    >;
72803    fn r#get_ipv6_traffic_class(&self) -> Self::GetIpv6TrafficClassResponseFut {
72804        fn _decode(
72805            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72806        ) -> Result<BaseNetworkSocketGetIpv6TrafficClassResult, fidl::Error> {
72807            let _response = fidl::client::decode_transaction_body::<
72808                fidl::encoding::ResultType<
72809                    BaseNetworkSocketGetIpv6TrafficClassResponse,
72810                    fidl_fuchsia_posix::Errno,
72811                >,
72812                fidl::encoding::DefaultFuchsiaResourceDialect,
72813                0x6baf6eed8fc2f04,
72814            >(_buf?)?;
72815            Ok(_response.map(|x| x.value))
72816        }
72817        self.client.send_query_and_decode::<
72818            fidl::encoding::EmptyPayload,
72819            BaseNetworkSocketGetIpv6TrafficClassResult,
72820        >(
72821            (),
72822            0x6baf6eed8fc2f04,
72823            fidl::encoding::DynamicFlags::empty(),
72824            _decode,
72825        )
72826    }
72827
72828    type SetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
72829        BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
72830        fidl::encoding::DefaultFuchsiaResourceDialect,
72831    >;
72832    fn r#set_ipv6_receive_packet_info(
72833        &self,
72834        mut value: bool,
72835    ) -> Self::SetIpv6ReceivePacketInfoResponseFut {
72836        fn _decode(
72837            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72838        ) -> Result<BaseNetworkSocketSetIpv6ReceivePacketInfoResult, fidl::Error> {
72839            let _response = fidl::client::decode_transaction_body::<
72840                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, fidl_fuchsia_posix::Errno>,
72841                fidl::encoding::DefaultFuchsiaResourceDialect,
72842                0x19259775b1a92768,
72843            >(_buf?)?;
72844            Ok(_response.map(|x| x))
72845        }
72846        self.client.send_query_and_decode::<
72847            BaseNetworkSocketSetIpv6ReceivePacketInfoRequest,
72848            BaseNetworkSocketSetIpv6ReceivePacketInfoResult,
72849        >(
72850            (value,),
72851            0x19259775b1a92768,
72852            fidl::encoding::DynamicFlags::empty(),
72853            _decode,
72854        )
72855    }
72856
72857    type GetIpv6ReceivePacketInfoResponseFut = fidl::client::QueryResponseFut<
72858        BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
72859        fidl::encoding::DefaultFuchsiaResourceDialect,
72860    >;
72861    fn r#get_ipv6_receive_packet_info(&self) -> Self::GetIpv6ReceivePacketInfoResponseFut {
72862        fn _decode(
72863            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72864        ) -> Result<BaseNetworkSocketGetIpv6ReceivePacketInfoResult, fidl::Error> {
72865            let _response = fidl::client::decode_transaction_body::<
72866                fidl::encoding::ResultType<
72867                    BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
72868                    fidl_fuchsia_posix::Errno,
72869                >,
72870                fidl::encoding::DefaultFuchsiaResourceDialect,
72871                0x7acd4a2775baec75,
72872            >(_buf?)?;
72873            Ok(_response.map(|x| x.value))
72874        }
72875        self.client.send_query_and_decode::<
72876            fidl::encoding::EmptyPayload,
72877            BaseNetworkSocketGetIpv6ReceivePacketInfoResult,
72878        >(
72879            (),
72880            0x7acd4a2775baec75,
72881            fidl::encoding::DynamicFlags::empty(),
72882            _decode,
72883        )
72884    }
72885
72886    type GetOriginalDestinationResponseFut = fidl::client::QueryResponseFut<
72887        BaseNetworkSocketGetOriginalDestinationResult,
72888        fidl::encoding::DefaultFuchsiaResourceDialect,
72889    >;
72890    fn r#get_original_destination(&self) -> Self::GetOriginalDestinationResponseFut {
72891        fn _decode(
72892            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72893        ) -> Result<BaseNetworkSocketGetOriginalDestinationResult, fidl::Error> {
72894            let _response = fidl::client::decode_transaction_body::<
72895                fidl::encoding::ResultType<
72896                    BaseNetworkSocketGetOriginalDestinationResponse,
72897                    fidl_fuchsia_posix::Errno,
72898                >,
72899                fidl::encoding::DefaultFuchsiaResourceDialect,
72900                0x38bf28f0dafdbac0,
72901            >(_buf?)?;
72902            Ok(_response.map(|x| x.value))
72903        }
72904        self.client.send_query_and_decode::<
72905            fidl::encoding::EmptyPayload,
72906            BaseNetworkSocketGetOriginalDestinationResult,
72907        >(
72908            (),
72909            0x38bf28f0dafdbac0,
72910            fidl::encoding::DynamicFlags::empty(),
72911            _decode,
72912        )
72913    }
72914
72915    type GetInfoResponseFut = fidl::client::QueryResponseFut<
72916        BaseDatagramSocketGetInfoResult,
72917        fidl::encoding::DefaultFuchsiaResourceDialect,
72918    >;
72919    fn r#get_info(&self) -> Self::GetInfoResponseFut {
72920        fn _decode(
72921            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72922        ) -> Result<BaseDatagramSocketGetInfoResult, fidl::Error> {
72923            let _response = fidl::client::decode_transaction_body::<
72924                fidl::encoding::ResultType<
72925                    BaseDatagramSocketGetInfoResponse,
72926                    fidl_fuchsia_posix::Errno,
72927                >,
72928                fidl::encoding::DefaultFuchsiaResourceDialect,
72929                0x48aa0a1f6a32d2ed,
72930            >(_buf?)?;
72931            Ok(_response.map(|x| (x.domain, x.proto)))
72932        }
72933        self.client
72934            .send_query_and_decode::<fidl::encoding::EmptyPayload, BaseDatagramSocketGetInfoResult>(
72935                (),
72936                0x48aa0a1f6a32d2ed,
72937                fidl::encoding::DynamicFlags::empty(),
72938                _decode,
72939            )
72940    }
72941
72942    type DescribeResponseFut = fidl::client::QueryResponseFut<
72943        SynchronousDatagramSocketDescribeResponse,
72944        fidl::encoding::DefaultFuchsiaResourceDialect,
72945    >;
72946    fn r#describe(&self) -> Self::DescribeResponseFut {
72947        fn _decode(
72948            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72949        ) -> Result<SynchronousDatagramSocketDescribeResponse, fidl::Error> {
72950            let _response = fidl::client::decode_transaction_body::<
72951                SynchronousDatagramSocketDescribeResponse,
72952                fidl::encoding::DefaultFuchsiaResourceDialect,
72953                0x585f20b73631070d,
72954            >(_buf?)?;
72955            Ok(_response)
72956        }
72957        self.client.send_query_and_decode::<
72958            fidl::encoding::EmptyPayload,
72959            SynchronousDatagramSocketDescribeResponse,
72960        >(
72961            (),
72962            0x585f20b73631070d,
72963            fidl::encoding::DynamicFlags::empty(),
72964            _decode,
72965        )
72966    }
72967
72968    type RecvMsgResponseFut = fidl::client::QueryResponseFut<
72969        SynchronousDatagramSocketRecvMsgResult,
72970        fidl::encoding::DefaultFuchsiaResourceDialect,
72971    >;
72972    fn r#recv_msg(
72973        &self,
72974        mut want_addr: bool,
72975        mut data_len: u32,
72976        mut want_control: bool,
72977        mut flags: RecvMsgFlags,
72978    ) -> Self::RecvMsgResponseFut {
72979        fn _decode(
72980            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
72981        ) -> Result<SynchronousDatagramSocketRecvMsgResult, fidl::Error> {
72982            let _response = fidl::client::decode_transaction_body::<
72983                fidl::encoding::ResultType<
72984                    SynchronousDatagramSocketRecvMsgResponse,
72985                    fidl_fuchsia_posix::Errno,
72986                >,
72987                fidl::encoding::DefaultFuchsiaResourceDialect,
72988                0x28e494e48fb5dbf3,
72989            >(_buf?)?;
72990            Ok(_response.map(|x| (x.addr, x.data, x.control, x.truncated)))
72991        }
72992        self.client.send_query_and_decode::<
72993            SynchronousDatagramSocketRecvMsgRequest,
72994            SynchronousDatagramSocketRecvMsgResult,
72995        >(
72996            (want_addr, data_len, want_control, flags,),
72997            0x28e494e48fb5dbf3,
72998            fidl::encoding::DynamicFlags::empty(),
72999            _decode,
73000        )
73001    }
73002
73003    type SendMsgResponseFut = fidl::client::QueryResponseFut<
73004        SynchronousDatagramSocketSendMsgResult,
73005        fidl::encoding::DefaultFuchsiaResourceDialect,
73006    >;
73007    fn r#send_msg(
73008        &self,
73009        mut addr: Option<&fidl_fuchsia_net::SocketAddress>,
73010        mut data: &[u8],
73011        mut control: &DatagramSocketSendControlData,
73012        mut flags: SendMsgFlags,
73013    ) -> Self::SendMsgResponseFut {
73014        fn _decode(
73015            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
73016        ) -> Result<SynchronousDatagramSocketSendMsgResult, fidl::Error> {
73017            let _response = fidl::client::decode_transaction_body::<
73018                fidl::encoding::ResultType<
73019                    SynchronousDatagramSocketSendMsgResponse,
73020                    fidl_fuchsia_posix::Errno,
73021                >,
73022                fidl::encoding::DefaultFuchsiaResourceDialect,
73023                0x12dc2fceab6cefaa,
73024            >(_buf?)?;
73025            Ok(_response.map(|x| x.len))
73026        }
73027        self.client.send_query_and_decode::<
73028            SynchronousDatagramSocketSendMsgRequest,
73029            SynchronousDatagramSocketSendMsgResult,
73030        >(
73031            (addr, data, control, flags,),
73032            0x12dc2fceab6cefaa,
73033            fidl::encoding::DynamicFlags::empty(),
73034            _decode,
73035        )
73036    }
73037}
73038
73039pub struct SynchronousDatagramSocketEventStream {
73040    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
73041}
73042
73043impl std::marker::Unpin for SynchronousDatagramSocketEventStream {}
73044
73045impl futures::stream::FusedStream for SynchronousDatagramSocketEventStream {
73046    fn is_terminated(&self) -> bool {
73047        self.event_receiver.is_terminated()
73048    }
73049}
73050
73051impl futures::Stream for SynchronousDatagramSocketEventStream {
73052    type Item = Result<SynchronousDatagramSocketEvent, fidl::Error>;
73053
73054    fn poll_next(
73055        mut self: std::pin::Pin<&mut Self>,
73056        cx: &mut std::task::Context<'_>,
73057    ) -> std::task::Poll<Option<Self::Item>> {
73058        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
73059            &mut self.event_receiver,
73060            cx
73061        )?) {
73062            Some(buf) => std::task::Poll::Ready(Some(SynchronousDatagramSocketEvent::decode(buf))),
73063            None => std::task::Poll::Ready(None),
73064        }
73065    }
73066}
73067
73068#[derive(Debug)]
73069pub enum SynchronousDatagramSocketEvent {}
73070
73071impl SynchronousDatagramSocketEvent {
73072    /// Decodes a message buffer as a [`SynchronousDatagramSocketEvent`].
73073    fn decode(
73074        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
73075    ) -> Result<SynchronousDatagramSocketEvent, fidl::Error> {
73076        let (bytes, _handles) = buf.split_mut();
73077        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
73078        debug_assert_eq!(tx_header.tx_id, 0);
73079        match tx_header.ordinal {
73080            _ => Err(fidl::Error::UnknownOrdinal {
73081                ordinal: tx_header.ordinal,
73082                protocol_name:
73083                    <SynchronousDatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
73084            }),
73085        }
73086    }
73087}
73088
73089/// A Stream of incoming requests for fuchsia.posix.socket/SynchronousDatagramSocket.
73090pub struct SynchronousDatagramSocketRequestStream {
73091    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
73092    is_terminated: bool,
73093}
73094
73095impl std::marker::Unpin for SynchronousDatagramSocketRequestStream {}
73096
73097impl futures::stream::FusedStream for SynchronousDatagramSocketRequestStream {
73098    fn is_terminated(&self) -> bool {
73099        self.is_terminated
73100    }
73101}
73102
73103impl fidl::endpoints::RequestStream for SynchronousDatagramSocketRequestStream {
73104    type Protocol = SynchronousDatagramSocketMarker;
73105    type ControlHandle = SynchronousDatagramSocketControlHandle;
73106
73107    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
73108        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
73109    }
73110
73111    fn control_handle(&self) -> Self::ControlHandle {
73112        SynchronousDatagramSocketControlHandle { inner: self.inner.clone() }
73113    }
73114
73115    fn into_inner(
73116        self,
73117    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
73118    {
73119        (self.inner, self.is_terminated)
73120    }
73121
73122    fn from_inner(
73123        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
73124        is_terminated: bool,
73125    ) -> Self {
73126        Self { inner, is_terminated }
73127    }
73128}
73129
73130impl futures::Stream for SynchronousDatagramSocketRequestStream {
73131    type Item = Result<SynchronousDatagramSocketRequest, fidl::Error>;
73132
73133    fn poll_next(
73134        mut self: std::pin::Pin<&mut Self>,
73135        cx: &mut std::task::Context<'_>,
73136    ) -> std::task::Poll<Option<Self::Item>> {
73137        let this = &mut *self;
73138        if this.inner.check_shutdown(cx) {
73139            this.is_terminated = true;
73140            return std::task::Poll::Ready(None);
73141        }
73142        if this.is_terminated {
73143            panic!("polled SynchronousDatagramSocketRequestStream after completion");
73144        }
73145        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
73146            |bytes, handles| {
73147                match this.inner.channel().read_etc(cx, bytes, handles) {
73148                    std::task::Poll::Ready(Ok(())) => {}
73149                    std::task::Poll::Pending => return std::task::Poll::Pending,
73150                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
73151                        this.is_terminated = true;
73152                        return std::task::Poll::Ready(None);
73153                    }
73154                    std::task::Poll::Ready(Err(e)) => {
73155                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
73156                            e.into(),
73157                        ))))
73158                    }
73159                }
73160
73161                // A message has been received from the channel
73162                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
73163
73164                std::task::Poll::Ready(Some(match header.ordinal {
73165                0x20d8a7aba2168a79 => {
73166                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
73167                    let mut req = fidl::new_empty!(fidl_fuchsia_unknown::CloneableCloneRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73168                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fuchsia_unknown::CloneableCloneRequest>(&header, _body_bytes, handles, &mut req)?;
73169                    let control_handle = SynchronousDatagramSocketControlHandle {
73170                        inner: this.inner.clone(),
73171                    };
73172                    Ok(SynchronousDatagramSocketRequest::Clone {request: req.request,
73173
73174                        control_handle,
73175                    })
73176                }
73177                0x5ac5d459ad7f657e => {
73178                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73179                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73180                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73181                    let control_handle = SynchronousDatagramSocketControlHandle {
73182                        inner: this.inner.clone(),
73183                    };
73184                    Ok(SynchronousDatagramSocketRequest::Close {
73185                        responder: SynchronousDatagramSocketCloseResponder {
73186                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73187                            tx_id: header.tx_id,
73188                        },
73189                    })
73190                }
73191                0x2658edee9decfc06 => {
73192                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73193                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73194                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73195                    let control_handle = SynchronousDatagramSocketControlHandle {
73196                        inner: this.inner.clone(),
73197                    };
73198                    Ok(SynchronousDatagramSocketRequest::Query {
73199                        responder: SynchronousDatagramSocketQueryResponder {
73200                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73201                            tx_id: header.tx_id,
73202                        },
73203                    })
73204                }
73205                0x1fd74ee8b9a4a876 => {
73206                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73207                    let mut req = fidl::new_empty!(BaseSocketSetReuseAddressRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73208                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReuseAddressRequest>(&header, _body_bytes, handles, &mut req)?;
73209                    let control_handle = SynchronousDatagramSocketControlHandle {
73210                        inner: this.inner.clone(),
73211                    };
73212                    Ok(SynchronousDatagramSocketRequest::SetReuseAddress {value: req.value,
73213
73214                        responder: SynchronousDatagramSocketSetReuseAddressResponder {
73215                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73216                            tx_id: header.tx_id,
73217                        },
73218                    })
73219                }
73220                0x67b7206b8d1bc0a5 => {
73221                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73222                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73223                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73224                    let control_handle = SynchronousDatagramSocketControlHandle {
73225                        inner: this.inner.clone(),
73226                    };
73227                    Ok(SynchronousDatagramSocketRequest::GetReuseAddress {
73228                        responder: SynchronousDatagramSocketGetReuseAddressResponder {
73229                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73230                            tx_id: header.tx_id,
73231                        },
73232                    })
73233                }
73234                0x5aad39b33e5f6ebb => {
73235                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73236                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73237                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73238                    let control_handle = SynchronousDatagramSocketControlHandle {
73239                        inner: this.inner.clone(),
73240                    };
73241                    Ok(SynchronousDatagramSocketRequest::GetError {
73242                        responder: SynchronousDatagramSocketGetErrorResponder {
73243                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73244                            tx_id: header.tx_id,
73245                        },
73246                    })
73247                }
73248                0x6023e081ce3cd947 => {
73249                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73250                    let mut req = fidl::new_empty!(BaseSocketSetBroadcastRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73251                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBroadcastRequest>(&header, _body_bytes, handles, &mut req)?;
73252                    let control_handle = SynchronousDatagramSocketControlHandle {
73253                        inner: this.inner.clone(),
73254                    };
73255                    Ok(SynchronousDatagramSocketRequest::SetBroadcast {value: req.value,
73256
73257                        responder: SynchronousDatagramSocketSetBroadcastResponder {
73258                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73259                            tx_id: header.tx_id,
73260                        },
73261                    })
73262                }
73263                0x68796fc556f9780d => {
73264                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73265                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73266                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73267                    let control_handle = SynchronousDatagramSocketControlHandle {
73268                        inner: this.inner.clone(),
73269                    };
73270                    Ok(SynchronousDatagramSocketRequest::GetBroadcast {
73271                        responder: SynchronousDatagramSocketGetBroadcastResponder {
73272                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73273                            tx_id: header.tx_id,
73274                        },
73275                    })
73276                }
73277                0x756eac32d73a7a70 => {
73278                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73279                    let mut req = fidl::new_empty!(BaseSocketSetSendBufferRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73280                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetSendBufferRequest>(&header, _body_bytes, handles, &mut req)?;
73281                    let control_handle = SynchronousDatagramSocketControlHandle {
73282                        inner: this.inner.clone(),
73283                    };
73284                    Ok(SynchronousDatagramSocketRequest::SetSendBuffer {value_bytes: req.value_bytes,
73285
73286                        responder: SynchronousDatagramSocketSetSendBufferResponder {
73287                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73288                            tx_id: header.tx_id,
73289                        },
73290                    })
73291                }
73292                0x78a52fd9c7b2410b => {
73293                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73294                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73295                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73296                    let control_handle = SynchronousDatagramSocketControlHandle {
73297                        inner: this.inner.clone(),
73298                    };
73299                    Ok(SynchronousDatagramSocketRequest::GetSendBuffer {
73300                        responder: SynchronousDatagramSocketGetSendBufferResponder {
73301                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73302                            tx_id: header.tx_id,
73303                        },
73304                    })
73305                }
73306                0x6b0cf2f1919c7001 => {
73307                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73308                    let mut req = fidl::new_empty!(BaseSocketSetReceiveBufferRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73309                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReceiveBufferRequest>(&header, _body_bytes, handles, &mut req)?;
73310                    let control_handle = SynchronousDatagramSocketControlHandle {
73311                        inner: this.inner.clone(),
73312                    };
73313                    Ok(SynchronousDatagramSocketRequest::SetReceiveBuffer {value_bytes: req.value_bytes,
73314
73315                        responder: SynchronousDatagramSocketSetReceiveBufferResponder {
73316                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73317                            tx_id: header.tx_id,
73318                        },
73319                    })
73320                }
73321                0x14c1a4b64f709e5c => {
73322                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73323                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73324                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73325                    let control_handle = SynchronousDatagramSocketControlHandle {
73326                        inner: this.inner.clone(),
73327                    };
73328                    Ok(SynchronousDatagramSocketRequest::GetReceiveBuffer {
73329                        responder: SynchronousDatagramSocketGetReceiveBufferResponder {
73330                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73331                            tx_id: header.tx_id,
73332                        },
73333                    })
73334                }
73335                0x572df8f0b920d2c7 => {
73336                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73337                    let mut req = fidl::new_empty!(BaseSocketSetKeepAliveRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73338                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetKeepAliveRequest>(&header, _body_bytes, handles, &mut req)?;
73339                    let control_handle = SynchronousDatagramSocketControlHandle {
73340                        inner: this.inner.clone(),
73341                    };
73342                    Ok(SynchronousDatagramSocketRequest::SetKeepAlive {value: req.value,
73343
73344                        responder: SynchronousDatagramSocketSetKeepAliveResponder {
73345                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73346                            tx_id: header.tx_id,
73347                        },
73348                    })
73349                }
73350                0x2dd29d3215f2c9d2 => {
73351                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73352                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73353                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73354                    let control_handle = SynchronousDatagramSocketControlHandle {
73355                        inner: this.inner.clone(),
73356                    };
73357                    Ok(SynchronousDatagramSocketRequest::GetKeepAlive {
73358                        responder: SynchronousDatagramSocketGetKeepAliveResponder {
73359                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73360                            tx_id: header.tx_id,
73361                        },
73362                    })
73363                }
73364                0x3ecb49968bee439 => {
73365                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73366                    let mut req = fidl::new_empty!(BaseSocketSetOutOfBandInlineRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73367                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetOutOfBandInlineRequest>(&header, _body_bytes, handles, &mut req)?;
73368                    let control_handle = SynchronousDatagramSocketControlHandle {
73369                        inner: this.inner.clone(),
73370                    };
73371                    Ok(SynchronousDatagramSocketRequest::SetOutOfBandInline {value: req.value,
73372
73373                        responder: SynchronousDatagramSocketSetOutOfBandInlineResponder {
73374                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73375                            tx_id: header.tx_id,
73376                        },
73377                    })
73378                }
73379                0x348c1ab3aeca1745 => {
73380                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73381                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73382                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73383                    let control_handle = SynchronousDatagramSocketControlHandle {
73384                        inner: this.inner.clone(),
73385                    };
73386                    Ok(SynchronousDatagramSocketRequest::GetOutOfBandInline {
73387                        responder: SynchronousDatagramSocketGetOutOfBandInlineResponder {
73388                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73389                            tx_id: header.tx_id,
73390                        },
73391                    })
73392                }
73393                0x6bbf00c53a4c78c2 => {
73394                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73395                    let mut req = fidl::new_empty!(BaseSocketSetNoCheckRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73396                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetNoCheckRequest>(&header, _body_bytes, handles, &mut req)?;
73397                    let control_handle = SynchronousDatagramSocketControlHandle {
73398                        inner: this.inner.clone(),
73399                    };
73400                    Ok(SynchronousDatagramSocketRequest::SetNoCheck {value: req.value,
73401
73402                        responder: SynchronousDatagramSocketSetNoCheckResponder {
73403                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73404                            tx_id: header.tx_id,
73405                        },
73406                    })
73407                }
73408                0x2cd4249286417694 => {
73409                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73410                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73411                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73412                    let control_handle = SynchronousDatagramSocketControlHandle {
73413                        inner: this.inner.clone(),
73414                    };
73415                    Ok(SynchronousDatagramSocketRequest::GetNoCheck {
73416                        responder: SynchronousDatagramSocketGetNoCheckResponder {
73417                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73418                            tx_id: header.tx_id,
73419                        },
73420                    })
73421                }
73422                0x45386351246e998e => {
73423                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73424                    let mut req = fidl::new_empty!(BaseSocketSetLingerRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73425                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetLingerRequest>(&header, _body_bytes, handles, &mut req)?;
73426                    let control_handle = SynchronousDatagramSocketControlHandle {
73427                        inner: this.inner.clone(),
73428                    };
73429                    Ok(SynchronousDatagramSocketRequest::SetLinger {linger: req.linger,
73430length_secs: req.length_secs,
73431
73432                        responder: SynchronousDatagramSocketSetLingerResponder {
73433                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73434                            tx_id: header.tx_id,
73435                        },
73436                    })
73437                }
73438                0x48eb20fc5ccb0e45 => {
73439                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73440                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73441                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73442                    let control_handle = SynchronousDatagramSocketControlHandle {
73443                        inner: this.inner.clone(),
73444                    };
73445                    Ok(SynchronousDatagramSocketRequest::GetLinger {
73446                        responder: SynchronousDatagramSocketGetLingerResponder {
73447                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73448                            tx_id: header.tx_id,
73449                        },
73450                    })
73451                }
73452                0x24dd3e5cb36d9ccb => {
73453                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73454                    let mut req = fidl::new_empty!(BaseSocketSetReusePortRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73455                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetReusePortRequest>(&header, _body_bytes, handles, &mut req)?;
73456                    let control_handle = SynchronousDatagramSocketControlHandle {
73457                        inner: this.inner.clone(),
73458                    };
73459                    Ok(SynchronousDatagramSocketRequest::SetReusePort {value: req.value,
73460
73461                        responder: SynchronousDatagramSocketSetReusePortResponder {
73462                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73463                            tx_id: header.tx_id,
73464                        },
73465                    })
73466                }
73467                0x7a112c1ab54ff828 => {
73468                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73469                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73470                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73471                    let control_handle = SynchronousDatagramSocketControlHandle {
73472                        inner: this.inner.clone(),
73473                    };
73474                    Ok(SynchronousDatagramSocketRequest::GetReusePort {
73475                        responder: SynchronousDatagramSocketGetReusePortResponder {
73476                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73477                            tx_id: header.tx_id,
73478                        },
73479                    })
73480                }
73481                0x67ce6db6c2ec8966 => {
73482                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73483                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73484                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73485                    let control_handle = SynchronousDatagramSocketControlHandle {
73486                        inner: this.inner.clone(),
73487                    };
73488                    Ok(SynchronousDatagramSocketRequest::GetAcceptConn {
73489                        responder: SynchronousDatagramSocketGetAcceptConnResponder {
73490                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73491                            tx_id: header.tx_id,
73492                        },
73493                    })
73494                }
73495                0x2118b483f28aafc4 => {
73496                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73497                    let mut req = fidl::new_empty!(BaseSocketSetBindToDeviceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73498                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToDeviceRequest>(&header, _body_bytes, handles, &mut req)?;
73499                    let control_handle = SynchronousDatagramSocketControlHandle {
73500                        inner: this.inner.clone(),
73501                    };
73502                    Ok(SynchronousDatagramSocketRequest::SetBindToDevice {value: req.value,
73503
73504                        responder: SynchronousDatagramSocketSetBindToDeviceResponder {
73505                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73506                            tx_id: header.tx_id,
73507                        },
73508                    })
73509                }
73510                0x1ab1fbf0ef7906c8 => {
73511                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73512                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73513                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73514                    let control_handle = SynchronousDatagramSocketControlHandle {
73515                        inner: this.inner.clone(),
73516                    };
73517                    Ok(SynchronousDatagramSocketRequest::GetBindToDevice {
73518                        responder: SynchronousDatagramSocketGetBindToDeviceResponder {
73519                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73520                            tx_id: header.tx_id,
73521                        },
73522                    })
73523                }
73524                0x6e387a0def00821 => {
73525                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73526                    let mut req = fidl::new_empty!(BaseSocketSetBindToInterfaceIndexRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73527                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetBindToInterfaceIndexRequest>(&header, _body_bytes, handles, &mut req)?;
73528                    let control_handle = SynchronousDatagramSocketControlHandle {
73529                        inner: this.inner.clone(),
73530                    };
73531                    Ok(SynchronousDatagramSocketRequest::SetBindToInterfaceIndex {value: req.value,
73532
73533                        responder: SynchronousDatagramSocketSetBindToInterfaceIndexResponder {
73534                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73535                            tx_id: header.tx_id,
73536                        },
73537                    })
73538                }
73539                0x59c31dd3e3078295 => {
73540                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73541                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73542                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73543                    let control_handle = SynchronousDatagramSocketControlHandle {
73544                        inner: this.inner.clone(),
73545                    };
73546                    Ok(SynchronousDatagramSocketRequest::GetBindToInterfaceIndex {
73547                        responder: SynchronousDatagramSocketGetBindToInterfaceIndexResponder {
73548                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73549                            tx_id: header.tx_id,
73550                        },
73551                    })
73552                }
73553                0x285d6516c263d839 => {
73554                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73555                    let mut req = fidl::new_empty!(BaseSocketSetTimestampRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73556                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetTimestampRequest>(&header, _body_bytes, handles, &mut req)?;
73557                    let control_handle = SynchronousDatagramSocketControlHandle {
73558                        inner: this.inner.clone(),
73559                    };
73560                    Ok(SynchronousDatagramSocketRequest::SetTimestamp {value: req.value,
73561
73562                        responder: SynchronousDatagramSocketSetTimestampResponder {
73563                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73564                            tx_id: header.tx_id,
73565                        },
73566                    })
73567                }
73568                0x49f2fffbbcc2bd27 => {
73569                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73570                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73571                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73572                    let control_handle = SynchronousDatagramSocketControlHandle {
73573                        inner: this.inner.clone(),
73574                    };
73575                    Ok(SynchronousDatagramSocketRequest::GetTimestamp {
73576                        responder: SynchronousDatagramSocketGetTimestampResponder {
73577                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73578                            tx_id: header.tx_id,
73579                        },
73580                    })
73581                }
73582                0x6ead6de09f653236 => {
73583                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73584                    let mut req = fidl::new_empty!(BaseSocketSetMarkRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73585                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketSetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
73586                    let control_handle = SynchronousDatagramSocketControlHandle {
73587                        inner: this.inner.clone(),
73588                    };
73589                    Ok(SynchronousDatagramSocketRequest::SetMark {domain: req.domain,
73590mark: req.mark,
73591
73592                        responder: SynchronousDatagramSocketSetMarkResponder {
73593                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73594                            tx_id: header.tx_id,
73595                        },
73596                    })
73597                }
73598                0x57a2752c61d93d47 => {
73599                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73600                    let mut req = fidl::new_empty!(BaseSocketGetMarkRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73601                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseSocketGetMarkRequest>(&header, _body_bytes, handles, &mut req)?;
73602                    let control_handle = SynchronousDatagramSocketControlHandle {
73603                        inner: this.inner.clone(),
73604                    };
73605                    Ok(SynchronousDatagramSocketRequest::GetMark {domain: req.domain,
73606
73607                        responder: SynchronousDatagramSocketGetMarkResponder {
73608                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73609                            tx_id: header.tx_id,
73610                        },
73611                    })
73612                }
73613                0x4bc6400ae92125d => {
73614                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73615                    let mut req = fidl::new_empty!(BaseNetworkSocketBindRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73616                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketBindRequest>(&header, _body_bytes, handles, &mut req)?;
73617                    let control_handle = SynchronousDatagramSocketControlHandle {
73618                        inner: this.inner.clone(),
73619                    };
73620                    Ok(SynchronousDatagramSocketRequest::Bind {addr: req.addr,
73621
73622                        responder: SynchronousDatagramSocketBindResponder {
73623                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73624                            tx_id: header.tx_id,
73625                        },
73626                    })
73627                }
73628                0x5f05f19bfdd38871 => {
73629                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73630                    let mut req = fidl::new_empty!(BaseNetworkSocketConnectRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73631                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketConnectRequest>(&header, _body_bytes, handles, &mut req)?;
73632                    let control_handle = SynchronousDatagramSocketControlHandle {
73633                        inner: this.inner.clone(),
73634                    };
73635                    Ok(SynchronousDatagramSocketRequest::Connect {addr: req.addr,
73636
73637                        responder: SynchronousDatagramSocketConnectResponder {
73638                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73639                            tx_id: header.tx_id,
73640                        },
73641                    })
73642                }
73643                0x74e63b91f7b29b2 => {
73644                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73645                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73646                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73647                    let control_handle = SynchronousDatagramSocketControlHandle {
73648                        inner: this.inner.clone(),
73649                    };
73650                    Ok(SynchronousDatagramSocketRequest::Disconnect {
73651                        responder: SynchronousDatagramSocketDisconnectResponder {
73652                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73653                            tx_id: header.tx_id,
73654                        },
73655                    })
73656                }
73657                0x475f23f84a1a4f85 => {
73658                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73659                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73660                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73661                    let control_handle = SynchronousDatagramSocketControlHandle {
73662                        inner: this.inner.clone(),
73663                    };
73664                    Ok(SynchronousDatagramSocketRequest::GetSockName {
73665                        responder: SynchronousDatagramSocketGetSockNameResponder {
73666                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73667                            tx_id: header.tx_id,
73668                        },
73669                    })
73670                }
73671                0x1ffecf4bd5b6432e => {
73672                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73673                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73674                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73675                    let control_handle = SynchronousDatagramSocketControlHandle {
73676                        inner: this.inner.clone(),
73677                    };
73678                    Ok(SynchronousDatagramSocketRequest::GetPeerName {
73679                        responder: SynchronousDatagramSocketGetPeerNameResponder {
73680                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73681                            tx_id: header.tx_id,
73682                        },
73683                    })
73684                }
73685                0x247f38b6db68c336 => {
73686                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73687                    let mut req = fidl::new_empty!(BaseNetworkSocketShutdownRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73688                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketShutdownRequest>(&header, _body_bytes, handles, &mut req)?;
73689                    let control_handle = SynchronousDatagramSocketControlHandle {
73690                        inner: this.inner.clone(),
73691                    };
73692                    Ok(SynchronousDatagramSocketRequest::Shutdown {mode: req.mode,
73693
73694                        responder: SynchronousDatagramSocketShutdownResponder {
73695                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73696                            tx_id: header.tx_id,
73697                        },
73698                    })
73699                }
73700                0x995c600475b6d46 => {
73701                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73702                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpTypeOfServiceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73703                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
73704                    let control_handle = SynchronousDatagramSocketControlHandle {
73705                        inner: this.inner.clone(),
73706                    };
73707                    Ok(SynchronousDatagramSocketRequest::SetIpTypeOfService {value: req.value,
73708
73709                        responder: SynchronousDatagramSocketSetIpTypeOfServiceResponder {
73710                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73711                            tx_id: header.tx_id,
73712                        },
73713                    })
73714                }
73715                0x3814a04259f75fcb => {
73716                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73717                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73718                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73719                    let control_handle = SynchronousDatagramSocketControlHandle {
73720                        inner: this.inner.clone(),
73721                    };
73722                    Ok(SynchronousDatagramSocketRequest::GetIpTypeOfService {
73723                        responder: SynchronousDatagramSocketGetIpTypeOfServiceResponder {
73724                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73725                            tx_id: header.tx_id,
73726                        },
73727                    })
73728                }
73729                0x29e2424b433ae1ef => {
73730                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73731                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpTtlRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73732                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTtlRequest>(&header, _body_bytes, handles, &mut req)?;
73733                    let control_handle = SynchronousDatagramSocketControlHandle {
73734                        inner: this.inner.clone(),
73735                    };
73736                    Ok(SynchronousDatagramSocketRequest::SetIpTtl {value: req.value,
73737
73738                        responder: SynchronousDatagramSocketSetIpTtlResponder {
73739                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73740                            tx_id: header.tx_id,
73741                        },
73742                    })
73743                }
73744                0x47e47fa1f24da471 => {
73745                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73746                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73747                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73748                    let control_handle = SynchronousDatagramSocketControlHandle {
73749                        inner: this.inner.clone(),
73750                    };
73751                    Ok(SynchronousDatagramSocketRequest::GetIpTtl {
73752                        responder: SynchronousDatagramSocketGetIpTtlResponder {
73753                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73754                            tx_id: header.tx_id,
73755                        },
73756                    })
73757                }
73758                0x392d16bee20c0e16 => {
73759                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73760                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpPacketInfoRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73761                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpPacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
73762                    let control_handle = SynchronousDatagramSocketControlHandle {
73763                        inner: this.inner.clone(),
73764                    };
73765                    Ok(SynchronousDatagramSocketRequest::SetIpPacketInfo {value: req.value,
73766
73767                        responder: SynchronousDatagramSocketSetIpPacketInfoResponder {
73768                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73769                            tx_id: header.tx_id,
73770                        },
73771                    })
73772                }
73773                0x54b505f242280740 => {
73774                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73775                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73776                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73777                    let control_handle = SynchronousDatagramSocketControlHandle {
73778                        inner: this.inner.clone(),
73779                    };
73780                    Ok(SynchronousDatagramSocketRequest::GetIpPacketInfo {
73781                        responder: SynchronousDatagramSocketGetIpPacketInfoResponder {
73782                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73783                            tx_id: header.tx_id,
73784                        },
73785                    })
73786                }
73787                0x6c4f6714995f84ef => {
73788                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73789                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpReceiveTypeOfServiceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73790                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveTypeOfServiceRequest>(&header, _body_bytes, handles, &mut req)?;
73791                    let control_handle = SynchronousDatagramSocketControlHandle {
73792                        inner: this.inner.clone(),
73793                    };
73794                    Ok(SynchronousDatagramSocketRequest::SetIpReceiveTypeOfService {value: req.value,
73795
73796                        responder: SynchronousDatagramSocketSetIpReceiveTypeOfServiceResponder {
73797                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73798                            tx_id: header.tx_id,
73799                        },
73800                    })
73801                }
73802                0x4158ba7dc2795960 => {
73803                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73804                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73805                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73806                    let control_handle = SynchronousDatagramSocketControlHandle {
73807                        inner: this.inner.clone(),
73808                    };
73809                    Ok(SynchronousDatagramSocketRequest::GetIpReceiveTypeOfService {
73810                        responder: SynchronousDatagramSocketGetIpReceiveTypeOfServiceResponder {
73811                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73812                            tx_id: header.tx_id,
73813                        },
73814                    })
73815                }
73816                0x46f15be0ce0ab82b => {
73817                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73818                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpReceiveTtlRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73819                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveTtlRequest>(&header, _body_bytes, handles, &mut req)?;
73820                    let control_handle = SynchronousDatagramSocketControlHandle {
73821                        inner: this.inner.clone(),
73822                    };
73823                    Ok(SynchronousDatagramSocketRequest::SetIpReceiveTtl {value: req.value,
73824
73825                        responder: SynchronousDatagramSocketSetIpReceiveTtlResponder {
73826                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73827                            tx_id: header.tx_id,
73828                        },
73829                    })
73830                }
73831                0x678ddd5a5dfa2eb5 => {
73832                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73833                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73834                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73835                    let control_handle = SynchronousDatagramSocketControlHandle {
73836                        inner: this.inner.clone(),
73837                    };
73838                    Ok(SynchronousDatagramSocketRequest::GetIpReceiveTtl {
73839                        responder: SynchronousDatagramSocketGetIpReceiveTtlResponder {
73840                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73841                            tx_id: header.tx_id,
73842                        },
73843                    })
73844                }
73845                0x752fbfa9b12befe => {
73846                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73847                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpMulticastInterfaceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73848                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
73849                    let control_handle = SynchronousDatagramSocketControlHandle {
73850                        inner: this.inner.clone(),
73851                    };
73852                    Ok(SynchronousDatagramSocketRequest::SetIpMulticastInterface {iface: req.iface,
73853address: req.address,
73854
73855                        responder: SynchronousDatagramSocketSetIpMulticastInterfaceResponder {
73856                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73857                            tx_id: header.tx_id,
73858                        },
73859                    })
73860                }
73861                0x320bd14c4df046c4 => {
73862                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73863                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73864                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73865                    let control_handle = SynchronousDatagramSocketControlHandle {
73866                        inner: this.inner.clone(),
73867                    };
73868                    Ok(SynchronousDatagramSocketRequest::GetIpMulticastInterface {
73869                        responder: SynchronousDatagramSocketGetIpMulticastInterfaceResponder {
73870                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73871                            tx_id: header.tx_id,
73872                        },
73873                    })
73874                }
73875                0x63134d53772916a1 => {
73876                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73877                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpMulticastTtlRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73878                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastTtlRequest>(&header, _body_bytes, handles, &mut req)?;
73879                    let control_handle = SynchronousDatagramSocketControlHandle {
73880                        inner: this.inner.clone(),
73881                    };
73882                    Ok(SynchronousDatagramSocketRequest::SetIpMulticastTtl {value: req.value,
73883
73884                        responder: SynchronousDatagramSocketSetIpMulticastTtlResponder {
73885                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73886                            tx_id: header.tx_id,
73887                        },
73888                    })
73889                }
73890                0x4665cd378f39e1a => {
73891                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73892                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73893                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73894                    let control_handle = SynchronousDatagramSocketControlHandle {
73895                        inner: this.inner.clone(),
73896                    };
73897                    Ok(SynchronousDatagramSocketRequest::GetIpMulticastTtl {
73898                        responder: SynchronousDatagramSocketGetIpMulticastTtlResponder {
73899                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73900                            tx_id: header.tx_id,
73901                        },
73902                    })
73903                }
73904                0x20c55c11f00943ea => {
73905                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73906                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpMulticastLoopbackRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73907                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpMulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
73908                    let control_handle = SynchronousDatagramSocketControlHandle {
73909                        inner: this.inner.clone(),
73910                    };
73911                    Ok(SynchronousDatagramSocketRequest::SetIpMulticastLoopback {value: req.value,
73912
73913                        responder: SynchronousDatagramSocketSetIpMulticastLoopbackResponder {
73914                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73915                            tx_id: header.tx_id,
73916                        },
73917                    })
73918                }
73919                0x3b6b26ff558298f2 => {
73920                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73921                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73922                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73923                    let control_handle = SynchronousDatagramSocketControlHandle {
73924                        inner: this.inner.clone(),
73925                    };
73926                    Ok(SynchronousDatagramSocketRequest::GetIpMulticastLoopback {
73927                        responder: SynchronousDatagramSocketGetIpMulticastLoopbackResponder {
73928                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73929                            tx_id: header.tx_id,
73930                        },
73931                    })
73932                }
73933                0x76bc7df115a3b4d0 => {
73934                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73935                    let mut req = fidl::new_empty!(BaseNetworkSocketAddIpMembershipRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73936                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketAddIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
73937                    let control_handle = SynchronousDatagramSocketControlHandle {
73938                        inner: this.inner.clone(),
73939                    };
73940                    Ok(SynchronousDatagramSocketRequest::AddIpMembership {membership: req.membership,
73941
73942                        responder: SynchronousDatagramSocketAddIpMembershipResponder {
73943                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73944                            tx_id: header.tx_id,
73945                        },
73946                    })
73947                }
73948                0x2888f3099188d03 => {
73949                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73950                    let mut req = fidl::new_empty!(BaseNetworkSocketDropIpMembershipRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73951                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketDropIpMembershipRequest>(&header, _body_bytes, handles, &mut req)?;
73952                    let control_handle = SynchronousDatagramSocketControlHandle {
73953                        inner: this.inner.clone(),
73954                    };
73955                    Ok(SynchronousDatagramSocketRequest::DropIpMembership {membership: req.membership,
73956
73957                        responder: SynchronousDatagramSocketDropIpMembershipResponder {
73958                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73959                            tx_id: header.tx_id,
73960                        },
73961                    })
73962                }
73963                0x1ae532b0c066e3a0 => {
73964                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73965                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpTransparentRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73966                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpTransparentRequest>(&header, _body_bytes, handles, &mut req)?;
73967                    let control_handle = SynchronousDatagramSocketControlHandle {
73968                        inner: this.inner.clone(),
73969                    };
73970                    Ok(SynchronousDatagramSocketRequest::SetIpTransparent {value: req.value,
73971
73972                        responder: SynchronousDatagramSocketSetIpTransparentResponder {
73973                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73974                            tx_id: header.tx_id,
73975                        },
73976                    })
73977                }
73978                0x51d43695962ebfb5 => {
73979                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73980                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
73981                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
73982                    let control_handle = SynchronousDatagramSocketControlHandle {
73983                        inner: this.inner.clone(),
73984                    };
73985                    Ok(SynchronousDatagramSocketRequest::GetIpTransparent {
73986                        responder: SynchronousDatagramSocketGetIpTransparentResponder {
73987                            control_handle: std::mem::ManuallyDrop::new(control_handle),
73988                            tx_id: header.tx_id,
73989                        },
73990                    })
73991                }
73992                0x4722b4ce52f7840 => {
73993                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
73994                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
73995                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpReceiveOriginalDestinationAddressRequest>(&header, _body_bytes, handles, &mut req)?;
73996                    let control_handle = SynchronousDatagramSocketControlHandle {
73997                        inner: this.inner.clone(),
73998                    };
73999                    Ok(SynchronousDatagramSocketRequest::SetIpReceiveOriginalDestinationAddress {value: req.value,
74000
74001                        responder: SynchronousDatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
74002                            control_handle: std::mem::ManuallyDrop::new(control_handle),
74003                            tx_id: header.tx_id,
74004                        },
74005                    })
74006                }
74007                0x2a0e7dc5d6bfdfe9 => {
74008                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74009                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
74010                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
74011                    let control_handle = SynchronousDatagramSocketControlHandle {
74012                        inner: this.inner.clone(),
74013                    };
74014                    Ok(SynchronousDatagramSocketRequest::GetIpReceiveOriginalDestinationAddress {
74015                        responder: SynchronousDatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
74016                            control_handle: std::mem::ManuallyDrop::new(control_handle),
74017                            tx_id: header.tx_id,
74018                        },
74019                    })
74020                }
74021                0x7c94727acb4ea4b3 => {
74022                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74023                    let mut req = fidl::new_empty!(BaseNetworkSocketAddIpv6MembershipRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
74024                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketAddIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
74025                    let control_handle = SynchronousDatagramSocketControlHandle {
74026                        inner: this.inner.clone(),
74027                    };
74028                    Ok(SynchronousDatagramSocketRequest::AddIpv6Membership {membership: req.membership,
74029
74030                        responder: SynchronousDatagramSocketAddIpv6MembershipResponder {
74031                            control_handle: std::mem::ManuallyDrop::new(control_handle),
74032                            tx_id: header.tx_id,
74033                        },
74034                    })
74035                }
74036                0x42104c70ccaba304 => {
74037                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74038                    let mut req = fidl::new_empty!(BaseNetworkSocketDropIpv6MembershipRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
74039                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketDropIpv6MembershipRequest>(&header, _body_bytes, handles, &mut req)?;
74040                    let control_handle = SynchronousDatagramSocketControlHandle {
74041                        inner: this.inner.clone(),
74042                    };
74043                    Ok(SynchronousDatagramSocketRequest::DropIpv6Membership {membership: req.membership,
74044
74045                        responder: SynchronousDatagramSocketDropIpv6MembershipResponder {
74046                            control_handle: std::mem::ManuallyDrop::new(control_handle),
74047                            tx_id: header.tx_id,
74048                        },
74049                    })
74050                }
74051                0x135f76db3774ab3b => {
74052                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74053                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6MulticastInterfaceRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
74054                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastInterfaceRequest>(&header, _body_bytes, handles, &mut req)?;
74055                    let control_handle = SynchronousDatagramSocketControlHandle {
74056                        inner: this.inner.clone(),
74057                    };
74058                    Ok(SynchronousDatagramSocketRequest::SetIpv6MulticastInterface {value: req.value,
74059
74060                        responder: SynchronousDatagramSocketSetIpv6MulticastInterfaceResponder {
74061                            control_handle: std::mem::ManuallyDrop::new(control_handle),
74062                            tx_id: header.tx_id,
74063                        },
74064                    })
74065                }
74066                0x1f26fcdd348f1882 => {
74067                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74068                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
74069                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
74070                    let control_handle = SynchronousDatagramSocketControlHandle {
74071                        inner: this.inner.clone(),
74072                    };
74073                    Ok(SynchronousDatagramSocketRequest::GetIpv6MulticastInterface {
74074                        responder: SynchronousDatagramSocketGetIpv6MulticastInterfaceResponder {
74075                            control_handle: std::mem::ManuallyDrop::new(control_handle),
74076                            tx_id: header.tx_id,
74077                        },
74078                    })
74079                }
74080                0x157d51e98f462859 => {
74081                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74082                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6UnicastHopsRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
74083                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6UnicastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
74084                    let control_handle = SynchronousDatagramSocketControlHandle {
74085                        inner: this.inner.clone(),
74086                    };
74087                    Ok(SynchronousDatagramSocketRequest::SetIpv6UnicastHops {value: req.value,
74088
74089                        responder: SynchronousDatagramSocketSetIpv6UnicastHopsResponder {
74090                            control_handle: std::mem::ManuallyDrop::new(control_handle),
74091                            tx_id: header.tx_id,
74092                        },
74093                    })
74094                }
74095                0x21f4641cad8bd8d2 => {
74096                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74097                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
74098                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
74099                    let control_handle = SynchronousDatagramSocketControlHandle {
74100                        inner: this.inner.clone(),
74101                    };
74102                    Ok(SynchronousDatagramSocketRequest::GetIpv6UnicastHops {
74103                        responder: SynchronousDatagramSocketGetIpv6UnicastHopsResponder {
74104                            control_handle: std::mem::ManuallyDrop::new(control_handle),
74105                            tx_id: header.tx_id,
74106                        },
74107                    })
74108                }
74109                0x5c24808ed2e84a1e => {
74110                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74111                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6ReceiveHopLimitRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
74112                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceiveHopLimitRequest>(&header, _body_bytes, handles, &mut req)?;
74113                    let control_handle = SynchronousDatagramSocketControlHandle {
74114                        inner: this.inner.clone(),
74115                    };
74116                    Ok(SynchronousDatagramSocketRequest::SetIpv6ReceiveHopLimit {value: req.value,
74117
74118                        responder: SynchronousDatagramSocketSetIpv6ReceiveHopLimitResponder {
74119                            control_handle: std::mem::ManuallyDrop::new(control_handle),
74120                            tx_id: header.tx_id,
74121                        },
74122                    })
74123                }
74124                0x341e06689885b4c0 => {
74125                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74126                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
74127                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
74128                    let control_handle = SynchronousDatagramSocketControlHandle {
74129                        inner: this.inner.clone(),
74130                    };
74131                    Ok(SynchronousDatagramSocketRequest::GetIpv6ReceiveHopLimit {
74132                        responder: SynchronousDatagramSocketGetIpv6ReceiveHopLimitResponder {
74133                            control_handle: std::mem::ManuallyDrop::new(control_handle),
74134                            tx_id: header.tx_id,
74135                        },
74136                    })
74137                }
74138                0x25b9cd4d181f82c1 => {
74139                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74140                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6MulticastHopsRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
74141                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastHopsRequest>(&header, _body_bytes, handles, &mut req)?;
74142                    let control_handle = SynchronousDatagramSocketControlHandle {
74143                        inner: this.inner.clone(),
74144                    };
74145                    Ok(SynchronousDatagramSocketRequest::SetIpv6MulticastHops {value: req.value,
74146
74147                        responder: SynchronousDatagramSocketSetIpv6MulticastHopsResponder {
74148                            control_handle: std::mem::ManuallyDrop::new(control_handle),
74149                            tx_id: header.tx_id,
74150                        },
74151                    })
74152                }
74153                0x52916948a365012a => {
74154                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74155                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
74156                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
74157                    let control_handle = SynchronousDatagramSocketControlHandle {
74158                        inner: this.inner.clone(),
74159                    };
74160                    Ok(SynchronousDatagramSocketRequest::GetIpv6MulticastHops {
74161                        responder: SynchronousDatagramSocketGetIpv6MulticastHopsResponder {
74162                            control_handle: std::mem::ManuallyDrop::new(control_handle),
74163                            tx_id: header.tx_id,
74164                        },
74165                    })
74166                }
74167                0x55701c409ff41b40 => {
74168                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74169                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6MulticastLoopbackRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
74170                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6MulticastLoopbackRequest>(&header, _body_bytes, handles, &mut req)?;
74171                    let control_handle = SynchronousDatagramSocketControlHandle {
74172                        inner: this.inner.clone(),
74173                    };
74174                    Ok(SynchronousDatagramSocketRequest::SetIpv6MulticastLoopback {value: req.value,
74175
74176                        responder: SynchronousDatagramSocketSetIpv6MulticastLoopbackResponder {
74177                            control_handle: std::mem::ManuallyDrop::new(control_handle),
74178                            tx_id: header.tx_id,
74179                        },
74180                    })
74181                }
74182                0x4415b701fde319c3 => {
74183                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74184                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
74185                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
74186                    let control_handle = SynchronousDatagramSocketControlHandle {
74187                        inner: this.inner.clone(),
74188                    };
74189                    Ok(SynchronousDatagramSocketRequest::GetIpv6MulticastLoopback {
74190                        responder: SynchronousDatagramSocketGetIpv6MulticastLoopbackResponder {
74191                            control_handle: std::mem::ManuallyDrop::new(control_handle),
74192                            tx_id: header.tx_id,
74193                        },
74194                    })
74195                }
74196                0x4873f1364758cbba => {
74197                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74198                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6OnlyRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
74199                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6OnlyRequest>(&header, _body_bytes, handles, &mut req)?;
74200                    let control_handle = SynchronousDatagramSocketControlHandle {
74201                        inner: this.inner.clone(),
74202                    };
74203                    Ok(SynchronousDatagramSocketRequest::SetIpv6Only {value: req.value,
74204
74205                        responder: SynchronousDatagramSocketSetIpv6OnlyResponder {
74206                            control_handle: std::mem::ManuallyDrop::new(control_handle),
74207                            tx_id: header.tx_id,
74208                        },
74209                    })
74210                }
74211                0x4aa3340a1a26b89c => {
74212                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74213                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
74214                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
74215                    let control_handle = SynchronousDatagramSocketControlHandle {
74216                        inner: this.inner.clone(),
74217                    };
74218                    Ok(SynchronousDatagramSocketRequest::GetIpv6Only {
74219                        responder: SynchronousDatagramSocketGetIpv6OnlyResponder {
74220                            control_handle: std::mem::ManuallyDrop::new(control_handle),
74221                            tx_id: header.tx_id,
74222                        },
74223                    })
74224                }
74225                0x58f07c8788d099a0 => {
74226                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74227                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
74228                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceiveTrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
74229                    let control_handle = SynchronousDatagramSocketControlHandle {
74230                        inner: this.inner.clone(),
74231                    };
74232                    Ok(SynchronousDatagramSocketRequest::SetIpv6ReceiveTrafficClass {value: req.value,
74233
74234                        responder: SynchronousDatagramSocketSetIpv6ReceiveTrafficClassResponder {
74235                            control_handle: std::mem::ManuallyDrop::new(control_handle),
74236                            tx_id: header.tx_id,
74237                        },
74238                    })
74239                }
74240                0x2e334df1da553ffa => {
74241                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74242                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
74243                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
74244                    let control_handle = SynchronousDatagramSocketControlHandle {
74245                        inner: this.inner.clone(),
74246                    };
74247                    Ok(SynchronousDatagramSocketRequest::GetIpv6ReceiveTrafficClass {
74248                        responder: SynchronousDatagramSocketGetIpv6ReceiveTrafficClassResponder {
74249                            control_handle: std::mem::ManuallyDrop::new(control_handle),
74250                            tx_id: header.tx_id,
74251                        },
74252                    })
74253                }
74254                0x6af077800c5a0b4f => {
74255                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74256                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6TrafficClassRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
74257                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6TrafficClassRequest>(&header, _body_bytes, handles, &mut req)?;
74258                    let control_handle = SynchronousDatagramSocketControlHandle {
74259                        inner: this.inner.clone(),
74260                    };
74261                    Ok(SynchronousDatagramSocketRequest::SetIpv6TrafficClass {value: req.value,
74262
74263                        responder: SynchronousDatagramSocketSetIpv6TrafficClassResponder {
74264                            control_handle: std::mem::ManuallyDrop::new(control_handle),
74265                            tx_id: header.tx_id,
74266                        },
74267                    })
74268                }
74269                0x6baf6eed8fc2f04 => {
74270                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74271                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
74272                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
74273                    let control_handle = SynchronousDatagramSocketControlHandle {
74274                        inner: this.inner.clone(),
74275                    };
74276                    Ok(SynchronousDatagramSocketRequest::GetIpv6TrafficClass {
74277                        responder: SynchronousDatagramSocketGetIpv6TrafficClassResponder {
74278                            control_handle: std::mem::ManuallyDrop::new(control_handle),
74279                            tx_id: header.tx_id,
74280                        },
74281                    })
74282                }
74283                0x19259775b1a92768 => {
74284                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74285                    let mut req = fidl::new_empty!(BaseNetworkSocketSetIpv6ReceivePacketInfoRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
74286                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<BaseNetworkSocketSetIpv6ReceivePacketInfoRequest>(&header, _body_bytes, handles, &mut req)?;
74287                    let control_handle = SynchronousDatagramSocketControlHandle {
74288                        inner: this.inner.clone(),
74289                    };
74290                    Ok(SynchronousDatagramSocketRequest::SetIpv6ReceivePacketInfo {value: req.value,
74291
74292                        responder: SynchronousDatagramSocketSetIpv6ReceivePacketInfoResponder {
74293                            control_handle: std::mem::ManuallyDrop::new(control_handle),
74294                            tx_id: header.tx_id,
74295                        },
74296                    })
74297                }
74298                0x7acd4a2775baec75 => {
74299                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74300                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
74301                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
74302                    let control_handle = SynchronousDatagramSocketControlHandle {
74303                        inner: this.inner.clone(),
74304                    };
74305                    Ok(SynchronousDatagramSocketRequest::GetIpv6ReceivePacketInfo {
74306                        responder: SynchronousDatagramSocketGetIpv6ReceivePacketInfoResponder {
74307                            control_handle: std::mem::ManuallyDrop::new(control_handle),
74308                            tx_id: header.tx_id,
74309                        },
74310                    })
74311                }
74312                0x38bf28f0dafdbac0 => {
74313                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74314                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
74315                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
74316                    let control_handle = SynchronousDatagramSocketControlHandle {
74317                        inner: this.inner.clone(),
74318                    };
74319                    Ok(SynchronousDatagramSocketRequest::GetOriginalDestination {
74320                        responder: SynchronousDatagramSocketGetOriginalDestinationResponder {
74321                            control_handle: std::mem::ManuallyDrop::new(control_handle),
74322                            tx_id: header.tx_id,
74323                        },
74324                    })
74325                }
74326                0x48aa0a1f6a32d2ed => {
74327                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74328                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
74329                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
74330                    let control_handle = SynchronousDatagramSocketControlHandle {
74331                        inner: this.inner.clone(),
74332                    };
74333                    Ok(SynchronousDatagramSocketRequest::GetInfo {
74334                        responder: SynchronousDatagramSocketGetInfoResponder {
74335                            control_handle: std::mem::ManuallyDrop::new(control_handle),
74336                            tx_id: header.tx_id,
74337                        },
74338                    })
74339                }
74340                0x585f20b73631070d => {
74341                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74342                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
74343                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
74344                    let control_handle = SynchronousDatagramSocketControlHandle {
74345                        inner: this.inner.clone(),
74346                    };
74347                    Ok(SynchronousDatagramSocketRequest::Describe {
74348                        responder: SynchronousDatagramSocketDescribeResponder {
74349                            control_handle: std::mem::ManuallyDrop::new(control_handle),
74350                            tx_id: header.tx_id,
74351                        },
74352                    })
74353                }
74354                0x28e494e48fb5dbf3 => {
74355                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74356                    let mut req = fidl::new_empty!(SynchronousDatagramSocketRecvMsgRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
74357                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SynchronousDatagramSocketRecvMsgRequest>(&header, _body_bytes, handles, &mut req)?;
74358                    let control_handle = SynchronousDatagramSocketControlHandle {
74359                        inner: this.inner.clone(),
74360                    };
74361                    Ok(SynchronousDatagramSocketRequest::RecvMsg {want_addr: req.want_addr,
74362data_len: req.data_len,
74363want_control: req.want_control,
74364flags: req.flags,
74365
74366                        responder: SynchronousDatagramSocketRecvMsgResponder {
74367                            control_handle: std::mem::ManuallyDrop::new(control_handle),
74368                            tx_id: header.tx_id,
74369                        },
74370                    })
74371                }
74372                0x12dc2fceab6cefaa => {
74373                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
74374                    let mut req = fidl::new_empty!(SynchronousDatagramSocketSendMsgRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
74375                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<SynchronousDatagramSocketSendMsgRequest>(&header, _body_bytes, handles, &mut req)?;
74376                    let control_handle = SynchronousDatagramSocketControlHandle {
74377                        inner: this.inner.clone(),
74378                    };
74379                    Ok(SynchronousDatagramSocketRequest::SendMsg {addr: req.addr,
74380data: req.data,
74381control: req.control,
74382flags: req.flags,
74383
74384                        responder: SynchronousDatagramSocketSendMsgResponder {
74385                            control_handle: std::mem::ManuallyDrop::new(control_handle),
74386                            tx_id: header.tx_id,
74387                        },
74388                    })
74389                }
74390                _ => Err(fidl::Error::UnknownOrdinal {
74391                    ordinal: header.ordinal,
74392                    protocol_name: <SynchronousDatagramSocketMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
74393                }),
74394            }))
74395            },
74396        )
74397    }
74398}
74399
74400/// A synchronous datagram socket.
74401///
74402/// This protocol defines synchronous methods for sending and receiving datagram
74403/// payloads over a channel. All methods are nonblocking; their behavior roughly
74404/// matches their Linux counterparts.
74405///
74406/// *Warning:* This protocol is not yet ready for direct use by clients.
74407/// Instead, clients should use the BSD sockets API to interact with sockets.
74408/// We plan to change this protocol substantially and clients that couple
74409/// directly to this protocol will make those changes more difficult.
74410#[derive(Debug)]
74411pub enum SynchronousDatagramSocketRequest {
74412    Clone {
74413        request: fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
74414        control_handle: SynchronousDatagramSocketControlHandle,
74415    },
74416    /// Terminates the connection.
74417    ///
74418    /// After calling `Close`, the client must not send any other requests.
74419    ///
74420    /// Servers, after sending the status response, should close the connection
74421    /// regardless of status and without sending an epitaph.
74422    ///
74423    /// Closing the client end of the channel should be semantically equivalent
74424    /// to calling `Close` without knowing when the close has completed or its
74425    /// status.
74426    Close {
74427        responder: SynchronousDatagramSocketCloseResponder,
74428    },
74429    Query {
74430        responder: SynchronousDatagramSocketQueryResponder,
74431    },
74432    /// Set `SOL_SOCKET` -> `SO_REUSEADDR`.
74433    SetReuseAddress {
74434        value: bool,
74435        responder: SynchronousDatagramSocketSetReuseAddressResponder,
74436    },
74437    /// Get `SOL_SOCKET` -> `SO_REUSEADDR`.
74438    GetReuseAddress {
74439        responder: SynchronousDatagramSocketGetReuseAddressResponder,
74440    },
74441    /// Get `SOL_SOCKET` -> `SO_ERROR`.
74442    /// Returns the last error if there is an error set on the socket.
74443    GetError {
74444        responder: SynchronousDatagramSocketGetErrorResponder,
74445    },
74446    /// Set `SOL_SOCKET` -> `SO_BROADCAST`.
74447    SetBroadcast {
74448        value: bool,
74449        responder: SynchronousDatagramSocketSetBroadcastResponder,
74450    },
74451    /// Get `SOL_SOCKET` -> `SO_BROADCAST`.
74452    GetBroadcast {
74453        responder: SynchronousDatagramSocketGetBroadcastResponder,
74454    },
74455    /// Set `SOL_SOCKET` -> `SO_SNDBUF`.
74456    SetSendBuffer {
74457        value_bytes: u64,
74458        responder: SynchronousDatagramSocketSetSendBufferResponder,
74459    },
74460    /// Get `SOL_SOCKET` -> `SO_SNDBUF`.
74461    GetSendBuffer {
74462        responder: SynchronousDatagramSocketGetSendBufferResponder,
74463    },
74464    /// Set `SOL_SOCKET` -> `SO_RCVBUF`.
74465    SetReceiveBuffer {
74466        value_bytes: u64,
74467        responder: SynchronousDatagramSocketSetReceiveBufferResponder,
74468    },
74469    /// Get `SOL_SOCKET` -> `SO_RCVBUF`.
74470    GetReceiveBuffer {
74471        responder: SynchronousDatagramSocketGetReceiveBufferResponder,
74472    },
74473    /// Set `SOL_SOCKET` -> `SO_KEEPALIVE`.
74474    SetKeepAlive {
74475        value: bool,
74476        responder: SynchronousDatagramSocketSetKeepAliveResponder,
74477    },
74478    /// Get `SOL_SOCKET` -> `SO_KEEPALIVE`.
74479    GetKeepAlive {
74480        responder: SynchronousDatagramSocketGetKeepAliveResponder,
74481    },
74482    /// Set `SOL_SOCKET` -> `SO_OOBINLINE`.
74483    SetOutOfBandInline {
74484        value: bool,
74485        responder: SynchronousDatagramSocketSetOutOfBandInlineResponder,
74486    },
74487    /// Get `SOL_SOCKET` -> `SO_OOBINLINE`.
74488    GetOutOfBandInline {
74489        responder: SynchronousDatagramSocketGetOutOfBandInlineResponder,
74490    },
74491    /// Set `SOL_SOCKET` -> `SO_NO_CHECK`.
74492    SetNoCheck {
74493        value: bool,
74494        responder: SynchronousDatagramSocketSetNoCheckResponder,
74495    },
74496    /// Get `SOL_SOCKET` -> `SO_NO_CHECK`.
74497    GetNoCheck {
74498        responder: SynchronousDatagramSocketGetNoCheckResponder,
74499    },
74500    /// Set `SOL_SOCKET` -> `SO_LINGER`.
74501    SetLinger {
74502        linger: bool,
74503        length_secs: u32,
74504        responder: SynchronousDatagramSocketSetLingerResponder,
74505    },
74506    /// Get `SOL_SOCKET` -> `SO_LINGER`.
74507    GetLinger {
74508        responder: SynchronousDatagramSocketGetLingerResponder,
74509    },
74510    /// Set `SOL_SOCKET` -> `SO_REUSEPORT`.
74511    SetReusePort {
74512        value: bool,
74513        responder: SynchronousDatagramSocketSetReusePortResponder,
74514    },
74515    /// Get `SOL_SOCKET` -> `SO_REUSEPORT`.
74516    GetReusePort {
74517        responder: SynchronousDatagramSocketGetReusePortResponder,
74518    },
74519    /// Get `SOL_SOCKET` -> `SO_ACCEPTCONN`.
74520    GetAcceptConn {
74521        responder: SynchronousDatagramSocketGetAcceptConnResponder,
74522    },
74523    /// Set `SOL_SOCKET` -> `SO_BINDTODEVICE`.
74524    SetBindToDevice {
74525        value: String,
74526        responder: SynchronousDatagramSocketSetBindToDeviceResponder,
74527    },
74528    /// Get `SOL_SOCKET` -> `SO_BINDTODEVICE`.
74529    GetBindToDevice {
74530        responder: SynchronousDatagramSocketGetBindToDeviceResponder,
74531    },
74532    /// Set `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
74533    /// If `value` is 0, this clears the bound interface.
74534    SetBindToInterfaceIndex {
74535        value: u64,
74536        responder: SynchronousDatagramSocketSetBindToInterfaceIndexResponder,
74537    },
74538    /// Get `SOL_SOCKET` -> `SO_BINDTOIFINDEX`.
74539    GetBindToInterfaceIndex {
74540        responder: SynchronousDatagramSocketGetBindToInterfaceIndexResponder,
74541    },
74542    /// Set `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
74543    SetTimestamp {
74544        value: TimestampOption,
74545        responder: SynchronousDatagramSocketSetTimestampResponder,
74546    },
74547    /// Get `SOL_SOCKET` -> `SO_TIMESTAMP` or `SO_TIMESTAMPNS`.
74548    GetTimestamp {
74549        responder: SynchronousDatagramSocketGetTimestampResponder,
74550    },
74551    /// Like setting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
74552    /// unlike the standard SO_MARK, this API has multiple mark domains and each
74553    /// mark can be set independently in each domain.
74554    SetMark {
74555        domain: fidl_fuchsia_net::MarkDomain,
74556        mark: OptionalUint32,
74557        responder: SynchronousDatagramSocketSetMarkResponder,
74558    },
74559    /// Like getting `SOL_SOCKET` -> `SO_MARK`. The major difference is that
74560    /// unlike the standard SO_MARK, this API has multiple mark domains and each
74561    /// mark can be retrieved independently in each domain.
74562    GetMark {
74563        domain: fidl_fuchsia_net::MarkDomain,
74564        responder: SynchronousDatagramSocketGetMarkResponder,
74565    },
74566    /// Sets the local address used for the socket.
74567    Bind {
74568        addr: fidl_fuchsia_net::SocketAddress,
74569        responder: SynchronousDatagramSocketBindResponder,
74570    },
74571    /// Initiates a connection to a remote address.
74572    Connect {
74573        addr: fidl_fuchsia_net::SocketAddress,
74574        responder: SynchronousDatagramSocketConnectResponder,
74575    },
74576    /// Clears connection information from this socket.
74577    Disconnect {
74578        responder: SynchronousDatagramSocketDisconnectResponder,
74579    },
74580    /// Retrieves the local socket address.
74581    GetSockName {
74582        responder: SynchronousDatagramSocketGetSockNameResponder,
74583    },
74584    /// Retrieves the remote socket address.
74585    GetPeerName {
74586        responder: SynchronousDatagramSocketGetPeerNameResponder,
74587    },
74588    /// Shuts down part of the socket.
74589    Shutdown {
74590        mode: ShutdownMode,
74591        responder: SynchronousDatagramSocketShutdownResponder,
74592    },
74593    /// Set `SOL_IP` -> `IP_TOS`.
74594    SetIpTypeOfService {
74595        value: u8,
74596        responder: SynchronousDatagramSocketSetIpTypeOfServiceResponder,
74597    },
74598    /// Get `SOL_IP` -> `IP_TOS`.
74599    GetIpTypeOfService {
74600        responder: SynchronousDatagramSocketGetIpTypeOfServiceResponder,
74601    },
74602    /// Set `SOL_IP` -> `IP_TTL`.
74603    SetIpTtl {
74604        value: OptionalUint8,
74605        responder: SynchronousDatagramSocketSetIpTtlResponder,
74606    },
74607    /// Get `SOL_IP` -> `IP_TTL`.
74608    GetIpTtl {
74609        responder: SynchronousDatagramSocketGetIpTtlResponder,
74610    },
74611    /// Set `SOL_IP` -> `IP_PKTINFO`.
74612    SetIpPacketInfo {
74613        value: bool,
74614        responder: SynchronousDatagramSocketSetIpPacketInfoResponder,
74615    },
74616    /// Get `SOL_IP` -> `IP_PKTINFO`.
74617    GetIpPacketInfo {
74618        responder: SynchronousDatagramSocketGetIpPacketInfoResponder,
74619    },
74620    /// Set `SOL_IP` -> `IP_RECVTOS`.
74621    SetIpReceiveTypeOfService {
74622        value: bool,
74623        responder: SynchronousDatagramSocketSetIpReceiveTypeOfServiceResponder,
74624    },
74625    /// Get `SOL_IP` -> `IP_RECVTOS`.
74626    GetIpReceiveTypeOfService {
74627        responder: SynchronousDatagramSocketGetIpReceiveTypeOfServiceResponder,
74628    },
74629    /// Set `SOL_IP` -> `IP_RECVTTL`.
74630    SetIpReceiveTtl {
74631        value: bool,
74632        responder: SynchronousDatagramSocketSetIpReceiveTtlResponder,
74633    },
74634    /// Get `SOL_IP` -> `IP_RECVTTL`.
74635    GetIpReceiveTtl {
74636        responder: SynchronousDatagramSocketGetIpReceiveTtlResponder,
74637    },
74638    /// Set `SOL_IP` -> `IP_MULTICAST_IF`.
74639    SetIpMulticastInterface {
74640        iface: u64,
74641        address: fidl_fuchsia_net::Ipv4Address,
74642        responder: SynchronousDatagramSocketSetIpMulticastInterfaceResponder,
74643    },
74644    /// Get `SOL_IP` -> `IP_MULTICAST_IF`.
74645    GetIpMulticastInterface {
74646        responder: SynchronousDatagramSocketGetIpMulticastInterfaceResponder,
74647    },
74648    /// Set `SOL_IP` -> `IP_MULTICAST_TTL`.
74649    SetIpMulticastTtl {
74650        value: OptionalUint8,
74651        responder: SynchronousDatagramSocketSetIpMulticastTtlResponder,
74652    },
74653    /// Get `SOL_IP` -> `IP_MULTICAST_TTL`.
74654    GetIpMulticastTtl {
74655        responder: SynchronousDatagramSocketGetIpMulticastTtlResponder,
74656    },
74657    /// Set `SOL_IP` -> `IP_MULTICAST_LOOP`.
74658    SetIpMulticastLoopback {
74659        value: bool,
74660        responder: SynchronousDatagramSocketSetIpMulticastLoopbackResponder,
74661    },
74662    /// Get `SOL_IP` -> `IP_MULTICAST_LOOP`.
74663    GetIpMulticastLoopback {
74664        responder: SynchronousDatagramSocketGetIpMulticastLoopbackResponder,
74665    },
74666    /// Set `SOL_IP` -> `IP_ADD_MEMBERSHIP`
74667    AddIpMembership {
74668        membership: IpMulticastMembership,
74669        responder: SynchronousDatagramSocketAddIpMembershipResponder,
74670    },
74671    /// Set `SOL_IP` -> `IP_DROP_MEMBERSHIP`
74672    DropIpMembership {
74673        membership: IpMulticastMembership,
74674        responder: SynchronousDatagramSocketDropIpMembershipResponder,
74675    },
74676    /// Set `SOL_IP` -> `IP_TRANSPARENT`
74677    SetIpTransparent {
74678        value: bool,
74679        responder: SynchronousDatagramSocketSetIpTransparentResponder,
74680    },
74681    /// Get `SOL_IP` -> `IP_TRANSPARENT`
74682    GetIpTransparent {
74683        responder: SynchronousDatagramSocketGetIpTransparentResponder,
74684    },
74685    /// Set `SOL_IP` -> `IP_RECVORIGDSTADDR`
74686    SetIpReceiveOriginalDestinationAddress {
74687        value: bool,
74688        responder: SynchronousDatagramSocketSetIpReceiveOriginalDestinationAddressResponder,
74689    },
74690    /// Get `SOL_IP` -> `IP_RECVORIGDSTADDR`
74691    GetIpReceiveOriginalDestinationAddress {
74692        responder: SynchronousDatagramSocketGetIpReceiveOriginalDestinationAddressResponder,
74693    },
74694    /// Set `SOL_IPV6` -> `IPV6_ADD_MEMBERSHIP`.
74695    AddIpv6Membership {
74696        membership: Ipv6MulticastMembership,
74697        responder: SynchronousDatagramSocketAddIpv6MembershipResponder,
74698    },
74699    /// Set `SOL_IPV6` -> `IPV6_DROP_MEMBERSHIP`.
74700    DropIpv6Membership {
74701        membership: Ipv6MulticastMembership,
74702        responder: SynchronousDatagramSocketDropIpv6MembershipResponder,
74703    },
74704    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
74705    SetIpv6MulticastInterface {
74706        value: u64,
74707        responder: SynchronousDatagramSocketSetIpv6MulticastInterfaceResponder,
74708    },
74709    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_IF`.
74710    GetIpv6MulticastInterface {
74711        responder: SynchronousDatagramSocketGetIpv6MulticastInterfaceResponder,
74712    },
74713    /// Set `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
74714    SetIpv6UnicastHops {
74715        value: OptionalUint8,
74716        responder: SynchronousDatagramSocketSetIpv6UnicastHopsResponder,
74717    },
74718    /// Get `SOL_IPV6` -> `IPV6_UNICAST_HOPS`.
74719    GetIpv6UnicastHops {
74720        responder: SynchronousDatagramSocketGetIpv6UnicastHopsResponder,
74721    },
74722    /// Set `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
74723    SetIpv6ReceiveHopLimit {
74724        value: bool,
74725        responder: SynchronousDatagramSocketSetIpv6ReceiveHopLimitResponder,
74726    },
74727    /// Get `SOL_IPV6` -> `IPV6_RECVHOPLIMIT`.
74728    GetIpv6ReceiveHopLimit {
74729        responder: SynchronousDatagramSocketGetIpv6ReceiveHopLimitResponder,
74730    },
74731    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
74732    SetIpv6MulticastHops {
74733        value: OptionalUint8,
74734        responder: SynchronousDatagramSocketSetIpv6MulticastHopsResponder,
74735    },
74736    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_HOPS`.
74737    GetIpv6MulticastHops {
74738        responder: SynchronousDatagramSocketGetIpv6MulticastHopsResponder,
74739    },
74740    /// Set `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
74741    SetIpv6MulticastLoopback {
74742        value: bool,
74743        responder: SynchronousDatagramSocketSetIpv6MulticastLoopbackResponder,
74744    },
74745    /// Get `SOL_IPV6` -> `IPV6_MULTICAST_LOOP`.
74746    GetIpv6MulticastLoopback {
74747        responder: SynchronousDatagramSocketGetIpv6MulticastLoopbackResponder,
74748    },
74749    /// Set `SOL_IPV6` -> `IPV6_V6ONLY`.
74750    SetIpv6Only {
74751        value: bool,
74752        responder: SynchronousDatagramSocketSetIpv6OnlyResponder,
74753    },
74754    /// Get `SOL_IPV6` -> `IPV6_V6ONLY`.
74755    GetIpv6Only {
74756        responder: SynchronousDatagramSocketGetIpv6OnlyResponder,
74757    },
74758    /// Set `SOL_IPV6` -> `IPV6_RECVTCLASS`.
74759    SetIpv6ReceiveTrafficClass {
74760        value: bool,
74761        responder: SynchronousDatagramSocketSetIpv6ReceiveTrafficClassResponder,
74762    },
74763    /// Get `SOL_IPV6` -> `IPV6_RECVTCLASS`.
74764    GetIpv6ReceiveTrafficClass {
74765        responder: SynchronousDatagramSocketGetIpv6ReceiveTrafficClassResponder,
74766    },
74767    /// Set `SOL_IPV6` -> `IPV6_TCLASS`
74768    SetIpv6TrafficClass {
74769        value: OptionalUint8,
74770        responder: SynchronousDatagramSocketSetIpv6TrafficClassResponder,
74771    },
74772    /// Get `SOL_IPV6` -> `IPV6_TCLASS`.
74773    GetIpv6TrafficClass {
74774        responder: SynchronousDatagramSocketGetIpv6TrafficClassResponder,
74775    },
74776    /// Set `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
74777    SetIpv6ReceivePacketInfo {
74778        value: bool,
74779        responder: SynchronousDatagramSocketSetIpv6ReceivePacketInfoResponder,
74780    },
74781    /// Get `SOL_IPV6` -> `IPV6_RECVPKTINFO`.
74782    GetIpv6ReceivePacketInfo {
74783        responder: SynchronousDatagramSocketGetIpv6ReceivePacketInfoResponder,
74784    },
74785    /// Get `SOL_IP` -> `SO_ORIGINAL_DST`.
74786    GetOriginalDestination {
74787        responder: SynchronousDatagramSocketGetOriginalDestinationResponder,
74788    },
74789    /// Retrieves creation information from the socket.
74790    ///
74791    /// - response `domain` the socket's associated domain.
74792    /// - response `proto` the socket's associated protocol.
74793    GetInfo {
74794        responder: SynchronousDatagramSocketGetInfoResponder,
74795    },
74796    Describe {
74797        responder: SynchronousDatagramSocketDescribeResponder,
74798    },
74799    /// Receives a message from the socket.
74800    ///
74801    /// + request `want_addr` request message's source address information to
74802    ///   be returned.
74803    /// + request `data_len` the maximum allowed length of the response data
74804    ///   buffer.
74805    /// + request `want_control` request ancillary data to be returned.
74806    /// + request `flags` flags for the receive request.
74807    /// - response `addr` the message's source address information, if
74808    ///   requested.
74809    /// - response `data` the message.
74810    /// - response `control` control messages, if requested.
74811    /// - response `truncated` indicates whether or not the returned message
74812    ///   was truncated.
74813    RecvMsg {
74814        want_addr: bool,
74815        data_len: u32,
74816        want_control: bool,
74817        flags: RecvMsgFlags,
74818        responder: SynchronousDatagramSocketRecvMsgResponder,
74819    },
74820    /// Sends a message on the socket.
74821    ///
74822    /// + request `addr` the address to send the message to. If unset, will send
74823    ///   to the connected peer.
74824    /// + request `data` the message.
74825    /// + request `control` ancillary data.
74826    /// + request `flags` flags for the send request.
74827    /// - response `len` the number of bytes sent.
74828    SendMsg {
74829        addr: Option<Box<fidl_fuchsia_net::SocketAddress>>,
74830        data: Vec<u8>,
74831        control: DatagramSocketSendControlData,
74832        flags: SendMsgFlags,
74833        responder: SynchronousDatagramSocketSendMsgResponder,
74834    },
74835}
74836
74837impl SynchronousDatagramSocketRequest {
74838    #[allow(irrefutable_let_patterns)]
74839    pub fn into_clone(
74840        self,
74841    ) -> Option<(
74842        fidl::endpoints::ServerEnd<fidl_fuchsia_unknown::CloneableMarker>,
74843        SynchronousDatagramSocketControlHandle,
74844    )> {
74845        if let SynchronousDatagramSocketRequest::Clone { request, control_handle } = self {
74846            Some((request, control_handle))
74847        } else {
74848            None
74849        }
74850    }
74851
74852    #[allow(irrefutable_let_patterns)]
74853    pub fn into_close(self) -> Option<(SynchronousDatagramSocketCloseResponder)> {
74854        if let SynchronousDatagramSocketRequest::Close { responder } = self {
74855            Some((responder))
74856        } else {
74857            None
74858        }
74859    }
74860
74861    #[allow(irrefutable_let_patterns)]
74862    pub fn into_query(self) -> Option<(SynchronousDatagramSocketQueryResponder)> {
74863        if let SynchronousDatagramSocketRequest::Query { responder } = self {
74864            Some((responder))
74865        } else {
74866            None
74867        }
74868    }
74869
74870    #[allow(irrefutable_let_patterns)]
74871    pub fn into_set_reuse_address(
74872        self,
74873    ) -> Option<(bool, SynchronousDatagramSocketSetReuseAddressResponder)> {
74874        if let SynchronousDatagramSocketRequest::SetReuseAddress { value, responder } = self {
74875            Some((value, responder))
74876        } else {
74877            None
74878        }
74879    }
74880
74881    #[allow(irrefutable_let_patterns)]
74882    pub fn into_get_reuse_address(
74883        self,
74884    ) -> Option<(SynchronousDatagramSocketGetReuseAddressResponder)> {
74885        if let SynchronousDatagramSocketRequest::GetReuseAddress { responder } = self {
74886            Some((responder))
74887        } else {
74888            None
74889        }
74890    }
74891
74892    #[allow(irrefutable_let_patterns)]
74893    pub fn into_get_error(self) -> Option<(SynchronousDatagramSocketGetErrorResponder)> {
74894        if let SynchronousDatagramSocketRequest::GetError { responder } = self {
74895            Some((responder))
74896        } else {
74897            None
74898        }
74899    }
74900
74901    #[allow(irrefutable_let_patterns)]
74902    pub fn into_set_broadcast(
74903        self,
74904    ) -> Option<(bool, SynchronousDatagramSocketSetBroadcastResponder)> {
74905        if let SynchronousDatagramSocketRequest::SetBroadcast { value, responder } = self {
74906            Some((value, responder))
74907        } else {
74908            None
74909        }
74910    }
74911
74912    #[allow(irrefutable_let_patterns)]
74913    pub fn into_get_broadcast(self) -> Option<(SynchronousDatagramSocketGetBroadcastResponder)> {
74914        if let SynchronousDatagramSocketRequest::GetBroadcast { responder } = self {
74915            Some((responder))
74916        } else {
74917            None
74918        }
74919    }
74920
74921    #[allow(irrefutable_let_patterns)]
74922    pub fn into_set_send_buffer(
74923        self,
74924    ) -> Option<(u64, SynchronousDatagramSocketSetSendBufferResponder)> {
74925        if let SynchronousDatagramSocketRequest::SetSendBuffer { value_bytes, responder } = self {
74926            Some((value_bytes, responder))
74927        } else {
74928            None
74929        }
74930    }
74931
74932    #[allow(irrefutable_let_patterns)]
74933    pub fn into_get_send_buffer(self) -> Option<(SynchronousDatagramSocketGetSendBufferResponder)> {
74934        if let SynchronousDatagramSocketRequest::GetSendBuffer { responder } = self {
74935            Some((responder))
74936        } else {
74937            None
74938        }
74939    }
74940
74941    #[allow(irrefutable_let_patterns)]
74942    pub fn into_set_receive_buffer(
74943        self,
74944    ) -> Option<(u64, SynchronousDatagramSocketSetReceiveBufferResponder)> {
74945        if let SynchronousDatagramSocketRequest::SetReceiveBuffer { value_bytes, responder } = self
74946        {
74947            Some((value_bytes, responder))
74948        } else {
74949            None
74950        }
74951    }
74952
74953    #[allow(irrefutable_let_patterns)]
74954    pub fn into_get_receive_buffer(
74955        self,
74956    ) -> Option<(SynchronousDatagramSocketGetReceiveBufferResponder)> {
74957        if let SynchronousDatagramSocketRequest::GetReceiveBuffer { responder } = self {
74958            Some((responder))
74959        } else {
74960            None
74961        }
74962    }
74963
74964    #[allow(irrefutable_let_patterns)]
74965    pub fn into_set_keep_alive(
74966        self,
74967    ) -> Option<(bool, SynchronousDatagramSocketSetKeepAliveResponder)> {
74968        if let SynchronousDatagramSocketRequest::SetKeepAlive { value, responder } = self {
74969            Some((value, responder))
74970        } else {
74971            None
74972        }
74973    }
74974
74975    #[allow(irrefutable_let_patterns)]
74976    pub fn into_get_keep_alive(self) -> Option<(SynchronousDatagramSocketGetKeepAliveResponder)> {
74977        if let SynchronousDatagramSocketRequest::GetKeepAlive { responder } = self {
74978            Some((responder))
74979        } else {
74980            None
74981        }
74982    }
74983
74984    #[allow(irrefutable_let_patterns)]
74985    pub fn into_set_out_of_band_inline(
74986        self,
74987    ) -> Option<(bool, SynchronousDatagramSocketSetOutOfBandInlineResponder)> {
74988        if let SynchronousDatagramSocketRequest::SetOutOfBandInline { value, responder } = self {
74989            Some((value, responder))
74990        } else {
74991            None
74992        }
74993    }
74994
74995    #[allow(irrefutable_let_patterns)]
74996    pub fn into_get_out_of_band_inline(
74997        self,
74998    ) -> Option<(SynchronousDatagramSocketGetOutOfBandInlineResponder)> {
74999        if let SynchronousDatagramSocketRequest::GetOutOfBandInline { responder } = self {
75000            Some((responder))
75001        } else {
75002            None
75003        }
75004    }
75005
75006    #[allow(irrefutable_let_patterns)]
75007    pub fn into_set_no_check(self) -> Option<(bool, SynchronousDatagramSocketSetNoCheckResponder)> {
75008        if let SynchronousDatagramSocketRequest::SetNoCheck { value, responder } = self {
75009            Some((value, responder))
75010        } else {
75011            None
75012        }
75013    }
75014
75015    #[allow(irrefutable_let_patterns)]
75016    pub fn into_get_no_check(self) -> Option<(SynchronousDatagramSocketGetNoCheckResponder)> {
75017        if let SynchronousDatagramSocketRequest::GetNoCheck { responder } = self {
75018            Some((responder))
75019        } else {
75020            None
75021        }
75022    }
75023
75024    #[allow(irrefutable_let_patterns)]
75025    pub fn into_set_linger(
75026        self,
75027    ) -> Option<(bool, u32, SynchronousDatagramSocketSetLingerResponder)> {
75028        if let SynchronousDatagramSocketRequest::SetLinger { linger, length_secs, responder } = self
75029        {
75030            Some((linger, length_secs, responder))
75031        } else {
75032            None
75033        }
75034    }
75035
75036    #[allow(irrefutable_let_patterns)]
75037    pub fn into_get_linger(self) -> Option<(SynchronousDatagramSocketGetLingerResponder)> {
75038        if let SynchronousDatagramSocketRequest::GetLinger { responder } = self {
75039            Some((responder))
75040        } else {
75041            None
75042        }
75043    }
75044
75045    #[allow(irrefutable_let_patterns)]
75046    pub fn into_set_reuse_port(
75047        self,
75048    ) -> Option<(bool, SynchronousDatagramSocketSetReusePortResponder)> {
75049        if let SynchronousDatagramSocketRequest::SetReusePort { value, responder } = self {
75050            Some((value, responder))
75051        } else {
75052            None
75053        }
75054    }
75055
75056    #[allow(irrefutable_let_patterns)]
75057    pub fn into_get_reuse_port(self) -> Option<(SynchronousDatagramSocketGetReusePortResponder)> {
75058        if let SynchronousDatagramSocketRequest::GetReusePort { responder } = self {
75059            Some((responder))
75060        } else {
75061            None
75062        }
75063    }
75064
75065    #[allow(irrefutable_let_patterns)]
75066    pub fn into_get_accept_conn(self) -> Option<(SynchronousDatagramSocketGetAcceptConnResponder)> {
75067        if let SynchronousDatagramSocketRequest::GetAcceptConn { responder } = self {
75068            Some((responder))
75069        } else {
75070            None
75071        }
75072    }
75073
75074    #[allow(irrefutable_let_patterns)]
75075    pub fn into_set_bind_to_device(
75076        self,
75077    ) -> Option<(String, SynchronousDatagramSocketSetBindToDeviceResponder)> {
75078        if let SynchronousDatagramSocketRequest::SetBindToDevice { value, responder } = self {
75079            Some((value, responder))
75080        } else {
75081            None
75082        }
75083    }
75084
75085    #[allow(irrefutable_let_patterns)]
75086    pub fn into_get_bind_to_device(
75087        self,
75088    ) -> Option<(SynchronousDatagramSocketGetBindToDeviceResponder)> {
75089        if let SynchronousDatagramSocketRequest::GetBindToDevice { responder } = self {
75090            Some((responder))
75091        } else {
75092            None
75093        }
75094    }
75095
75096    #[allow(irrefutable_let_patterns)]
75097    pub fn into_set_bind_to_interface_index(
75098        self,
75099    ) -> Option<(u64, SynchronousDatagramSocketSetBindToInterfaceIndexResponder)> {
75100        if let SynchronousDatagramSocketRequest::SetBindToInterfaceIndex { value, responder } = self
75101        {
75102            Some((value, responder))
75103        } else {
75104            None
75105        }
75106    }
75107
75108    #[allow(irrefutable_let_patterns)]
75109    pub fn into_get_bind_to_interface_index(
75110        self,
75111    ) -> Option<(SynchronousDatagramSocketGetBindToInterfaceIndexResponder)> {
75112        if let SynchronousDatagramSocketRequest::GetBindToInterfaceIndex { responder } = self {
75113            Some((responder))
75114        } else {
75115            None
75116        }
75117    }
75118
75119    #[allow(irrefutable_let_patterns)]
75120    pub fn into_set_timestamp(
75121        self,
75122    ) -> Option<(TimestampOption, SynchronousDatagramSocketSetTimestampResponder)> {
75123        if let SynchronousDatagramSocketRequest::SetTimestamp { value, responder } = self {
75124            Some((value, responder))
75125        } else {
75126            None
75127        }
75128    }
75129
75130    #[allow(irrefutable_let_patterns)]
75131    pub fn into_get_timestamp(self) -> Option<(SynchronousDatagramSocketGetTimestampResponder)> {
75132        if let SynchronousDatagramSocketRequest::GetTimestamp { responder } = self {
75133            Some((responder))
75134        } else {
75135            None
75136        }
75137    }
75138
75139    #[allow(irrefutable_let_patterns)]
75140    pub fn into_set_mark(
75141        self,
75142    ) -> Option<(
75143        fidl_fuchsia_net::MarkDomain,
75144        OptionalUint32,
75145        SynchronousDatagramSocketSetMarkResponder,
75146    )> {
75147        if let SynchronousDatagramSocketRequest::SetMark { domain, mark, responder } = self {
75148            Some((domain, mark, responder))
75149        } else {
75150            None
75151        }
75152    }
75153
75154    #[allow(irrefutable_let_patterns)]
75155    pub fn into_get_mark(
75156        self,
75157    ) -> Option<(fidl_fuchsia_net::MarkDomain, SynchronousDatagramSocketGetMarkResponder)> {
75158        if let SynchronousDatagramSocketRequest::GetMark { domain, responder } = self {
75159            Some((domain, responder))
75160        } else {
75161            None
75162        }
75163    }
75164
75165    #[allow(irrefutable_let_patterns)]
75166    pub fn into_bind(
75167        self,
75168    ) -> Option<(fidl_fuchsia_net::SocketAddress, SynchronousDatagramSocketBindResponder)> {
75169        if let SynchronousDatagramSocketRequest::Bind { addr, responder } = self {
75170            Some((addr, responder))
75171        } else {
75172            None
75173        }
75174    }
75175
75176    #[allow(irrefutable_let_patterns)]
75177    pub fn into_connect(
75178        self,
75179    ) -> Option<(fidl_fuchsia_net::SocketAddress, SynchronousDatagramSocketConnectResponder)> {
75180        if let SynchronousDatagramSocketRequest::Connect { addr, responder } = self {
75181            Some((addr, responder))
75182        } else {
75183            None
75184        }
75185    }
75186
75187    #[allow(irrefutable_let_patterns)]
75188    pub fn into_disconnect(self) -> Option<(SynchronousDatagramSocketDisconnectResponder)> {
75189        if let SynchronousDatagramSocketRequest::Disconnect { responder } = self {
75190            Some((responder))
75191        } else {
75192            None
75193        }
75194    }
75195
75196    #[allow(irrefutable_let_patterns)]
75197    pub fn into_get_sock_name(self) -> Option<(SynchronousDatagramSocketGetSockNameResponder)> {
75198        if let SynchronousDatagramSocketRequest::GetSockName { responder } = self {
75199            Some((responder))
75200        } else {
75201            None
75202        }
75203    }
75204
75205    #[allow(irrefutable_let_patterns)]
75206    pub fn into_get_peer_name(self) -> Option<(SynchronousDatagramSocketGetPeerNameResponder)> {
75207        if let SynchronousDatagramSocketRequest::GetPeerName { responder } = self {
75208            Some((responder))
75209        } else {
75210            None
75211        }
75212    }
75213
75214    #[allow(irrefutable_let_patterns)]
75215    pub fn into_shutdown(
75216        self,
75217    ) -> Option<(ShutdownMode, SynchronousDatagramSocketShutdownResponder)> {
75218        if let SynchronousDatagramSocketRequest::Shutdown { mode, responder } = self {
75219            Some((mode, responder))
75220        } else {
75221            None
75222        }
75223    }
75224
75225    #[allow(irrefutable_let_patterns)]
75226    pub fn into_set_ip_type_of_service(
75227        self,
75228    ) -> Option<(u8, SynchronousDatagramSocketSetIpTypeOfServiceResponder)> {
75229        if let SynchronousDatagramSocketRequest::SetIpTypeOfService { value, responder } = self {
75230            Some((value, responder))
75231        } else {
75232            None
75233        }
75234    }
75235
75236    #[allow(irrefutable_let_patterns)]
75237    pub fn into_get_ip_type_of_service(
75238        self,
75239    ) -> Option<(SynchronousDatagramSocketGetIpTypeOfServiceResponder)> {
75240        if let SynchronousDatagramSocketRequest::GetIpTypeOfService { responder } = self {
75241            Some((responder))
75242        } else {
75243            None
75244        }
75245    }
75246
75247    #[allow(irrefutable_let_patterns)]
75248    pub fn into_set_ip_ttl(
75249        self,
75250    ) -> Option<(OptionalUint8, SynchronousDatagramSocketSetIpTtlResponder)> {
75251        if let SynchronousDatagramSocketRequest::SetIpTtl { value, responder } = self {
75252            Some((value, responder))
75253        } else {
75254            None
75255        }
75256    }
75257
75258    #[allow(irrefutable_let_patterns)]
75259    pub fn into_get_ip_ttl(self) -> Option<(SynchronousDatagramSocketGetIpTtlResponder)> {
75260        if let SynchronousDatagramSocketRequest::GetIpTtl { responder } = self {
75261            Some((responder))
75262        } else {
75263            None
75264        }
75265    }
75266
75267    #[allow(irrefutable_let_patterns)]
75268    pub fn into_set_ip_packet_info(
75269        self,
75270    ) -> Option<(bool, SynchronousDatagramSocketSetIpPacketInfoResponder)> {
75271        if let SynchronousDatagramSocketRequest::SetIpPacketInfo { value, responder } = self {
75272            Some((value, responder))
75273        } else {
75274            None
75275        }
75276    }
75277
75278    #[allow(irrefutable_let_patterns)]
75279    pub fn into_get_ip_packet_info(
75280        self,
75281    ) -> Option<(SynchronousDatagramSocketGetIpPacketInfoResponder)> {
75282        if let SynchronousDatagramSocketRequest::GetIpPacketInfo { responder } = self {
75283            Some((responder))
75284        } else {
75285            None
75286        }
75287    }
75288
75289    #[allow(irrefutable_let_patterns)]
75290    pub fn into_set_ip_receive_type_of_service(
75291        self,
75292    ) -> Option<(bool, SynchronousDatagramSocketSetIpReceiveTypeOfServiceResponder)> {
75293        if let SynchronousDatagramSocketRequest::SetIpReceiveTypeOfService { value, responder } =
75294            self
75295        {
75296            Some((value, responder))
75297        } else {
75298            None
75299        }
75300    }
75301
75302    #[allow(irrefutable_let_patterns)]
75303    pub fn into_get_ip_receive_type_of_service(
75304        self,
75305    ) -> Option<(SynchronousDatagramSocketGetIpReceiveTypeOfServiceResponder)> {
75306        if let SynchronousDatagramSocketRequest::GetIpReceiveTypeOfService { responder } = self {
75307            Some((responder))
75308        } else {
75309            None
75310        }
75311    }
75312
75313    #[allow(irrefutable_let_patterns)]
75314    pub fn into_set_ip_receive_ttl(
75315        self,
75316    ) -> Option<(bool, SynchronousDatagramSocketSetIpReceiveTtlResponder)> {
75317        if let SynchronousDatagramSocketRequest::SetIpReceiveTtl { value, responder } = self {
75318            Some((value, responder))
75319        } else {
75320            None
75321        }
75322    }
75323
75324    #[allow(irrefutable_let_patterns)]
75325    pub fn into_get_ip_receive_ttl(
75326        self,
75327    ) -> Option<(SynchronousDatagramSocketGetIpReceiveTtlResponder)> {
75328        if let SynchronousDatagramSocketRequest::GetIpReceiveTtl { responder } = self {
75329            Some((responder))
75330        } else {
75331            None
75332        }
75333    }
75334
75335    #[allow(irrefutable_let_patterns)]
75336    pub fn into_set_ip_multicast_interface(
75337        self,
75338    ) -> Option<(
75339        u64,
75340        fidl_fuchsia_net::Ipv4Address,
75341        SynchronousDatagramSocketSetIpMulticastInterfaceResponder,
75342    )> {
75343        if let SynchronousDatagramSocketRequest::SetIpMulticastInterface {
75344            iface,
75345            address,
75346            responder,
75347        } = self
75348        {
75349            Some((iface, address, responder))
75350        } else {
75351            None
75352        }
75353    }
75354
75355    #[allow(irrefutable_let_patterns)]
75356    pub fn into_get_ip_multicast_interface(
75357        self,
75358    ) -> Option<(SynchronousDatagramSocketGetIpMulticastInterfaceResponder)> {
75359        if let SynchronousDatagramSocketRequest::GetIpMulticastInterface { responder } = self {
75360            Some((responder))
75361        } else {
75362            None
75363        }
75364    }
75365
75366    #[allow(irrefutable_let_patterns)]
75367    pub fn into_set_ip_multicast_ttl(
75368        self,
75369    ) -> Option<(OptionalUint8, SynchronousDatagramSocketSetIpMulticastTtlResponder)> {
75370        if let SynchronousDatagramSocketRequest::SetIpMulticastTtl { value, responder } = self {
75371            Some((value, responder))
75372        } else {
75373            None
75374        }
75375    }
75376
75377    #[allow(irrefutable_let_patterns)]
75378    pub fn into_get_ip_multicast_ttl(
75379        self,
75380    ) -> Option<(SynchronousDatagramSocketGetIpMulticastTtlResponder)> {
75381        if let SynchronousDatagramSocketRequest::GetIpMulticastTtl { responder } = self {
75382            Some((responder))
75383        } else {
75384            None
75385        }
75386    }
75387
75388    #[allow(irrefutable_let_patterns)]
75389    pub fn into_set_ip_multicast_loopback(
75390        self,
75391    ) -> Option<(bool, SynchronousDatagramSocketSetIpMulticastLoopbackResponder)> {
75392        if let SynchronousDatagramSocketRequest::SetIpMulticastLoopback { value, responder } = self
75393        {
75394            Some((value, responder))
75395        } else {
75396            None
75397        }
75398    }
75399
75400    #[allow(irrefutable_let_patterns)]
75401    pub fn into_get_ip_multicast_loopback(
75402        self,
75403    ) -> Option<(SynchronousDatagramSocketGetIpMulticastLoopbackResponder)> {
75404        if let SynchronousDatagramSocketRequest::GetIpMulticastLoopback { responder } = self {
75405            Some((responder))
75406        } else {
75407            None
75408        }
75409    }
75410
75411    #[allow(irrefutable_let_patterns)]
75412    pub fn into_add_ip_membership(
75413        self,
75414    ) -> Option<(IpMulticastMembership, SynchronousDatagramSocketAddIpMembershipResponder)> {
75415        if let SynchronousDatagramSocketRequest::AddIpMembership { membership, responder } = self {
75416            Some((membership, responder))
75417        } else {
75418            None
75419        }
75420    }
75421
75422    #[allow(irrefutable_let_patterns)]
75423    pub fn into_drop_ip_membership(
75424        self,
75425    ) -> Option<(IpMulticastMembership, SynchronousDatagramSocketDropIpMembershipResponder)> {
75426        if let SynchronousDatagramSocketRequest::DropIpMembership { membership, responder } = self {
75427            Some((membership, responder))
75428        } else {
75429            None
75430        }
75431    }
75432
75433    #[allow(irrefutable_let_patterns)]
75434    pub fn into_set_ip_transparent(
75435        self,
75436    ) -> Option<(bool, SynchronousDatagramSocketSetIpTransparentResponder)> {
75437        if let SynchronousDatagramSocketRequest::SetIpTransparent { value, responder } = self {
75438            Some((value, responder))
75439        } else {
75440            None
75441        }
75442    }
75443
75444    #[allow(irrefutable_let_patterns)]
75445    pub fn into_get_ip_transparent(
75446        self,
75447    ) -> Option<(SynchronousDatagramSocketGetIpTransparentResponder)> {
75448        if let SynchronousDatagramSocketRequest::GetIpTransparent { responder } = self {
75449            Some((responder))
75450        } else {
75451            None
75452        }
75453    }
75454
75455    #[allow(irrefutable_let_patterns)]
75456    pub fn into_set_ip_receive_original_destination_address(
75457        self,
75458    ) -> Option<(bool, SynchronousDatagramSocketSetIpReceiveOriginalDestinationAddressResponder)>
75459    {
75460        if let SynchronousDatagramSocketRequest::SetIpReceiveOriginalDestinationAddress {
75461            value,
75462            responder,
75463        } = self
75464        {
75465            Some((value, responder))
75466        } else {
75467            None
75468        }
75469    }
75470
75471    #[allow(irrefutable_let_patterns)]
75472    pub fn into_get_ip_receive_original_destination_address(
75473        self,
75474    ) -> Option<(SynchronousDatagramSocketGetIpReceiveOriginalDestinationAddressResponder)> {
75475        if let SynchronousDatagramSocketRequest::GetIpReceiveOriginalDestinationAddress {
75476            responder,
75477        } = self
75478        {
75479            Some((responder))
75480        } else {
75481            None
75482        }
75483    }
75484
75485    #[allow(irrefutable_let_patterns)]
75486    pub fn into_add_ipv6_membership(
75487        self,
75488    ) -> Option<(Ipv6MulticastMembership, SynchronousDatagramSocketAddIpv6MembershipResponder)>
75489    {
75490        if let SynchronousDatagramSocketRequest::AddIpv6Membership { membership, responder } = self
75491        {
75492            Some((membership, responder))
75493        } else {
75494            None
75495        }
75496    }
75497
75498    #[allow(irrefutable_let_patterns)]
75499    pub fn into_drop_ipv6_membership(
75500        self,
75501    ) -> Option<(Ipv6MulticastMembership, SynchronousDatagramSocketDropIpv6MembershipResponder)>
75502    {
75503        if let SynchronousDatagramSocketRequest::DropIpv6Membership { membership, responder } = self
75504        {
75505            Some((membership, responder))
75506        } else {
75507            None
75508        }
75509    }
75510
75511    #[allow(irrefutable_let_patterns)]
75512    pub fn into_set_ipv6_multicast_interface(
75513        self,
75514    ) -> Option<(u64, SynchronousDatagramSocketSetIpv6MulticastInterfaceResponder)> {
75515        if let SynchronousDatagramSocketRequest::SetIpv6MulticastInterface { value, responder } =
75516            self
75517        {
75518            Some((value, responder))
75519        } else {
75520            None
75521        }
75522    }
75523
75524    #[allow(irrefutable_let_patterns)]
75525    pub fn into_get_ipv6_multicast_interface(
75526        self,
75527    ) -> Option<(SynchronousDatagramSocketGetIpv6MulticastInterfaceResponder)> {
75528        if let SynchronousDatagramSocketRequest::GetIpv6MulticastInterface { responder } = self {
75529            Some((responder))
75530        } else {
75531            None
75532        }
75533    }
75534
75535    #[allow(irrefutable_let_patterns)]
75536    pub fn into_set_ipv6_unicast_hops(
75537        self,
75538    ) -> Option<(OptionalUint8, SynchronousDatagramSocketSetIpv6UnicastHopsResponder)> {
75539        if let SynchronousDatagramSocketRequest::SetIpv6UnicastHops { value, responder } = self {
75540            Some((value, responder))
75541        } else {
75542            None
75543        }
75544    }
75545
75546    #[allow(irrefutable_let_patterns)]
75547    pub fn into_get_ipv6_unicast_hops(
75548        self,
75549    ) -> Option<(SynchronousDatagramSocketGetIpv6UnicastHopsResponder)> {
75550        if let SynchronousDatagramSocketRequest::GetIpv6UnicastHops { responder } = self {
75551            Some((responder))
75552        } else {
75553            None
75554        }
75555    }
75556
75557    #[allow(irrefutable_let_patterns)]
75558    pub fn into_set_ipv6_receive_hop_limit(
75559        self,
75560    ) -> Option<(bool, SynchronousDatagramSocketSetIpv6ReceiveHopLimitResponder)> {
75561        if let SynchronousDatagramSocketRequest::SetIpv6ReceiveHopLimit { value, responder } = self
75562        {
75563            Some((value, responder))
75564        } else {
75565            None
75566        }
75567    }
75568
75569    #[allow(irrefutable_let_patterns)]
75570    pub fn into_get_ipv6_receive_hop_limit(
75571        self,
75572    ) -> Option<(SynchronousDatagramSocketGetIpv6ReceiveHopLimitResponder)> {
75573        if let SynchronousDatagramSocketRequest::GetIpv6ReceiveHopLimit { responder } = self {
75574            Some((responder))
75575        } else {
75576            None
75577        }
75578    }
75579
75580    #[allow(irrefutable_let_patterns)]
75581    pub fn into_set_ipv6_multicast_hops(
75582        self,
75583    ) -> Option<(OptionalUint8, SynchronousDatagramSocketSetIpv6MulticastHopsResponder)> {
75584        if let SynchronousDatagramSocketRequest::SetIpv6MulticastHops { value, responder } = self {
75585            Some((value, responder))
75586        } else {
75587            None
75588        }
75589    }
75590
75591    #[allow(irrefutable_let_patterns)]
75592    pub fn into_get_ipv6_multicast_hops(
75593        self,
75594    ) -> Option<(SynchronousDatagramSocketGetIpv6MulticastHopsResponder)> {
75595        if let SynchronousDatagramSocketRequest::GetIpv6MulticastHops { responder } = self {
75596            Some((responder))
75597        } else {
75598            None
75599        }
75600    }
75601
75602    #[allow(irrefutable_let_patterns)]
75603    pub fn into_set_ipv6_multicast_loopback(
75604        self,
75605    ) -> Option<(bool, SynchronousDatagramSocketSetIpv6MulticastLoopbackResponder)> {
75606        if let SynchronousDatagramSocketRequest::SetIpv6MulticastLoopback { value, responder } =
75607            self
75608        {
75609            Some((value, responder))
75610        } else {
75611            None
75612        }
75613    }
75614
75615    #[allow(irrefutable_let_patterns)]
75616    pub fn into_get_ipv6_multicast_loopback(
75617        self,
75618    ) -> Option<(SynchronousDatagramSocketGetIpv6MulticastLoopbackResponder)> {
75619        if let SynchronousDatagramSocketRequest::GetIpv6MulticastLoopback { responder } = self {
75620            Some((responder))
75621        } else {
75622            None
75623        }
75624    }
75625
75626    #[allow(irrefutable_let_patterns)]
75627    pub fn into_set_ipv6_only(
75628        self,
75629    ) -> Option<(bool, SynchronousDatagramSocketSetIpv6OnlyResponder)> {
75630        if let SynchronousDatagramSocketRequest::SetIpv6Only { value, responder } = self {
75631            Some((value, responder))
75632        } else {
75633            None
75634        }
75635    }
75636
75637    #[allow(irrefutable_let_patterns)]
75638    pub fn into_get_ipv6_only(self) -> Option<(SynchronousDatagramSocketGetIpv6OnlyResponder)> {
75639        if let SynchronousDatagramSocketRequest::GetIpv6Only { responder } = self {
75640            Some((responder))
75641        } else {
75642            None
75643        }
75644    }
75645
75646    #[allow(irrefutable_let_patterns)]
75647    pub fn into_set_ipv6_receive_traffic_class(
75648        self,
75649    ) -> Option<(bool, SynchronousDatagramSocketSetIpv6ReceiveTrafficClassResponder)> {
75650        if let SynchronousDatagramSocketRequest::SetIpv6ReceiveTrafficClass { value, responder } =
75651            self
75652        {
75653            Some((value, responder))
75654        } else {
75655            None
75656        }
75657    }
75658
75659    #[allow(irrefutable_let_patterns)]
75660    pub fn into_get_ipv6_receive_traffic_class(
75661        self,
75662    ) -> Option<(SynchronousDatagramSocketGetIpv6ReceiveTrafficClassResponder)> {
75663        if let SynchronousDatagramSocketRequest::GetIpv6ReceiveTrafficClass { responder } = self {
75664            Some((responder))
75665        } else {
75666            None
75667        }
75668    }
75669
75670    #[allow(irrefutable_let_patterns)]
75671    pub fn into_set_ipv6_traffic_class(
75672        self,
75673    ) -> Option<(OptionalUint8, SynchronousDatagramSocketSetIpv6TrafficClassResponder)> {
75674        if let SynchronousDatagramSocketRequest::SetIpv6TrafficClass { value, responder } = self {
75675            Some((value, responder))
75676        } else {
75677            None
75678        }
75679    }
75680
75681    #[allow(irrefutable_let_patterns)]
75682    pub fn into_get_ipv6_traffic_class(
75683        self,
75684    ) -> Option<(SynchronousDatagramSocketGetIpv6TrafficClassResponder)> {
75685        if let SynchronousDatagramSocketRequest::GetIpv6TrafficClass { responder } = self {
75686            Some((responder))
75687        } else {
75688            None
75689        }
75690    }
75691
75692    #[allow(irrefutable_let_patterns)]
75693    pub fn into_set_ipv6_receive_packet_info(
75694        self,
75695    ) -> Option<(bool, SynchronousDatagramSocketSetIpv6ReceivePacketInfoResponder)> {
75696        if let SynchronousDatagramSocketRequest::SetIpv6ReceivePacketInfo { value, responder } =
75697            self
75698        {
75699            Some((value, responder))
75700        } else {
75701            None
75702        }
75703    }
75704
75705    #[allow(irrefutable_let_patterns)]
75706    pub fn into_get_ipv6_receive_packet_info(
75707        self,
75708    ) -> Option<(SynchronousDatagramSocketGetIpv6ReceivePacketInfoResponder)> {
75709        if let SynchronousDatagramSocketRequest::GetIpv6ReceivePacketInfo { responder } = self {
75710            Some((responder))
75711        } else {
75712            None
75713        }
75714    }
75715
75716    #[allow(irrefutable_let_patterns)]
75717    pub fn into_get_original_destination(
75718        self,
75719    ) -> Option<(SynchronousDatagramSocketGetOriginalDestinationResponder)> {
75720        if let SynchronousDatagramSocketRequest::GetOriginalDestination { responder } = self {
75721            Some((responder))
75722        } else {
75723            None
75724        }
75725    }
75726
75727    #[allow(irrefutable_let_patterns)]
75728    pub fn into_get_info(self) -> Option<(SynchronousDatagramSocketGetInfoResponder)> {
75729        if let SynchronousDatagramSocketRequest::GetInfo { responder } = self {
75730            Some((responder))
75731        } else {
75732            None
75733        }
75734    }
75735
75736    #[allow(irrefutable_let_patterns)]
75737    pub fn into_describe(self) -> Option<(SynchronousDatagramSocketDescribeResponder)> {
75738        if let SynchronousDatagramSocketRequest::Describe { responder } = self {
75739            Some((responder))
75740        } else {
75741            None
75742        }
75743    }
75744
75745    #[allow(irrefutable_let_patterns)]
75746    pub fn into_recv_msg(
75747        self,
75748    ) -> Option<(bool, u32, bool, RecvMsgFlags, SynchronousDatagramSocketRecvMsgResponder)> {
75749        if let SynchronousDatagramSocketRequest::RecvMsg {
75750            want_addr,
75751            data_len,
75752            want_control,
75753            flags,
75754            responder,
75755        } = self
75756        {
75757            Some((want_addr, data_len, want_control, flags, responder))
75758        } else {
75759            None
75760        }
75761    }
75762
75763    #[allow(irrefutable_let_patterns)]
75764    pub fn into_send_msg(
75765        self,
75766    ) -> Option<(
75767        Option<Box<fidl_fuchsia_net::SocketAddress>>,
75768        Vec<u8>,
75769        DatagramSocketSendControlData,
75770        SendMsgFlags,
75771        SynchronousDatagramSocketSendMsgResponder,
75772    )> {
75773        if let SynchronousDatagramSocketRequest::SendMsg { addr, data, control, flags, responder } =
75774            self
75775        {
75776            Some((addr, data, control, flags, responder))
75777        } else {
75778            None
75779        }
75780    }
75781
75782    /// Name of the method defined in FIDL
75783    pub fn method_name(&self) -> &'static str {
75784        match *self {
75785            SynchronousDatagramSocketRequest::Clone { .. } => "clone",
75786            SynchronousDatagramSocketRequest::Close { .. } => "close",
75787            SynchronousDatagramSocketRequest::Query { .. } => "query",
75788            SynchronousDatagramSocketRequest::SetReuseAddress { .. } => "set_reuse_address",
75789            SynchronousDatagramSocketRequest::GetReuseAddress { .. } => "get_reuse_address",
75790            SynchronousDatagramSocketRequest::GetError { .. } => "get_error",
75791            SynchronousDatagramSocketRequest::SetBroadcast { .. } => "set_broadcast",
75792            SynchronousDatagramSocketRequest::GetBroadcast { .. } => "get_broadcast",
75793            SynchronousDatagramSocketRequest::SetSendBuffer { .. } => "set_send_buffer",
75794            SynchronousDatagramSocketRequest::GetSendBuffer { .. } => "get_send_buffer",
75795            SynchronousDatagramSocketRequest::SetReceiveBuffer { .. } => "set_receive_buffer",
75796            SynchronousDatagramSocketRequest::GetReceiveBuffer { .. } => "get_receive_buffer",
75797            SynchronousDatagramSocketRequest::SetKeepAlive { .. } => "set_keep_alive",
75798            SynchronousDatagramSocketRequest::GetKeepAlive { .. } => "get_keep_alive",
75799            SynchronousDatagramSocketRequest::SetOutOfBandInline { .. } => "set_out_of_band_inline",
75800            SynchronousDatagramSocketRequest::GetOutOfBandInline { .. } => "get_out_of_band_inline",
75801            SynchronousDatagramSocketRequest::SetNoCheck { .. } => "set_no_check",
75802            SynchronousDatagramSocketRequest::GetNoCheck { .. } => "get_no_check",
75803            SynchronousDatagramSocketRequest::SetLinger { .. } => "set_linger",
75804            SynchronousDatagramSocketRequest::GetLinger { .. } => "get_linger",
75805            SynchronousDatagramSocketRequest::SetReusePort { .. } => "set_reuse_port",
75806            SynchronousDatagramSocketRequest::GetReusePort { .. } => "get_reuse_port",
75807            SynchronousDatagramSocketRequest::GetAcceptConn { .. } => "get_accept_conn",
75808            SynchronousDatagramSocketRequest::SetBindToDevice { .. } => "set_bind_to_device",
75809            SynchronousDatagramSocketRequest::GetBindToDevice { .. } => "get_bind_to_device",
75810            SynchronousDatagramSocketRequest::SetBindToInterfaceIndex { .. } => {
75811                "set_bind_to_interface_index"
75812            }
75813            SynchronousDatagramSocketRequest::GetBindToInterfaceIndex { .. } => {
75814                "get_bind_to_interface_index"
75815            }
75816            SynchronousDatagramSocketRequest::SetTimestamp { .. } => "set_timestamp",
75817            SynchronousDatagramSocketRequest::GetTimestamp { .. } => "get_timestamp",
75818            SynchronousDatagramSocketRequest::SetMark { .. } => "set_mark",
75819            SynchronousDatagramSocketRequest::GetMark { .. } => "get_mark",
75820            SynchronousDatagramSocketRequest::Bind { .. } => "bind",
75821            SynchronousDatagramSocketRequest::Connect { .. } => "connect",
75822            SynchronousDatagramSocketRequest::Disconnect { .. } => "disconnect",
75823            SynchronousDatagramSocketRequest::GetSockName { .. } => "get_sock_name",
75824            SynchronousDatagramSocketRequest::GetPeerName { .. } => "get_peer_name",
75825            SynchronousDatagramSocketRequest::Shutdown { .. } => "shutdown",
75826            SynchronousDatagramSocketRequest::SetIpTypeOfService { .. } => "set_ip_type_of_service",
75827            SynchronousDatagramSocketRequest::GetIpTypeOfService { .. } => "get_ip_type_of_service",
75828            SynchronousDatagramSocketRequest::SetIpTtl { .. } => "set_ip_ttl",
75829            SynchronousDatagramSocketRequest::GetIpTtl { .. } => "get_ip_ttl",
75830            SynchronousDatagramSocketRequest::SetIpPacketInfo { .. } => "set_ip_packet_info",
75831            SynchronousDatagramSocketRequest::GetIpPacketInfo { .. } => "get_ip_packet_info",
75832            SynchronousDatagramSocketRequest::SetIpReceiveTypeOfService { .. } => {
75833                "set_ip_receive_type_of_service"
75834            }
75835            SynchronousDatagramSocketRequest::GetIpReceiveTypeOfService { .. } => {
75836                "get_ip_receive_type_of_service"
75837            }
75838            SynchronousDatagramSocketRequest::SetIpReceiveTtl { .. } => "set_ip_receive_ttl",
75839            SynchronousDatagramSocketRequest::GetIpReceiveTtl { .. } => "get_ip_receive_ttl",
75840            SynchronousDatagramSocketRequest::SetIpMulticastInterface { .. } => {
75841                "set_ip_multicast_interface"
75842            }
75843            SynchronousDatagramSocketRequest::GetIpMulticastInterface { .. } => {
75844                "get_ip_multicast_interface"
75845            }
75846            SynchronousDatagramSocketRequest::SetIpMulticastTtl { .. } => "set_ip_multicast_ttl",
75847            SynchronousDatagramSocketRequest::GetIpMulticastTtl { .. } => "get_ip_multicast_ttl",
75848            SynchronousDatagramSocketRequest::SetIpMulticastLoopback { .. } => {
75849                "set_ip_multicast_loopback"
75850            }
75851            SynchronousDatagramSocketRequest::GetIpMulticastLoopback { .. } => {
75852                "get_ip_multicast_loopback"
75853            }
75854            SynchronousDatagramSocketRequest::AddIpMembership { .. } => "add_ip_membership",
75855            SynchronousDatagramSocketRequest::DropIpMembership { .. } => "drop_ip_membership",
75856            SynchronousDatagramSocketRequest::SetIpTransparent { .. } => "set_ip_transparent",
75857            SynchronousDatagramSocketRequest::GetIpTransparent { .. } => "get_ip_transparent",
75858            SynchronousDatagramSocketRequest::SetIpReceiveOriginalDestinationAddress { .. } => {
75859                "set_ip_receive_original_destination_address"
75860            }
75861            SynchronousDatagramSocketRequest::GetIpReceiveOriginalDestinationAddress { .. } => {
75862                "get_ip_receive_original_destination_address"
75863            }
75864            SynchronousDatagramSocketRequest::AddIpv6Membership { .. } => "add_ipv6_membership",
75865            SynchronousDatagramSocketRequest::DropIpv6Membership { .. } => "drop_ipv6_membership",
75866            SynchronousDatagramSocketRequest::SetIpv6MulticastInterface { .. } => {
75867                "set_ipv6_multicast_interface"
75868            }
75869            SynchronousDatagramSocketRequest::GetIpv6MulticastInterface { .. } => {
75870                "get_ipv6_multicast_interface"
75871            }
75872            SynchronousDatagramSocketRequest::SetIpv6UnicastHops { .. } => "set_ipv6_unicast_hops",
75873            SynchronousDatagramSocketRequest::GetIpv6UnicastHops { .. } => "get_ipv6_unicast_hops",
75874            SynchronousDatagramSocketRequest::SetIpv6ReceiveHopLimit { .. } => {
75875                "set_ipv6_receive_hop_limit"
75876            }
75877            SynchronousDatagramSocketRequest::GetIpv6ReceiveHopLimit { .. } => {
75878                "get_ipv6_receive_hop_limit"
75879            }
75880            SynchronousDatagramSocketRequest::SetIpv6MulticastHops { .. } => {
75881                "set_ipv6_multicast_hops"
75882            }
75883            SynchronousDatagramSocketRequest::GetIpv6MulticastHops { .. } => {
75884                "get_ipv6_multicast_hops"
75885            }
75886            SynchronousDatagramSocketRequest::SetIpv6MulticastLoopback { .. } => {
75887                "set_ipv6_multicast_loopback"
75888            }
75889            SynchronousDatagramSocketRequest::GetIpv6MulticastLoopback { .. } => {
75890                "get_ipv6_multicast_loopback"
75891            }
75892            SynchronousDatagramSocketRequest::SetIpv6Only { .. } => "set_ipv6_only",
75893            SynchronousDatagramSocketRequest::GetIpv6Only { .. } => "get_ipv6_only",
75894            SynchronousDatagramSocketRequest::SetIpv6ReceiveTrafficClass { .. } => {
75895                "set_ipv6_receive_traffic_class"
75896            }
75897            SynchronousDatagramSocketRequest::GetIpv6ReceiveTrafficClass { .. } => {
75898                "get_ipv6_receive_traffic_class"
75899            }
75900            SynchronousDatagramSocketRequest::SetIpv6TrafficClass { .. } => {
75901                "set_ipv6_traffic_class"
75902            }
75903            SynchronousDatagramSocketRequest::GetIpv6TrafficClass { .. } => {
75904                "get_ipv6_traffic_class"
75905            }
75906            SynchronousDatagramSocketRequest::SetIpv6ReceivePacketInfo { .. } => {
75907                "set_ipv6_receive_packet_info"
75908            }
75909            SynchronousDatagramSocketRequest::GetIpv6ReceivePacketInfo { .. } => {
75910                "get_ipv6_receive_packet_info"
75911            }
75912            SynchronousDatagramSocketRequest::GetOriginalDestination { .. } => {
75913                "get_original_destination"
75914            }
75915            SynchronousDatagramSocketRequest::GetInfo { .. } => "get_info",
75916            SynchronousDatagramSocketRequest::Describe { .. } => "describe",
75917            SynchronousDatagramSocketRequest::RecvMsg { .. } => "recv_msg",
75918            SynchronousDatagramSocketRequest::SendMsg { .. } => "send_msg",
75919        }
75920    }
75921}
75922
75923#[derive(Debug, Clone)]
75924pub struct SynchronousDatagramSocketControlHandle {
75925    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
75926}
75927
75928impl fidl::endpoints::ControlHandle for SynchronousDatagramSocketControlHandle {
75929    fn shutdown(&self) {
75930        self.inner.shutdown()
75931    }
75932    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
75933        self.inner.shutdown_with_epitaph(status)
75934    }
75935
75936    fn is_closed(&self) -> bool {
75937        self.inner.channel().is_closed()
75938    }
75939    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
75940        self.inner.channel().on_closed()
75941    }
75942
75943    #[cfg(target_os = "fuchsia")]
75944    fn signal_peer(
75945        &self,
75946        clear_mask: zx::Signals,
75947        set_mask: zx::Signals,
75948    ) -> Result<(), zx_status::Status> {
75949        use fidl::Peered;
75950        self.inner.channel().signal_peer(clear_mask, set_mask)
75951    }
75952}
75953
75954impl SynchronousDatagramSocketControlHandle {}
75955
75956#[must_use = "FIDL methods require a response to be sent"]
75957#[derive(Debug)]
75958pub struct SynchronousDatagramSocketCloseResponder {
75959    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
75960    tx_id: u32,
75961}
75962
75963/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
75964/// if the responder is dropped without sending a response, so that the client
75965/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
75966impl std::ops::Drop for SynchronousDatagramSocketCloseResponder {
75967    fn drop(&mut self) {
75968        self.control_handle.shutdown();
75969        // Safety: drops once, never accessed again
75970        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
75971    }
75972}
75973
75974impl fidl::endpoints::Responder for SynchronousDatagramSocketCloseResponder {
75975    type ControlHandle = SynchronousDatagramSocketControlHandle;
75976
75977    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
75978        &self.control_handle
75979    }
75980
75981    fn drop_without_shutdown(mut self) {
75982        // Safety: drops once, never accessed again due to mem::forget
75983        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
75984        // Prevent Drop from running (which would shut down the channel)
75985        std::mem::forget(self);
75986    }
75987}
75988
75989impl SynchronousDatagramSocketCloseResponder {
75990    /// Sends a response to the FIDL transaction.
75991    ///
75992    /// Sets the channel to shutdown if an error occurs.
75993    pub fn send(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
75994        let _result = self.send_raw(result);
75995        if _result.is_err() {
75996            self.control_handle.shutdown();
75997        }
75998        self.drop_without_shutdown();
75999        _result
76000    }
76001
76002    /// Similar to "send" but does not shutdown the channel if an error occurs.
76003    pub fn send_no_shutdown_on_err(self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
76004        let _result = self.send_raw(result);
76005        self.drop_without_shutdown();
76006        _result
76007    }
76008
76009    fn send_raw(&self, mut result: Result<(), i32>) -> Result<(), fidl::Error> {
76010        self.control_handle
76011            .inner
76012            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, i32>>(
76013                result,
76014                self.tx_id,
76015                0x5ac5d459ad7f657e,
76016                fidl::encoding::DynamicFlags::empty(),
76017            )
76018    }
76019}
76020
76021#[must_use = "FIDL methods require a response to be sent"]
76022#[derive(Debug)]
76023pub struct SynchronousDatagramSocketQueryResponder {
76024    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
76025    tx_id: u32,
76026}
76027
76028/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
76029/// if the responder is dropped without sending a response, so that the client
76030/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
76031impl std::ops::Drop for SynchronousDatagramSocketQueryResponder {
76032    fn drop(&mut self) {
76033        self.control_handle.shutdown();
76034        // Safety: drops once, never accessed again
76035        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76036    }
76037}
76038
76039impl fidl::endpoints::Responder for SynchronousDatagramSocketQueryResponder {
76040    type ControlHandle = SynchronousDatagramSocketControlHandle;
76041
76042    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
76043        &self.control_handle
76044    }
76045
76046    fn drop_without_shutdown(mut self) {
76047        // Safety: drops once, never accessed again due to mem::forget
76048        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76049        // Prevent Drop from running (which would shut down the channel)
76050        std::mem::forget(self);
76051    }
76052}
76053
76054impl SynchronousDatagramSocketQueryResponder {
76055    /// Sends a response to the FIDL transaction.
76056    ///
76057    /// Sets the channel to shutdown if an error occurs.
76058    pub fn send(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
76059        let _result = self.send_raw(protocol);
76060        if _result.is_err() {
76061            self.control_handle.shutdown();
76062        }
76063        self.drop_without_shutdown();
76064        _result
76065    }
76066
76067    /// Similar to "send" but does not shutdown the channel if an error occurs.
76068    pub fn send_no_shutdown_on_err(self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
76069        let _result = self.send_raw(protocol);
76070        self.drop_without_shutdown();
76071        _result
76072    }
76073
76074    fn send_raw(&self, mut protocol: &[u8]) -> Result<(), fidl::Error> {
76075        self.control_handle.inner.send::<fidl_fuchsia_unknown::QueryableQueryResponse>(
76076            (protocol,),
76077            self.tx_id,
76078            0x2658edee9decfc06,
76079            fidl::encoding::DynamicFlags::empty(),
76080        )
76081    }
76082}
76083
76084#[must_use = "FIDL methods require a response to be sent"]
76085#[derive(Debug)]
76086pub struct SynchronousDatagramSocketSetReuseAddressResponder {
76087    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
76088    tx_id: u32,
76089}
76090
76091/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
76092/// if the responder is dropped without sending a response, so that the client
76093/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
76094impl std::ops::Drop for SynchronousDatagramSocketSetReuseAddressResponder {
76095    fn drop(&mut self) {
76096        self.control_handle.shutdown();
76097        // Safety: drops once, never accessed again
76098        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76099    }
76100}
76101
76102impl fidl::endpoints::Responder for SynchronousDatagramSocketSetReuseAddressResponder {
76103    type ControlHandle = SynchronousDatagramSocketControlHandle;
76104
76105    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
76106        &self.control_handle
76107    }
76108
76109    fn drop_without_shutdown(mut self) {
76110        // Safety: drops once, never accessed again due to mem::forget
76111        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76112        // Prevent Drop from running (which would shut down the channel)
76113        std::mem::forget(self);
76114    }
76115}
76116
76117impl SynchronousDatagramSocketSetReuseAddressResponder {
76118    /// Sends a response to the FIDL transaction.
76119    ///
76120    /// Sets the channel to shutdown if an error occurs.
76121    pub fn send(
76122        self,
76123        mut result: Result<(), fidl_fuchsia_posix::Errno>,
76124    ) -> Result<(), fidl::Error> {
76125        let _result = self.send_raw(result);
76126        if _result.is_err() {
76127            self.control_handle.shutdown();
76128        }
76129        self.drop_without_shutdown();
76130        _result
76131    }
76132
76133    /// Similar to "send" but does not shutdown the channel if an error occurs.
76134    pub fn send_no_shutdown_on_err(
76135        self,
76136        mut result: Result<(), fidl_fuchsia_posix::Errno>,
76137    ) -> Result<(), fidl::Error> {
76138        let _result = self.send_raw(result);
76139        self.drop_without_shutdown();
76140        _result
76141    }
76142
76143    fn send_raw(
76144        &self,
76145        mut result: Result<(), fidl_fuchsia_posix::Errno>,
76146    ) -> Result<(), fidl::Error> {
76147        self.control_handle.inner.send::<fidl::encoding::ResultType<
76148            fidl::encoding::EmptyStruct,
76149            fidl_fuchsia_posix::Errno,
76150        >>(
76151            result,
76152            self.tx_id,
76153            0x1fd74ee8b9a4a876,
76154            fidl::encoding::DynamicFlags::empty(),
76155        )
76156    }
76157}
76158
76159#[must_use = "FIDL methods require a response to be sent"]
76160#[derive(Debug)]
76161pub struct SynchronousDatagramSocketGetReuseAddressResponder {
76162    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
76163    tx_id: u32,
76164}
76165
76166/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
76167/// if the responder is dropped without sending a response, so that the client
76168/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
76169impl std::ops::Drop for SynchronousDatagramSocketGetReuseAddressResponder {
76170    fn drop(&mut self) {
76171        self.control_handle.shutdown();
76172        // Safety: drops once, never accessed again
76173        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76174    }
76175}
76176
76177impl fidl::endpoints::Responder for SynchronousDatagramSocketGetReuseAddressResponder {
76178    type ControlHandle = SynchronousDatagramSocketControlHandle;
76179
76180    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
76181        &self.control_handle
76182    }
76183
76184    fn drop_without_shutdown(mut self) {
76185        // Safety: drops once, never accessed again due to mem::forget
76186        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76187        // Prevent Drop from running (which would shut down the channel)
76188        std::mem::forget(self);
76189    }
76190}
76191
76192impl SynchronousDatagramSocketGetReuseAddressResponder {
76193    /// Sends a response to the FIDL transaction.
76194    ///
76195    /// Sets the channel to shutdown if an error occurs.
76196    pub fn send(
76197        self,
76198        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
76199    ) -> Result<(), fidl::Error> {
76200        let _result = self.send_raw(result);
76201        if _result.is_err() {
76202            self.control_handle.shutdown();
76203        }
76204        self.drop_without_shutdown();
76205        _result
76206    }
76207
76208    /// Similar to "send" but does not shutdown the channel if an error occurs.
76209    pub fn send_no_shutdown_on_err(
76210        self,
76211        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
76212    ) -> Result<(), fidl::Error> {
76213        let _result = self.send_raw(result);
76214        self.drop_without_shutdown();
76215        _result
76216    }
76217
76218    fn send_raw(
76219        &self,
76220        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
76221    ) -> Result<(), fidl::Error> {
76222        self.control_handle.inner.send::<fidl::encoding::ResultType<
76223            BaseSocketGetReuseAddressResponse,
76224            fidl_fuchsia_posix::Errno,
76225        >>(
76226            result.map(|value| (value,)),
76227            self.tx_id,
76228            0x67b7206b8d1bc0a5,
76229            fidl::encoding::DynamicFlags::empty(),
76230        )
76231    }
76232}
76233
76234#[must_use = "FIDL methods require a response to be sent"]
76235#[derive(Debug)]
76236pub struct SynchronousDatagramSocketGetErrorResponder {
76237    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
76238    tx_id: u32,
76239}
76240
76241/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
76242/// if the responder is dropped without sending a response, so that the client
76243/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
76244impl std::ops::Drop for SynchronousDatagramSocketGetErrorResponder {
76245    fn drop(&mut self) {
76246        self.control_handle.shutdown();
76247        // Safety: drops once, never accessed again
76248        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76249    }
76250}
76251
76252impl fidl::endpoints::Responder for SynchronousDatagramSocketGetErrorResponder {
76253    type ControlHandle = SynchronousDatagramSocketControlHandle;
76254
76255    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
76256        &self.control_handle
76257    }
76258
76259    fn drop_without_shutdown(mut self) {
76260        // Safety: drops once, never accessed again due to mem::forget
76261        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76262        // Prevent Drop from running (which would shut down the channel)
76263        std::mem::forget(self);
76264    }
76265}
76266
76267impl SynchronousDatagramSocketGetErrorResponder {
76268    /// Sends a response to the FIDL transaction.
76269    ///
76270    /// Sets the channel to shutdown if an error occurs.
76271    pub fn send(
76272        self,
76273        mut result: Result<(), fidl_fuchsia_posix::Errno>,
76274    ) -> Result<(), fidl::Error> {
76275        let _result = self.send_raw(result);
76276        if _result.is_err() {
76277            self.control_handle.shutdown();
76278        }
76279        self.drop_without_shutdown();
76280        _result
76281    }
76282
76283    /// Similar to "send" but does not shutdown the channel if an error occurs.
76284    pub fn send_no_shutdown_on_err(
76285        self,
76286        mut result: Result<(), fidl_fuchsia_posix::Errno>,
76287    ) -> Result<(), fidl::Error> {
76288        let _result = self.send_raw(result);
76289        self.drop_without_shutdown();
76290        _result
76291    }
76292
76293    fn send_raw(
76294        &self,
76295        mut result: Result<(), fidl_fuchsia_posix::Errno>,
76296    ) -> Result<(), fidl::Error> {
76297        self.control_handle.inner.send::<fidl::encoding::ResultType<
76298            fidl::encoding::EmptyStruct,
76299            fidl_fuchsia_posix::Errno,
76300        >>(
76301            result,
76302            self.tx_id,
76303            0x5aad39b33e5f6ebb,
76304            fidl::encoding::DynamicFlags::empty(),
76305        )
76306    }
76307}
76308
76309#[must_use = "FIDL methods require a response to be sent"]
76310#[derive(Debug)]
76311pub struct SynchronousDatagramSocketSetBroadcastResponder {
76312    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
76313    tx_id: u32,
76314}
76315
76316/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
76317/// if the responder is dropped without sending a response, so that the client
76318/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
76319impl std::ops::Drop for SynchronousDatagramSocketSetBroadcastResponder {
76320    fn drop(&mut self) {
76321        self.control_handle.shutdown();
76322        // Safety: drops once, never accessed again
76323        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76324    }
76325}
76326
76327impl fidl::endpoints::Responder for SynchronousDatagramSocketSetBroadcastResponder {
76328    type ControlHandle = SynchronousDatagramSocketControlHandle;
76329
76330    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
76331        &self.control_handle
76332    }
76333
76334    fn drop_without_shutdown(mut self) {
76335        // Safety: drops once, never accessed again due to mem::forget
76336        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76337        // Prevent Drop from running (which would shut down the channel)
76338        std::mem::forget(self);
76339    }
76340}
76341
76342impl SynchronousDatagramSocketSetBroadcastResponder {
76343    /// Sends a response to the FIDL transaction.
76344    ///
76345    /// Sets the channel to shutdown if an error occurs.
76346    pub fn send(
76347        self,
76348        mut result: Result<(), fidl_fuchsia_posix::Errno>,
76349    ) -> Result<(), fidl::Error> {
76350        let _result = self.send_raw(result);
76351        if _result.is_err() {
76352            self.control_handle.shutdown();
76353        }
76354        self.drop_without_shutdown();
76355        _result
76356    }
76357
76358    /// Similar to "send" but does not shutdown the channel if an error occurs.
76359    pub fn send_no_shutdown_on_err(
76360        self,
76361        mut result: Result<(), fidl_fuchsia_posix::Errno>,
76362    ) -> Result<(), fidl::Error> {
76363        let _result = self.send_raw(result);
76364        self.drop_without_shutdown();
76365        _result
76366    }
76367
76368    fn send_raw(
76369        &self,
76370        mut result: Result<(), fidl_fuchsia_posix::Errno>,
76371    ) -> Result<(), fidl::Error> {
76372        self.control_handle.inner.send::<fidl::encoding::ResultType<
76373            fidl::encoding::EmptyStruct,
76374            fidl_fuchsia_posix::Errno,
76375        >>(
76376            result,
76377            self.tx_id,
76378            0x6023e081ce3cd947,
76379            fidl::encoding::DynamicFlags::empty(),
76380        )
76381    }
76382}
76383
76384#[must_use = "FIDL methods require a response to be sent"]
76385#[derive(Debug)]
76386pub struct SynchronousDatagramSocketGetBroadcastResponder {
76387    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
76388    tx_id: u32,
76389}
76390
76391/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
76392/// if the responder is dropped without sending a response, so that the client
76393/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
76394impl std::ops::Drop for SynchronousDatagramSocketGetBroadcastResponder {
76395    fn drop(&mut self) {
76396        self.control_handle.shutdown();
76397        // Safety: drops once, never accessed again
76398        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76399    }
76400}
76401
76402impl fidl::endpoints::Responder for SynchronousDatagramSocketGetBroadcastResponder {
76403    type ControlHandle = SynchronousDatagramSocketControlHandle;
76404
76405    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
76406        &self.control_handle
76407    }
76408
76409    fn drop_without_shutdown(mut self) {
76410        // Safety: drops once, never accessed again due to mem::forget
76411        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76412        // Prevent Drop from running (which would shut down the channel)
76413        std::mem::forget(self);
76414    }
76415}
76416
76417impl SynchronousDatagramSocketGetBroadcastResponder {
76418    /// Sends a response to the FIDL transaction.
76419    ///
76420    /// Sets the channel to shutdown if an error occurs.
76421    pub fn send(
76422        self,
76423        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
76424    ) -> Result<(), fidl::Error> {
76425        let _result = self.send_raw(result);
76426        if _result.is_err() {
76427            self.control_handle.shutdown();
76428        }
76429        self.drop_without_shutdown();
76430        _result
76431    }
76432
76433    /// Similar to "send" but does not shutdown the channel if an error occurs.
76434    pub fn send_no_shutdown_on_err(
76435        self,
76436        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
76437    ) -> Result<(), fidl::Error> {
76438        let _result = self.send_raw(result);
76439        self.drop_without_shutdown();
76440        _result
76441    }
76442
76443    fn send_raw(
76444        &self,
76445        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
76446    ) -> Result<(), fidl::Error> {
76447        self.control_handle.inner.send::<fidl::encoding::ResultType<
76448            BaseSocketGetBroadcastResponse,
76449            fidl_fuchsia_posix::Errno,
76450        >>(
76451            result.map(|value| (value,)),
76452            self.tx_id,
76453            0x68796fc556f9780d,
76454            fidl::encoding::DynamicFlags::empty(),
76455        )
76456    }
76457}
76458
76459#[must_use = "FIDL methods require a response to be sent"]
76460#[derive(Debug)]
76461pub struct SynchronousDatagramSocketSetSendBufferResponder {
76462    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
76463    tx_id: u32,
76464}
76465
76466/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
76467/// if the responder is dropped without sending a response, so that the client
76468/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
76469impl std::ops::Drop for SynchronousDatagramSocketSetSendBufferResponder {
76470    fn drop(&mut self) {
76471        self.control_handle.shutdown();
76472        // Safety: drops once, never accessed again
76473        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76474    }
76475}
76476
76477impl fidl::endpoints::Responder for SynchronousDatagramSocketSetSendBufferResponder {
76478    type ControlHandle = SynchronousDatagramSocketControlHandle;
76479
76480    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
76481        &self.control_handle
76482    }
76483
76484    fn drop_without_shutdown(mut self) {
76485        // Safety: drops once, never accessed again due to mem::forget
76486        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76487        // Prevent Drop from running (which would shut down the channel)
76488        std::mem::forget(self);
76489    }
76490}
76491
76492impl SynchronousDatagramSocketSetSendBufferResponder {
76493    /// Sends a response to the FIDL transaction.
76494    ///
76495    /// Sets the channel to shutdown if an error occurs.
76496    pub fn send(
76497        self,
76498        mut result: Result<(), fidl_fuchsia_posix::Errno>,
76499    ) -> Result<(), fidl::Error> {
76500        let _result = self.send_raw(result);
76501        if _result.is_err() {
76502            self.control_handle.shutdown();
76503        }
76504        self.drop_without_shutdown();
76505        _result
76506    }
76507
76508    /// Similar to "send" but does not shutdown the channel if an error occurs.
76509    pub fn send_no_shutdown_on_err(
76510        self,
76511        mut result: Result<(), fidl_fuchsia_posix::Errno>,
76512    ) -> Result<(), fidl::Error> {
76513        let _result = self.send_raw(result);
76514        self.drop_without_shutdown();
76515        _result
76516    }
76517
76518    fn send_raw(
76519        &self,
76520        mut result: Result<(), fidl_fuchsia_posix::Errno>,
76521    ) -> Result<(), fidl::Error> {
76522        self.control_handle.inner.send::<fidl::encoding::ResultType<
76523            fidl::encoding::EmptyStruct,
76524            fidl_fuchsia_posix::Errno,
76525        >>(
76526            result,
76527            self.tx_id,
76528            0x756eac32d73a7a70,
76529            fidl::encoding::DynamicFlags::empty(),
76530        )
76531    }
76532}
76533
76534#[must_use = "FIDL methods require a response to be sent"]
76535#[derive(Debug)]
76536pub struct SynchronousDatagramSocketGetSendBufferResponder {
76537    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
76538    tx_id: u32,
76539}
76540
76541/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
76542/// if the responder is dropped without sending a response, so that the client
76543/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
76544impl std::ops::Drop for SynchronousDatagramSocketGetSendBufferResponder {
76545    fn drop(&mut self) {
76546        self.control_handle.shutdown();
76547        // Safety: drops once, never accessed again
76548        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76549    }
76550}
76551
76552impl fidl::endpoints::Responder for SynchronousDatagramSocketGetSendBufferResponder {
76553    type ControlHandle = SynchronousDatagramSocketControlHandle;
76554
76555    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
76556        &self.control_handle
76557    }
76558
76559    fn drop_without_shutdown(mut self) {
76560        // Safety: drops once, never accessed again due to mem::forget
76561        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76562        // Prevent Drop from running (which would shut down the channel)
76563        std::mem::forget(self);
76564    }
76565}
76566
76567impl SynchronousDatagramSocketGetSendBufferResponder {
76568    /// Sends a response to the FIDL transaction.
76569    ///
76570    /// Sets the channel to shutdown if an error occurs.
76571    pub fn send(
76572        self,
76573        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
76574    ) -> Result<(), fidl::Error> {
76575        let _result = self.send_raw(result);
76576        if _result.is_err() {
76577            self.control_handle.shutdown();
76578        }
76579        self.drop_without_shutdown();
76580        _result
76581    }
76582
76583    /// Similar to "send" but does not shutdown the channel if an error occurs.
76584    pub fn send_no_shutdown_on_err(
76585        self,
76586        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
76587    ) -> Result<(), fidl::Error> {
76588        let _result = self.send_raw(result);
76589        self.drop_without_shutdown();
76590        _result
76591    }
76592
76593    fn send_raw(
76594        &self,
76595        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
76596    ) -> Result<(), fidl::Error> {
76597        self.control_handle.inner.send::<fidl::encoding::ResultType<
76598            BaseSocketGetSendBufferResponse,
76599            fidl_fuchsia_posix::Errno,
76600        >>(
76601            result.map(|value_bytes| (value_bytes,)),
76602            self.tx_id,
76603            0x78a52fd9c7b2410b,
76604            fidl::encoding::DynamicFlags::empty(),
76605        )
76606    }
76607}
76608
76609#[must_use = "FIDL methods require a response to be sent"]
76610#[derive(Debug)]
76611pub struct SynchronousDatagramSocketSetReceiveBufferResponder {
76612    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
76613    tx_id: u32,
76614}
76615
76616/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
76617/// if the responder is dropped without sending a response, so that the client
76618/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
76619impl std::ops::Drop for SynchronousDatagramSocketSetReceiveBufferResponder {
76620    fn drop(&mut self) {
76621        self.control_handle.shutdown();
76622        // Safety: drops once, never accessed again
76623        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76624    }
76625}
76626
76627impl fidl::endpoints::Responder for SynchronousDatagramSocketSetReceiveBufferResponder {
76628    type ControlHandle = SynchronousDatagramSocketControlHandle;
76629
76630    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
76631        &self.control_handle
76632    }
76633
76634    fn drop_without_shutdown(mut self) {
76635        // Safety: drops once, never accessed again due to mem::forget
76636        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76637        // Prevent Drop from running (which would shut down the channel)
76638        std::mem::forget(self);
76639    }
76640}
76641
76642impl SynchronousDatagramSocketSetReceiveBufferResponder {
76643    /// Sends a response to the FIDL transaction.
76644    ///
76645    /// Sets the channel to shutdown if an error occurs.
76646    pub fn send(
76647        self,
76648        mut result: Result<(), fidl_fuchsia_posix::Errno>,
76649    ) -> Result<(), fidl::Error> {
76650        let _result = self.send_raw(result);
76651        if _result.is_err() {
76652            self.control_handle.shutdown();
76653        }
76654        self.drop_without_shutdown();
76655        _result
76656    }
76657
76658    /// Similar to "send" but does not shutdown the channel if an error occurs.
76659    pub fn send_no_shutdown_on_err(
76660        self,
76661        mut result: Result<(), fidl_fuchsia_posix::Errno>,
76662    ) -> Result<(), fidl::Error> {
76663        let _result = self.send_raw(result);
76664        self.drop_without_shutdown();
76665        _result
76666    }
76667
76668    fn send_raw(
76669        &self,
76670        mut result: Result<(), fidl_fuchsia_posix::Errno>,
76671    ) -> Result<(), fidl::Error> {
76672        self.control_handle.inner.send::<fidl::encoding::ResultType<
76673            fidl::encoding::EmptyStruct,
76674            fidl_fuchsia_posix::Errno,
76675        >>(
76676            result,
76677            self.tx_id,
76678            0x6b0cf2f1919c7001,
76679            fidl::encoding::DynamicFlags::empty(),
76680        )
76681    }
76682}
76683
76684#[must_use = "FIDL methods require a response to be sent"]
76685#[derive(Debug)]
76686pub struct SynchronousDatagramSocketGetReceiveBufferResponder {
76687    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
76688    tx_id: u32,
76689}
76690
76691/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
76692/// if the responder is dropped without sending a response, so that the client
76693/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
76694impl std::ops::Drop for SynchronousDatagramSocketGetReceiveBufferResponder {
76695    fn drop(&mut self) {
76696        self.control_handle.shutdown();
76697        // Safety: drops once, never accessed again
76698        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76699    }
76700}
76701
76702impl fidl::endpoints::Responder for SynchronousDatagramSocketGetReceiveBufferResponder {
76703    type ControlHandle = SynchronousDatagramSocketControlHandle;
76704
76705    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
76706        &self.control_handle
76707    }
76708
76709    fn drop_without_shutdown(mut self) {
76710        // Safety: drops once, never accessed again due to mem::forget
76711        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76712        // Prevent Drop from running (which would shut down the channel)
76713        std::mem::forget(self);
76714    }
76715}
76716
76717impl SynchronousDatagramSocketGetReceiveBufferResponder {
76718    /// Sends a response to the FIDL transaction.
76719    ///
76720    /// Sets the channel to shutdown if an error occurs.
76721    pub fn send(
76722        self,
76723        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
76724    ) -> Result<(), fidl::Error> {
76725        let _result = self.send_raw(result);
76726        if _result.is_err() {
76727            self.control_handle.shutdown();
76728        }
76729        self.drop_without_shutdown();
76730        _result
76731    }
76732
76733    /// Similar to "send" but does not shutdown the channel if an error occurs.
76734    pub fn send_no_shutdown_on_err(
76735        self,
76736        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
76737    ) -> Result<(), fidl::Error> {
76738        let _result = self.send_raw(result);
76739        self.drop_without_shutdown();
76740        _result
76741    }
76742
76743    fn send_raw(
76744        &self,
76745        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
76746    ) -> Result<(), fidl::Error> {
76747        self.control_handle.inner.send::<fidl::encoding::ResultType<
76748            BaseSocketGetReceiveBufferResponse,
76749            fidl_fuchsia_posix::Errno,
76750        >>(
76751            result.map(|value_bytes| (value_bytes,)),
76752            self.tx_id,
76753            0x14c1a4b64f709e5c,
76754            fidl::encoding::DynamicFlags::empty(),
76755        )
76756    }
76757}
76758
76759#[must_use = "FIDL methods require a response to be sent"]
76760#[derive(Debug)]
76761pub struct SynchronousDatagramSocketSetKeepAliveResponder {
76762    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
76763    tx_id: u32,
76764}
76765
76766/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
76767/// if the responder is dropped without sending a response, so that the client
76768/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
76769impl std::ops::Drop for SynchronousDatagramSocketSetKeepAliveResponder {
76770    fn drop(&mut self) {
76771        self.control_handle.shutdown();
76772        // Safety: drops once, never accessed again
76773        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76774    }
76775}
76776
76777impl fidl::endpoints::Responder for SynchronousDatagramSocketSetKeepAliveResponder {
76778    type ControlHandle = SynchronousDatagramSocketControlHandle;
76779
76780    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
76781        &self.control_handle
76782    }
76783
76784    fn drop_without_shutdown(mut self) {
76785        // Safety: drops once, never accessed again due to mem::forget
76786        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76787        // Prevent Drop from running (which would shut down the channel)
76788        std::mem::forget(self);
76789    }
76790}
76791
76792impl SynchronousDatagramSocketSetKeepAliveResponder {
76793    /// Sends a response to the FIDL transaction.
76794    ///
76795    /// Sets the channel to shutdown if an error occurs.
76796    pub fn send(
76797        self,
76798        mut result: Result<(), fidl_fuchsia_posix::Errno>,
76799    ) -> Result<(), fidl::Error> {
76800        let _result = self.send_raw(result);
76801        if _result.is_err() {
76802            self.control_handle.shutdown();
76803        }
76804        self.drop_without_shutdown();
76805        _result
76806    }
76807
76808    /// Similar to "send" but does not shutdown the channel if an error occurs.
76809    pub fn send_no_shutdown_on_err(
76810        self,
76811        mut result: Result<(), fidl_fuchsia_posix::Errno>,
76812    ) -> Result<(), fidl::Error> {
76813        let _result = self.send_raw(result);
76814        self.drop_without_shutdown();
76815        _result
76816    }
76817
76818    fn send_raw(
76819        &self,
76820        mut result: Result<(), fidl_fuchsia_posix::Errno>,
76821    ) -> Result<(), fidl::Error> {
76822        self.control_handle.inner.send::<fidl::encoding::ResultType<
76823            fidl::encoding::EmptyStruct,
76824            fidl_fuchsia_posix::Errno,
76825        >>(
76826            result,
76827            self.tx_id,
76828            0x572df8f0b920d2c7,
76829            fidl::encoding::DynamicFlags::empty(),
76830        )
76831    }
76832}
76833
76834#[must_use = "FIDL methods require a response to be sent"]
76835#[derive(Debug)]
76836pub struct SynchronousDatagramSocketGetKeepAliveResponder {
76837    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
76838    tx_id: u32,
76839}
76840
76841/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
76842/// if the responder is dropped without sending a response, so that the client
76843/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
76844impl std::ops::Drop for SynchronousDatagramSocketGetKeepAliveResponder {
76845    fn drop(&mut self) {
76846        self.control_handle.shutdown();
76847        // Safety: drops once, never accessed again
76848        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76849    }
76850}
76851
76852impl fidl::endpoints::Responder for SynchronousDatagramSocketGetKeepAliveResponder {
76853    type ControlHandle = SynchronousDatagramSocketControlHandle;
76854
76855    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
76856        &self.control_handle
76857    }
76858
76859    fn drop_without_shutdown(mut self) {
76860        // Safety: drops once, never accessed again due to mem::forget
76861        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76862        // Prevent Drop from running (which would shut down the channel)
76863        std::mem::forget(self);
76864    }
76865}
76866
76867impl SynchronousDatagramSocketGetKeepAliveResponder {
76868    /// Sends a response to the FIDL transaction.
76869    ///
76870    /// Sets the channel to shutdown if an error occurs.
76871    pub fn send(
76872        self,
76873        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
76874    ) -> Result<(), fidl::Error> {
76875        let _result = self.send_raw(result);
76876        if _result.is_err() {
76877            self.control_handle.shutdown();
76878        }
76879        self.drop_without_shutdown();
76880        _result
76881    }
76882
76883    /// Similar to "send" but does not shutdown the channel if an error occurs.
76884    pub fn send_no_shutdown_on_err(
76885        self,
76886        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
76887    ) -> Result<(), fidl::Error> {
76888        let _result = self.send_raw(result);
76889        self.drop_without_shutdown();
76890        _result
76891    }
76892
76893    fn send_raw(
76894        &self,
76895        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
76896    ) -> Result<(), fidl::Error> {
76897        self.control_handle.inner.send::<fidl::encoding::ResultType<
76898            BaseSocketGetKeepAliveResponse,
76899            fidl_fuchsia_posix::Errno,
76900        >>(
76901            result.map(|value| (value,)),
76902            self.tx_id,
76903            0x2dd29d3215f2c9d2,
76904            fidl::encoding::DynamicFlags::empty(),
76905        )
76906    }
76907}
76908
76909#[must_use = "FIDL methods require a response to be sent"]
76910#[derive(Debug)]
76911pub struct SynchronousDatagramSocketSetOutOfBandInlineResponder {
76912    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
76913    tx_id: u32,
76914}
76915
76916/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
76917/// if the responder is dropped without sending a response, so that the client
76918/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
76919impl std::ops::Drop for SynchronousDatagramSocketSetOutOfBandInlineResponder {
76920    fn drop(&mut self) {
76921        self.control_handle.shutdown();
76922        // Safety: drops once, never accessed again
76923        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76924    }
76925}
76926
76927impl fidl::endpoints::Responder for SynchronousDatagramSocketSetOutOfBandInlineResponder {
76928    type ControlHandle = SynchronousDatagramSocketControlHandle;
76929
76930    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
76931        &self.control_handle
76932    }
76933
76934    fn drop_without_shutdown(mut self) {
76935        // Safety: drops once, never accessed again due to mem::forget
76936        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76937        // Prevent Drop from running (which would shut down the channel)
76938        std::mem::forget(self);
76939    }
76940}
76941
76942impl SynchronousDatagramSocketSetOutOfBandInlineResponder {
76943    /// Sends a response to the FIDL transaction.
76944    ///
76945    /// Sets the channel to shutdown if an error occurs.
76946    pub fn send(
76947        self,
76948        mut result: Result<(), fidl_fuchsia_posix::Errno>,
76949    ) -> Result<(), fidl::Error> {
76950        let _result = self.send_raw(result);
76951        if _result.is_err() {
76952            self.control_handle.shutdown();
76953        }
76954        self.drop_without_shutdown();
76955        _result
76956    }
76957
76958    /// Similar to "send" but does not shutdown the channel if an error occurs.
76959    pub fn send_no_shutdown_on_err(
76960        self,
76961        mut result: Result<(), fidl_fuchsia_posix::Errno>,
76962    ) -> Result<(), fidl::Error> {
76963        let _result = self.send_raw(result);
76964        self.drop_without_shutdown();
76965        _result
76966    }
76967
76968    fn send_raw(
76969        &self,
76970        mut result: Result<(), fidl_fuchsia_posix::Errno>,
76971    ) -> Result<(), fidl::Error> {
76972        self.control_handle.inner.send::<fidl::encoding::ResultType<
76973            fidl::encoding::EmptyStruct,
76974            fidl_fuchsia_posix::Errno,
76975        >>(
76976            result,
76977            self.tx_id,
76978            0x3ecb49968bee439,
76979            fidl::encoding::DynamicFlags::empty(),
76980        )
76981    }
76982}
76983
76984#[must_use = "FIDL methods require a response to be sent"]
76985#[derive(Debug)]
76986pub struct SynchronousDatagramSocketGetOutOfBandInlineResponder {
76987    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
76988    tx_id: u32,
76989}
76990
76991/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
76992/// if the responder is dropped without sending a response, so that the client
76993/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
76994impl std::ops::Drop for SynchronousDatagramSocketGetOutOfBandInlineResponder {
76995    fn drop(&mut self) {
76996        self.control_handle.shutdown();
76997        // Safety: drops once, never accessed again
76998        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
76999    }
77000}
77001
77002impl fidl::endpoints::Responder for SynchronousDatagramSocketGetOutOfBandInlineResponder {
77003    type ControlHandle = SynchronousDatagramSocketControlHandle;
77004
77005    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
77006        &self.control_handle
77007    }
77008
77009    fn drop_without_shutdown(mut self) {
77010        // Safety: drops once, never accessed again due to mem::forget
77011        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77012        // Prevent Drop from running (which would shut down the channel)
77013        std::mem::forget(self);
77014    }
77015}
77016
77017impl SynchronousDatagramSocketGetOutOfBandInlineResponder {
77018    /// Sends a response to the FIDL transaction.
77019    ///
77020    /// Sets the channel to shutdown if an error occurs.
77021    pub fn send(
77022        self,
77023        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
77024    ) -> Result<(), fidl::Error> {
77025        let _result = self.send_raw(result);
77026        if _result.is_err() {
77027            self.control_handle.shutdown();
77028        }
77029        self.drop_without_shutdown();
77030        _result
77031    }
77032
77033    /// Similar to "send" but does not shutdown the channel if an error occurs.
77034    pub fn send_no_shutdown_on_err(
77035        self,
77036        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
77037    ) -> Result<(), fidl::Error> {
77038        let _result = self.send_raw(result);
77039        self.drop_without_shutdown();
77040        _result
77041    }
77042
77043    fn send_raw(
77044        &self,
77045        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
77046    ) -> Result<(), fidl::Error> {
77047        self.control_handle.inner.send::<fidl::encoding::ResultType<
77048            BaseSocketGetOutOfBandInlineResponse,
77049            fidl_fuchsia_posix::Errno,
77050        >>(
77051            result.map(|value| (value,)),
77052            self.tx_id,
77053            0x348c1ab3aeca1745,
77054            fidl::encoding::DynamicFlags::empty(),
77055        )
77056    }
77057}
77058
77059#[must_use = "FIDL methods require a response to be sent"]
77060#[derive(Debug)]
77061pub struct SynchronousDatagramSocketSetNoCheckResponder {
77062    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
77063    tx_id: u32,
77064}
77065
77066/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
77067/// if the responder is dropped without sending a response, so that the client
77068/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
77069impl std::ops::Drop for SynchronousDatagramSocketSetNoCheckResponder {
77070    fn drop(&mut self) {
77071        self.control_handle.shutdown();
77072        // Safety: drops once, never accessed again
77073        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77074    }
77075}
77076
77077impl fidl::endpoints::Responder for SynchronousDatagramSocketSetNoCheckResponder {
77078    type ControlHandle = SynchronousDatagramSocketControlHandle;
77079
77080    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
77081        &self.control_handle
77082    }
77083
77084    fn drop_without_shutdown(mut self) {
77085        // Safety: drops once, never accessed again due to mem::forget
77086        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77087        // Prevent Drop from running (which would shut down the channel)
77088        std::mem::forget(self);
77089    }
77090}
77091
77092impl SynchronousDatagramSocketSetNoCheckResponder {
77093    /// Sends a response to the FIDL transaction.
77094    ///
77095    /// Sets the channel to shutdown if an error occurs.
77096    pub fn send(
77097        self,
77098        mut result: Result<(), fidl_fuchsia_posix::Errno>,
77099    ) -> Result<(), fidl::Error> {
77100        let _result = self.send_raw(result);
77101        if _result.is_err() {
77102            self.control_handle.shutdown();
77103        }
77104        self.drop_without_shutdown();
77105        _result
77106    }
77107
77108    /// Similar to "send" but does not shutdown the channel if an error occurs.
77109    pub fn send_no_shutdown_on_err(
77110        self,
77111        mut result: Result<(), fidl_fuchsia_posix::Errno>,
77112    ) -> Result<(), fidl::Error> {
77113        let _result = self.send_raw(result);
77114        self.drop_without_shutdown();
77115        _result
77116    }
77117
77118    fn send_raw(
77119        &self,
77120        mut result: Result<(), fidl_fuchsia_posix::Errno>,
77121    ) -> Result<(), fidl::Error> {
77122        self.control_handle.inner.send::<fidl::encoding::ResultType<
77123            fidl::encoding::EmptyStruct,
77124            fidl_fuchsia_posix::Errno,
77125        >>(
77126            result,
77127            self.tx_id,
77128            0x6bbf00c53a4c78c2,
77129            fidl::encoding::DynamicFlags::empty(),
77130        )
77131    }
77132}
77133
77134#[must_use = "FIDL methods require a response to be sent"]
77135#[derive(Debug)]
77136pub struct SynchronousDatagramSocketGetNoCheckResponder {
77137    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
77138    tx_id: u32,
77139}
77140
77141/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
77142/// if the responder is dropped without sending a response, so that the client
77143/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
77144impl std::ops::Drop for SynchronousDatagramSocketGetNoCheckResponder {
77145    fn drop(&mut self) {
77146        self.control_handle.shutdown();
77147        // Safety: drops once, never accessed again
77148        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77149    }
77150}
77151
77152impl fidl::endpoints::Responder for SynchronousDatagramSocketGetNoCheckResponder {
77153    type ControlHandle = SynchronousDatagramSocketControlHandle;
77154
77155    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
77156        &self.control_handle
77157    }
77158
77159    fn drop_without_shutdown(mut self) {
77160        // Safety: drops once, never accessed again due to mem::forget
77161        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77162        // Prevent Drop from running (which would shut down the channel)
77163        std::mem::forget(self);
77164    }
77165}
77166
77167impl SynchronousDatagramSocketGetNoCheckResponder {
77168    /// Sends a response to the FIDL transaction.
77169    ///
77170    /// Sets the channel to shutdown if an error occurs.
77171    pub fn send(
77172        self,
77173        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
77174    ) -> Result<(), fidl::Error> {
77175        let _result = self.send_raw(result);
77176        if _result.is_err() {
77177            self.control_handle.shutdown();
77178        }
77179        self.drop_without_shutdown();
77180        _result
77181    }
77182
77183    /// Similar to "send" but does not shutdown the channel if an error occurs.
77184    pub fn send_no_shutdown_on_err(
77185        self,
77186        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
77187    ) -> Result<(), fidl::Error> {
77188        let _result = self.send_raw(result);
77189        self.drop_without_shutdown();
77190        _result
77191    }
77192
77193    fn send_raw(
77194        &self,
77195        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
77196    ) -> Result<(), fidl::Error> {
77197        self.control_handle.inner.send::<fidl::encoding::ResultType<
77198            BaseSocketGetNoCheckResponse,
77199            fidl_fuchsia_posix::Errno,
77200        >>(
77201            result.map(|value| (value,)),
77202            self.tx_id,
77203            0x2cd4249286417694,
77204            fidl::encoding::DynamicFlags::empty(),
77205        )
77206    }
77207}
77208
77209#[must_use = "FIDL methods require a response to be sent"]
77210#[derive(Debug)]
77211pub struct SynchronousDatagramSocketSetLingerResponder {
77212    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
77213    tx_id: u32,
77214}
77215
77216/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
77217/// if the responder is dropped without sending a response, so that the client
77218/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
77219impl std::ops::Drop for SynchronousDatagramSocketSetLingerResponder {
77220    fn drop(&mut self) {
77221        self.control_handle.shutdown();
77222        // Safety: drops once, never accessed again
77223        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77224    }
77225}
77226
77227impl fidl::endpoints::Responder for SynchronousDatagramSocketSetLingerResponder {
77228    type ControlHandle = SynchronousDatagramSocketControlHandle;
77229
77230    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
77231        &self.control_handle
77232    }
77233
77234    fn drop_without_shutdown(mut self) {
77235        // Safety: drops once, never accessed again due to mem::forget
77236        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77237        // Prevent Drop from running (which would shut down the channel)
77238        std::mem::forget(self);
77239    }
77240}
77241
77242impl SynchronousDatagramSocketSetLingerResponder {
77243    /// Sends a response to the FIDL transaction.
77244    ///
77245    /// Sets the channel to shutdown if an error occurs.
77246    pub fn send(
77247        self,
77248        mut result: Result<(), fidl_fuchsia_posix::Errno>,
77249    ) -> Result<(), fidl::Error> {
77250        let _result = self.send_raw(result);
77251        if _result.is_err() {
77252            self.control_handle.shutdown();
77253        }
77254        self.drop_without_shutdown();
77255        _result
77256    }
77257
77258    /// Similar to "send" but does not shutdown the channel if an error occurs.
77259    pub fn send_no_shutdown_on_err(
77260        self,
77261        mut result: Result<(), fidl_fuchsia_posix::Errno>,
77262    ) -> Result<(), fidl::Error> {
77263        let _result = self.send_raw(result);
77264        self.drop_without_shutdown();
77265        _result
77266    }
77267
77268    fn send_raw(
77269        &self,
77270        mut result: Result<(), fidl_fuchsia_posix::Errno>,
77271    ) -> Result<(), fidl::Error> {
77272        self.control_handle.inner.send::<fidl::encoding::ResultType<
77273            fidl::encoding::EmptyStruct,
77274            fidl_fuchsia_posix::Errno,
77275        >>(
77276            result,
77277            self.tx_id,
77278            0x45386351246e998e,
77279            fidl::encoding::DynamicFlags::empty(),
77280        )
77281    }
77282}
77283
77284#[must_use = "FIDL methods require a response to be sent"]
77285#[derive(Debug)]
77286pub struct SynchronousDatagramSocketGetLingerResponder {
77287    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
77288    tx_id: u32,
77289}
77290
77291/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
77292/// if the responder is dropped without sending a response, so that the client
77293/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
77294impl std::ops::Drop for SynchronousDatagramSocketGetLingerResponder {
77295    fn drop(&mut self) {
77296        self.control_handle.shutdown();
77297        // Safety: drops once, never accessed again
77298        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77299    }
77300}
77301
77302impl fidl::endpoints::Responder for SynchronousDatagramSocketGetLingerResponder {
77303    type ControlHandle = SynchronousDatagramSocketControlHandle;
77304
77305    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
77306        &self.control_handle
77307    }
77308
77309    fn drop_without_shutdown(mut self) {
77310        // Safety: drops once, never accessed again due to mem::forget
77311        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77312        // Prevent Drop from running (which would shut down the channel)
77313        std::mem::forget(self);
77314    }
77315}
77316
77317impl SynchronousDatagramSocketGetLingerResponder {
77318    /// Sends a response to the FIDL transaction.
77319    ///
77320    /// Sets the channel to shutdown if an error occurs.
77321    pub fn send(
77322        self,
77323        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
77324    ) -> Result<(), fidl::Error> {
77325        let _result = self.send_raw(result);
77326        if _result.is_err() {
77327            self.control_handle.shutdown();
77328        }
77329        self.drop_without_shutdown();
77330        _result
77331    }
77332
77333    /// Similar to "send" but does not shutdown the channel if an error occurs.
77334    pub fn send_no_shutdown_on_err(
77335        self,
77336        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
77337    ) -> Result<(), fidl::Error> {
77338        let _result = self.send_raw(result);
77339        self.drop_without_shutdown();
77340        _result
77341    }
77342
77343    fn send_raw(
77344        &self,
77345        mut result: Result<(bool, u32), fidl_fuchsia_posix::Errno>,
77346    ) -> Result<(), fidl::Error> {
77347        self.control_handle.inner.send::<fidl::encoding::ResultType<
77348            BaseSocketGetLingerResponse,
77349            fidl_fuchsia_posix::Errno,
77350        >>(
77351            result,
77352            self.tx_id,
77353            0x48eb20fc5ccb0e45,
77354            fidl::encoding::DynamicFlags::empty(),
77355        )
77356    }
77357}
77358
77359#[must_use = "FIDL methods require a response to be sent"]
77360#[derive(Debug)]
77361pub struct SynchronousDatagramSocketSetReusePortResponder {
77362    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
77363    tx_id: u32,
77364}
77365
77366/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
77367/// if the responder is dropped without sending a response, so that the client
77368/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
77369impl std::ops::Drop for SynchronousDatagramSocketSetReusePortResponder {
77370    fn drop(&mut self) {
77371        self.control_handle.shutdown();
77372        // Safety: drops once, never accessed again
77373        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77374    }
77375}
77376
77377impl fidl::endpoints::Responder for SynchronousDatagramSocketSetReusePortResponder {
77378    type ControlHandle = SynchronousDatagramSocketControlHandle;
77379
77380    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
77381        &self.control_handle
77382    }
77383
77384    fn drop_without_shutdown(mut self) {
77385        // Safety: drops once, never accessed again due to mem::forget
77386        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77387        // Prevent Drop from running (which would shut down the channel)
77388        std::mem::forget(self);
77389    }
77390}
77391
77392impl SynchronousDatagramSocketSetReusePortResponder {
77393    /// Sends a response to the FIDL transaction.
77394    ///
77395    /// Sets the channel to shutdown if an error occurs.
77396    pub fn send(
77397        self,
77398        mut result: Result<(), fidl_fuchsia_posix::Errno>,
77399    ) -> Result<(), fidl::Error> {
77400        let _result = self.send_raw(result);
77401        if _result.is_err() {
77402            self.control_handle.shutdown();
77403        }
77404        self.drop_without_shutdown();
77405        _result
77406    }
77407
77408    /// Similar to "send" but does not shutdown the channel if an error occurs.
77409    pub fn send_no_shutdown_on_err(
77410        self,
77411        mut result: Result<(), fidl_fuchsia_posix::Errno>,
77412    ) -> Result<(), fidl::Error> {
77413        let _result = self.send_raw(result);
77414        self.drop_without_shutdown();
77415        _result
77416    }
77417
77418    fn send_raw(
77419        &self,
77420        mut result: Result<(), fidl_fuchsia_posix::Errno>,
77421    ) -> Result<(), fidl::Error> {
77422        self.control_handle.inner.send::<fidl::encoding::ResultType<
77423            fidl::encoding::EmptyStruct,
77424            fidl_fuchsia_posix::Errno,
77425        >>(
77426            result,
77427            self.tx_id,
77428            0x24dd3e5cb36d9ccb,
77429            fidl::encoding::DynamicFlags::empty(),
77430        )
77431    }
77432}
77433
77434#[must_use = "FIDL methods require a response to be sent"]
77435#[derive(Debug)]
77436pub struct SynchronousDatagramSocketGetReusePortResponder {
77437    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
77438    tx_id: u32,
77439}
77440
77441/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
77442/// if the responder is dropped without sending a response, so that the client
77443/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
77444impl std::ops::Drop for SynchronousDatagramSocketGetReusePortResponder {
77445    fn drop(&mut self) {
77446        self.control_handle.shutdown();
77447        // Safety: drops once, never accessed again
77448        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77449    }
77450}
77451
77452impl fidl::endpoints::Responder for SynchronousDatagramSocketGetReusePortResponder {
77453    type ControlHandle = SynchronousDatagramSocketControlHandle;
77454
77455    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
77456        &self.control_handle
77457    }
77458
77459    fn drop_without_shutdown(mut self) {
77460        // Safety: drops once, never accessed again due to mem::forget
77461        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77462        // Prevent Drop from running (which would shut down the channel)
77463        std::mem::forget(self);
77464    }
77465}
77466
77467impl SynchronousDatagramSocketGetReusePortResponder {
77468    /// Sends a response to the FIDL transaction.
77469    ///
77470    /// Sets the channel to shutdown if an error occurs.
77471    pub fn send(
77472        self,
77473        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
77474    ) -> Result<(), fidl::Error> {
77475        let _result = self.send_raw(result);
77476        if _result.is_err() {
77477            self.control_handle.shutdown();
77478        }
77479        self.drop_without_shutdown();
77480        _result
77481    }
77482
77483    /// Similar to "send" but does not shutdown the channel if an error occurs.
77484    pub fn send_no_shutdown_on_err(
77485        self,
77486        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
77487    ) -> Result<(), fidl::Error> {
77488        let _result = self.send_raw(result);
77489        self.drop_without_shutdown();
77490        _result
77491    }
77492
77493    fn send_raw(
77494        &self,
77495        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
77496    ) -> Result<(), fidl::Error> {
77497        self.control_handle.inner.send::<fidl::encoding::ResultType<
77498            BaseSocketGetReusePortResponse,
77499            fidl_fuchsia_posix::Errno,
77500        >>(
77501            result.map(|value| (value,)),
77502            self.tx_id,
77503            0x7a112c1ab54ff828,
77504            fidl::encoding::DynamicFlags::empty(),
77505        )
77506    }
77507}
77508
77509#[must_use = "FIDL methods require a response to be sent"]
77510#[derive(Debug)]
77511pub struct SynchronousDatagramSocketGetAcceptConnResponder {
77512    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
77513    tx_id: u32,
77514}
77515
77516/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
77517/// if the responder is dropped without sending a response, so that the client
77518/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
77519impl std::ops::Drop for SynchronousDatagramSocketGetAcceptConnResponder {
77520    fn drop(&mut self) {
77521        self.control_handle.shutdown();
77522        // Safety: drops once, never accessed again
77523        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77524    }
77525}
77526
77527impl fidl::endpoints::Responder for SynchronousDatagramSocketGetAcceptConnResponder {
77528    type ControlHandle = SynchronousDatagramSocketControlHandle;
77529
77530    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
77531        &self.control_handle
77532    }
77533
77534    fn drop_without_shutdown(mut self) {
77535        // Safety: drops once, never accessed again due to mem::forget
77536        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77537        // Prevent Drop from running (which would shut down the channel)
77538        std::mem::forget(self);
77539    }
77540}
77541
77542impl SynchronousDatagramSocketGetAcceptConnResponder {
77543    /// Sends a response to the FIDL transaction.
77544    ///
77545    /// Sets the channel to shutdown if an error occurs.
77546    pub fn send(
77547        self,
77548        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
77549    ) -> Result<(), fidl::Error> {
77550        let _result = self.send_raw(result);
77551        if _result.is_err() {
77552            self.control_handle.shutdown();
77553        }
77554        self.drop_without_shutdown();
77555        _result
77556    }
77557
77558    /// Similar to "send" but does not shutdown the channel if an error occurs.
77559    pub fn send_no_shutdown_on_err(
77560        self,
77561        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
77562    ) -> Result<(), fidl::Error> {
77563        let _result = self.send_raw(result);
77564        self.drop_without_shutdown();
77565        _result
77566    }
77567
77568    fn send_raw(
77569        &self,
77570        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
77571    ) -> Result<(), fidl::Error> {
77572        self.control_handle.inner.send::<fidl::encoding::ResultType<
77573            BaseSocketGetAcceptConnResponse,
77574            fidl_fuchsia_posix::Errno,
77575        >>(
77576            result.map(|value| (value,)),
77577            self.tx_id,
77578            0x67ce6db6c2ec8966,
77579            fidl::encoding::DynamicFlags::empty(),
77580        )
77581    }
77582}
77583
77584#[must_use = "FIDL methods require a response to be sent"]
77585#[derive(Debug)]
77586pub struct SynchronousDatagramSocketSetBindToDeviceResponder {
77587    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
77588    tx_id: u32,
77589}
77590
77591/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
77592/// if the responder is dropped without sending a response, so that the client
77593/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
77594impl std::ops::Drop for SynchronousDatagramSocketSetBindToDeviceResponder {
77595    fn drop(&mut self) {
77596        self.control_handle.shutdown();
77597        // Safety: drops once, never accessed again
77598        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77599    }
77600}
77601
77602impl fidl::endpoints::Responder for SynchronousDatagramSocketSetBindToDeviceResponder {
77603    type ControlHandle = SynchronousDatagramSocketControlHandle;
77604
77605    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
77606        &self.control_handle
77607    }
77608
77609    fn drop_without_shutdown(mut self) {
77610        // Safety: drops once, never accessed again due to mem::forget
77611        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77612        // Prevent Drop from running (which would shut down the channel)
77613        std::mem::forget(self);
77614    }
77615}
77616
77617impl SynchronousDatagramSocketSetBindToDeviceResponder {
77618    /// Sends a response to the FIDL transaction.
77619    ///
77620    /// Sets the channel to shutdown if an error occurs.
77621    pub fn send(
77622        self,
77623        mut result: Result<(), fidl_fuchsia_posix::Errno>,
77624    ) -> Result<(), fidl::Error> {
77625        let _result = self.send_raw(result);
77626        if _result.is_err() {
77627            self.control_handle.shutdown();
77628        }
77629        self.drop_without_shutdown();
77630        _result
77631    }
77632
77633    /// Similar to "send" but does not shutdown the channel if an error occurs.
77634    pub fn send_no_shutdown_on_err(
77635        self,
77636        mut result: Result<(), fidl_fuchsia_posix::Errno>,
77637    ) -> Result<(), fidl::Error> {
77638        let _result = self.send_raw(result);
77639        self.drop_without_shutdown();
77640        _result
77641    }
77642
77643    fn send_raw(
77644        &self,
77645        mut result: Result<(), fidl_fuchsia_posix::Errno>,
77646    ) -> Result<(), fidl::Error> {
77647        self.control_handle.inner.send::<fidl::encoding::ResultType<
77648            fidl::encoding::EmptyStruct,
77649            fidl_fuchsia_posix::Errno,
77650        >>(
77651            result,
77652            self.tx_id,
77653            0x2118b483f28aafc4,
77654            fidl::encoding::DynamicFlags::empty(),
77655        )
77656    }
77657}
77658
77659#[must_use = "FIDL methods require a response to be sent"]
77660#[derive(Debug)]
77661pub struct SynchronousDatagramSocketGetBindToDeviceResponder {
77662    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
77663    tx_id: u32,
77664}
77665
77666/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
77667/// if the responder is dropped without sending a response, so that the client
77668/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
77669impl std::ops::Drop for SynchronousDatagramSocketGetBindToDeviceResponder {
77670    fn drop(&mut self) {
77671        self.control_handle.shutdown();
77672        // Safety: drops once, never accessed again
77673        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77674    }
77675}
77676
77677impl fidl::endpoints::Responder for SynchronousDatagramSocketGetBindToDeviceResponder {
77678    type ControlHandle = SynchronousDatagramSocketControlHandle;
77679
77680    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
77681        &self.control_handle
77682    }
77683
77684    fn drop_without_shutdown(mut self) {
77685        // Safety: drops once, never accessed again due to mem::forget
77686        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77687        // Prevent Drop from running (which would shut down the channel)
77688        std::mem::forget(self);
77689    }
77690}
77691
77692impl SynchronousDatagramSocketGetBindToDeviceResponder {
77693    /// Sends a response to the FIDL transaction.
77694    ///
77695    /// Sets the channel to shutdown if an error occurs.
77696    pub fn send(
77697        self,
77698        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
77699    ) -> Result<(), fidl::Error> {
77700        let _result = self.send_raw(result);
77701        if _result.is_err() {
77702            self.control_handle.shutdown();
77703        }
77704        self.drop_without_shutdown();
77705        _result
77706    }
77707
77708    /// Similar to "send" but does not shutdown the channel if an error occurs.
77709    pub fn send_no_shutdown_on_err(
77710        self,
77711        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
77712    ) -> Result<(), fidl::Error> {
77713        let _result = self.send_raw(result);
77714        self.drop_without_shutdown();
77715        _result
77716    }
77717
77718    fn send_raw(
77719        &self,
77720        mut result: Result<&str, fidl_fuchsia_posix::Errno>,
77721    ) -> Result<(), fidl::Error> {
77722        self.control_handle.inner.send::<fidl::encoding::ResultType<
77723            BaseSocketGetBindToDeviceResponse,
77724            fidl_fuchsia_posix::Errno,
77725        >>(
77726            result.map(|value| (value,)),
77727            self.tx_id,
77728            0x1ab1fbf0ef7906c8,
77729            fidl::encoding::DynamicFlags::empty(),
77730        )
77731    }
77732}
77733
77734#[must_use = "FIDL methods require a response to be sent"]
77735#[derive(Debug)]
77736pub struct SynchronousDatagramSocketSetBindToInterfaceIndexResponder {
77737    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
77738    tx_id: u32,
77739}
77740
77741/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
77742/// if the responder is dropped without sending a response, so that the client
77743/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
77744impl std::ops::Drop for SynchronousDatagramSocketSetBindToInterfaceIndexResponder {
77745    fn drop(&mut self) {
77746        self.control_handle.shutdown();
77747        // Safety: drops once, never accessed again
77748        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77749    }
77750}
77751
77752impl fidl::endpoints::Responder for SynchronousDatagramSocketSetBindToInterfaceIndexResponder {
77753    type ControlHandle = SynchronousDatagramSocketControlHandle;
77754
77755    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
77756        &self.control_handle
77757    }
77758
77759    fn drop_without_shutdown(mut self) {
77760        // Safety: drops once, never accessed again due to mem::forget
77761        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77762        // Prevent Drop from running (which would shut down the channel)
77763        std::mem::forget(self);
77764    }
77765}
77766
77767impl SynchronousDatagramSocketSetBindToInterfaceIndexResponder {
77768    /// Sends a response to the FIDL transaction.
77769    ///
77770    /// Sets the channel to shutdown if an error occurs.
77771    pub fn send(
77772        self,
77773        mut result: Result<(), fidl_fuchsia_posix::Errno>,
77774    ) -> Result<(), fidl::Error> {
77775        let _result = self.send_raw(result);
77776        if _result.is_err() {
77777            self.control_handle.shutdown();
77778        }
77779        self.drop_without_shutdown();
77780        _result
77781    }
77782
77783    /// Similar to "send" but does not shutdown the channel if an error occurs.
77784    pub fn send_no_shutdown_on_err(
77785        self,
77786        mut result: Result<(), fidl_fuchsia_posix::Errno>,
77787    ) -> Result<(), fidl::Error> {
77788        let _result = self.send_raw(result);
77789        self.drop_without_shutdown();
77790        _result
77791    }
77792
77793    fn send_raw(
77794        &self,
77795        mut result: Result<(), fidl_fuchsia_posix::Errno>,
77796    ) -> Result<(), fidl::Error> {
77797        self.control_handle.inner.send::<fidl::encoding::ResultType<
77798            fidl::encoding::EmptyStruct,
77799            fidl_fuchsia_posix::Errno,
77800        >>(
77801            result,
77802            self.tx_id,
77803            0x6e387a0def00821,
77804            fidl::encoding::DynamicFlags::empty(),
77805        )
77806    }
77807}
77808
77809#[must_use = "FIDL methods require a response to be sent"]
77810#[derive(Debug)]
77811pub struct SynchronousDatagramSocketGetBindToInterfaceIndexResponder {
77812    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
77813    tx_id: u32,
77814}
77815
77816/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
77817/// if the responder is dropped without sending a response, so that the client
77818/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
77819impl std::ops::Drop for SynchronousDatagramSocketGetBindToInterfaceIndexResponder {
77820    fn drop(&mut self) {
77821        self.control_handle.shutdown();
77822        // Safety: drops once, never accessed again
77823        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77824    }
77825}
77826
77827impl fidl::endpoints::Responder for SynchronousDatagramSocketGetBindToInterfaceIndexResponder {
77828    type ControlHandle = SynchronousDatagramSocketControlHandle;
77829
77830    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
77831        &self.control_handle
77832    }
77833
77834    fn drop_without_shutdown(mut self) {
77835        // Safety: drops once, never accessed again due to mem::forget
77836        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77837        // Prevent Drop from running (which would shut down the channel)
77838        std::mem::forget(self);
77839    }
77840}
77841
77842impl SynchronousDatagramSocketGetBindToInterfaceIndexResponder {
77843    /// Sends a response to the FIDL transaction.
77844    ///
77845    /// Sets the channel to shutdown if an error occurs.
77846    pub fn send(
77847        self,
77848        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
77849    ) -> Result<(), fidl::Error> {
77850        let _result = self.send_raw(result);
77851        if _result.is_err() {
77852            self.control_handle.shutdown();
77853        }
77854        self.drop_without_shutdown();
77855        _result
77856    }
77857
77858    /// Similar to "send" but does not shutdown the channel if an error occurs.
77859    pub fn send_no_shutdown_on_err(
77860        self,
77861        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
77862    ) -> Result<(), fidl::Error> {
77863        let _result = self.send_raw(result);
77864        self.drop_without_shutdown();
77865        _result
77866    }
77867
77868    fn send_raw(
77869        &self,
77870        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
77871    ) -> Result<(), fidl::Error> {
77872        self.control_handle.inner.send::<fidl::encoding::ResultType<
77873            BaseSocketGetBindToInterfaceIndexResponse,
77874            fidl_fuchsia_posix::Errno,
77875        >>(
77876            result.map(|value| (value,)),
77877            self.tx_id,
77878            0x59c31dd3e3078295,
77879            fidl::encoding::DynamicFlags::empty(),
77880        )
77881    }
77882}
77883
77884#[must_use = "FIDL methods require a response to be sent"]
77885#[derive(Debug)]
77886pub struct SynchronousDatagramSocketSetTimestampResponder {
77887    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
77888    tx_id: u32,
77889}
77890
77891/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
77892/// if the responder is dropped without sending a response, so that the client
77893/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
77894impl std::ops::Drop for SynchronousDatagramSocketSetTimestampResponder {
77895    fn drop(&mut self) {
77896        self.control_handle.shutdown();
77897        // Safety: drops once, never accessed again
77898        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77899    }
77900}
77901
77902impl fidl::endpoints::Responder for SynchronousDatagramSocketSetTimestampResponder {
77903    type ControlHandle = SynchronousDatagramSocketControlHandle;
77904
77905    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
77906        &self.control_handle
77907    }
77908
77909    fn drop_without_shutdown(mut self) {
77910        // Safety: drops once, never accessed again due to mem::forget
77911        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77912        // Prevent Drop from running (which would shut down the channel)
77913        std::mem::forget(self);
77914    }
77915}
77916
77917impl SynchronousDatagramSocketSetTimestampResponder {
77918    /// Sends a response to the FIDL transaction.
77919    ///
77920    /// Sets the channel to shutdown if an error occurs.
77921    pub fn send(
77922        self,
77923        mut result: Result<(), fidl_fuchsia_posix::Errno>,
77924    ) -> Result<(), fidl::Error> {
77925        let _result = self.send_raw(result);
77926        if _result.is_err() {
77927            self.control_handle.shutdown();
77928        }
77929        self.drop_without_shutdown();
77930        _result
77931    }
77932
77933    /// Similar to "send" but does not shutdown the channel if an error occurs.
77934    pub fn send_no_shutdown_on_err(
77935        self,
77936        mut result: Result<(), fidl_fuchsia_posix::Errno>,
77937    ) -> Result<(), fidl::Error> {
77938        let _result = self.send_raw(result);
77939        self.drop_without_shutdown();
77940        _result
77941    }
77942
77943    fn send_raw(
77944        &self,
77945        mut result: Result<(), fidl_fuchsia_posix::Errno>,
77946    ) -> Result<(), fidl::Error> {
77947        self.control_handle.inner.send::<fidl::encoding::ResultType<
77948            fidl::encoding::EmptyStruct,
77949            fidl_fuchsia_posix::Errno,
77950        >>(
77951            result,
77952            self.tx_id,
77953            0x285d6516c263d839,
77954            fidl::encoding::DynamicFlags::empty(),
77955        )
77956    }
77957}
77958
77959#[must_use = "FIDL methods require a response to be sent"]
77960#[derive(Debug)]
77961pub struct SynchronousDatagramSocketGetTimestampResponder {
77962    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
77963    tx_id: u32,
77964}
77965
77966/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
77967/// if the responder is dropped without sending a response, so that the client
77968/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
77969impl std::ops::Drop for SynchronousDatagramSocketGetTimestampResponder {
77970    fn drop(&mut self) {
77971        self.control_handle.shutdown();
77972        // Safety: drops once, never accessed again
77973        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77974    }
77975}
77976
77977impl fidl::endpoints::Responder for SynchronousDatagramSocketGetTimestampResponder {
77978    type ControlHandle = SynchronousDatagramSocketControlHandle;
77979
77980    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
77981        &self.control_handle
77982    }
77983
77984    fn drop_without_shutdown(mut self) {
77985        // Safety: drops once, never accessed again due to mem::forget
77986        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
77987        // Prevent Drop from running (which would shut down the channel)
77988        std::mem::forget(self);
77989    }
77990}
77991
77992impl SynchronousDatagramSocketGetTimestampResponder {
77993    /// Sends a response to the FIDL transaction.
77994    ///
77995    /// Sets the channel to shutdown if an error occurs.
77996    pub fn send(
77997        self,
77998        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
77999    ) -> Result<(), fidl::Error> {
78000        let _result = self.send_raw(result);
78001        if _result.is_err() {
78002            self.control_handle.shutdown();
78003        }
78004        self.drop_without_shutdown();
78005        _result
78006    }
78007
78008    /// Similar to "send" but does not shutdown the channel if an error occurs.
78009    pub fn send_no_shutdown_on_err(
78010        self,
78011        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
78012    ) -> Result<(), fidl::Error> {
78013        let _result = self.send_raw(result);
78014        self.drop_without_shutdown();
78015        _result
78016    }
78017
78018    fn send_raw(
78019        &self,
78020        mut result: Result<TimestampOption, fidl_fuchsia_posix::Errno>,
78021    ) -> Result<(), fidl::Error> {
78022        self.control_handle.inner.send::<fidl::encoding::ResultType<
78023            BaseSocketGetTimestampResponse,
78024            fidl_fuchsia_posix::Errno,
78025        >>(
78026            result.map(|value| (value,)),
78027            self.tx_id,
78028            0x49f2fffbbcc2bd27,
78029            fidl::encoding::DynamicFlags::empty(),
78030        )
78031    }
78032}
78033
78034#[must_use = "FIDL methods require a response to be sent"]
78035#[derive(Debug)]
78036pub struct SynchronousDatagramSocketSetMarkResponder {
78037    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
78038    tx_id: u32,
78039}
78040
78041/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
78042/// if the responder is dropped without sending a response, so that the client
78043/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
78044impl std::ops::Drop for SynchronousDatagramSocketSetMarkResponder {
78045    fn drop(&mut self) {
78046        self.control_handle.shutdown();
78047        // Safety: drops once, never accessed again
78048        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78049    }
78050}
78051
78052impl fidl::endpoints::Responder for SynchronousDatagramSocketSetMarkResponder {
78053    type ControlHandle = SynchronousDatagramSocketControlHandle;
78054
78055    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
78056        &self.control_handle
78057    }
78058
78059    fn drop_without_shutdown(mut self) {
78060        // Safety: drops once, never accessed again due to mem::forget
78061        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78062        // Prevent Drop from running (which would shut down the channel)
78063        std::mem::forget(self);
78064    }
78065}
78066
78067impl SynchronousDatagramSocketSetMarkResponder {
78068    /// Sends a response to the FIDL transaction.
78069    ///
78070    /// Sets the channel to shutdown if an error occurs.
78071    pub fn send(
78072        self,
78073        mut result: Result<(), fidl_fuchsia_posix::Errno>,
78074    ) -> Result<(), fidl::Error> {
78075        let _result = self.send_raw(result);
78076        if _result.is_err() {
78077            self.control_handle.shutdown();
78078        }
78079        self.drop_without_shutdown();
78080        _result
78081    }
78082
78083    /// Similar to "send" but does not shutdown the channel if an error occurs.
78084    pub fn send_no_shutdown_on_err(
78085        self,
78086        mut result: Result<(), fidl_fuchsia_posix::Errno>,
78087    ) -> Result<(), fidl::Error> {
78088        let _result = self.send_raw(result);
78089        self.drop_without_shutdown();
78090        _result
78091    }
78092
78093    fn send_raw(
78094        &self,
78095        mut result: Result<(), fidl_fuchsia_posix::Errno>,
78096    ) -> Result<(), fidl::Error> {
78097        self.control_handle.inner.send::<fidl::encoding::ResultType<
78098            fidl::encoding::EmptyStruct,
78099            fidl_fuchsia_posix::Errno,
78100        >>(
78101            result,
78102            self.tx_id,
78103            0x6ead6de09f653236,
78104            fidl::encoding::DynamicFlags::empty(),
78105        )
78106    }
78107}
78108
78109#[must_use = "FIDL methods require a response to be sent"]
78110#[derive(Debug)]
78111pub struct SynchronousDatagramSocketGetMarkResponder {
78112    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
78113    tx_id: u32,
78114}
78115
78116/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
78117/// if the responder is dropped without sending a response, so that the client
78118/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
78119impl std::ops::Drop for SynchronousDatagramSocketGetMarkResponder {
78120    fn drop(&mut self) {
78121        self.control_handle.shutdown();
78122        // Safety: drops once, never accessed again
78123        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78124    }
78125}
78126
78127impl fidl::endpoints::Responder for SynchronousDatagramSocketGetMarkResponder {
78128    type ControlHandle = SynchronousDatagramSocketControlHandle;
78129
78130    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
78131        &self.control_handle
78132    }
78133
78134    fn drop_without_shutdown(mut self) {
78135        // Safety: drops once, never accessed again due to mem::forget
78136        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78137        // Prevent Drop from running (which would shut down the channel)
78138        std::mem::forget(self);
78139    }
78140}
78141
78142impl SynchronousDatagramSocketGetMarkResponder {
78143    /// Sends a response to the FIDL transaction.
78144    ///
78145    /// Sets the channel to shutdown if an error occurs.
78146    pub fn send(
78147        self,
78148        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
78149    ) -> Result<(), fidl::Error> {
78150        let _result = self.send_raw(result);
78151        if _result.is_err() {
78152            self.control_handle.shutdown();
78153        }
78154        self.drop_without_shutdown();
78155        _result
78156    }
78157
78158    /// Similar to "send" but does not shutdown the channel if an error occurs.
78159    pub fn send_no_shutdown_on_err(
78160        self,
78161        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
78162    ) -> Result<(), fidl::Error> {
78163        let _result = self.send_raw(result);
78164        self.drop_without_shutdown();
78165        _result
78166    }
78167
78168    fn send_raw(
78169        &self,
78170        mut result: Result<&OptionalUint32, fidl_fuchsia_posix::Errno>,
78171    ) -> Result<(), fidl::Error> {
78172        self.control_handle.inner.send::<fidl::encoding::ResultType<
78173            BaseSocketGetMarkResponse,
78174            fidl_fuchsia_posix::Errno,
78175        >>(
78176            result.map(|mark| (mark,)),
78177            self.tx_id,
78178            0x57a2752c61d93d47,
78179            fidl::encoding::DynamicFlags::empty(),
78180        )
78181    }
78182}
78183
78184#[must_use = "FIDL methods require a response to be sent"]
78185#[derive(Debug)]
78186pub struct SynchronousDatagramSocketBindResponder {
78187    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
78188    tx_id: u32,
78189}
78190
78191/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
78192/// if the responder is dropped without sending a response, so that the client
78193/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
78194impl std::ops::Drop for SynchronousDatagramSocketBindResponder {
78195    fn drop(&mut self) {
78196        self.control_handle.shutdown();
78197        // Safety: drops once, never accessed again
78198        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78199    }
78200}
78201
78202impl fidl::endpoints::Responder for SynchronousDatagramSocketBindResponder {
78203    type ControlHandle = SynchronousDatagramSocketControlHandle;
78204
78205    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
78206        &self.control_handle
78207    }
78208
78209    fn drop_without_shutdown(mut self) {
78210        // Safety: drops once, never accessed again due to mem::forget
78211        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78212        // Prevent Drop from running (which would shut down the channel)
78213        std::mem::forget(self);
78214    }
78215}
78216
78217impl SynchronousDatagramSocketBindResponder {
78218    /// Sends a response to the FIDL transaction.
78219    ///
78220    /// Sets the channel to shutdown if an error occurs.
78221    pub fn send(
78222        self,
78223        mut result: Result<(), fidl_fuchsia_posix::Errno>,
78224    ) -> Result<(), fidl::Error> {
78225        let _result = self.send_raw(result);
78226        if _result.is_err() {
78227            self.control_handle.shutdown();
78228        }
78229        self.drop_without_shutdown();
78230        _result
78231    }
78232
78233    /// Similar to "send" but does not shutdown the channel if an error occurs.
78234    pub fn send_no_shutdown_on_err(
78235        self,
78236        mut result: Result<(), fidl_fuchsia_posix::Errno>,
78237    ) -> Result<(), fidl::Error> {
78238        let _result = self.send_raw(result);
78239        self.drop_without_shutdown();
78240        _result
78241    }
78242
78243    fn send_raw(
78244        &self,
78245        mut result: Result<(), fidl_fuchsia_posix::Errno>,
78246    ) -> Result<(), fidl::Error> {
78247        self.control_handle.inner.send::<fidl::encoding::ResultType<
78248            fidl::encoding::EmptyStruct,
78249            fidl_fuchsia_posix::Errno,
78250        >>(
78251            result,
78252            self.tx_id,
78253            0x4bc6400ae92125d,
78254            fidl::encoding::DynamicFlags::empty(),
78255        )
78256    }
78257}
78258
78259#[must_use = "FIDL methods require a response to be sent"]
78260#[derive(Debug)]
78261pub struct SynchronousDatagramSocketConnectResponder {
78262    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
78263    tx_id: u32,
78264}
78265
78266/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
78267/// if the responder is dropped without sending a response, so that the client
78268/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
78269impl std::ops::Drop for SynchronousDatagramSocketConnectResponder {
78270    fn drop(&mut self) {
78271        self.control_handle.shutdown();
78272        // Safety: drops once, never accessed again
78273        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78274    }
78275}
78276
78277impl fidl::endpoints::Responder for SynchronousDatagramSocketConnectResponder {
78278    type ControlHandle = SynchronousDatagramSocketControlHandle;
78279
78280    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
78281        &self.control_handle
78282    }
78283
78284    fn drop_without_shutdown(mut self) {
78285        // Safety: drops once, never accessed again due to mem::forget
78286        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78287        // Prevent Drop from running (which would shut down the channel)
78288        std::mem::forget(self);
78289    }
78290}
78291
78292impl SynchronousDatagramSocketConnectResponder {
78293    /// Sends a response to the FIDL transaction.
78294    ///
78295    /// Sets the channel to shutdown if an error occurs.
78296    pub fn send(
78297        self,
78298        mut result: Result<(), fidl_fuchsia_posix::Errno>,
78299    ) -> Result<(), fidl::Error> {
78300        let _result = self.send_raw(result);
78301        if _result.is_err() {
78302            self.control_handle.shutdown();
78303        }
78304        self.drop_without_shutdown();
78305        _result
78306    }
78307
78308    /// Similar to "send" but does not shutdown the channel if an error occurs.
78309    pub fn send_no_shutdown_on_err(
78310        self,
78311        mut result: Result<(), fidl_fuchsia_posix::Errno>,
78312    ) -> Result<(), fidl::Error> {
78313        let _result = self.send_raw(result);
78314        self.drop_without_shutdown();
78315        _result
78316    }
78317
78318    fn send_raw(
78319        &self,
78320        mut result: Result<(), fidl_fuchsia_posix::Errno>,
78321    ) -> Result<(), fidl::Error> {
78322        self.control_handle.inner.send::<fidl::encoding::ResultType<
78323            fidl::encoding::EmptyStruct,
78324            fidl_fuchsia_posix::Errno,
78325        >>(
78326            result,
78327            self.tx_id,
78328            0x5f05f19bfdd38871,
78329            fidl::encoding::DynamicFlags::empty(),
78330        )
78331    }
78332}
78333
78334#[must_use = "FIDL methods require a response to be sent"]
78335#[derive(Debug)]
78336pub struct SynchronousDatagramSocketDisconnectResponder {
78337    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
78338    tx_id: u32,
78339}
78340
78341/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
78342/// if the responder is dropped without sending a response, so that the client
78343/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
78344impl std::ops::Drop for SynchronousDatagramSocketDisconnectResponder {
78345    fn drop(&mut self) {
78346        self.control_handle.shutdown();
78347        // Safety: drops once, never accessed again
78348        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78349    }
78350}
78351
78352impl fidl::endpoints::Responder for SynchronousDatagramSocketDisconnectResponder {
78353    type ControlHandle = SynchronousDatagramSocketControlHandle;
78354
78355    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
78356        &self.control_handle
78357    }
78358
78359    fn drop_without_shutdown(mut self) {
78360        // Safety: drops once, never accessed again due to mem::forget
78361        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78362        // Prevent Drop from running (which would shut down the channel)
78363        std::mem::forget(self);
78364    }
78365}
78366
78367impl SynchronousDatagramSocketDisconnectResponder {
78368    /// Sends a response to the FIDL transaction.
78369    ///
78370    /// Sets the channel to shutdown if an error occurs.
78371    pub fn send(
78372        self,
78373        mut result: Result<(), fidl_fuchsia_posix::Errno>,
78374    ) -> Result<(), fidl::Error> {
78375        let _result = self.send_raw(result);
78376        if _result.is_err() {
78377            self.control_handle.shutdown();
78378        }
78379        self.drop_without_shutdown();
78380        _result
78381    }
78382
78383    /// Similar to "send" but does not shutdown the channel if an error occurs.
78384    pub fn send_no_shutdown_on_err(
78385        self,
78386        mut result: Result<(), fidl_fuchsia_posix::Errno>,
78387    ) -> Result<(), fidl::Error> {
78388        let _result = self.send_raw(result);
78389        self.drop_without_shutdown();
78390        _result
78391    }
78392
78393    fn send_raw(
78394        &self,
78395        mut result: Result<(), fidl_fuchsia_posix::Errno>,
78396    ) -> Result<(), fidl::Error> {
78397        self.control_handle.inner.send::<fidl::encoding::ResultType<
78398            fidl::encoding::EmptyStruct,
78399            fidl_fuchsia_posix::Errno,
78400        >>(
78401            result,
78402            self.tx_id,
78403            0x74e63b91f7b29b2,
78404            fidl::encoding::DynamicFlags::empty(),
78405        )
78406    }
78407}
78408
78409#[must_use = "FIDL methods require a response to be sent"]
78410#[derive(Debug)]
78411pub struct SynchronousDatagramSocketGetSockNameResponder {
78412    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
78413    tx_id: u32,
78414}
78415
78416/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
78417/// if the responder is dropped without sending a response, so that the client
78418/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
78419impl std::ops::Drop for SynchronousDatagramSocketGetSockNameResponder {
78420    fn drop(&mut self) {
78421        self.control_handle.shutdown();
78422        // Safety: drops once, never accessed again
78423        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78424    }
78425}
78426
78427impl fidl::endpoints::Responder for SynchronousDatagramSocketGetSockNameResponder {
78428    type ControlHandle = SynchronousDatagramSocketControlHandle;
78429
78430    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
78431        &self.control_handle
78432    }
78433
78434    fn drop_without_shutdown(mut self) {
78435        // Safety: drops once, never accessed again due to mem::forget
78436        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78437        // Prevent Drop from running (which would shut down the channel)
78438        std::mem::forget(self);
78439    }
78440}
78441
78442impl SynchronousDatagramSocketGetSockNameResponder {
78443    /// Sends a response to the FIDL transaction.
78444    ///
78445    /// Sets the channel to shutdown if an error occurs.
78446    pub fn send(
78447        self,
78448        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
78449    ) -> Result<(), fidl::Error> {
78450        let _result = self.send_raw(result);
78451        if _result.is_err() {
78452            self.control_handle.shutdown();
78453        }
78454        self.drop_without_shutdown();
78455        _result
78456    }
78457
78458    /// Similar to "send" but does not shutdown the channel if an error occurs.
78459    pub fn send_no_shutdown_on_err(
78460        self,
78461        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
78462    ) -> Result<(), fidl::Error> {
78463        let _result = self.send_raw(result);
78464        self.drop_without_shutdown();
78465        _result
78466    }
78467
78468    fn send_raw(
78469        &self,
78470        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
78471    ) -> Result<(), fidl::Error> {
78472        self.control_handle.inner.send::<fidl::encoding::ResultType<
78473            BaseNetworkSocketGetSockNameResponse,
78474            fidl_fuchsia_posix::Errno,
78475        >>(
78476            result.map(|addr| (addr,)),
78477            self.tx_id,
78478            0x475f23f84a1a4f85,
78479            fidl::encoding::DynamicFlags::empty(),
78480        )
78481    }
78482}
78483
78484#[must_use = "FIDL methods require a response to be sent"]
78485#[derive(Debug)]
78486pub struct SynchronousDatagramSocketGetPeerNameResponder {
78487    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
78488    tx_id: u32,
78489}
78490
78491/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
78492/// if the responder is dropped without sending a response, so that the client
78493/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
78494impl std::ops::Drop for SynchronousDatagramSocketGetPeerNameResponder {
78495    fn drop(&mut self) {
78496        self.control_handle.shutdown();
78497        // Safety: drops once, never accessed again
78498        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78499    }
78500}
78501
78502impl fidl::endpoints::Responder for SynchronousDatagramSocketGetPeerNameResponder {
78503    type ControlHandle = SynchronousDatagramSocketControlHandle;
78504
78505    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
78506        &self.control_handle
78507    }
78508
78509    fn drop_without_shutdown(mut self) {
78510        // Safety: drops once, never accessed again due to mem::forget
78511        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78512        // Prevent Drop from running (which would shut down the channel)
78513        std::mem::forget(self);
78514    }
78515}
78516
78517impl SynchronousDatagramSocketGetPeerNameResponder {
78518    /// Sends a response to the FIDL transaction.
78519    ///
78520    /// Sets the channel to shutdown if an error occurs.
78521    pub fn send(
78522        self,
78523        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
78524    ) -> Result<(), fidl::Error> {
78525        let _result = self.send_raw(result);
78526        if _result.is_err() {
78527            self.control_handle.shutdown();
78528        }
78529        self.drop_without_shutdown();
78530        _result
78531    }
78532
78533    /// Similar to "send" but does not shutdown the channel if an error occurs.
78534    pub fn send_no_shutdown_on_err(
78535        self,
78536        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
78537    ) -> Result<(), fidl::Error> {
78538        let _result = self.send_raw(result);
78539        self.drop_without_shutdown();
78540        _result
78541    }
78542
78543    fn send_raw(
78544        &self,
78545        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
78546    ) -> Result<(), fidl::Error> {
78547        self.control_handle.inner.send::<fidl::encoding::ResultType<
78548            BaseNetworkSocketGetPeerNameResponse,
78549            fidl_fuchsia_posix::Errno,
78550        >>(
78551            result.map(|addr| (addr,)),
78552            self.tx_id,
78553            0x1ffecf4bd5b6432e,
78554            fidl::encoding::DynamicFlags::empty(),
78555        )
78556    }
78557}
78558
78559#[must_use = "FIDL methods require a response to be sent"]
78560#[derive(Debug)]
78561pub struct SynchronousDatagramSocketShutdownResponder {
78562    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
78563    tx_id: u32,
78564}
78565
78566/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
78567/// if the responder is dropped without sending a response, so that the client
78568/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
78569impl std::ops::Drop for SynchronousDatagramSocketShutdownResponder {
78570    fn drop(&mut self) {
78571        self.control_handle.shutdown();
78572        // Safety: drops once, never accessed again
78573        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78574    }
78575}
78576
78577impl fidl::endpoints::Responder for SynchronousDatagramSocketShutdownResponder {
78578    type ControlHandle = SynchronousDatagramSocketControlHandle;
78579
78580    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
78581        &self.control_handle
78582    }
78583
78584    fn drop_without_shutdown(mut self) {
78585        // Safety: drops once, never accessed again due to mem::forget
78586        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78587        // Prevent Drop from running (which would shut down the channel)
78588        std::mem::forget(self);
78589    }
78590}
78591
78592impl SynchronousDatagramSocketShutdownResponder {
78593    /// Sends a response to the FIDL transaction.
78594    ///
78595    /// Sets the channel to shutdown if an error occurs.
78596    pub fn send(
78597        self,
78598        mut result: Result<(), fidl_fuchsia_posix::Errno>,
78599    ) -> Result<(), fidl::Error> {
78600        let _result = self.send_raw(result);
78601        if _result.is_err() {
78602            self.control_handle.shutdown();
78603        }
78604        self.drop_without_shutdown();
78605        _result
78606    }
78607
78608    /// Similar to "send" but does not shutdown the channel if an error occurs.
78609    pub fn send_no_shutdown_on_err(
78610        self,
78611        mut result: Result<(), fidl_fuchsia_posix::Errno>,
78612    ) -> Result<(), fidl::Error> {
78613        let _result = self.send_raw(result);
78614        self.drop_without_shutdown();
78615        _result
78616    }
78617
78618    fn send_raw(
78619        &self,
78620        mut result: Result<(), fidl_fuchsia_posix::Errno>,
78621    ) -> Result<(), fidl::Error> {
78622        self.control_handle.inner.send::<fidl::encoding::ResultType<
78623            fidl::encoding::EmptyStruct,
78624            fidl_fuchsia_posix::Errno,
78625        >>(
78626            result,
78627            self.tx_id,
78628            0x247f38b6db68c336,
78629            fidl::encoding::DynamicFlags::empty(),
78630        )
78631    }
78632}
78633
78634#[must_use = "FIDL methods require a response to be sent"]
78635#[derive(Debug)]
78636pub struct SynchronousDatagramSocketSetIpTypeOfServiceResponder {
78637    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
78638    tx_id: u32,
78639}
78640
78641/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
78642/// if the responder is dropped without sending a response, so that the client
78643/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
78644impl std::ops::Drop for SynchronousDatagramSocketSetIpTypeOfServiceResponder {
78645    fn drop(&mut self) {
78646        self.control_handle.shutdown();
78647        // Safety: drops once, never accessed again
78648        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78649    }
78650}
78651
78652impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpTypeOfServiceResponder {
78653    type ControlHandle = SynchronousDatagramSocketControlHandle;
78654
78655    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
78656        &self.control_handle
78657    }
78658
78659    fn drop_without_shutdown(mut self) {
78660        // Safety: drops once, never accessed again due to mem::forget
78661        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78662        // Prevent Drop from running (which would shut down the channel)
78663        std::mem::forget(self);
78664    }
78665}
78666
78667impl SynchronousDatagramSocketSetIpTypeOfServiceResponder {
78668    /// Sends a response to the FIDL transaction.
78669    ///
78670    /// Sets the channel to shutdown if an error occurs.
78671    pub fn send(
78672        self,
78673        mut result: Result<(), fidl_fuchsia_posix::Errno>,
78674    ) -> Result<(), fidl::Error> {
78675        let _result = self.send_raw(result);
78676        if _result.is_err() {
78677            self.control_handle.shutdown();
78678        }
78679        self.drop_without_shutdown();
78680        _result
78681    }
78682
78683    /// Similar to "send" but does not shutdown the channel if an error occurs.
78684    pub fn send_no_shutdown_on_err(
78685        self,
78686        mut result: Result<(), fidl_fuchsia_posix::Errno>,
78687    ) -> Result<(), fidl::Error> {
78688        let _result = self.send_raw(result);
78689        self.drop_without_shutdown();
78690        _result
78691    }
78692
78693    fn send_raw(
78694        &self,
78695        mut result: Result<(), fidl_fuchsia_posix::Errno>,
78696    ) -> Result<(), fidl::Error> {
78697        self.control_handle.inner.send::<fidl::encoding::ResultType<
78698            fidl::encoding::EmptyStruct,
78699            fidl_fuchsia_posix::Errno,
78700        >>(
78701            result,
78702            self.tx_id,
78703            0x995c600475b6d46,
78704            fidl::encoding::DynamicFlags::empty(),
78705        )
78706    }
78707}
78708
78709#[must_use = "FIDL methods require a response to be sent"]
78710#[derive(Debug)]
78711pub struct SynchronousDatagramSocketGetIpTypeOfServiceResponder {
78712    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
78713    tx_id: u32,
78714}
78715
78716/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
78717/// if the responder is dropped without sending a response, so that the client
78718/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
78719impl std::ops::Drop for SynchronousDatagramSocketGetIpTypeOfServiceResponder {
78720    fn drop(&mut self) {
78721        self.control_handle.shutdown();
78722        // Safety: drops once, never accessed again
78723        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78724    }
78725}
78726
78727impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpTypeOfServiceResponder {
78728    type ControlHandle = SynchronousDatagramSocketControlHandle;
78729
78730    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
78731        &self.control_handle
78732    }
78733
78734    fn drop_without_shutdown(mut self) {
78735        // Safety: drops once, never accessed again due to mem::forget
78736        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78737        // Prevent Drop from running (which would shut down the channel)
78738        std::mem::forget(self);
78739    }
78740}
78741
78742impl SynchronousDatagramSocketGetIpTypeOfServiceResponder {
78743    /// Sends a response to the FIDL transaction.
78744    ///
78745    /// Sets the channel to shutdown if an error occurs.
78746    pub fn send(
78747        self,
78748        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
78749    ) -> Result<(), fidl::Error> {
78750        let _result = self.send_raw(result);
78751        if _result.is_err() {
78752            self.control_handle.shutdown();
78753        }
78754        self.drop_without_shutdown();
78755        _result
78756    }
78757
78758    /// Similar to "send" but does not shutdown the channel if an error occurs.
78759    pub fn send_no_shutdown_on_err(
78760        self,
78761        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
78762    ) -> Result<(), fidl::Error> {
78763        let _result = self.send_raw(result);
78764        self.drop_without_shutdown();
78765        _result
78766    }
78767
78768    fn send_raw(
78769        &self,
78770        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
78771    ) -> Result<(), fidl::Error> {
78772        self.control_handle.inner.send::<fidl::encoding::ResultType<
78773            BaseNetworkSocketGetIpTypeOfServiceResponse,
78774            fidl_fuchsia_posix::Errno,
78775        >>(
78776            result.map(|value| (value,)),
78777            self.tx_id,
78778            0x3814a04259f75fcb,
78779            fidl::encoding::DynamicFlags::empty(),
78780        )
78781    }
78782}
78783
78784#[must_use = "FIDL methods require a response to be sent"]
78785#[derive(Debug)]
78786pub struct SynchronousDatagramSocketSetIpTtlResponder {
78787    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
78788    tx_id: u32,
78789}
78790
78791/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
78792/// if the responder is dropped without sending a response, so that the client
78793/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
78794impl std::ops::Drop for SynchronousDatagramSocketSetIpTtlResponder {
78795    fn drop(&mut self) {
78796        self.control_handle.shutdown();
78797        // Safety: drops once, never accessed again
78798        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78799    }
78800}
78801
78802impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpTtlResponder {
78803    type ControlHandle = SynchronousDatagramSocketControlHandle;
78804
78805    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
78806        &self.control_handle
78807    }
78808
78809    fn drop_without_shutdown(mut self) {
78810        // Safety: drops once, never accessed again due to mem::forget
78811        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78812        // Prevent Drop from running (which would shut down the channel)
78813        std::mem::forget(self);
78814    }
78815}
78816
78817impl SynchronousDatagramSocketSetIpTtlResponder {
78818    /// Sends a response to the FIDL transaction.
78819    ///
78820    /// Sets the channel to shutdown if an error occurs.
78821    pub fn send(
78822        self,
78823        mut result: Result<(), fidl_fuchsia_posix::Errno>,
78824    ) -> Result<(), fidl::Error> {
78825        let _result = self.send_raw(result);
78826        if _result.is_err() {
78827            self.control_handle.shutdown();
78828        }
78829        self.drop_without_shutdown();
78830        _result
78831    }
78832
78833    /// Similar to "send" but does not shutdown the channel if an error occurs.
78834    pub fn send_no_shutdown_on_err(
78835        self,
78836        mut result: Result<(), fidl_fuchsia_posix::Errno>,
78837    ) -> Result<(), fidl::Error> {
78838        let _result = self.send_raw(result);
78839        self.drop_without_shutdown();
78840        _result
78841    }
78842
78843    fn send_raw(
78844        &self,
78845        mut result: Result<(), fidl_fuchsia_posix::Errno>,
78846    ) -> Result<(), fidl::Error> {
78847        self.control_handle.inner.send::<fidl::encoding::ResultType<
78848            fidl::encoding::EmptyStruct,
78849            fidl_fuchsia_posix::Errno,
78850        >>(
78851            result,
78852            self.tx_id,
78853            0x29e2424b433ae1ef,
78854            fidl::encoding::DynamicFlags::empty(),
78855        )
78856    }
78857}
78858
78859#[must_use = "FIDL methods require a response to be sent"]
78860#[derive(Debug)]
78861pub struct SynchronousDatagramSocketGetIpTtlResponder {
78862    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
78863    tx_id: u32,
78864}
78865
78866/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
78867/// if the responder is dropped without sending a response, so that the client
78868/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
78869impl std::ops::Drop for SynchronousDatagramSocketGetIpTtlResponder {
78870    fn drop(&mut self) {
78871        self.control_handle.shutdown();
78872        // Safety: drops once, never accessed again
78873        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78874    }
78875}
78876
78877impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpTtlResponder {
78878    type ControlHandle = SynchronousDatagramSocketControlHandle;
78879
78880    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
78881        &self.control_handle
78882    }
78883
78884    fn drop_without_shutdown(mut self) {
78885        // Safety: drops once, never accessed again due to mem::forget
78886        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78887        // Prevent Drop from running (which would shut down the channel)
78888        std::mem::forget(self);
78889    }
78890}
78891
78892impl SynchronousDatagramSocketGetIpTtlResponder {
78893    /// Sends a response to the FIDL transaction.
78894    ///
78895    /// Sets the channel to shutdown if an error occurs.
78896    pub fn send(
78897        self,
78898        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
78899    ) -> Result<(), fidl::Error> {
78900        let _result = self.send_raw(result);
78901        if _result.is_err() {
78902            self.control_handle.shutdown();
78903        }
78904        self.drop_without_shutdown();
78905        _result
78906    }
78907
78908    /// Similar to "send" but does not shutdown the channel if an error occurs.
78909    pub fn send_no_shutdown_on_err(
78910        self,
78911        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
78912    ) -> Result<(), fidl::Error> {
78913        let _result = self.send_raw(result);
78914        self.drop_without_shutdown();
78915        _result
78916    }
78917
78918    fn send_raw(
78919        &self,
78920        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
78921    ) -> Result<(), fidl::Error> {
78922        self.control_handle.inner.send::<fidl::encoding::ResultType<
78923            BaseNetworkSocketGetIpTtlResponse,
78924            fidl_fuchsia_posix::Errno,
78925        >>(
78926            result.map(|value| (value,)),
78927            self.tx_id,
78928            0x47e47fa1f24da471,
78929            fidl::encoding::DynamicFlags::empty(),
78930        )
78931    }
78932}
78933
78934#[must_use = "FIDL methods require a response to be sent"]
78935#[derive(Debug)]
78936pub struct SynchronousDatagramSocketSetIpPacketInfoResponder {
78937    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
78938    tx_id: u32,
78939}
78940
78941/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
78942/// if the responder is dropped without sending a response, so that the client
78943/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
78944impl std::ops::Drop for SynchronousDatagramSocketSetIpPacketInfoResponder {
78945    fn drop(&mut self) {
78946        self.control_handle.shutdown();
78947        // Safety: drops once, never accessed again
78948        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78949    }
78950}
78951
78952impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpPacketInfoResponder {
78953    type ControlHandle = SynchronousDatagramSocketControlHandle;
78954
78955    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
78956        &self.control_handle
78957    }
78958
78959    fn drop_without_shutdown(mut self) {
78960        // Safety: drops once, never accessed again due to mem::forget
78961        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
78962        // Prevent Drop from running (which would shut down the channel)
78963        std::mem::forget(self);
78964    }
78965}
78966
78967impl SynchronousDatagramSocketSetIpPacketInfoResponder {
78968    /// Sends a response to the FIDL transaction.
78969    ///
78970    /// Sets the channel to shutdown if an error occurs.
78971    pub fn send(
78972        self,
78973        mut result: Result<(), fidl_fuchsia_posix::Errno>,
78974    ) -> Result<(), fidl::Error> {
78975        let _result = self.send_raw(result);
78976        if _result.is_err() {
78977            self.control_handle.shutdown();
78978        }
78979        self.drop_without_shutdown();
78980        _result
78981    }
78982
78983    /// Similar to "send" but does not shutdown the channel if an error occurs.
78984    pub fn send_no_shutdown_on_err(
78985        self,
78986        mut result: Result<(), fidl_fuchsia_posix::Errno>,
78987    ) -> Result<(), fidl::Error> {
78988        let _result = self.send_raw(result);
78989        self.drop_without_shutdown();
78990        _result
78991    }
78992
78993    fn send_raw(
78994        &self,
78995        mut result: Result<(), fidl_fuchsia_posix::Errno>,
78996    ) -> Result<(), fidl::Error> {
78997        self.control_handle.inner.send::<fidl::encoding::ResultType<
78998            fidl::encoding::EmptyStruct,
78999            fidl_fuchsia_posix::Errno,
79000        >>(
79001            result,
79002            self.tx_id,
79003            0x392d16bee20c0e16,
79004            fidl::encoding::DynamicFlags::empty(),
79005        )
79006    }
79007}
79008
79009#[must_use = "FIDL methods require a response to be sent"]
79010#[derive(Debug)]
79011pub struct SynchronousDatagramSocketGetIpPacketInfoResponder {
79012    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
79013    tx_id: u32,
79014}
79015
79016/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
79017/// if the responder is dropped without sending a response, so that the client
79018/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
79019impl std::ops::Drop for SynchronousDatagramSocketGetIpPacketInfoResponder {
79020    fn drop(&mut self) {
79021        self.control_handle.shutdown();
79022        // Safety: drops once, never accessed again
79023        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79024    }
79025}
79026
79027impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpPacketInfoResponder {
79028    type ControlHandle = SynchronousDatagramSocketControlHandle;
79029
79030    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
79031        &self.control_handle
79032    }
79033
79034    fn drop_without_shutdown(mut self) {
79035        // Safety: drops once, never accessed again due to mem::forget
79036        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79037        // Prevent Drop from running (which would shut down the channel)
79038        std::mem::forget(self);
79039    }
79040}
79041
79042impl SynchronousDatagramSocketGetIpPacketInfoResponder {
79043    /// Sends a response to the FIDL transaction.
79044    ///
79045    /// Sets the channel to shutdown if an error occurs.
79046    pub fn send(
79047        self,
79048        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
79049    ) -> Result<(), fidl::Error> {
79050        let _result = self.send_raw(result);
79051        if _result.is_err() {
79052            self.control_handle.shutdown();
79053        }
79054        self.drop_without_shutdown();
79055        _result
79056    }
79057
79058    /// Similar to "send" but does not shutdown the channel if an error occurs.
79059    pub fn send_no_shutdown_on_err(
79060        self,
79061        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
79062    ) -> Result<(), fidl::Error> {
79063        let _result = self.send_raw(result);
79064        self.drop_without_shutdown();
79065        _result
79066    }
79067
79068    fn send_raw(
79069        &self,
79070        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
79071    ) -> Result<(), fidl::Error> {
79072        self.control_handle.inner.send::<fidl::encoding::ResultType<
79073            BaseNetworkSocketGetIpPacketInfoResponse,
79074            fidl_fuchsia_posix::Errno,
79075        >>(
79076            result.map(|value| (value,)),
79077            self.tx_id,
79078            0x54b505f242280740,
79079            fidl::encoding::DynamicFlags::empty(),
79080        )
79081    }
79082}
79083
79084#[must_use = "FIDL methods require a response to be sent"]
79085#[derive(Debug)]
79086pub struct SynchronousDatagramSocketSetIpReceiveTypeOfServiceResponder {
79087    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
79088    tx_id: u32,
79089}
79090
79091/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
79092/// if the responder is dropped without sending a response, so that the client
79093/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
79094impl std::ops::Drop for SynchronousDatagramSocketSetIpReceiveTypeOfServiceResponder {
79095    fn drop(&mut self) {
79096        self.control_handle.shutdown();
79097        // Safety: drops once, never accessed again
79098        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79099    }
79100}
79101
79102impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpReceiveTypeOfServiceResponder {
79103    type ControlHandle = SynchronousDatagramSocketControlHandle;
79104
79105    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
79106        &self.control_handle
79107    }
79108
79109    fn drop_without_shutdown(mut self) {
79110        // Safety: drops once, never accessed again due to mem::forget
79111        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79112        // Prevent Drop from running (which would shut down the channel)
79113        std::mem::forget(self);
79114    }
79115}
79116
79117impl SynchronousDatagramSocketSetIpReceiveTypeOfServiceResponder {
79118    /// Sends a response to the FIDL transaction.
79119    ///
79120    /// Sets the channel to shutdown if an error occurs.
79121    pub fn send(
79122        self,
79123        mut result: Result<(), fidl_fuchsia_posix::Errno>,
79124    ) -> Result<(), fidl::Error> {
79125        let _result = self.send_raw(result);
79126        if _result.is_err() {
79127            self.control_handle.shutdown();
79128        }
79129        self.drop_without_shutdown();
79130        _result
79131    }
79132
79133    /// Similar to "send" but does not shutdown the channel if an error occurs.
79134    pub fn send_no_shutdown_on_err(
79135        self,
79136        mut result: Result<(), fidl_fuchsia_posix::Errno>,
79137    ) -> Result<(), fidl::Error> {
79138        let _result = self.send_raw(result);
79139        self.drop_without_shutdown();
79140        _result
79141    }
79142
79143    fn send_raw(
79144        &self,
79145        mut result: Result<(), fidl_fuchsia_posix::Errno>,
79146    ) -> Result<(), fidl::Error> {
79147        self.control_handle.inner.send::<fidl::encoding::ResultType<
79148            fidl::encoding::EmptyStruct,
79149            fidl_fuchsia_posix::Errno,
79150        >>(
79151            result,
79152            self.tx_id,
79153            0x6c4f6714995f84ef,
79154            fidl::encoding::DynamicFlags::empty(),
79155        )
79156    }
79157}
79158
79159#[must_use = "FIDL methods require a response to be sent"]
79160#[derive(Debug)]
79161pub struct SynchronousDatagramSocketGetIpReceiveTypeOfServiceResponder {
79162    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
79163    tx_id: u32,
79164}
79165
79166/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
79167/// if the responder is dropped without sending a response, so that the client
79168/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
79169impl std::ops::Drop for SynchronousDatagramSocketGetIpReceiveTypeOfServiceResponder {
79170    fn drop(&mut self) {
79171        self.control_handle.shutdown();
79172        // Safety: drops once, never accessed again
79173        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79174    }
79175}
79176
79177impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpReceiveTypeOfServiceResponder {
79178    type ControlHandle = SynchronousDatagramSocketControlHandle;
79179
79180    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
79181        &self.control_handle
79182    }
79183
79184    fn drop_without_shutdown(mut self) {
79185        // Safety: drops once, never accessed again due to mem::forget
79186        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79187        // Prevent Drop from running (which would shut down the channel)
79188        std::mem::forget(self);
79189    }
79190}
79191
79192impl SynchronousDatagramSocketGetIpReceiveTypeOfServiceResponder {
79193    /// Sends a response to the FIDL transaction.
79194    ///
79195    /// Sets the channel to shutdown if an error occurs.
79196    pub fn send(
79197        self,
79198        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
79199    ) -> Result<(), fidl::Error> {
79200        let _result = self.send_raw(result);
79201        if _result.is_err() {
79202            self.control_handle.shutdown();
79203        }
79204        self.drop_without_shutdown();
79205        _result
79206    }
79207
79208    /// Similar to "send" but does not shutdown the channel if an error occurs.
79209    pub fn send_no_shutdown_on_err(
79210        self,
79211        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
79212    ) -> Result<(), fidl::Error> {
79213        let _result = self.send_raw(result);
79214        self.drop_without_shutdown();
79215        _result
79216    }
79217
79218    fn send_raw(
79219        &self,
79220        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
79221    ) -> Result<(), fidl::Error> {
79222        self.control_handle.inner.send::<fidl::encoding::ResultType<
79223            BaseNetworkSocketGetIpReceiveTypeOfServiceResponse,
79224            fidl_fuchsia_posix::Errno,
79225        >>(
79226            result.map(|value| (value,)),
79227            self.tx_id,
79228            0x4158ba7dc2795960,
79229            fidl::encoding::DynamicFlags::empty(),
79230        )
79231    }
79232}
79233
79234#[must_use = "FIDL methods require a response to be sent"]
79235#[derive(Debug)]
79236pub struct SynchronousDatagramSocketSetIpReceiveTtlResponder {
79237    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
79238    tx_id: u32,
79239}
79240
79241/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
79242/// if the responder is dropped without sending a response, so that the client
79243/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
79244impl std::ops::Drop for SynchronousDatagramSocketSetIpReceiveTtlResponder {
79245    fn drop(&mut self) {
79246        self.control_handle.shutdown();
79247        // Safety: drops once, never accessed again
79248        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79249    }
79250}
79251
79252impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpReceiveTtlResponder {
79253    type ControlHandle = SynchronousDatagramSocketControlHandle;
79254
79255    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
79256        &self.control_handle
79257    }
79258
79259    fn drop_without_shutdown(mut self) {
79260        // Safety: drops once, never accessed again due to mem::forget
79261        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79262        // Prevent Drop from running (which would shut down the channel)
79263        std::mem::forget(self);
79264    }
79265}
79266
79267impl SynchronousDatagramSocketSetIpReceiveTtlResponder {
79268    /// Sends a response to the FIDL transaction.
79269    ///
79270    /// Sets the channel to shutdown if an error occurs.
79271    pub fn send(
79272        self,
79273        mut result: Result<(), fidl_fuchsia_posix::Errno>,
79274    ) -> Result<(), fidl::Error> {
79275        let _result = self.send_raw(result);
79276        if _result.is_err() {
79277            self.control_handle.shutdown();
79278        }
79279        self.drop_without_shutdown();
79280        _result
79281    }
79282
79283    /// Similar to "send" but does not shutdown the channel if an error occurs.
79284    pub fn send_no_shutdown_on_err(
79285        self,
79286        mut result: Result<(), fidl_fuchsia_posix::Errno>,
79287    ) -> Result<(), fidl::Error> {
79288        let _result = self.send_raw(result);
79289        self.drop_without_shutdown();
79290        _result
79291    }
79292
79293    fn send_raw(
79294        &self,
79295        mut result: Result<(), fidl_fuchsia_posix::Errno>,
79296    ) -> Result<(), fidl::Error> {
79297        self.control_handle.inner.send::<fidl::encoding::ResultType<
79298            fidl::encoding::EmptyStruct,
79299            fidl_fuchsia_posix::Errno,
79300        >>(
79301            result,
79302            self.tx_id,
79303            0x46f15be0ce0ab82b,
79304            fidl::encoding::DynamicFlags::empty(),
79305        )
79306    }
79307}
79308
79309#[must_use = "FIDL methods require a response to be sent"]
79310#[derive(Debug)]
79311pub struct SynchronousDatagramSocketGetIpReceiveTtlResponder {
79312    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
79313    tx_id: u32,
79314}
79315
79316/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
79317/// if the responder is dropped without sending a response, so that the client
79318/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
79319impl std::ops::Drop for SynchronousDatagramSocketGetIpReceiveTtlResponder {
79320    fn drop(&mut self) {
79321        self.control_handle.shutdown();
79322        // Safety: drops once, never accessed again
79323        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79324    }
79325}
79326
79327impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpReceiveTtlResponder {
79328    type ControlHandle = SynchronousDatagramSocketControlHandle;
79329
79330    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
79331        &self.control_handle
79332    }
79333
79334    fn drop_without_shutdown(mut self) {
79335        // Safety: drops once, never accessed again due to mem::forget
79336        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79337        // Prevent Drop from running (which would shut down the channel)
79338        std::mem::forget(self);
79339    }
79340}
79341
79342impl SynchronousDatagramSocketGetIpReceiveTtlResponder {
79343    /// Sends a response to the FIDL transaction.
79344    ///
79345    /// Sets the channel to shutdown if an error occurs.
79346    pub fn send(
79347        self,
79348        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
79349    ) -> Result<(), fidl::Error> {
79350        let _result = self.send_raw(result);
79351        if _result.is_err() {
79352            self.control_handle.shutdown();
79353        }
79354        self.drop_without_shutdown();
79355        _result
79356    }
79357
79358    /// Similar to "send" but does not shutdown the channel if an error occurs.
79359    pub fn send_no_shutdown_on_err(
79360        self,
79361        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
79362    ) -> Result<(), fidl::Error> {
79363        let _result = self.send_raw(result);
79364        self.drop_without_shutdown();
79365        _result
79366    }
79367
79368    fn send_raw(
79369        &self,
79370        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
79371    ) -> Result<(), fidl::Error> {
79372        self.control_handle.inner.send::<fidl::encoding::ResultType<
79373            BaseNetworkSocketGetIpReceiveTtlResponse,
79374            fidl_fuchsia_posix::Errno,
79375        >>(
79376            result.map(|value| (value,)),
79377            self.tx_id,
79378            0x678ddd5a5dfa2eb5,
79379            fidl::encoding::DynamicFlags::empty(),
79380        )
79381    }
79382}
79383
79384#[must_use = "FIDL methods require a response to be sent"]
79385#[derive(Debug)]
79386pub struct SynchronousDatagramSocketSetIpMulticastInterfaceResponder {
79387    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
79388    tx_id: u32,
79389}
79390
79391/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
79392/// if the responder is dropped without sending a response, so that the client
79393/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
79394impl std::ops::Drop for SynchronousDatagramSocketSetIpMulticastInterfaceResponder {
79395    fn drop(&mut self) {
79396        self.control_handle.shutdown();
79397        // Safety: drops once, never accessed again
79398        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79399    }
79400}
79401
79402impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpMulticastInterfaceResponder {
79403    type ControlHandle = SynchronousDatagramSocketControlHandle;
79404
79405    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
79406        &self.control_handle
79407    }
79408
79409    fn drop_without_shutdown(mut self) {
79410        // Safety: drops once, never accessed again due to mem::forget
79411        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79412        // Prevent Drop from running (which would shut down the channel)
79413        std::mem::forget(self);
79414    }
79415}
79416
79417impl SynchronousDatagramSocketSetIpMulticastInterfaceResponder {
79418    /// Sends a response to the FIDL transaction.
79419    ///
79420    /// Sets the channel to shutdown if an error occurs.
79421    pub fn send(
79422        self,
79423        mut result: Result<(), fidl_fuchsia_posix::Errno>,
79424    ) -> Result<(), fidl::Error> {
79425        let _result = self.send_raw(result);
79426        if _result.is_err() {
79427            self.control_handle.shutdown();
79428        }
79429        self.drop_without_shutdown();
79430        _result
79431    }
79432
79433    /// Similar to "send" but does not shutdown the channel if an error occurs.
79434    pub fn send_no_shutdown_on_err(
79435        self,
79436        mut result: Result<(), fidl_fuchsia_posix::Errno>,
79437    ) -> Result<(), fidl::Error> {
79438        let _result = self.send_raw(result);
79439        self.drop_without_shutdown();
79440        _result
79441    }
79442
79443    fn send_raw(
79444        &self,
79445        mut result: Result<(), fidl_fuchsia_posix::Errno>,
79446    ) -> Result<(), fidl::Error> {
79447        self.control_handle.inner.send::<fidl::encoding::ResultType<
79448            fidl::encoding::EmptyStruct,
79449            fidl_fuchsia_posix::Errno,
79450        >>(
79451            result,
79452            self.tx_id,
79453            0x752fbfa9b12befe,
79454            fidl::encoding::DynamicFlags::empty(),
79455        )
79456    }
79457}
79458
79459#[must_use = "FIDL methods require a response to be sent"]
79460#[derive(Debug)]
79461pub struct SynchronousDatagramSocketGetIpMulticastInterfaceResponder {
79462    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
79463    tx_id: u32,
79464}
79465
79466/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
79467/// if the responder is dropped without sending a response, so that the client
79468/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
79469impl std::ops::Drop for SynchronousDatagramSocketGetIpMulticastInterfaceResponder {
79470    fn drop(&mut self) {
79471        self.control_handle.shutdown();
79472        // Safety: drops once, never accessed again
79473        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79474    }
79475}
79476
79477impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpMulticastInterfaceResponder {
79478    type ControlHandle = SynchronousDatagramSocketControlHandle;
79479
79480    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
79481        &self.control_handle
79482    }
79483
79484    fn drop_without_shutdown(mut self) {
79485        // Safety: drops once, never accessed again due to mem::forget
79486        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79487        // Prevent Drop from running (which would shut down the channel)
79488        std::mem::forget(self);
79489    }
79490}
79491
79492impl SynchronousDatagramSocketGetIpMulticastInterfaceResponder {
79493    /// Sends a response to the FIDL transaction.
79494    ///
79495    /// Sets the channel to shutdown if an error occurs.
79496    pub fn send(
79497        self,
79498        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
79499    ) -> Result<(), fidl::Error> {
79500        let _result = self.send_raw(result);
79501        if _result.is_err() {
79502            self.control_handle.shutdown();
79503        }
79504        self.drop_without_shutdown();
79505        _result
79506    }
79507
79508    /// Similar to "send" but does not shutdown the channel if an error occurs.
79509    pub fn send_no_shutdown_on_err(
79510        self,
79511        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
79512    ) -> Result<(), fidl::Error> {
79513        let _result = self.send_raw(result);
79514        self.drop_without_shutdown();
79515        _result
79516    }
79517
79518    fn send_raw(
79519        &self,
79520        mut result: Result<&fidl_fuchsia_net::Ipv4Address, fidl_fuchsia_posix::Errno>,
79521    ) -> Result<(), fidl::Error> {
79522        self.control_handle.inner.send::<fidl::encoding::ResultType<
79523            BaseNetworkSocketGetIpMulticastInterfaceResponse,
79524            fidl_fuchsia_posix::Errno,
79525        >>(
79526            result.map(|value| (value,)),
79527            self.tx_id,
79528            0x320bd14c4df046c4,
79529            fidl::encoding::DynamicFlags::empty(),
79530        )
79531    }
79532}
79533
79534#[must_use = "FIDL methods require a response to be sent"]
79535#[derive(Debug)]
79536pub struct SynchronousDatagramSocketSetIpMulticastTtlResponder {
79537    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
79538    tx_id: u32,
79539}
79540
79541/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
79542/// if the responder is dropped without sending a response, so that the client
79543/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
79544impl std::ops::Drop for SynchronousDatagramSocketSetIpMulticastTtlResponder {
79545    fn drop(&mut self) {
79546        self.control_handle.shutdown();
79547        // Safety: drops once, never accessed again
79548        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79549    }
79550}
79551
79552impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpMulticastTtlResponder {
79553    type ControlHandle = SynchronousDatagramSocketControlHandle;
79554
79555    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
79556        &self.control_handle
79557    }
79558
79559    fn drop_without_shutdown(mut self) {
79560        // Safety: drops once, never accessed again due to mem::forget
79561        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79562        // Prevent Drop from running (which would shut down the channel)
79563        std::mem::forget(self);
79564    }
79565}
79566
79567impl SynchronousDatagramSocketSetIpMulticastTtlResponder {
79568    /// Sends a response to the FIDL transaction.
79569    ///
79570    /// Sets the channel to shutdown if an error occurs.
79571    pub fn send(
79572        self,
79573        mut result: Result<(), fidl_fuchsia_posix::Errno>,
79574    ) -> Result<(), fidl::Error> {
79575        let _result = self.send_raw(result);
79576        if _result.is_err() {
79577            self.control_handle.shutdown();
79578        }
79579        self.drop_without_shutdown();
79580        _result
79581    }
79582
79583    /// Similar to "send" but does not shutdown the channel if an error occurs.
79584    pub fn send_no_shutdown_on_err(
79585        self,
79586        mut result: Result<(), fidl_fuchsia_posix::Errno>,
79587    ) -> Result<(), fidl::Error> {
79588        let _result = self.send_raw(result);
79589        self.drop_without_shutdown();
79590        _result
79591    }
79592
79593    fn send_raw(
79594        &self,
79595        mut result: Result<(), fidl_fuchsia_posix::Errno>,
79596    ) -> Result<(), fidl::Error> {
79597        self.control_handle.inner.send::<fidl::encoding::ResultType<
79598            fidl::encoding::EmptyStruct,
79599            fidl_fuchsia_posix::Errno,
79600        >>(
79601            result,
79602            self.tx_id,
79603            0x63134d53772916a1,
79604            fidl::encoding::DynamicFlags::empty(),
79605        )
79606    }
79607}
79608
79609#[must_use = "FIDL methods require a response to be sent"]
79610#[derive(Debug)]
79611pub struct SynchronousDatagramSocketGetIpMulticastTtlResponder {
79612    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
79613    tx_id: u32,
79614}
79615
79616/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
79617/// if the responder is dropped without sending a response, so that the client
79618/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
79619impl std::ops::Drop for SynchronousDatagramSocketGetIpMulticastTtlResponder {
79620    fn drop(&mut self) {
79621        self.control_handle.shutdown();
79622        // Safety: drops once, never accessed again
79623        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79624    }
79625}
79626
79627impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpMulticastTtlResponder {
79628    type ControlHandle = SynchronousDatagramSocketControlHandle;
79629
79630    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
79631        &self.control_handle
79632    }
79633
79634    fn drop_without_shutdown(mut self) {
79635        // Safety: drops once, never accessed again due to mem::forget
79636        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79637        // Prevent Drop from running (which would shut down the channel)
79638        std::mem::forget(self);
79639    }
79640}
79641
79642impl SynchronousDatagramSocketGetIpMulticastTtlResponder {
79643    /// Sends a response to the FIDL transaction.
79644    ///
79645    /// Sets the channel to shutdown if an error occurs.
79646    pub fn send(
79647        self,
79648        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
79649    ) -> Result<(), fidl::Error> {
79650        let _result = self.send_raw(result);
79651        if _result.is_err() {
79652            self.control_handle.shutdown();
79653        }
79654        self.drop_without_shutdown();
79655        _result
79656    }
79657
79658    /// Similar to "send" but does not shutdown the channel if an error occurs.
79659    pub fn send_no_shutdown_on_err(
79660        self,
79661        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
79662    ) -> Result<(), fidl::Error> {
79663        let _result = self.send_raw(result);
79664        self.drop_without_shutdown();
79665        _result
79666    }
79667
79668    fn send_raw(
79669        &self,
79670        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
79671    ) -> Result<(), fidl::Error> {
79672        self.control_handle.inner.send::<fidl::encoding::ResultType<
79673            BaseNetworkSocketGetIpMulticastTtlResponse,
79674            fidl_fuchsia_posix::Errno,
79675        >>(
79676            result.map(|value| (value,)),
79677            self.tx_id,
79678            0x4665cd378f39e1a,
79679            fidl::encoding::DynamicFlags::empty(),
79680        )
79681    }
79682}
79683
79684#[must_use = "FIDL methods require a response to be sent"]
79685#[derive(Debug)]
79686pub struct SynchronousDatagramSocketSetIpMulticastLoopbackResponder {
79687    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
79688    tx_id: u32,
79689}
79690
79691/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
79692/// if the responder is dropped without sending a response, so that the client
79693/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
79694impl std::ops::Drop for SynchronousDatagramSocketSetIpMulticastLoopbackResponder {
79695    fn drop(&mut self) {
79696        self.control_handle.shutdown();
79697        // Safety: drops once, never accessed again
79698        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79699    }
79700}
79701
79702impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpMulticastLoopbackResponder {
79703    type ControlHandle = SynchronousDatagramSocketControlHandle;
79704
79705    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
79706        &self.control_handle
79707    }
79708
79709    fn drop_without_shutdown(mut self) {
79710        // Safety: drops once, never accessed again due to mem::forget
79711        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79712        // Prevent Drop from running (which would shut down the channel)
79713        std::mem::forget(self);
79714    }
79715}
79716
79717impl SynchronousDatagramSocketSetIpMulticastLoopbackResponder {
79718    /// Sends a response to the FIDL transaction.
79719    ///
79720    /// Sets the channel to shutdown if an error occurs.
79721    pub fn send(
79722        self,
79723        mut result: Result<(), fidl_fuchsia_posix::Errno>,
79724    ) -> Result<(), fidl::Error> {
79725        let _result = self.send_raw(result);
79726        if _result.is_err() {
79727            self.control_handle.shutdown();
79728        }
79729        self.drop_without_shutdown();
79730        _result
79731    }
79732
79733    /// Similar to "send" but does not shutdown the channel if an error occurs.
79734    pub fn send_no_shutdown_on_err(
79735        self,
79736        mut result: Result<(), fidl_fuchsia_posix::Errno>,
79737    ) -> Result<(), fidl::Error> {
79738        let _result = self.send_raw(result);
79739        self.drop_without_shutdown();
79740        _result
79741    }
79742
79743    fn send_raw(
79744        &self,
79745        mut result: Result<(), fidl_fuchsia_posix::Errno>,
79746    ) -> Result<(), fidl::Error> {
79747        self.control_handle.inner.send::<fidl::encoding::ResultType<
79748            fidl::encoding::EmptyStruct,
79749            fidl_fuchsia_posix::Errno,
79750        >>(
79751            result,
79752            self.tx_id,
79753            0x20c55c11f00943ea,
79754            fidl::encoding::DynamicFlags::empty(),
79755        )
79756    }
79757}
79758
79759#[must_use = "FIDL methods require a response to be sent"]
79760#[derive(Debug)]
79761pub struct SynchronousDatagramSocketGetIpMulticastLoopbackResponder {
79762    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
79763    tx_id: u32,
79764}
79765
79766/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
79767/// if the responder is dropped without sending a response, so that the client
79768/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
79769impl std::ops::Drop for SynchronousDatagramSocketGetIpMulticastLoopbackResponder {
79770    fn drop(&mut self) {
79771        self.control_handle.shutdown();
79772        // Safety: drops once, never accessed again
79773        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79774    }
79775}
79776
79777impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpMulticastLoopbackResponder {
79778    type ControlHandle = SynchronousDatagramSocketControlHandle;
79779
79780    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
79781        &self.control_handle
79782    }
79783
79784    fn drop_without_shutdown(mut self) {
79785        // Safety: drops once, never accessed again due to mem::forget
79786        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79787        // Prevent Drop from running (which would shut down the channel)
79788        std::mem::forget(self);
79789    }
79790}
79791
79792impl SynchronousDatagramSocketGetIpMulticastLoopbackResponder {
79793    /// Sends a response to the FIDL transaction.
79794    ///
79795    /// Sets the channel to shutdown if an error occurs.
79796    pub fn send(
79797        self,
79798        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
79799    ) -> Result<(), fidl::Error> {
79800        let _result = self.send_raw(result);
79801        if _result.is_err() {
79802            self.control_handle.shutdown();
79803        }
79804        self.drop_without_shutdown();
79805        _result
79806    }
79807
79808    /// Similar to "send" but does not shutdown the channel if an error occurs.
79809    pub fn send_no_shutdown_on_err(
79810        self,
79811        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
79812    ) -> Result<(), fidl::Error> {
79813        let _result = self.send_raw(result);
79814        self.drop_without_shutdown();
79815        _result
79816    }
79817
79818    fn send_raw(
79819        &self,
79820        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
79821    ) -> Result<(), fidl::Error> {
79822        self.control_handle.inner.send::<fidl::encoding::ResultType<
79823            BaseNetworkSocketGetIpMulticastLoopbackResponse,
79824            fidl_fuchsia_posix::Errno,
79825        >>(
79826            result.map(|value| (value,)),
79827            self.tx_id,
79828            0x3b6b26ff558298f2,
79829            fidl::encoding::DynamicFlags::empty(),
79830        )
79831    }
79832}
79833
79834#[must_use = "FIDL methods require a response to be sent"]
79835#[derive(Debug)]
79836pub struct SynchronousDatagramSocketAddIpMembershipResponder {
79837    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
79838    tx_id: u32,
79839}
79840
79841/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
79842/// if the responder is dropped without sending a response, so that the client
79843/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
79844impl std::ops::Drop for SynchronousDatagramSocketAddIpMembershipResponder {
79845    fn drop(&mut self) {
79846        self.control_handle.shutdown();
79847        // Safety: drops once, never accessed again
79848        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79849    }
79850}
79851
79852impl fidl::endpoints::Responder for SynchronousDatagramSocketAddIpMembershipResponder {
79853    type ControlHandle = SynchronousDatagramSocketControlHandle;
79854
79855    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
79856        &self.control_handle
79857    }
79858
79859    fn drop_without_shutdown(mut self) {
79860        // Safety: drops once, never accessed again due to mem::forget
79861        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79862        // Prevent Drop from running (which would shut down the channel)
79863        std::mem::forget(self);
79864    }
79865}
79866
79867impl SynchronousDatagramSocketAddIpMembershipResponder {
79868    /// Sends a response to the FIDL transaction.
79869    ///
79870    /// Sets the channel to shutdown if an error occurs.
79871    pub fn send(
79872        self,
79873        mut result: Result<(), fidl_fuchsia_posix::Errno>,
79874    ) -> Result<(), fidl::Error> {
79875        let _result = self.send_raw(result);
79876        if _result.is_err() {
79877            self.control_handle.shutdown();
79878        }
79879        self.drop_without_shutdown();
79880        _result
79881    }
79882
79883    /// Similar to "send" but does not shutdown the channel if an error occurs.
79884    pub fn send_no_shutdown_on_err(
79885        self,
79886        mut result: Result<(), fidl_fuchsia_posix::Errno>,
79887    ) -> Result<(), fidl::Error> {
79888        let _result = self.send_raw(result);
79889        self.drop_without_shutdown();
79890        _result
79891    }
79892
79893    fn send_raw(
79894        &self,
79895        mut result: Result<(), fidl_fuchsia_posix::Errno>,
79896    ) -> Result<(), fidl::Error> {
79897        self.control_handle.inner.send::<fidl::encoding::ResultType<
79898            fidl::encoding::EmptyStruct,
79899            fidl_fuchsia_posix::Errno,
79900        >>(
79901            result,
79902            self.tx_id,
79903            0x76bc7df115a3b4d0,
79904            fidl::encoding::DynamicFlags::empty(),
79905        )
79906    }
79907}
79908
79909#[must_use = "FIDL methods require a response to be sent"]
79910#[derive(Debug)]
79911pub struct SynchronousDatagramSocketDropIpMembershipResponder {
79912    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
79913    tx_id: u32,
79914}
79915
79916/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
79917/// if the responder is dropped without sending a response, so that the client
79918/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
79919impl std::ops::Drop for SynchronousDatagramSocketDropIpMembershipResponder {
79920    fn drop(&mut self) {
79921        self.control_handle.shutdown();
79922        // Safety: drops once, never accessed again
79923        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79924    }
79925}
79926
79927impl fidl::endpoints::Responder for SynchronousDatagramSocketDropIpMembershipResponder {
79928    type ControlHandle = SynchronousDatagramSocketControlHandle;
79929
79930    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
79931        &self.control_handle
79932    }
79933
79934    fn drop_without_shutdown(mut self) {
79935        // Safety: drops once, never accessed again due to mem::forget
79936        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79937        // Prevent Drop from running (which would shut down the channel)
79938        std::mem::forget(self);
79939    }
79940}
79941
79942impl SynchronousDatagramSocketDropIpMembershipResponder {
79943    /// Sends a response to the FIDL transaction.
79944    ///
79945    /// Sets the channel to shutdown if an error occurs.
79946    pub fn send(
79947        self,
79948        mut result: Result<(), fidl_fuchsia_posix::Errno>,
79949    ) -> Result<(), fidl::Error> {
79950        let _result = self.send_raw(result);
79951        if _result.is_err() {
79952            self.control_handle.shutdown();
79953        }
79954        self.drop_without_shutdown();
79955        _result
79956    }
79957
79958    /// Similar to "send" but does not shutdown the channel if an error occurs.
79959    pub fn send_no_shutdown_on_err(
79960        self,
79961        mut result: Result<(), fidl_fuchsia_posix::Errno>,
79962    ) -> Result<(), fidl::Error> {
79963        let _result = self.send_raw(result);
79964        self.drop_without_shutdown();
79965        _result
79966    }
79967
79968    fn send_raw(
79969        &self,
79970        mut result: Result<(), fidl_fuchsia_posix::Errno>,
79971    ) -> Result<(), fidl::Error> {
79972        self.control_handle.inner.send::<fidl::encoding::ResultType<
79973            fidl::encoding::EmptyStruct,
79974            fidl_fuchsia_posix::Errno,
79975        >>(
79976            result,
79977            self.tx_id,
79978            0x2888f3099188d03,
79979            fidl::encoding::DynamicFlags::empty(),
79980        )
79981    }
79982}
79983
79984#[must_use = "FIDL methods require a response to be sent"]
79985#[derive(Debug)]
79986pub struct SynchronousDatagramSocketSetIpTransparentResponder {
79987    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
79988    tx_id: u32,
79989}
79990
79991/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
79992/// if the responder is dropped without sending a response, so that the client
79993/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
79994impl std::ops::Drop for SynchronousDatagramSocketSetIpTransparentResponder {
79995    fn drop(&mut self) {
79996        self.control_handle.shutdown();
79997        // Safety: drops once, never accessed again
79998        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
79999    }
80000}
80001
80002impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpTransparentResponder {
80003    type ControlHandle = SynchronousDatagramSocketControlHandle;
80004
80005    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
80006        &self.control_handle
80007    }
80008
80009    fn drop_without_shutdown(mut self) {
80010        // Safety: drops once, never accessed again due to mem::forget
80011        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80012        // Prevent Drop from running (which would shut down the channel)
80013        std::mem::forget(self);
80014    }
80015}
80016
80017impl SynchronousDatagramSocketSetIpTransparentResponder {
80018    /// Sends a response to the FIDL transaction.
80019    ///
80020    /// Sets the channel to shutdown if an error occurs.
80021    pub fn send(
80022        self,
80023        mut result: Result<(), fidl_fuchsia_posix::Errno>,
80024    ) -> Result<(), fidl::Error> {
80025        let _result = self.send_raw(result);
80026        if _result.is_err() {
80027            self.control_handle.shutdown();
80028        }
80029        self.drop_without_shutdown();
80030        _result
80031    }
80032
80033    /// Similar to "send" but does not shutdown the channel if an error occurs.
80034    pub fn send_no_shutdown_on_err(
80035        self,
80036        mut result: Result<(), fidl_fuchsia_posix::Errno>,
80037    ) -> Result<(), fidl::Error> {
80038        let _result = self.send_raw(result);
80039        self.drop_without_shutdown();
80040        _result
80041    }
80042
80043    fn send_raw(
80044        &self,
80045        mut result: Result<(), fidl_fuchsia_posix::Errno>,
80046    ) -> Result<(), fidl::Error> {
80047        self.control_handle.inner.send::<fidl::encoding::ResultType<
80048            fidl::encoding::EmptyStruct,
80049            fidl_fuchsia_posix::Errno,
80050        >>(
80051            result,
80052            self.tx_id,
80053            0x1ae532b0c066e3a0,
80054            fidl::encoding::DynamicFlags::empty(),
80055        )
80056    }
80057}
80058
80059#[must_use = "FIDL methods require a response to be sent"]
80060#[derive(Debug)]
80061pub struct SynchronousDatagramSocketGetIpTransparentResponder {
80062    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
80063    tx_id: u32,
80064}
80065
80066/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
80067/// if the responder is dropped without sending a response, so that the client
80068/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
80069impl std::ops::Drop for SynchronousDatagramSocketGetIpTransparentResponder {
80070    fn drop(&mut self) {
80071        self.control_handle.shutdown();
80072        // Safety: drops once, never accessed again
80073        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80074    }
80075}
80076
80077impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpTransparentResponder {
80078    type ControlHandle = SynchronousDatagramSocketControlHandle;
80079
80080    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
80081        &self.control_handle
80082    }
80083
80084    fn drop_without_shutdown(mut self) {
80085        // Safety: drops once, never accessed again due to mem::forget
80086        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80087        // Prevent Drop from running (which would shut down the channel)
80088        std::mem::forget(self);
80089    }
80090}
80091
80092impl SynchronousDatagramSocketGetIpTransparentResponder {
80093    /// Sends a response to the FIDL transaction.
80094    ///
80095    /// Sets the channel to shutdown if an error occurs.
80096    pub fn send(
80097        self,
80098        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
80099    ) -> Result<(), fidl::Error> {
80100        let _result = self.send_raw(result);
80101        if _result.is_err() {
80102            self.control_handle.shutdown();
80103        }
80104        self.drop_without_shutdown();
80105        _result
80106    }
80107
80108    /// Similar to "send" but does not shutdown the channel if an error occurs.
80109    pub fn send_no_shutdown_on_err(
80110        self,
80111        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
80112    ) -> Result<(), fidl::Error> {
80113        let _result = self.send_raw(result);
80114        self.drop_without_shutdown();
80115        _result
80116    }
80117
80118    fn send_raw(
80119        &self,
80120        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
80121    ) -> Result<(), fidl::Error> {
80122        self.control_handle.inner.send::<fidl::encoding::ResultType<
80123            BaseNetworkSocketGetIpTransparentResponse,
80124            fidl_fuchsia_posix::Errno,
80125        >>(
80126            result.map(|value| (value,)),
80127            self.tx_id,
80128            0x51d43695962ebfb5,
80129            fidl::encoding::DynamicFlags::empty(),
80130        )
80131    }
80132}
80133
80134#[must_use = "FIDL methods require a response to be sent"]
80135#[derive(Debug)]
80136pub struct SynchronousDatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
80137    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
80138    tx_id: u32,
80139}
80140
80141/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
80142/// if the responder is dropped without sending a response, so that the client
80143/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
80144impl std::ops::Drop for SynchronousDatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
80145    fn drop(&mut self) {
80146        self.control_handle.shutdown();
80147        // Safety: drops once, never accessed again
80148        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80149    }
80150}
80151
80152impl fidl::endpoints::Responder
80153    for SynchronousDatagramSocketSetIpReceiveOriginalDestinationAddressResponder
80154{
80155    type ControlHandle = SynchronousDatagramSocketControlHandle;
80156
80157    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
80158        &self.control_handle
80159    }
80160
80161    fn drop_without_shutdown(mut self) {
80162        // Safety: drops once, never accessed again due to mem::forget
80163        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80164        // Prevent Drop from running (which would shut down the channel)
80165        std::mem::forget(self);
80166    }
80167}
80168
80169impl SynchronousDatagramSocketSetIpReceiveOriginalDestinationAddressResponder {
80170    /// Sends a response to the FIDL transaction.
80171    ///
80172    /// Sets the channel to shutdown if an error occurs.
80173    pub fn send(
80174        self,
80175        mut result: Result<(), fidl_fuchsia_posix::Errno>,
80176    ) -> Result<(), fidl::Error> {
80177        let _result = self.send_raw(result);
80178        if _result.is_err() {
80179            self.control_handle.shutdown();
80180        }
80181        self.drop_without_shutdown();
80182        _result
80183    }
80184
80185    /// Similar to "send" but does not shutdown the channel if an error occurs.
80186    pub fn send_no_shutdown_on_err(
80187        self,
80188        mut result: Result<(), fidl_fuchsia_posix::Errno>,
80189    ) -> Result<(), fidl::Error> {
80190        let _result = self.send_raw(result);
80191        self.drop_without_shutdown();
80192        _result
80193    }
80194
80195    fn send_raw(
80196        &self,
80197        mut result: Result<(), fidl_fuchsia_posix::Errno>,
80198    ) -> Result<(), fidl::Error> {
80199        self.control_handle.inner.send::<fidl::encoding::ResultType<
80200            fidl::encoding::EmptyStruct,
80201            fidl_fuchsia_posix::Errno,
80202        >>(
80203            result,
80204            self.tx_id,
80205            0x4722b4ce52f7840,
80206            fidl::encoding::DynamicFlags::empty(),
80207        )
80208    }
80209}
80210
80211#[must_use = "FIDL methods require a response to be sent"]
80212#[derive(Debug)]
80213pub struct SynchronousDatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
80214    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
80215    tx_id: u32,
80216}
80217
80218/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
80219/// if the responder is dropped without sending a response, so that the client
80220/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
80221impl std::ops::Drop for SynchronousDatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
80222    fn drop(&mut self) {
80223        self.control_handle.shutdown();
80224        // Safety: drops once, never accessed again
80225        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80226    }
80227}
80228
80229impl fidl::endpoints::Responder
80230    for SynchronousDatagramSocketGetIpReceiveOriginalDestinationAddressResponder
80231{
80232    type ControlHandle = SynchronousDatagramSocketControlHandle;
80233
80234    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
80235        &self.control_handle
80236    }
80237
80238    fn drop_without_shutdown(mut self) {
80239        // Safety: drops once, never accessed again due to mem::forget
80240        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80241        // Prevent Drop from running (which would shut down the channel)
80242        std::mem::forget(self);
80243    }
80244}
80245
80246impl SynchronousDatagramSocketGetIpReceiveOriginalDestinationAddressResponder {
80247    /// Sends a response to the FIDL transaction.
80248    ///
80249    /// Sets the channel to shutdown if an error occurs.
80250    pub fn send(
80251        self,
80252        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
80253    ) -> Result<(), fidl::Error> {
80254        let _result = self.send_raw(result);
80255        if _result.is_err() {
80256            self.control_handle.shutdown();
80257        }
80258        self.drop_without_shutdown();
80259        _result
80260    }
80261
80262    /// Similar to "send" but does not shutdown the channel if an error occurs.
80263    pub fn send_no_shutdown_on_err(
80264        self,
80265        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
80266    ) -> Result<(), fidl::Error> {
80267        let _result = self.send_raw(result);
80268        self.drop_without_shutdown();
80269        _result
80270    }
80271
80272    fn send_raw(
80273        &self,
80274        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
80275    ) -> Result<(), fidl::Error> {
80276        self.control_handle.inner.send::<fidl::encoding::ResultType<
80277            BaseNetworkSocketGetIpReceiveOriginalDestinationAddressResponse,
80278            fidl_fuchsia_posix::Errno,
80279        >>(
80280            result.map(|value| (value,)),
80281            self.tx_id,
80282            0x2a0e7dc5d6bfdfe9,
80283            fidl::encoding::DynamicFlags::empty(),
80284        )
80285    }
80286}
80287
80288#[must_use = "FIDL methods require a response to be sent"]
80289#[derive(Debug)]
80290pub struct SynchronousDatagramSocketAddIpv6MembershipResponder {
80291    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
80292    tx_id: u32,
80293}
80294
80295/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
80296/// if the responder is dropped without sending a response, so that the client
80297/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
80298impl std::ops::Drop for SynchronousDatagramSocketAddIpv6MembershipResponder {
80299    fn drop(&mut self) {
80300        self.control_handle.shutdown();
80301        // Safety: drops once, never accessed again
80302        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80303    }
80304}
80305
80306impl fidl::endpoints::Responder for SynchronousDatagramSocketAddIpv6MembershipResponder {
80307    type ControlHandle = SynchronousDatagramSocketControlHandle;
80308
80309    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
80310        &self.control_handle
80311    }
80312
80313    fn drop_without_shutdown(mut self) {
80314        // Safety: drops once, never accessed again due to mem::forget
80315        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80316        // Prevent Drop from running (which would shut down the channel)
80317        std::mem::forget(self);
80318    }
80319}
80320
80321impl SynchronousDatagramSocketAddIpv6MembershipResponder {
80322    /// Sends a response to the FIDL transaction.
80323    ///
80324    /// Sets the channel to shutdown if an error occurs.
80325    pub fn send(
80326        self,
80327        mut result: Result<(), fidl_fuchsia_posix::Errno>,
80328    ) -> Result<(), fidl::Error> {
80329        let _result = self.send_raw(result);
80330        if _result.is_err() {
80331            self.control_handle.shutdown();
80332        }
80333        self.drop_without_shutdown();
80334        _result
80335    }
80336
80337    /// Similar to "send" but does not shutdown the channel if an error occurs.
80338    pub fn send_no_shutdown_on_err(
80339        self,
80340        mut result: Result<(), fidl_fuchsia_posix::Errno>,
80341    ) -> Result<(), fidl::Error> {
80342        let _result = self.send_raw(result);
80343        self.drop_without_shutdown();
80344        _result
80345    }
80346
80347    fn send_raw(
80348        &self,
80349        mut result: Result<(), fidl_fuchsia_posix::Errno>,
80350    ) -> Result<(), fidl::Error> {
80351        self.control_handle.inner.send::<fidl::encoding::ResultType<
80352            fidl::encoding::EmptyStruct,
80353            fidl_fuchsia_posix::Errno,
80354        >>(
80355            result,
80356            self.tx_id,
80357            0x7c94727acb4ea4b3,
80358            fidl::encoding::DynamicFlags::empty(),
80359        )
80360    }
80361}
80362
80363#[must_use = "FIDL methods require a response to be sent"]
80364#[derive(Debug)]
80365pub struct SynchronousDatagramSocketDropIpv6MembershipResponder {
80366    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
80367    tx_id: u32,
80368}
80369
80370/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
80371/// if the responder is dropped without sending a response, so that the client
80372/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
80373impl std::ops::Drop for SynchronousDatagramSocketDropIpv6MembershipResponder {
80374    fn drop(&mut self) {
80375        self.control_handle.shutdown();
80376        // Safety: drops once, never accessed again
80377        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80378    }
80379}
80380
80381impl fidl::endpoints::Responder for SynchronousDatagramSocketDropIpv6MembershipResponder {
80382    type ControlHandle = SynchronousDatagramSocketControlHandle;
80383
80384    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
80385        &self.control_handle
80386    }
80387
80388    fn drop_without_shutdown(mut self) {
80389        // Safety: drops once, never accessed again due to mem::forget
80390        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80391        // Prevent Drop from running (which would shut down the channel)
80392        std::mem::forget(self);
80393    }
80394}
80395
80396impl SynchronousDatagramSocketDropIpv6MembershipResponder {
80397    /// Sends a response to the FIDL transaction.
80398    ///
80399    /// Sets the channel to shutdown if an error occurs.
80400    pub fn send(
80401        self,
80402        mut result: Result<(), fidl_fuchsia_posix::Errno>,
80403    ) -> Result<(), fidl::Error> {
80404        let _result = self.send_raw(result);
80405        if _result.is_err() {
80406            self.control_handle.shutdown();
80407        }
80408        self.drop_without_shutdown();
80409        _result
80410    }
80411
80412    /// Similar to "send" but does not shutdown the channel if an error occurs.
80413    pub fn send_no_shutdown_on_err(
80414        self,
80415        mut result: Result<(), fidl_fuchsia_posix::Errno>,
80416    ) -> Result<(), fidl::Error> {
80417        let _result = self.send_raw(result);
80418        self.drop_without_shutdown();
80419        _result
80420    }
80421
80422    fn send_raw(
80423        &self,
80424        mut result: Result<(), fidl_fuchsia_posix::Errno>,
80425    ) -> Result<(), fidl::Error> {
80426        self.control_handle.inner.send::<fidl::encoding::ResultType<
80427            fidl::encoding::EmptyStruct,
80428            fidl_fuchsia_posix::Errno,
80429        >>(
80430            result,
80431            self.tx_id,
80432            0x42104c70ccaba304,
80433            fidl::encoding::DynamicFlags::empty(),
80434        )
80435    }
80436}
80437
80438#[must_use = "FIDL methods require a response to be sent"]
80439#[derive(Debug)]
80440pub struct SynchronousDatagramSocketSetIpv6MulticastInterfaceResponder {
80441    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
80442    tx_id: u32,
80443}
80444
80445/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
80446/// if the responder is dropped without sending a response, so that the client
80447/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
80448impl std::ops::Drop for SynchronousDatagramSocketSetIpv6MulticastInterfaceResponder {
80449    fn drop(&mut self) {
80450        self.control_handle.shutdown();
80451        // Safety: drops once, never accessed again
80452        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80453    }
80454}
80455
80456impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpv6MulticastInterfaceResponder {
80457    type ControlHandle = SynchronousDatagramSocketControlHandle;
80458
80459    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
80460        &self.control_handle
80461    }
80462
80463    fn drop_without_shutdown(mut self) {
80464        // Safety: drops once, never accessed again due to mem::forget
80465        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80466        // Prevent Drop from running (which would shut down the channel)
80467        std::mem::forget(self);
80468    }
80469}
80470
80471impl SynchronousDatagramSocketSetIpv6MulticastInterfaceResponder {
80472    /// Sends a response to the FIDL transaction.
80473    ///
80474    /// Sets the channel to shutdown if an error occurs.
80475    pub fn send(
80476        self,
80477        mut result: Result<(), fidl_fuchsia_posix::Errno>,
80478    ) -> Result<(), fidl::Error> {
80479        let _result = self.send_raw(result);
80480        if _result.is_err() {
80481            self.control_handle.shutdown();
80482        }
80483        self.drop_without_shutdown();
80484        _result
80485    }
80486
80487    /// Similar to "send" but does not shutdown the channel if an error occurs.
80488    pub fn send_no_shutdown_on_err(
80489        self,
80490        mut result: Result<(), fidl_fuchsia_posix::Errno>,
80491    ) -> Result<(), fidl::Error> {
80492        let _result = self.send_raw(result);
80493        self.drop_without_shutdown();
80494        _result
80495    }
80496
80497    fn send_raw(
80498        &self,
80499        mut result: Result<(), fidl_fuchsia_posix::Errno>,
80500    ) -> Result<(), fidl::Error> {
80501        self.control_handle.inner.send::<fidl::encoding::ResultType<
80502            fidl::encoding::EmptyStruct,
80503            fidl_fuchsia_posix::Errno,
80504        >>(
80505            result,
80506            self.tx_id,
80507            0x135f76db3774ab3b,
80508            fidl::encoding::DynamicFlags::empty(),
80509        )
80510    }
80511}
80512
80513#[must_use = "FIDL methods require a response to be sent"]
80514#[derive(Debug)]
80515pub struct SynchronousDatagramSocketGetIpv6MulticastInterfaceResponder {
80516    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
80517    tx_id: u32,
80518}
80519
80520/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
80521/// if the responder is dropped without sending a response, so that the client
80522/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
80523impl std::ops::Drop for SynchronousDatagramSocketGetIpv6MulticastInterfaceResponder {
80524    fn drop(&mut self) {
80525        self.control_handle.shutdown();
80526        // Safety: drops once, never accessed again
80527        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80528    }
80529}
80530
80531impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpv6MulticastInterfaceResponder {
80532    type ControlHandle = SynchronousDatagramSocketControlHandle;
80533
80534    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
80535        &self.control_handle
80536    }
80537
80538    fn drop_without_shutdown(mut self) {
80539        // Safety: drops once, never accessed again due to mem::forget
80540        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80541        // Prevent Drop from running (which would shut down the channel)
80542        std::mem::forget(self);
80543    }
80544}
80545
80546impl SynchronousDatagramSocketGetIpv6MulticastInterfaceResponder {
80547    /// Sends a response to the FIDL transaction.
80548    ///
80549    /// Sets the channel to shutdown if an error occurs.
80550    pub fn send(
80551        self,
80552        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
80553    ) -> Result<(), fidl::Error> {
80554        let _result = self.send_raw(result);
80555        if _result.is_err() {
80556            self.control_handle.shutdown();
80557        }
80558        self.drop_without_shutdown();
80559        _result
80560    }
80561
80562    /// Similar to "send" but does not shutdown the channel if an error occurs.
80563    pub fn send_no_shutdown_on_err(
80564        self,
80565        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
80566    ) -> Result<(), fidl::Error> {
80567        let _result = self.send_raw(result);
80568        self.drop_without_shutdown();
80569        _result
80570    }
80571
80572    fn send_raw(
80573        &self,
80574        mut result: Result<u64, fidl_fuchsia_posix::Errno>,
80575    ) -> Result<(), fidl::Error> {
80576        self.control_handle.inner.send::<fidl::encoding::ResultType<
80577            BaseNetworkSocketGetIpv6MulticastInterfaceResponse,
80578            fidl_fuchsia_posix::Errno,
80579        >>(
80580            result.map(|value| (value,)),
80581            self.tx_id,
80582            0x1f26fcdd348f1882,
80583            fidl::encoding::DynamicFlags::empty(),
80584        )
80585    }
80586}
80587
80588#[must_use = "FIDL methods require a response to be sent"]
80589#[derive(Debug)]
80590pub struct SynchronousDatagramSocketSetIpv6UnicastHopsResponder {
80591    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
80592    tx_id: u32,
80593}
80594
80595/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
80596/// if the responder is dropped without sending a response, so that the client
80597/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
80598impl std::ops::Drop for SynchronousDatagramSocketSetIpv6UnicastHopsResponder {
80599    fn drop(&mut self) {
80600        self.control_handle.shutdown();
80601        // Safety: drops once, never accessed again
80602        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80603    }
80604}
80605
80606impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpv6UnicastHopsResponder {
80607    type ControlHandle = SynchronousDatagramSocketControlHandle;
80608
80609    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
80610        &self.control_handle
80611    }
80612
80613    fn drop_without_shutdown(mut self) {
80614        // Safety: drops once, never accessed again due to mem::forget
80615        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80616        // Prevent Drop from running (which would shut down the channel)
80617        std::mem::forget(self);
80618    }
80619}
80620
80621impl SynchronousDatagramSocketSetIpv6UnicastHopsResponder {
80622    /// Sends a response to the FIDL transaction.
80623    ///
80624    /// Sets the channel to shutdown if an error occurs.
80625    pub fn send(
80626        self,
80627        mut result: Result<(), fidl_fuchsia_posix::Errno>,
80628    ) -> Result<(), fidl::Error> {
80629        let _result = self.send_raw(result);
80630        if _result.is_err() {
80631            self.control_handle.shutdown();
80632        }
80633        self.drop_without_shutdown();
80634        _result
80635    }
80636
80637    /// Similar to "send" but does not shutdown the channel if an error occurs.
80638    pub fn send_no_shutdown_on_err(
80639        self,
80640        mut result: Result<(), fidl_fuchsia_posix::Errno>,
80641    ) -> Result<(), fidl::Error> {
80642        let _result = self.send_raw(result);
80643        self.drop_without_shutdown();
80644        _result
80645    }
80646
80647    fn send_raw(
80648        &self,
80649        mut result: Result<(), fidl_fuchsia_posix::Errno>,
80650    ) -> Result<(), fidl::Error> {
80651        self.control_handle.inner.send::<fidl::encoding::ResultType<
80652            fidl::encoding::EmptyStruct,
80653            fidl_fuchsia_posix::Errno,
80654        >>(
80655            result,
80656            self.tx_id,
80657            0x157d51e98f462859,
80658            fidl::encoding::DynamicFlags::empty(),
80659        )
80660    }
80661}
80662
80663#[must_use = "FIDL methods require a response to be sent"]
80664#[derive(Debug)]
80665pub struct SynchronousDatagramSocketGetIpv6UnicastHopsResponder {
80666    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
80667    tx_id: u32,
80668}
80669
80670/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
80671/// if the responder is dropped without sending a response, so that the client
80672/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
80673impl std::ops::Drop for SynchronousDatagramSocketGetIpv6UnicastHopsResponder {
80674    fn drop(&mut self) {
80675        self.control_handle.shutdown();
80676        // Safety: drops once, never accessed again
80677        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80678    }
80679}
80680
80681impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpv6UnicastHopsResponder {
80682    type ControlHandle = SynchronousDatagramSocketControlHandle;
80683
80684    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
80685        &self.control_handle
80686    }
80687
80688    fn drop_without_shutdown(mut self) {
80689        // Safety: drops once, never accessed again due to mem::forget
80690        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80691        // Prevent Drop from running (which would shut down the channel)
80692        std::mem::forget(self);
80693    }
80694}
80695
80696impl SynchronousDatagramSocketGetIpv6UnicastHopsResponder {
80697    /// Sends a response to the FIDL transaction.
80698    ///
80699    /// Sets the channel to shutdown if an error occurs.
80700    pub fn send(
80701        self,
80702        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
80703    ) -> Result<(), fidl::Error> {
80704        let _result = self.send_raw(result);
80705        if _result.is_err() {
80706            self.control_handle.shutdown();
80707        }
80708        self.drop_without_shutdown();
80709        _result
80710    }
80711
80712    /// Similar to "send" but does not shutdown the channel if an error occurs.
80713    pub fn send_no_shutdown_on_err(
80714        self,
80715        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
80716    ) -> Result<(), fidl::Error> {
80717        let _result = self.send_raw(result);
80718        self.drop_without_shutdown();
80719        _result
80720    }
80721
80722    fn send_raw(
80723        &self,
80724        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
80725    ) -> Result<(), fidl::Error> {
80726        self.control_handle.inner.send::<fidl::encoding::ResultType<
80727            BaseNetworkSocketGetIpv6UnicastHopsResponse,
80728            fidl_fuchsia_posix::Errno,
80729        >>(
80730            result.map(|value| (value,)),
80731            self.tx_id,
80732            0x21f4641cad8bd8d2,
80733            fidl::encoding::DynamicFlags::empty(),
80734        )
80735    }
80736}
80737
80738#[must_use = "FIDL methods require a response to be sent"]
80739#[derive(Debug)]
80740pub struct SynchronousDatagramSocketSetIpv6ReceiveHopLimitResponder {
80741    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
80742    tx_id: u32,
80743}
80744
80745/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
80746/// if the responder is dropped without sending a response, so that the client
80747/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
80748impl std::ops::Drop for SynchronousDatagramSocketSetIpv6ReceiveHopLimitResponder {
80749    fn drop(&mut self) {
80750        self.control_handle.shutdown();
80751        // Safety: drops once, never accessed again
80752        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80753    }
80754}
80755
80756impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpv6ReceiveHopLimitResponder {
80757    type ControlHandle = SynchronousDatagramSocketControlHandle;
80758
80759    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
80760        &self.control_handle
80761    }
80762
80763    fn drop_without_shutdown(mut self) {
80764        // Safety: drops once, never accessed again due to mem::forget
80765        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80766        // Prevent Drop from running (which would shut down the channel)
80767        std::mem::forget(self);
80768    }
80769}
80770
80771impl SynchronousDatagramSocketSetIpv6ReceiveHopLimitResponder {
80772    /// Sends a response to the FIDL transaction.
80773    ///
80774    /// Sets the channel to shutdown if an error occurs.
80775    pub fn send(
80776        self,
80777        mut result: Result<(), fidl_fuchsia_posix::Errno>,
80778    ) -> Result<(), fidl::Error> {
80779        let _result = self.send_raw(result);
80780        if _result.is_err() {
80781            self.control_handle.shutdown();
80782        }
80783        self.drop_without_shutdown();
80784        _result
80785    }
80786
80787    /// Similar to "send" but does not shutdown the channel if an error occurs.
80788    pub fn send_no_shutdown_on_err(
80789        self,
80790        mut result: Result<(), fidl_fuchsia_posix::Errno>,
80791    ) -> Result<(), fidl::Error> {
80792        let _result = self.send_raw(result);
80793        self.drop_without_shutdown();
80794        _result
80795    }
80796
80797    fn send_raw(
80798        &self,
80799        mut result: Result<(), fidl_fuchsia_posix::Errno>,
80800    ) -> Result<(), fidl::Error> {
80801        self.control_handle.inner.send::<fidl::encoding::ResultType<
80802            fidl::encoding::EmptyStruct,
80803            fidl_fuchsia_posix::Errno,
80804        >>(
80805            result,
80806            self.tx_id,
80807            0x5c24808ed2e84a1e,
80808            fidl::encoding::DynamicFlags::empty(),
80809        )
80810    }
80811}
80812
80813#[must_use = "FIDL methods require a response to be sent"]
80814#[derive(Debug)]
80815pub struct SynchronousDatagramSocketGetIpv6ReceiveHopLimitResponder {
80816    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
80817    tx_id: u32,
80818}
80819
80820/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
80821/// if the responder is dropped without sending a response, so that the client
80822/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
80823impl std::ops::Drop for SynchronousDatagramSocketGetIpv6ReceiveHopLimitResponder {
80824    fn drop(&mut self) {
80825        self.control_handle.shutdown();
80826        // Safety: drops once, never accessed again
80827        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80828    }
80829}
80830
80831impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpv6ReceiveHopLimitResponder {
80832    type ControlHandle = SynchronousDatagramSocketControlHandle;
80833
80834    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
80835        &self.control_handle
80836    }
80837
80838    fn drop_without_shutdown(mut self) {
80839        // Safety: drops once, never accessed again due to mem::forget
80840        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80841        // Prevent Drop from running (which would shut down the channel)
80842        std::mem::forget(self);
80843    }
80844}
80845
80846impl SynchronousDatagramSocketGetIpv6ReceiveHopLimitResponder {
80847    /// Sends a response to the FIDL transaction.
80848    ///
80849    /// Sets the channel to shutdown if an error occurs.
80850    pub fn send(
80851        self,
80852        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
80853    ) -> Result<(), fidl::Error> {
80854        let _result = self.send_raw(result);
80855        if _result.is_err() {
80856            self.control_handle.shutdown();
80857        }
80858        self.drop_without_shutdown();
80859        _result
80860    }
80861
80862    /// Similar to "send" but does not shutdown the channel if an error occurs.
80863    pub fn send_no_shutdown_on_err(
80864        self,
80865        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
80866    ) -> Result<(), fidl::Error> {
80867        let _result = self.send_raw(result);
80868        self.drop_without_shutdown();
80869        _result
80870    }
80871
80872    fn send_raw(
80873        &self,
80874        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
80875    ) -> Result<(), fidl::Error> {
80876        self.control_handle.inner.send::<fidl::encoding::ResultType<
80877            BaseNetworkSocketGetIpv6ReceiveHopLimitResponse,
80878            fidl_fuchsia_posix::Errno,
80879        >>(
80880            result.map(|value| (value,)),
80881            self.tx_id,
80882            0x341e06689885b4c0,
80883            fidl::encoding::DynamicFlags::empty(),
80884        )
80885    }
80886}
80887
80888#[must_use = "FIDL methods require a response to be sent"]
80889#[derive(Debug)]
80890pub struct SynchronousDatagramSocketSetIpv6MulticastHopsResponder {
80891    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
80892    tx_id: u32,
80893}
80894
80895/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
80896/// if the responder is dropped without sending a response, so that the client
80897/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
80898impl std::ops::Drop for SynchronousDatagramSocketSetIpv6MulticastHopsResponder {
80899    fn drop(&mut self) {
80900        self.control_handle.shutdown();
80901        // Safety: drops once, never accessed again
80902        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80903    }
80904}
80905
80906impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpv6MulticastHopsResponder {
80907    type ControlHandle = SynchronousDatagramSocketControlHandle;
80908
80909    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
80910        &self.control_handle
80911    }
80912
80913    fn drop_without_shutdown(mut self) {
80914        // Safety: drops once, never accessed again due to mem::forget
80915        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80916        // Prevent Drop from running (which would shut down the channel)
80917        std::mem::forget(self);
80918    }
80919}
80920
80921impl SynchronousDatagramSocketSetIpv6MulticastHopsResponder {
80922    /// Sends a response to the FIDL transaction.
80923    ///
80924    /// Sets the channel to shutdown if an error occurs.
80925    pub fn send(
80926        self,
80927        mut result: Result<(), fidl_fuchsia_posix::Errno>,
80928    ) -> Result<(), fidl::Error> {
80929        let _result = self.send_raw(result);
80930        if _result.is_err() {
80931            self.control_handle.shutdown();
80932        }
80933        self.drop_without_shutdown();
80934        _result
80935    }
80936
80937    /// Similar to "send" but does not shutdown the channel if an error occurs.
80938    pub fn send_no_shutdown_on_err(
80939        self,
80940        mut result: Result<(), fidl_fuchsia_posix::Errno>,
80941    ) -> Result<(), fidl::Error> {
80942        let _result = self.send_raw(result);
80943        self.drop_without_shutdown();
80944        _result
80945    }
80946
80947    fn send_raw(
80948        &self,
80949        mut result: Result<(), fidl_fuchsia_posix::Errno>,
80950    ) -> Result<(), fidl::Error> {
80951        self.control_handle.inner.send::<fidl::encoding::ResultType<
80952            fidl::encoding::EmptyStruct,
80953            fidl_fuchsia_posix::Errno,
80954        >>(
80955            result,
80956            self.tx_id,
80957            0x25b9cd4d181f82c1,
80958            fidl::encoding::DynamicFlags::empty(),
80959        )
80960    }
80961}
80962
80963#[must_use = "FIDL methods require a response to be sent"]
80964#[derive(Debug)]
80965pub struct SynchronousDatagramSocketGetIpv6MulticastHopsResponder {
80966    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
80967    tx_id: u32,
80968}
80969
80970/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
80971/// if the responder is dropped without sending a response, so that the client
80972/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
80973impl std::ops::Drop for SynchronousDatagramSocketGetIpv6MulticastHopsResponder {
80974    fn drop(&mut self) {
80975        self.control_handle.shutdown();
80976        // Safety: drops once, never accessed again
80977        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80978    }
80979}
80980
80981impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpv6MulticastHopsResponder {
80982    type ControlHandle = SynchronousDatagramSocketControlHandle;
80983
80984    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
80985        &self.control_handle
80986    }
80987
80988    fn drop_without_shutdown(mut self) {
80989        // Safety: drops once, never accessed again due to mem::forget
80990        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
80991        // Prevent Drop from running (which would shut down the channel)
80992        std::mem::forget(self);
80993    }
80994}
80995
80996impl SynchronousDatagramSocketGetIpv6MulticastHopsResponder {
80997    /// Sends a response to the FIDL transaction.
80998    ///
80999    /// Sets the channel to shutdown if an error occurs.
81000    pub fn send(
81001        self,
81002        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
81003    ) -> Result<(), fidl::Error> {
81004        let _result = self.send_raw(result);
81005        if _result.is_err() {
81006            self.control_handle.shutdown();
81007        }
81008        self.drop_without_shutdown();
81009        _result
81010    }
81011
81012    /// Similar to "send" but does not shutdown the channel if an error occurs.
81013    pub fn send_no_shutdown_on_err(
81014        self,
81015        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
81016    ) -> Result<(), fidl::Error> {
81017        let _result = self.send_raw(result);
81018        self.drop_without_shutdown();
81019        _result
81020    }
81021
81022    fn send_raw(
81023        &self,
81024        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
81025    ) -> Result<(), fidl::Error> {
81026        self.control_handle.inner.send::<fidl::encoding::ResultType<
81027            BaseNetworkSocketGetIpv6MulticastHopsResponse,
81028            fidl_fuchsia_posix::Errno,
81029        >>(
81030            result.map(|value| (value,)),
81031            self.tx_id,
81032            0x52916948a365012a,
81033            fidl::encoding::DynamicFlags::empty(),
81034        )
81035    }
81036}
81037
81038#[must_use = "FIDL methods require a response to be sent"]
81039#[derive(Debug)]
81040pub struct SynchronousDatagramSocketSetIpv6MulticastLoopbackResponder {
81041    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
81042    tx_id: u32,
81043}
81044
81045/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
81046/// if the responder is dropped without sending a response, so that the client
81047/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
81048impl std::ops::Drop for SynchronousDatagramSocketSetIpv6MulticastLoopbackResponder {
81049    fn drop(&mut self) {
81050        self.control_handle.shutdown();
81051        // Safety: drops once, never accessed again
81052        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81053    }
81054}
81055
81056impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpv6MulticastLoopbackResponder {
81057    type ControlHandle = SynchronousDatagramSocketControlHandle;
81058
81059    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
81060        &self.control_handle
81061    }
81062
81063    fn drop_without_shutdown(mut self) {
81064        // Safety: drops once, never accessed again due to mem::forget
81065        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81066        // Prevent Drop from running (which would shut down the channel)
81067        std::mem::forget(self);
81068    }
81069}
81070
81071impl SynchronousDatagramSocketSetIpv6MulticastLoopbackResponder {
81072    /// Sends a response to the FIDL transaction.
81073    ///
81074    /// Sets the channel to shutdown if an error occurs.
81075    pub fn send(
81076        self,
81077        mut result: Result<(), fidl_fuchsia_posix::Errno>,
81078    ) -> Result<(), fidl::Error> {
81079        let _result = self.send_raw(result);
81080        if _result.is_err() {
81081            self.control_handle.shutdown();
81082        }
81083        self.drop_without_shutdown();
81084        _result
81085    }
81086
81087    /// Similar to "send" but does not shutdown the channel if an error occurs.
81088    pub fn send_no_shutdown_on_err(
81089        self,
81090        mut result: Result<(), fidl_fuchsia_posix::Errno>,
81091    ) -> Result<(), fidl::Error> {
81092        let _result = self.send_raw(result);
81093        self.drop_without_shutdown();
81094        _result
81095    }
81096
81097    fn send_raw(
81098        &self,
81099        mut result: Result<(), fidl_fuchsia_posix::Errno>,
81100    ) -> Result<(), fidl::Error> {
81101        self.control_handle.inner.send::<fidl::encoding::ResultType<
81102            fidl::encoding::EmptyStruct,
81103            fidl_fuchsia_posix::Errno,
81104        >>(
81105            result,
81106            self.tx_id,
81107            0x55701c409ff41b40,
81108            fidl::encoding::DynamicFlags::empty(),
81109        )
81110    }
81111}
81112
81113#[must_use = "FIDL methods require a response to be sent"]
81114#[derive(Debug)]
81115pub struct SynchronousDatagramSocketGetIpv6MulticastLoopbackResponder {
81116    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
81117    tx_id: u32,
81118}
81119
81120/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
81121/// if the responder is dropped without sending a response, so that the client
81122/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
81123impl std::ops::Drop for SynchronousDatagramSocketGetIpv6MulticastLoopbackResponder {
81124    fn drop(&mut self) {
81125        self.control_handle.shutdown();
81126        // Safety: drops once, never accessed again
81127        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81128    }
81129}
81130
81131impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpv6MulticastLoopbackResponder {
81132    type ControlHandle = SynchronousDatagramSocketControlHandle;
81133
81134    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
81135        &self.control_handle
81136    }
81137
81138    fn drop_without_shutdown(mut self) {
81139        // Safety: drops once, never accessed again due to mem::forget
81140        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81141        // Prevent Drop from running (which would shut down the channel)
81142        std::mem::forget(self);
81143    }
81144}
81145
81146impl SynchronousDatagramSocketGetIpv6MulticastLoopbackResponder {
81147    /// Sends a response to the FIDL transaction.
81148    ///
81149    /// Sets the channel to shutdown if an error occurs.
81150    pub fn send(
81151        self,
81152        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
81153    ) -> Result<(), fidl::Error> {
81154        let _result = self.send_raw(result);
81155        if _result.is_err() {
81156            self.control_handle.shutdown();
81157        }
81158        self.drop_without_shutdown();
81159        _result
81160    }
81161
81162    /// Similar to "send" but does not shutdown the channel if an error occurs.
81163    pub fn send_no_shutdown_on_err(
81164        self,
81165        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
81166    ) -> Result<(), fidl::Error> {
81167        let _result = self.send_raw(result);
81168        self.drop_without_shutdown();
81169        _result
81170    }
81171
81172    fn send_raw(
81173        &self,
81174        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
81175    ) -> Result<(), fidl::Error> {
81176        self.control_handle.inner.send::<fidl::encoding::ResultType<
81177            BaseNetworkSocketGetIpv6MulticastLoopbackResponse,
81178            fidl_fuchsia_posix::Errno,
81179        >>(
81180            result.map(|value| (value,)),
81181            self.tx_id,
81182            0x4415b701fde319c3,
81183            fidl::encoding::DynamicFlags::empty(),
81184        )
81185    }
81186}
81187
81188#[must_use = "FIDL methods require a response to be sent"]
81189#[derive(Debug)]
81190pub struct SynchronousDatagramSocketSetIpv6OnlyResponder {
81191    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
81192    tx_id: u32,
81193}
81194
81195/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
81196/// if the responder is dropped without sending a response, so that the client
81197/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
81198impl std::ops::Drop for SynchronousDatagramSocketSetIpv6OnlyResponder {
81199    fn drop(&mut self) {
81200        self.control_handle.shutdown();
81201        // Safety: drops once, never accessed again
81202        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81203    }
81204}
81205
81206impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpv6OnlyResponder {
81207    type ControlHandle = SynchronousDatagramSocketControlHandle;
81208
81209    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
81210        &self.control_handle
81211    }
81212
81213    fn drop_without_shutdown(mut self) {
81214        // Safety: drops once, never accessed again due to mem::forget
81215        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81216        // Prevent Drop from running (which would shut down the channel)
81217        std::mem::forget(self);
81218    }
81219}
81220
81221impl SynchronousDatagramSocketSetIpv6OnlyResponder {
81222    /// Sends a response to the FIDL transaction.
81223    ///
81224    /// Sets the channel to shutdown if an error occurs.
81225    pub fn send(
81226        self,
81227        mut result: Result<(), fidl_fuchsia_posix::Errno>,
81228    ) -> Result<(), fidl::Error> {
81229        let _result = self.send_raw(result);
81230        if _result.is_err() {
81231            self.control_handle.shutdown();
81232        }
81233        self.drop_without_shutdown();
81234        _result
81235    }
81236
81237    /// Similar to "send" but does not shutdown the channel if an error occurs.
81238    pub fn send_no_shutdown_on_err(
81239        self,
81240        mut result: Result<(), fidl_fuchsia_posix::Errno>,
81241    ) -> Result<(), fidl::Error> {
81242        let _result = self.send_raw(result);
81243        self.drop_without_shutdown();
81244        _result
81245    }
81246
81247    fn send_raw(
81248        &self,
81249        mut result: Result<(), fidl_fuchsia_posix::Errno>,
81250    ) -> Result<(), fidl::Error> {
81251        self.control_handle.inner.send::<fidl::encoding::ResultType<
81252            fidl::encoding::EmptyStruct,
81253            fidl_fuchsia_posix::Errno,
81254        >>(
81255            result,
81256            self.tx_id,
81257            0x4873f1364758cbba,
81258            fidl::encoding::DynamicFlags::empty(),
81259        )
81260    }
81261}
81262
81263#[must_use = "FIDL methods require a response to be sent"]
81264#[derive(Debug)]
81265pub struct SynchronousDatagramSocketGetIpv6OnlyResponder {
81266    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
81267    tx_id: u32,
81268}
81269
81270/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
81271/// if the responder is dropped without sending a response, so that the client
81272/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
81273impl std::ops::Drop for SynchronousDatagramSocketGetIpv6OnlyResponder {
81274    fn drop(&mut self) {
81275        self.control_handle.shutdown();
81276        // Safety: drops once, never accessed again
81277        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81278    }
81279}
81280
81281impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpv6OnlyResponder {
81282    type ControlHandle = SynchronousDatagramSocketControlHandle;
81283
81284    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
81285        &self.control_handle
81286    }
81287
81288    fn drop_without_shutdown(mut self) {
81289        // Safety: drops once, never accessed again due to mem::forget
81290        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81291        // Prevent Drop from running (which would shut down the channel)
81292        std::mem::forget(self);
81293    }
81294}
81295
81296impl SynchronousDatagramSocketGetIpv6OnlyResponder {
81297    /// Sends a response to the FIDL transaction.
81298    ///
81299    /// Sets the channel to shutdown if an error occurs.
81300    pub fn send(
81301        self,
81302        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
81303    ) -> Result<(), fidl::Error> {
81304        let _result = self.send_raw(result);
81305        if _result.is_err() {
81306            self.control_handle.shutdown();
81307        }
81308        self.drop_without_shutdown();
81309        _result
81310    }
81311
81312    /// Similar to "send" but does not shutdown the channel if an error occurs.
81313    pub fn send_no_shutdown_on_err(
81314        self,
81315        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
81316    ) -> Result<(), fidl::Error> {
81317        let _result = self.send_raw(result);
81318        self.drop_without_shutdown();
81319        _result
81320    }
81321
81322    fn send_raw(
81323        &self,
81324        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
81325    ) -> Result<(), fidl::Error> {
81326        self.control_handle.inner.send::<fidl::encoding::ResultType<
81327            BaseNetworkSocketGetIpv6OnlyResponse,
81328            fidl_fuchsia_posix::Errno,
81329        >>(
81330            result.map(|value| (value,)),
81331            self.tx_id,
81332            0x4aa3340a1a26b89c,
81333            fidl::encoding::DynamicFlags::empty(),
81334        )
81335    }
81336}
81337
81338#[must_use = "FIDL methods require a response to be sent"]
81339#[derive(Debug)]
81340pub struct SynchronousDatagramSocketSetIpv6ReceiveTrafficClassResponder {
81341    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
81342    tx_id: u32,
81343}
81344
81345/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
81346/// if the responder is dropped without sending a response, so that the client
81347/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
81348impl std::ops::Drop for SynchronousDatagramSocketSetIpv6ReceiveTrafficClassResponder {
81349    fn drop(&mut self) {
81350        self.control_handle.shutdown();
81351        // Safety: drops once, never accessed again
81352        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81353    }
81354}
81355
81356impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpv6ReceiveTrafficClassResponder {
81357    type ControlHandle = SynchronousDatagramSocketControlHandle;
81358
81359    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
81360        &self.control_handle
81361    }
81362
81363    fn drop_without_shutdown(mut self) {
81364        // Safety: drops once, never accessed again due to mem::forget
81365        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81366        // Prevent Drop from running (which would shut down the channel)
81367        std::mem::forget(self);
81368    }
81369}
81370
81371impl SynchronousDatagramSocketSetIpv6ReceiveTrafficClassResponder {
81372    /// Sends a response to the FIDL transaction.
81373    ///
81374    /// Sets the channel to shutdown if an error occurs.
81375    pub fn send(
81376        self,
81377        mut result: Result<(), fidl_fuchsia_posix::Errno>,
81378    ) -> Result<(), fidl::Error> {
81379        let _result = self.send_raw(result);
81380        if _result.is_err() {
81381            self.control_handle.shutdown();
81382        }
81383        self.drop_without_shutdown();
81384        _result
81385    }
81386
81387    /// Similar to "send" but does not shutdown the channel if an error occurs.
81388    pub fn send_no_shutdown_on_err(
81389        self,
81390        mut result: Result<(), fidl_fuchsia_posix::Errno>,
81391    ) -> Result<(), fidl::Error> {
81392        let _result = self.send_raw(result);
81393        self.drop_without_shutdown();
81394        _result
81395    }
81396
81397    fn send_raw(
81398        &self,
81399        mut result: Result<(), fidl_fuchsia_posix::Errno>,
81400    ) -> Result<(), fidl::Error> {
81401        self.control_handle.inner.send::<fidl::encoding::ResultType<
81402            fidl::encoding::EmptyStruct,
81403            fidl_fuchsia_posix::Errno,
81404        >>(
81405            result,
81406            self.tx_id,
81407            0x58f07c8788d099a0,
81408            fidl::encoding::DynamicFlags::empty(),
81409        )
81410    }
81411}
81412
81413#[must_use = "FIDL methods require a response to be sent"]
81414#[derive(Debug)]
81415pub struct SynchronousDatagramSocketGetIpv6ReceiveTrafficClassResponder {
81416    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
81417    tx_id: u32,
81418}
81419
81420/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
81421/// if the responder is dropped without sending a response, so that the client
81422/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
81423impl std::ops::Drop for SynchronousDatagramSocketGetIpv6ReceiveTrafficClassResponder {
81424    fn drop(&mut self) {
81425        self.control_handle.shutdown();
81426        // Safety: drops once, never accessed again
81427        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81428    }
81429}
81430
81431impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpv6ReceiveTrafficClassResponder {
81432    type ControlHandle = SynchronousDatagramSocketControlHandle;
81433
81434    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
81435        &self.control_handle
81436    }
81437
81438    fn drop_without_shutdown(mut self) {
81439        // Safety: drops once, never accessed again due to mem::forget
81440        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81441        // Prevent Drop from running (which would shut down the channel)
81442        std::mem::forget(self);
81443    }
81444}
81445
81446impl SynchronousDatagramSocketGetIpv6ReceiveTrafficClassResponder {
81447    /// Sends a response to the FIDL transaction.
81448    ///
81449    /// Sets the channel to shutdown if an error occurs.
81450    pub fn send(
81451        self,
81452        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
81453    ) -> Result<(), fidl::Error> {
81454        let _result = self.send_raw(result);
81455        if _result.is_err() {
81456            self.control_handle.shutdown();
81457        }
81458        self.drop_without_shutdown();
81459        _result
81460    }
81461
81462    /// Similar to "send" but does not shutdown the channel if an error occurs.
81463    pub fn send_no_shutdown_on_err(
81464        self,
81465        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
81466    ) -> Result<(), fidl::Error> {
81467        let _result = self.send_raw(result);
81468        self.drop_without_shutdown();
81469        _result
81470    }
81471
81472    fn send_raw(
81473        &self,
81474        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
81475    ) -> Result<(), fidl::Error> {
81476        self.control_handle.inner.send::<fidl::encoding::ResultType<
81477            BaseNetworkSocketGetIpv6ReceiveTrafficClassResponse,
81478            fidl_fuchsia_posix::Errno,
81479        >>(
81480            result.map(|value| (value,)),
81481            self.tx_id,
81482            0x2e334df1da553ffa,
81483            fidl::encoding::DynamicFlags::empty(),
81484        )
81485    }
81486}
81487
81488#[must_use = "FIDL methods require a response to be sent"]
81489#[derive(Debug)]
81490pub struct SynchronousDatagramSocketSetIpv6TrafficClassResponder {
81491    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
81492    tx_id: u32,
81493}
81494
81495/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
81496/// if the responder is dropped without sending a response, so that the client
81497/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
81498impl std::ops::Drop for SynchronousDatagramSocketSetIpv6TrafficClassResponder {
81499    fn drop(&mut self) {
81500        self.control_handle.shutdown();
81501        // Safety: drops once, never accessed again
81502        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81503    }
81504}
81505
81506impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpv6TrafficClassResponder {
81507    type ControlHandle = SynchronousDatagramSocketControlHandle;
81508
81509    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
81510        &self.control_handle
81511    }
81512
81513    fn drop_without_shutdown(mut self) {
81514        // Safety: drops once, never accessed again due to mem::forget
81515        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81516        // Prevent Drop from running (which would shut down the channel)
81517        std::mem::forget(self);
81518    }
81519}
81520
81521impl SynchronousDatagramSocketSetIpv6TrafficClassResponder {
81522    /// Sends a response to the FIDL transaction.
81523    ///
81524    /// Sets the channel to shutdown if an error occurs.
81525    pub fn send(
81526        self,
81527        mut result: Result<(), fidl_fuchsia_posix::Errno>,
81528    ) -> Result<(), fidl::Error> {
81529        let _result = self.send_raw(result);
81530        if _result.is_err() {
81531            self.control_handle.shutdown();
81532        }
81533        self.drop_without_shutdown();
81534        _result
81535    }
81536
81537    /// Similar to "send" but does not shutdown the channel if an error occurs.
81538    pub fn send_no_shutdown_on_err(
81539        self,
81540        mut result: Result<(), fidl_fuchsia_posix::Errno>,
81541    ) -> Result<(), fidl::Error> {
81542        let _result = self.send_raw(result);
81543        self.drop_without_shutdown();
81544        _result
81545    }
81546
81547    fn send_raw(
81548        &self,
81549        mut result: Result<(), fidl_fuchsia_posix::Errno>,
81550    ) -> Result<(), fidl::Error> {
81551        self.control_handle.inner.send::<fidl::encoding::ResultType<
81552            fidl::encoding::EmptyStruct,
81553            fidl_fuchsia_posix::Errno,
81554        >>(
81555            result,
81556            self.tx_id,
81557            0x6af077800c5a0b4f,
81558            fidl::encoding::DynamicFlags::empty(),
81559        )
81560    }
81561}
81562
81563#[must_use = "FIDL methods require a response to be sent"]
81564#[derive(Debug)]
81565pub struct SynchronousDatagramSocketGetIpv6TrafficClassResponder {
81566    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
81567    tx_id: u32,
81568}
81569
81570/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
81571/// if the responder is dropped without sending a response, so that the client
81572/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
81573impl std::ops::Drop for SynchronousDatagramSocketGetIpv6TrafficClassResponder {
81574    fn drop(&mut self) {
81575        self.control_handle.shutdown();
81576        // Safety: drops once, never accessed again
81577        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81578    }
81579}
81580
81581impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpv6TrafficClassResponder {
81582    type ControlHandle = SynchronousDatagramSocketControlHandle;
81583
81584    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
81585        &self.control_handle
81586    }
81587
81588    fn drop_without_shutdown(mut self) {
81589        // Safety: drops once, never accessed again due to mem::forget
81590        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81591        // Prevent Drop from running (which would shut down the channel)
81592        std::mem::forget(self);
81593    }
81594}
81595
81596impl SynchronousDatagramSocketGetIpv6TrafficClassResponder {
81597    /// Sends a response to the FIDL transaction.
81598    ///
81599    /// Sets the channel to shutdown if an error occurs.
81600    pub fn send(
81601        self,
81602        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
81603    ) -> Result<(), fidl::Error> {
81604        let _result = self.send_raw(result);
81605        if _result.is_err() {
81606            self.control_handle.shutdown();
81607        }
81608        self.drop_without_shutdown();
81609        _result
81610    }
81611
81612    /// Similar to "send" but does not shutdown the channel if an error occurs.
81613    pub fn send_no_shutdown_on_err(
81614        self,
81615        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
81616    ) -> Result<(), fidl::Error> {
81617        let _result = self.send_raw(result);
81618        self.drop_without_shutdown();
81619        _result
81620    }
81621
81622    fn send_raw(
81623        &self,
81624        mut result: Result<u8, fidl_fuchsia_posix::Errno>,
81625    ) -> Result<(), fidl::Error> {
81626        self.control_handle.inner.send::<fidl::encoding::ResultType<
81627            BaseNetworkSocketGetIpv6TrafficClassResponse,
81628            fidl_fuchsia_posix::Errno,
81629        >>(
81630            result.map(|value| (value,)),
81631            self.tx_id,
81632            0x6baf6eed8fc2f04,
81633            fidl::encoding::DynamicFlags::empty(),
81634        )
81635    }
81636}
81637
81638#[must_use = "FIDL methods require a response to be sent"]
81639#[derive(Debug)]
81640pub struct SynchronousDatagramSocketSetIpv6ReceivePacketInfoResponder {
81641    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
81642    tx_id: u32,
81643}
81644
81645/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
81646/// if the responder is dropped without sending a response, so that the client
81647/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
81648impl std::ops::Drop for SynchronousDatagramSocketSetIpv6ReceivePacketInfoResponder {
81649    fn drop(&mut self) {
81650        self.control_handle.shutdown();
81651        // Safety: drops once, never accessed again
81652        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81653    }
81654}
81655
81656impl fidl::endpoints::Responder for SynchronousDatagramSocketSetIpv6ReceivePacketInfoResponder {
81657    type ControlHandle = SynchronousDatagramSocketControlHandle;
81658
81659    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
81660        &self.control_handle
81661    }
81662
81663    fn drop_without_shutdown(mut self) {
81664        // Safety: drops once, never accessed again due to mem::forget
81665        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81666        // Prevent Drop from running (which would shut down the channel)
81667        std::mem::forget(self);
81668    }
81669}
81670
81671impl SynchronousDatagramSocketSetIpv6ReceivePacketInfoResponder {
81672    /// Sends a response to the FIDL transaction.
81673    ///
81674    /// Sets the channel to shutdown if an error occurs.
81675    pub fn send(
81676        self,
81677        mut result: Result<(), fidl_fuchsia_posix::Errno>,
81678    ) -> Result<(), fidl::Error> {
81679        let _result = self.send_raw(result);
81680        if _result.is_err() {
81681            self.control_handle.shutdown();
81682        }
81683        self.drop_without_shutdown();
81684        _result
81685    }
81686
81687    /// Similar to "send" but does not shutdown the channel if an error occurs.
81688    pub fn send_no_shutdown_on_err(
81689        self,
81690        mut result: Result<(), fidl_fuchsia_posix::Errno>,
81691    ) -> Result<(), fidl::Error> {
81692        let _result = self.send_raw(result);
81693        self.drop_without_shutdown();
81694        _result
81695    }
81696
81697    fn send_raw(
81698        &self,
81699        mut result: Result<(), fidl_fuchsia_posix::Errno>,
81700    ) -> Result<(), fidl::Error> {
81701        self.control_handle.inner.send::<fidl::encoding::ResultType<
81702            fidl::encoding::EmptyStruct,
81703            fidl_fuchsia_posix::Errno,
81704        >>(
81705            result,
81706            self.tx_id,
81707            0x19259775b1a92768,
81708            fidl::encoding::DynamicFlags::empty(),
81709        )
81710    }
81711}
81712
81713#[must_use = "FIDL methods require a response to be sent"]
81714#[derive(Debug)]
81715pub struct SynchronousDatagramSocketGetIpv6ReceivePacketInfoResponder {
81716    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
81717    tx_id: u32,
81718}
81719
81720/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
81721/// if the responder is dropped without sending a response, so that the client
81722/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
81723impl std::ops::Drop for SynchronousDatagramSocketGetIpv6ReceivePacketInfoResponder {
81724    fn drop(&mut self) {
81725        self.control_handle.shutdown();
81726        // Safety: drops once, never accessed again
81727        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81728    }
81729}
81730
81731impl fidl::endpoints::Responder for SynchronousDatagramSocketGetIpv6ReceivePacketInfoResponder {
81732    type ControlHandle = SynchronousDatagramSocketControlHandle;
81733
81734    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
81735        &self.control_handle
81736    }
81737
81738    fn drop_without_shutdown(mut self) {
81739        // Safety: drops once, never accessed again due to mem::forget
81740        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81741        // Prevent Drop from running (which would shut down the channel)
81742        std::mem::forget(self);
81743    }
81744}
81745
81746impl SynchronousDatagramSocketGetIpv6ReceivePacketInfoResponder {
81747    /// Sends a response to the FIDL transaction.
81748    ///
81749    /// Sets the channel to shutdown if an error occurs.
81750    pub fn send(
81751        self,
81752        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
81753    ) -> Result<(), fidl::Error> {
81754        let _result = self.send_raw(result);
81755        if _result.is_err() {
81756            self.control_handle.shutdown();
81757        }
81758        self.drop_without_shutdown();
81759        _result
81760    }
81761
81762    /// Similar to "send" but does not shutdown the channel if an error occurs.
81763    pub fn send_no_shutdown_on_err(
81764        self,
81765        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
81766    ) -> Result<(), fidl::Error> {
81767        let _result = self.send_raw(result);
81768        self.drop_without_shutdown();
81769        _result
81770    }
81771
81772    fn send_raw(
81773        &self,
81774        mut result: Result<bool, fidl_fuchsia_posix::Errno>,
81775    ) -> Result<(), fidl::Error> {
81776        self.control_handle.inner.send::<fidl::encoding::ResultType<
81777            BaseNetworkSocketGetIpv6ReceivePacketInfoResponse,
81778            fidl_fuchsia_posix::Errno,
81779        >>(
81780            result.map(|value| (value,)),
81781            self.tx_id,
81782            0x7acd4a2775baec75,
81783            fidl::encoding::DynamicFlags::empty(),
81784        )
81785    }
81786}
81787
81788#[must_use = "FIDL methods require a response to be sent"]
81789#[derive(Debug)]
81790pub struct SynchronousDatagramSocketGetOriginalDestinationResponder {
81791    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
81792    tx_id: u32,
81793}
81794
81795/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
81796/// if the responder is dropped without sending a response, so that the client
81797/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
81798impl std::ops::Drop for SynchronousDatagramSocketGetOriginalDestinationResponder {
81799    fn drop(&mut self) {
81800        self.control_handle.shutdown();
81801        // Safety: drops once, never accessed again
81802        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81803    }
81804}
81805
81806impl fidl::endpoints::Responder for SynchronousDatagramSocketGetOriginalDestinationResponder {
81807    type ControlHandle = SynchronousDatagramSocketControlHandle;
81808
81809    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
81810        &self.control_handle
81811    }
81812
81813    fn drop_without_shutdown(mut self) {
81814        // Safety: drops once, never accessed again due to mem::forget
81815        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81816        // Prevent Drop from running (which would shut down the channel)
81817        std::mem::forget(self);
81818    }
81819}
81820
81821impl SynchronousDatagramSocketGetOriginalDestinationResponder {
81822    /// Sends a response to the FIDL transaction.
81823    ///
81824    /// Sets the channel to shutdown if an error occurs.
81825    pub fn send(
81826        self,
81827        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
81828    ) -> Result<(), fidl::Error> {
81829        let _result = self.send_raw(result);
81830        if _result.is_err() {
81831            self.control_handle.shutdown();
81832        }
81833        self.drop_without_shutdown();
81834        _result
81835    }
81836
81837    /// Similar to "send" but does not shutdown the channel if an error occurs.
81838    pub fn send_no_shutdown_on_err(
81839        self,
81840        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
81841    ) -> Result<(), fidl::Error> {
81842        let _result = self.send_raw(result);
81843        self.drop_without_shutdown();
81844        _result
81845    }
81846
81847    fn send_raw(
81848        &self,
81849        mut result: Result<&fidl_fuchsia_net::SocketAddress, fidl_fuchsia_posix::Errno>,
81850    ) -> Result<(), fidl::Error> {
81851        self.control_handle.inner.send::<fidl::encoding::ResultType<
81852            BaseNetworkSocketGetOriginalDestinationResponse,
81853            fidl_fuchsia_posix::Errno,
81854        >>(
81855            result.map(|value| (value,)),
81856            self.tx_id,
81857            0x38bf28f0dafdbac0,
81858            fidl::encoding::DynamicFlags::empty(),
81859        )
81860    }
81861}
81862
81863#[must_use = "FIDL methods require a response to be sent"]
81864#[derive(Debug)]
81865pub struct SynchronousDatagramSocketGetInfoResponder {
81866    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
81867    tx_id: u32,
81868}
81869
81870/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
81871/// if the responder is dropped without sending a response, so that the client
81872/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
81873impl std::ops::Drop for SynchronousDatagramSocketGetInfoResponder {
81874    fn drop(&mut self) {
81875        self.control_handle.shutdown();
81876        // Safety: drops once, never accessed again
81877        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81878    }
81879}
81880
81881impl fidl::endpoints::Responder for SynchronousDatagramSocketGetInfoResponder {
81882    type ControlHandle = SynchronousDatagramSocketControlHandle;
81883
81884    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
81885        &self.control_handle
81886    }
81887
81888    fn drop_without_shutdown(mut self) {
81889        // Safety: drops once, never accessed again due to mem::forget
81890        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81891        // Prevent Drop from running (which would shut down the channel)
81892        std::mem::forget(self);
81893    }
81894}
81895
81896impl SynchronousDatagramSocketGetInfoResponder {
81897    /// Sends a response to the FIDL transaction.
81898    ///
81899    /// Sets the channel to shutdown if an error occurs.
81900    pub fn send(
81901        self,
81902        mut result: Result<(Domain, DatagramSocketProtocol), fidl_fuchsia_posix::Errno>,
81903    ) -> Result<(), fidl::Error> {
81904        let _result = self.send_raw(result);
81905        if _result.is_err() {
81906            self.control_handle.shutdown();
81907        }
81908        self.drop_without_shutdown();
81909        _result
81910    }
81911
81912    /// Similar to "send" but does not shutdown the channel if an error occurs.
81913    pub fn send_no_shutdown_on_err(
81914        self,
81915        mut result: Result<(Domain, DatagramSocketProtocol), fidl_fuchsia_posix::Errno>,
81916    ) -> Result<(), fidl::Error> {
81917        let _result = self.send_raw(result);
81918        self.drop_without_shutdown();
81919        _result
81920    }
81921
81922    fn send_raw(
81923        &self,
81924        mut result: Result<(Domain, DatagramSocketProtocol), fidl_fuchsia_posix::Errno>,
81925    ) -> Result<(), fidl::Error> {
81926        self.control_handle.inner.send::<fidl::encoding::ResultType<
81927            BaseDatagramSocketGetInfoResponse,
81928            fidl_fuchsia_posix::Errno,
81929        >>(
81930            result,
81931            self.tx_id,
81932            0x48aa0a1f6a32d2ed,
81933            fidl::encoding::DynamicFlags::empty(),
81934        )
81935    }
81936}
81937
81938#[must_use = "FIDL methods require a response to be sent"]
81939#[derive(Debug)]
81940pub struct SynchronousDatagramSocketDescribeResponder {
81941    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
81942    tx_id: u32,
81943}
81944
81945/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
81946/// if the responder is dropped without sending a response, so that the client
81947/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
81948impl std::ops::Drop for SynchronousDatagramSocketDescribeResponder {
81949    fn drop(&mut self) {
81950        self.control_handle.shutdown();
81951        // Safety: drops once, never accessed again
81952        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81953    }
81954}
81955
81956impl fidl::endpoints::Responder for SynchronousDatagramSocketDescribeResponder {
81957    type ControlHandle = SynchronousDatagramSocketControlHandle;
81958
81959    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
81960        &self.control_handle
81961    }
81962
81963    fn drop_without_shutdown(mut self) {
81964        // Safety: drops once, never accessed again due to mem::forget
81965        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
81966        // Prevent Drop from running (which would shut down the channel)
81967        std::mem::forget(self);
81968    }
81969}
81970
81971impl SynchronousDatagramSocketDescribeResponder {
81972    /// Sends a response to the FIDL transaction.
81973    ///
81974    /// Sets the channel to shutdown if an error occurs.
81975    pub fn send(
81976        self,
81977        mut payload: SynchronousDatagramSocketDescribeResponse,
81978    ) -> Result<(), fidl::Error> {
81979        let _result = self.send_raw(payload);
81980        if _result.is_err() {
81981            self.control_handle.shutdown();
81982        }
81983        self.drop_without_shutdown();
81984        _result
81985    }
81986
81987    /// Similar to "send" but does not shutdown the channel if an error occurs.
81988    pub fn send_no_shutdown_on_err(
81989        self,
81990        mut payload: SynchronousDatagramSocketDescribeResponse,
81991    ) -> Result<(), fidl::Error> {
81992        let _result = self.send_raw(payload);
81993        self.drop_without_shutdown();
81994        _result
81995    }
81996
81997    fn send_raw(
81998        &self,
81999        mut payload: SynchronousDatagramSocketDescribeResponse,
82000    ) -> Result<(), fidl::Error> {
82001        self.control_handle.inner.send::<SynchronousDatagramSocketDescribeResponse>(
82002            &mut payload,
82003            self.tx_id,
82004            0x585f20b73631070d,
82005            fidl::encoding::DynamicFlags::empty(),
82006        )
82007    }
82008}
82009
82010#[must_use = "FIDL methods require a response to be sent"]
82011#[derive(Debug)]
82012pub struct SynchronousDatagramSocketRecvMsgResponder {
82013    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
82014    tx_id: u32,
82015}
82016
82017/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
82018/// if the responder is dropped without sending a response, so that the client
82019/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
82020impl std::ops::Drop for SynchronousDatagramSocketRecvMsgResponder {
82021    fn drop(&mut self) {
82022        self.control_handle.shutdown();
82023        // Safety: drops once, never accessed again
82024        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
82025    }
82026}
82027
82028impl fidl::endpoints::Responder for SynchronousDatagramSocketRecvMsgResponder {
82029    type ControlHandle = SynchronousDatagramSocketControlHandle;
82030
82031    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
82032        &self.control_handle
82033    }
82034
82035    fn drop_without_shutdown(mut self) {
82036        // Safety: drops once, never accessed again due to mem::forget
82037        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
82038        // Prevent Drop from running (which would shut down the channel)
82039        std::mem::forget(self);
82040    }
82041}
82042
82043impl SynchronousDatagramSocketRecvMsgResponder {
82044    /// Sends a response to the FIDL transaction.
82045    ///
82046    /// Sets the channel to shutdown if an error occurs.
82047    pub fn send(
82048        self,
82049        mut result: Result<
82050            (Option<&fidl_fuchsia_net::SocketAddress>, &[u8], &DatagramSocketRecvControlData, u32),
82051            fidl_fuchsia_posix::Errno,
82052        >,
82053    ) -> Result<(), fidl::Error> {
82054        let _result = self.send_raw(result);
82055        if _result.is_err() {
82056            self.control_handle.shutdown();
82057        }
82058        self.drop_without_shutdown();
82059        _result
82060    }
82061
82062    /// Similar to "send" but does not shutdown the channel if an error occurs.
82063    pub fn send_no_shutdown_on_err(
82064        self,
82065        mut result: Result<
82066            (Option<&fidl_fuchsia_net::SocketAddress>, &[u8], &DatagramSocketRecvControlData, u32),
82067            fidl_fuchsia_posix::Errno,
82068        >,
82069    ) -> Result<(), fidl::Error> {
82070        let _result = self.send_raw(result);
82071        self.drop_without_shutdown();
82072        _result
82073    }
82074
82075    fn send_raw(
82076        &self,
82077        mut result: Result<
82078            (Option<&fidl_fuchsia_net::SocketAddress>, &[u8], &DatagramSocketRecvControlData, u32),
82079            fidl_fuchsia_posix::Errno,
82080        >,
82081    ) -> Result<(), fidl::Error> {
82082        self.control_handle.inner.send::<fidl::encoding::ResultType<
82083            SynchronousDatagramSocketRecvMsgResponse,
82084            fidl_fuchsia_posix::Errno,
82085        >>(
82086            result,
82087            self.tx_id,
82088            0x28e494e48fb5dbf3,
82089            fidl::encoding::DynamicFlags::empty(),
82090        )
82091    }
82092}
82093
82094#[must_use = "FIDL methods require a response to be sent"]
82095#[derive(Debug)]
82096pub struct SynchronousDatagramSocketSendMsgResponder {
82097    control_handle: std::mem::ManuallyDrop<SynchronousDatagramSocketControlHandle>,
82098    tx_id: u32,
82099}
82100
82101/// Set the the channel to be shutdown (see [`SynchronousDatagramSocketControlHandle::shutdown`])
82102/// if the responder is dropped without sending a response, so that the client
82103/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
82104impl std::ops::Drop for SynchronousDatagramSocketSendMsgResponder {
82105    fn drop(&mut self) {
82106        self.control_handle.shutdown();
82107        // Safety: drops once, never accessed again
82108        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
82109    }
82110}
82111
82112impl fidl::endpoints::Responder for SynchronousDatagramSocketSendMsgResponder {
82113    type ControlHandle = SynchronousDatagramSocketControlHandle;
82114
82115    fn control_handle(&self) -> &SynchronousDatagramSocketControlHandle {
82116        &self.control_handle
82117    }
82118
82119    fn drop_without_shutdown(mut self) {
82120        // Safety: drops once, never accessed again due to mem::forget
82121        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
82122        // Prevent Drop from running (which would shut down the channel)
82123        std::mem::forget(self);
82124    }
82125}
82126
82127impl SynchronousDatagramSocketSendMsgResponder {
82128    /// Sends a response to the FIDL transaction.
82129    ///
82130    /// Sets the channel to shutdown if an error occurs.
82131    pub fn send(
82132        self,
82133        mut result: Result<i64, fidl_fuchsia_posix::Errno>,
82134    ) -> Result<(), fidl::Error> {
82135        let _result = self.send_raw(result);
82136        if _result.is_err() {
82137            self.control_handle.shutdown();
82138        }
82139        self.drop_without_shutdown();
82140        _result
82141    }
82142
82143    /// Similar to "send" but does not shutdown the channel if an error occurs.
82144    pub fn send_no_shutdown_on_err(
82145        self,
82146        mut result: Result<i64, fidl_fuchsia_posix::Errno>,
82147    ) -> Result<(), fidl::Error> {
82148        let _result = self.send_raw(result);
82149        self.drop_without_shutdown();
82150        _result
82151    }
82152
82153    fn send_raw(
82154        &self,
82155        mut result: Result<i64, fidl_fuchsia_posix::Errno>,
82156    ) -> Result<(), fidl::Error> {
82157        self.control_handle.inner.send::<fidl::encoding::ResultType<
82158            SynchronousDatagramSocketSendMsgResponse,
82159            fidl_fuchsia_posix::Errno,
82160        >>(
82161            result.map(|len| (len,)),
82162            self.tx_id,
82163            0x12dc2fceab6cefaa,
82164            fidl::encoding::DynamicFlags::empty(),
82165        )
82166    }
82167}
82168
82169mod internal {
82170    use super::*;
82171
82172    impl fidl::encoding::ResourceTypeMarker for ProviderDatagramSocketDeprecatedResponse {
82173        type Borrowed<'a> = &'a mut Self;
82174        fn take_or_borrow<'a>(
82175            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
82176        ) -> Self::Borrowed<'a> {
82177            value
82178        }
82179    }
82180
82181    unsafe impl fidl::encoding::TypeMarker for ProviderDatagramSocketDeprecatedResponse {
82182        type Owned = Self;
82183
82184        #[inline(always)]
82185        fn inline_align(_context: fidl::encoding::Context) -> usize {
82186            4
82187        }
82188
82189        #[inline(always)]
82190        fn inline_size(_context: fidl::encoding::Context) -> usize {
82191            4
82192        }
82193    }
82194
82195    unsafe impl
82196        fidl::encoding::Encode<
82197            ProviderDatagramSocketDeprecatedResponse,
82198            fidl::encoding::DefaultFuchsiaResourceDialect,
82199        > for &mut ProviderDatagramSocketDeprecatedResponse
82200    {
82201        #[inline]
82202        unsafe fn encode(
82203            self,
82204            encoder: &mut fidl::encoding::Encoder<
82205                '_,
82206                fidl::encoding::DefaultFuchsiaResourceDialect,
82207            >,
82208            offset: usize,
82209            _depth: fidl::encoding::Depth,
82210        ) -> fidl::Result<()> {
82211            encoder.debug_check_bounds::<ProviderDatagramSocketDeprecatedResponse>(offset);
82212            // Delegate to tuple encoding.
82213            fidl::encoding::Encode::<
82214                ProviderDatagramSocketDeprecatedResponse,
82215                fidl::encoding::DefaultFuchsiaResourceDialect,
82216            >::encode(
82217                (<fidl::encoding::Endpoint<
82218                    fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
82219                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
82220                    &mut self.s
82221                ),),
82222                encoder,
82223                offset,
82224                _depth,
82225            )
82226        }
82227    }
82228    unsafe impl<
82229            T0: fidl::encoding::Encode<
82230                fidl::encoding::Endpoint<
82231                    fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
82232                >,
82233                fidl::encoding::DefaultFuchsiaResourceDialect,
82234            >,
82235        >
82236        fidl::encoding::Encode<
82237            ProviderDatagramSocketDeprecatedResponse,
82238            fidl::encoding::DefaultFuchsiaResourceDialect,
82239        > for (T0,)
82240    {
82241        #[inline]
82242        unsafe fn encode(
82243            self,
82244            encoder: &mut fidl::encoding::Encoder<
82245                '_,
82246                fidl::encoding::DefaultFuchsiaResourceDialect,
82247            >,
82248            offset: usize,
82249            depth: fidl::encoding::Depth,
82250        ) -> fidl::Result<()> {
82251            encoder.debug_check_bounds::<ProviderDatagramSocketDeprecatedResponse>(offset);
82252            // Zero out padding regions. There's no need to apply masks
82253            // because the unmasked parts will be overwritten by fields.
82254            // Write the fields.
82255            self.0.encode(encoder, offset + 0, depth)?;
82256            Ok(())
82257        }
82258    }
82259
82260    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
82261        for ProviderDatagramSocketDeprecatedResponse
82262    {
82263        #[inline(always)]
82264        fn new_empty() -> Self {
82265            Self {
82266                s: fidl::new_empty!(
82267                    fidl::encoding::Endpoint<
82268                        fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
82269                    >,
82270                    fidl::encoding::DefaultFuchsiaResourceDialect
82271                ),
82272            }
82273        }
82274
82275        #[inline]
82276        unsafe fn decode(
82277            &mut self,
82278            decoder: &mut fidl::encoding::Decoder<
82279                '_,
82280                fidl::encoding::DefaultFuchsiaResourceDialect,
82281            >,
82282            offset: usize,
82283            _depth: fidl::encoding::Depth,
82284        ) -> fidl::Result<()> {
82285            decoder.debug_check_bounds::<Self>(offset);
82286            // Verify that padding bytes are zero.
82287            fidl::decode!(
82288                fidl::encoding::Endpoint<
82289                    fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
82290                >,
82291                fidl::encoding::DefaultFuchsiaResourceDialect,
82292                &mut self.s,
82293                decoder,
82294                offset + 0,
82295                _depth
82296            )?;
82297            Ok(())
82298        }
82299    }
82300
82301    impl fidl::encoding::ResourceTypeMarker for ProviderStreamSocketWithOptionsResponse {
82302        type Borrowed<'a> = &'a mut Self;
82303        fn take_or_borrow<'a>(
82304            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
82305        ) -> Self::Borrowed<'a> {
82306            value
82307        }
82308    }
82309
82310    unsafe impl fidl::encoding::TypeMarker for ProviderStreamSocketWithOptionsResponse {
82311        type Owned = Self;
82312
82313        #[inline(always)]
82314        fn inline_align(_context: fidl::encoding::Context) -> usize {
82315            4
82316        }
82317
82318        #[inline(always)]
82319        fn inline_size(_context: fidl::encoding::Context) -> usize {
82320            4
82321        }
82322    }
82323
82324    unsafe impl
82325        fidl::encoding::Encode<
82326            ProviderStreamSocketWithOptionsResponse,
82327            fidl::encoding::DefaultFuchsiaResourceDialect,
82328        > for &mut ProviderStreamSocketWithOptionsResponse
82329    {
82330        #[inline]
82331        unsafe fn encode(
82332            self,
82333            encoder: &mut fidl::encoding::Encoder<
82334                '_,
82335                fidl::encoding::DefaultFuchsiaResourceDialect,
82336            >,
82337            offset: usize,
82338            _depth: fidl::encoding::Depth,
82339        ) -> fidl::Result<()> {
82340            encoder.debug_check_bounds::<ProviderStreamSocketWithOptionsResponse>(offset);
82341            // Delegate to tuple encoding.
82342            fidl::encoding::Encode::<ProviderStreamSocketWithOptionsResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
82343                (
82344                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.s),
82345                ),
82346                encoder, offset, _depth
82347            )
82348        }
82349    }
82350    unsafe impl<
82351            T0: fidl::encoding::Encode<
82352                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>>,
82353                fidl::encoding::DefaultFuchsiaResourceDialect,
82354            >,
82355        >
82356        fidl::encoding::Encode<
82357            ProviderStreamSocketWithOptionsResponse,
82358            fidl::encoding::DefaultFuchsiaResourceDialect,
82359        > for (T0,)
82360    {
82361        #[inline]
82362        unsafe fn encode(
82363            self,
82364            encoder: &mut fidl::encoding::Encoder<
82365                '_,
82366                fidl::encoding::DefaultFuchsiaResourceDialect,
82367            >,
82368            offset: usize,
82369            depth: fidl::encoding::Depth,
82370        ) -> fidl::Result<()> {
82371            encoder.debug_check_bounds::<ProviderStreamSocketWithOptionsResponse>(offset);
82372            // Zero out padding regions. There's no need to apply masks
82373            // because the unmasked parts will be overwritten by fields.
82374            // Write the fields.
82375            self.0.encode(encoder, offset + 0, depth)?;
82376            Ok(())
82377        }
82378    }
82379
82380    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
82381        for ProviderStreamSocketWithOptionsResponse
82382    {
82383        #[inline(always)]
82384        fn new_empty() -> Self {
82385            Self {
82386                s: fidl::new_empty!(
82387                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>>,
82388                    fidl::encoding::DefaultFuchsiaResourceDialect
82389                ),
82390            }
82391        }
82392
82393        #[inline]
82394        unsafe fn decode(
82395            &mut self,
82396            decoder: &mut fidl::encoding::Decoder<
82397                '_,
82398                fidl::encoding::DefaultFuchsiaResourceDialect,
82399            >,
82400            offset: usize,
82401            _depth: fidl::encoding::Depth,
82402        ) -> fidl::Result<()> {
82403            decoder.debug_check_bounds::<Self>(offset);
82404            // Verify that padding bytes are zero.
82405            fidl::decode!(
82406                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>>,
82407                fidl::encoding::DefaultFuchsiaResourceDialect,
82408                &mut self.s,
82409                decoder,
82410                offset + 0,
82411                _depth
82412            )?;
82413            Ok(())
82414        }
82415    }
82416
82417    impl fidl::encoding::ResourceTypeMarker for ProviderStreamSocketResponse {
82418        type Borrowed<'a> = &'a mut Self;
82419        fn take_or_borrow<'a>(
82420            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
82421        ) -> Self::Borrowed<'a> {
82422            value
82423        }
82424    }
82425
82426    unsafe impl fidl::encoding::TypeMarker for ProviderStreamSocketResponse {
82427        type Owned = Self;
82428
82429        #[inline(always)]
82430        fn inline_align(_context: fidl::encoding::Context) -> usize {
82431            4
82432        }
82433
82434        #[inline(always)]
82435        fn inline_size(_context: fidl::encoding::Context) -> usize {
82436            4
82437        }
82438    }
82439
82440    unsafe impl
82441        fidl::encoding::Encode<
82442            ProviderStreamSocketResponse,
82443            fidl::encoding::DefaultFuchsiaResourceDialect,
82444        > for &mut ProviderStreamSocketResponse
82445    {
82446        #[inline]
82447        unsafe fn encode(
82448            self,
82449            encoder: &mut fidl::encoding::Encoder<
82450                '_,
82451                fidl::encoding::DefaultFuchsiaResourceDialect,
82452            >,
82453            offset: usize,
82454            _depth: fidl::encoding::Depth,
82455        ) -> fidl::Result<()> {
82456            encoder.debug_check_bounds::<ProviderStreamSocketResponse>(offset);
82457            // Delegate to tuple encoding.
82458            fidl::encoding::Encode::<ProviderStreamSocketResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
82459                (
82460                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.s),
82461                ),
82462                encoder, offset, _depth
82463            )
82464        }
82465    }
82466    unsafe impl<
82467            T0: fidl::encoding::Encode<
82468                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>>,
82469                fidl::encoding::DefaultFuchsiaResourceDialect,
82470            >,
82471        >
82472        fidl::encoding::Encode<
82473            ProviderStreamSocketResponse,
82474            fidl::encoding::DefaultFuchsiaResourceDialect,
82475        > for (T0,)
82476    {
82477        #[inline]
82478        unsafe fn encode(
82479            self,
82480            encoder: &mut fidl::encoding::Encoder<
82481                '_,
82482                fidl::encoding::DefaultFuchsiaResourceDialect,
82483            >,
82484            offset: usize,
82485            depth: fidl::encoding::Depth,
82486        ) -> fidl::Result<()> {
82487            encoder.debug_check_bounds::<ProviderStreamSocketResponse>(offset);
82488            // Zero out padding regions. There's no need to apply masks
82489            // because the unmasked parts will be overwritten by fields.
82490            // Write the fields.
82491            self.0.encode(encoder, offset + 0, depth)?;
82492            Ok(())
82493        }
82494    }
82495
82496    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
82497        for ProviderStreamSocketResponse
82498    {
82499        #[inline(always)]
82500        fn new_empty() -> Self {
82501            Self {
82502                s: fidl::new_empty!(
82503                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>>,
82504                    fidl::encoding::DefaultFuchsiaResourceDialect
82505                ),
82506            }
82507        }
82508
82509        #[inline]
82510        unsafe fn decode(
82511            &mut self,
82512            decoder: &mut fidl::encoding::Decoder<
82513                '_,
82514                fidl::encoding::DefaultFuchsiaResourceDialect,
82515            >,
82516            offset: usize,
82517            _depth: fidl::encoding::Depth,
82518        ) -> fidl::Result<()> {
82519            decoder.debug_check_bounds::<Self>(offset);
82520            // Verify that padding bytes are zero.
82521            fidl::decode!(
82522                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>>,
82523                fidl::encoding::DefaultFuchsiaResourceDialect,
82524                &mut self.s,
82525                decoder,
82526                offset + 0,
82527                _depth
82528            )?;
82529            Ok(())
82530        }
82531    }
82532
82533    impl fidl::encoding::ResourceTypeMarker for StreamSocketAcceptResponse {
82534        type Borrowed<'a> = &'a mut Self;
82535        fn take_or_borrow<'a>(
82536            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
82537        ) -> Self::Borrowed<'a> {
82538            value
82539        }
82540    }
82541
82542    unsafe impl fidl::encoding::TypeMarker for StreamSocketAcceptResponse {
82543        type Owned = Self;
82544
82545        #[inline(always)]
82546        fn inline_align(_context: fidl::encoding::Context) -> usize {
82547            8
82548        }
82549
82550        #[inline(always)]
82551        fn inline_size(_context: fidl::encoding::Context) -> usize {
82552            24
82553        }
82554    }
82555
82556    unsafe impl
82557        fidl::encoding::Encode<
82558            StreamSocketAcceptResponse,
82559            fidl::encoding::DefaultFuchsiaResourceDialect,
82560        > for &mut StreamSocketAcceptResponse
82561    {
82562        #[inline]
82563        unsafe fn encode(
82564            self,
82565            encoder: &mut fidl::encoding::Encoder<
82566                '_,
82567                fidl::encoding::DefaultFuchsiaResourceDialect,
82568            >,
82569            offset: usize,
82570            _depth: fidl::encoding::Depth,
82571        ) -> fidl::Result<()> {
82572            encoder.debug_check_bounds::<StreamSocketAcceptResponse>(offset);
82573            // Delegate to tuple encoding.
82574            fidl::encoding::Encode::<StreamSocketAcceptResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
82575                (
82576                    <fidl::encoding::OptionalUnion<fidl_fuchsia_net::SocketAddress> as fidl::encoding::ValueTypeMarker>::borrow(&self.addr),
82577                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.s),
82578                ),
82579                encoder, offset, _depth
82580            )
82581        }
82582    }
82583    unsafe impl<
82584            T0: fidl::encoding::Encode<
82585                fidl::encoding::OptionalUnion<fidl_fuchsia_net::SocketAddress>,
82586                fidl::encoding::DefaultFuchsiaResourceDialect,
82587            >,
82588            T1: fidl::encoding::Encode<
82589                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>>,
82590                fidl::encoding::DefaultFuchsiaResourceDialect,
82591            >,
82592        >
82593        fidl::encoding::Encode<
82594            StreamSocketAcceptResponse,
82595            fidl::encoding::DefaultFuchsiaResourceDialect,
82596        > for (T0, T1)
82597    {
82598        #[inline]
82599        unsafe fn encode(
82600            self,
82601            encoder: &mut fidl::encoding::Encoder<
82602                '_,
82603                fidl::encoding::DefaultFuchsiaResourceDialect,
82604            >,
82605            offset: usize,
82606            depth: fidl::encoding::Depth,
82607        ) -> fidl::Result<()> {
82608            encoder.debug_check_bounds::<StreamSocketAcceptResponse>(offset);
82609            // Zero out padding regions. There's no need to apply masks
82610            // because the unmasked parts will be overwritten by fields.
82611            unsafe {
82612                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
82613                (ptr as *mut u64).write_unaligned(0);
82614            }
82615            // Write the fields.
82616            self.0.encode(encoder, offset + 0, depth)?;
82617            self.1.encode(encoder, offset + 16, depth)?;
82618            Ok(())
82619        }
82620    }
82621
82622    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
82623        for StreamSocketAcceptResponse
82624    {
82625        #[inline(always)]
82626        fn new_empty() -> Self {
82627            Self {
82628                addr: fidl::new_empty!(
82629                    fidl::encoding::OptionalUnion<fidl_fuchsia_net::SocketAddress>,
82630                    fidl::encoding::DefaultFuchsiaResourceDialect
82631                ),
82632                s: fidl::new_empty!(
82633                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>>,
82634                    fidl::encoding::DefaultFuchsiaResourceDialect
82635                ),
82636            }
82637        }
82638
82639        #[inline]
82640        unsafe fn decode(
82641            &mut self,
82642            decoder: &mut fidl::encoding::Decoder<
82643                '_,
82644                fidl::encoding::DefaultFuchsiaResourceDialect,
82645            >,
82646            offset: usize,
82647            _depth: fidl::encoding::Depth,
82648        ) -> fidl::Result<()> {
82649            decoder.debug_check_bounds::<Self>(offset);
82650            // Verify that padding bytes are zero.
82651            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
82652            let padval = unsafe { (ptr as *const u64).read_unaligned() };
82653            let mask = 0xffffffff00000000u64;
82654            let maskedval = padval & mask;
82655            if maskedval != 0 {
82656                return Err(fidl::Error::NonZeroPadding {
82657                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
82658                });
82659            }
82660            fidl::decode!(
82661                fidl::encoding::OptionalUnion<fidl_fuchsia_net::SocketAddress>,
82662                fidl::encoding::DefaultFuchsiaResourceDialect,
82663                &mut self.addr,
82664                decoder,
82665                offset + 0,
82666                _depth
82667            )?;
82668            fidl::decode!(
82669                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<StreamSocketMarker>>,
82670                fidl::encoding::DefaultFuchsiaResourceDialect,
82671                &mut self.s,
82672                decoder,
82673                offset + 16,
82674                _depth
82675            )?;
82676            Ok(())
82677        }
82678    }
82679
82680    impl DatagramSocketDescribeResponse {
82681        #[inline(always)]
82682        fn max_ordinal_present(&self) -> u64 {
82683            if let Some(_) = self.metadata_encoding_protocol_version {
82684                return 4;
82685            }
82686            if let Some(_) = self.rx_meta_buf_size {
82687                return 3;
82688            }
82689            if let Some(_) = self.tx_meta_buf_size {
82690                return 2;
82691            }
82692            if let Some(_) = self.socket {
82693                return 1;
82694            }
82695            0
82696        }
82697    }
82698
82699    impl fidl::encoding::ResourceTypeMarker for DatagramSocketDescribeResponse {
82700        type Borrowed<'a> = &'a mut Self;
82701        fn take_or_borrow<'a>(
82702            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
82703        ) -> Self::Borrowed<'a> {
82704            value
82705        }
82706    }
82707
82708    unsafe impl fidl::encoding::TypeMarker for DatagramSocketDescribeResponse {
82709        type Owned = Self;
82710
82711        #[inline(always)]
82712        fn inline_align(_context: fidl::encoding::Context) -> usize {
82713            8
82714        }
82715
82716        #[inline(always)]
82717        fn inline_size(_context: fidl::encoding::Context) -> usize {
82718            16
82719        }
82720    }
82721
82722    unsafe impl
82723        fidl::encoding::Encode<
82724            DatagramSocketDescribeResponse,
82725            fidl::encoding::DefaultFuchsiaResourceDialect,
82726        > for &mut DatagramSocketDescribeResponse
82727    {
82728        unsafe fn encode(
82729            self,
82730            encoder: &mut fidl::encoding::Encoder<
82731                '_,
82732                fidl::encoding::DefaultFuchsiaResourceDialect,
82733            >,
82734            offset: usize,
82735            mut depth: fidl::encoding::Depth,
82736        ) -> fidl::Result<()> {
82737            encoder.debug_check_bounds::<DatagramSocketDescribeResponse>(offset);
82738            // Vector header
82739            let max_ordinal: u64 = self.max_ordinal_present();
82740            encoder.write_num(max_ordinal, offset);
82741            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
82742            // Calling encoder.out_of_line_offset(0) is not allowed.
82743            if max_ordinal == 0 {
82744                return Ok(());
82745            }
82746            depth.increment()?;
82747            let envelope_size = 8;
82748            let bytes_len = max_ordinal as usize * envelope_size;
82749            #[allow(unused_variables)]
82750            let offset = encoder.out_of_line_offset(bytes_len);
82751            let mut _prev_end_offset: usize = 0;
82752            if 1 > max_ordinal {
82753                return Ok(());
82754            }
82755
82756            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
82757            // are envelope_size bytes.
82758            let cur_offset: usize = (1 - 1) * envelope_size;
82759
82760            // Zero reserved fields.
82761            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
82762
82763            // Safety:
82764            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
82765            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
82766            //   envelope_size bytes, there is always sufficient room.
82767            fidl::encoding::encode_in_envelope_optional::<
82768                fidl::encoding::HandleType<
82769                    fidl::Socket,
82770                    { fidl::ObjectType::SOCKET.into_raw() },
82771                    2147483648,
82772                >,
82773                fidl::encoding::DefaultFuchsiaResourceDialect,
82774            >(
82775                self.socket.as_mut().map(
82776                    <fidl::encoding::HandleType<
82777                        fidl::Socket,
82778                        { fidl::ObjectType::SOCKET.into_raw() },
82779                        2147483648,
82780                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
82781                ),
82782                encoder,
82783                offset + cur_offset,
82784                depth,
82785            )?;
82786
82787            _prev_end_offset = cur_offset + envelope_size;
82788            if 2 > max_ordinal {
82789                return Ok(());
82790            }
82791
82792            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
82793            // are envelope_size bytes.
82794            let cur_offset: usize = (2 - 1) * envelope_size;
82795
82796            // Zero reserved fields.
82797            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
82798
82799            // Safety:
82800            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
82801            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
82802            //   envelope_size bytes, there is always sufficient room.
82803            fidl::encoding::encode_in_envelope_optional::<
82804                u64,
82805                fidl::encoding::DefaultFuchsiaResourceDialect,
82806            >(
82807                self.tx_meta_buf_size
82808                    .as_ref()
82809                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
82810                encoder,
82811                offset + cur_offset,
82812                depth,
82813            )?;
82814
82815            _prev_end_offset = cur_offset + envelope_size;
82816            if 3 > max_ordinal {
82817                return Ok(());
82818            }
82819
82820            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
82821            // are envelope_size bytes.
82822            let cur_offset: usize = (3 - 1) * envelope_size;
82823
82824            // Zero reserved fields.
82825            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
82826
82827            // Safety:
82828            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
82829            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
82830            //   envelope_size bytes, there is always sufficient room.
82831            fidl::encoding::encode_in_envelope_optional::<
82832                u64,
82833                fidl::encoding::DefaultFuchsiaResourceDialect,
82834            >(
82835                self.rx_meta_buf_size
82836                    .as_ref()
82837                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
82838                encoder,
82839                offset + cur_offset,
82840                depth,
82841            )?;
82842
82843            _prev_end_offset = cur_offset + envelope_size;
82844            if 4 > max_ordinal {
82845                return Ok(());
82846            }
82847
82848            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
82849            // are envelope_size bytes.
82850            let cur_offset: usize = (4 - 1) * envelope_size;
82851
82852            // Zero reserved fields.
82853            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
82854
82855            // Safety:
82856            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
82857            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
82858            //   envelope_size bytes, there is always sufficient room.
82859            fidl::encoding::encode_in_envelope_optional::<
82860                UdpMetadataEncodingProtocolVersion,
82861                fidl::encoding::DefaultFuchsiaResourceDialect,
82862            >(
82863                self.metadata_encoding_protocol_version.as_ref().map(
82864                    <UdpMetadataEncodingProtocolVersion as fidl::encoding::ValueTypeMarker>::borrow,
82865                ),
82866                encoder,
82867                offset + cur_offset,
82868                depth,
82869            )?;
82870
82871            _prev_end_offset = cur_offset + envelope_size;
82872
82873            Ok(())
82874        }
82875    }
82876
82877    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
82878        for DatagramSocketDescribeResponse
82879    {
82880        #[inline(always)]
82881        fn new_empty() -> Self {
82882            Self::default()
82883        }
82884
82885        unsafe fn decode(
82886            &mut self,
82887            decoder: &mut fidl::encoding::Decoder<
82888                '_,
82889                fidl::encoding::DefaultFuchsiaResourceDialect,
82890            >,
82891            offset: usize,
82892            mut depth: fidl::encoding::Depth,
82893        ) -> fidl::Result<()> {
82894            decoder.debug_check_bounds::<Self>(offset);
82895            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
82896                None => return Err(fidl::Error::NotNullable),
82897                Some(len) => len,
82898            };
82899            // Calling decoder.out_of_line_offset(0) is not allowed.
82900            if len == 0 {
82901                return Ok(());
82902            };
82903            depth.increment()?;
82904            let envelope_size = 8;
82905            let bytes_len = len * envelope_size;
82906            let offset = decoder.out_of_line_offset(bytes_len)?;
82907            // Decode the envelope for each type.
82908            let mut _next_ordinal_to_read = 0;
82909            let mut next_offset = offset;
82910            let end_offset = offset + bytes_len;
82911            _next_ordinal_to_read += 1;
82912            if next_offset >= end_offset {
82913                return Ok(());
82914            }
82915
82916            // Decode unknown envelopes for gaps in ordinals.
82917            while _next_ordinal_to_read < 1 {
82918                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
82919                _next_ordinal_to_read += 1;
82920                next_offset += envelope_size;
82921            }
82922
82923            let next_out_of_line = decoder.next_out_of_line();
82924            let handles_before = decoder.remaining_handles();
82925            if let Some((inlined, num_bytes, num_handles)) =
82926                fidl::encoding::decode_envelope_header(decoder, next_offset)?
82927            {
82928                let member_inline_size = <fidl::encoding::HandleType<
82929                    fidl::Socket,
82930                    { fidl::ObjectType::SOCKET.into_raw() },
82931                    2147483648,
82932                > as fidl::encoding::TypeMarker>::inline_size(
82933                    decoder.context
82934                );
82935                if inlined != (member_inline_size <= 4) {
82936                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
82937                }
82938                let inner_offset;
82939                let mut inner_depth = depth.clone();
82940                if inlined {
82941                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
82942                    inner_offset = next_offset;
82943                } else {
82944                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
82945                    inner_depth.increment()?;
82946                }
82947                let val_ref =
82948                self.socket.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
82949                fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
82950                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
82951                {
82952                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
82953                }
82954                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
82955                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
82956                }
82957            }
82958
82959            next_offset += envelope_size;
82960            _next_ordinal_to_read += 1;
82961            if next_offset >= end_offset {
82962                return Ok(());
82963            }
82964
82965            // Decode unknown envelopes for gaps in ordinals.
82966            while _next_ordinal_to_read < 2 {
82967                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
82968                _next_ordinal_to_read += 1;
82969                next_offset += envelope_size;
82970            }
82971
82972            let next_out_of_line = decoder.next_out_of_line();
82973            let handles_before = decoder.remaining_handles();
82974            if let Some((inlined, num_bytes, num_handles)) =
82975                fidl::encoding::decode_envelope_header(decoder, next_offset)?
82976            {
82977                let member_inline_size =
82978                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
82979                if inlined != (member_inline_size <= 4) {
82980                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
82981                }
82982                let inner_offset;
82983                let mut inner_depth = depth.clone();
82984                if inlined {
82985                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
82986                    inner_offset = next_offset;
82987                } else {
82988                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
82989                    inner_depth.increment()?;
82990                }
82991                let val_ref = self.tx_meta_buf_size.get_or_insert_with(|| {
82992                    fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect)
82993                });
82994                fidl::decode!(
82995                    u64,
82996                    fidl::encoding::DefaultFuchsiaResourceDialect,
82997                    val_ref,
82998                    decoder,
82999                    inner_offset,
83000                    inner_depth
83001                )?;
83002                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
83003                {
83004                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
83005                }
83006                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
83007                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
83008                }
83009            }
83010
83011            next_offset += envelope_size;
83012            _next_ordinal_to_read += 1;
83013            if next_offset >= end_offset {
83014                return Ok(());
83015            }
83016
83017            // Decode unknown envelopes for gaps in ordinals.
83018            while _next_ordinal_to_read < 3 {
83019                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
83020                _next_ordinal_to_read += 1;
83021                next_offset += envelope_size;
83022            }
83023
83024            let next_out_of_line = decoder.next_out_of_line();
83025            let handles_before = decoder.remaining_handles();
83026            if let Some((inlined, num_bytes, num_handles)) =
83027                fidl::encoding::decode_envelope_header(decoder, next_offset)?
83028            {
83029                let member_inline_size =
83030                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
83031                if inlined != (member_inline_size <= 4) {
83032                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
83033                }
83034                let inner_offset;
83035                let mut inner_depth = depth.clone();
83036                if inlined {
83037                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
83038                    inner_offset = next_offset;
83039                } else {
83040                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
83041                    inner_depth.increment()?;
83042                }
83043                let val_ref = self.rx_meta_buf_size.get_or_insert_with(|| {
83044                    fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect)
83045                });
83046                fidl::decode!(
83047                    u64,
83048                    fidl::encoding::DefaultFuchsiaResourceDialect,
83049                    val_ref,
83050                    decoder,
83051                    inner_offset,
83052                    inner_depth
83053                )?;
83054                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
83055                {
83056                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
83057                }
83058                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
83059                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
83060                }
83061            }
83062
83063            next_offset += envelope_size;
83064            _next_ordinal_to_read += 1;
83065            if next_offset >= end_offset {
83066                return Ok(());
83067            }
83068
83069            // Decode unknown envelopes for gaps in ordinals.
83070            while _next_ordinal_to_read < 4 {
83071                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
83072                _next_ordinal_to_read += 1;
83073                next_offset += envelope_size;
83074            }
83075
83076            let next_out_of_line = decoder.next_out_of_line();
83077            let handles_before = decoder.remaining_handles();
83078            if let Some((inlined, num_bytes, num_handles)) =
83079                fidl::encoding::decode_envelope_header(decoder, next_offset)?
83080            {
83081                let member_inline_size =
83082                    <UdpMetadataEncodingProtocolVersion as fidl::encoding::TypeMarker>::inline_size(
83083                        decoder.context,
83084                    );
83085                if inlined != (member_inline_size <= 4) {
83086                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
83087                }
83088                let inner_offset;
83089                let mut inner_depth = depth.clone();
83090                if inlined {
83091                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
83092                    inner_offset = next_offset;
83093                } else {
83094                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
83095                    inner_depth.increment()?;
83096                }
83097                let val_ref = self.metadata_encoding_protocol_version.get_or_insert_with(|| {
83098                    fidl::new_empty!(
83099                        UdpMetadataEncodingProtocolVersion,
83100                        fidl::encoding::DefaultFuchsiaResourceDialect
83101                    )
83102                });
83103                fidl::decode!(
83104                    UdpMetadataEncodingProtocolVersion,
83105                    fidl::encoding::DefaultFuchsiaResourceDialect,
83106                    val_ref,
83107                    decoder,
83108                    inner_offset,
83109                    inner_depth
83110                )?;
83111                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
83112                {
83113                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
83114                }
83115                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
83116                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
83117                }
83118            }
83119
83120            next_offset += envelope_size;
83121
83122            // Decode the remaining unknown envelopes.
83123            while next_offset < end_offset {
83124                _next_ordinal_to_read += 1;
83125                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
83126                next_offset += envelope_size;
83127            }
83128
83129            Ok(())
83130        }
83131    }
83132
83133    impl DatagramSocketRecvMsgPostflightResponse {
83134        #[inline(always)]
83135        fn max_ordinal_present(&self) -> u64 {
83136            if let Some(_) = self.requests {
83137                return 3;
83138            }
83139            if let Some(_) = self.timestamp {
83140                return 2;
83141            }
83142            if let Some(_) = self.validity {
83143                return 1;
83144            }
83145            0
83146        }
83147    }
83148
83149    impl fidl::encoding::ResourceTypeMarker for DatagramSocketRecvMsgPostflightResponse {
83150        type Borrowed<'a> = &'a mut Self;
83151        fn take_or_borrow<'a>(
83152            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
83153        ) -> Self::Borrowed<'a> {
83154            value
83155        }
83156    }
83157
83158    unsafe impl fidl::encoding::TypeMarker for DatagramSocketRecvMsgPostflightResponse {
83159        type Owned = Self;
83160
83161        #[inline(always)]
83162        fn inline_align(_context: fidl::encoding::Context) -> usize {
83163            8
83164        }
83165
83166        #[inline(always)]
83167        fn inline_size(_context: fidl::encoding::Context) -> usize {
83168            16
83169        }
83170    }
83171
83172    unsafe impl
83173        fidl::encoding::Encode<
83174            DatagramSocketRecvMsgPostflightResponse,
83175            fidl::encoding::DefaultFuchsiaResourceDialect,
83176        > for &mut DatagramSocketRecvMsgPostflightResponse
83177    {
83178        unsafe fn encode(
83179            self,
83180            encoder: &mut fidl::encoding::Encoder<
83181                '_,
83182                fidl::encoding::DefaultFuchsiaResourceDialect,
83183            >,
83184            offset: usize,
83185            mut depth: fidl::encoding::Depth,
83186        ) -> fidl::Result<()> {
83187            encoder.debug_check_bounds::<DatagramSocketRecvMsgPostflightResponse>(offset);
83188            // Vector header
83189            let max_ordinal: u64 = self.max_ordinal_present();
83190            encoder.write_num(max_ordinal, offset);
83191            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
83192            // Calling encoder.out_of_line_offset(0) is not allowed.
83193            if max_ordinal == 0 {
83194                return Ok(());
83195            }
83196            depth.increment()?;
83197            let envelope_size = 8;
83198            let bytes_len = max_ordinal as usize * envelope_size;
83199            #[allow(unused_variables)]
83200            let offset = encoder.out_of_line_offset(bytes_len);
83201            let mut _prev_end_offset: usize = 0;
83202            if 1 > max_ordinal {
83203                return Ok(());
83204            }
83205
83206            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
83207            // are envelope_size bytes.
83208            let cur_offset: usize = (1 - 1) * envelope_size;
83209
83210            // Zero reserved fields.
83211            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
83212
83213            // Safety:
83214            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
83215            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
83216            //   envelope_size bytes, there is always sufficient room.
83217            fidl::encoding::encode_in_envelope_optional::<
83218                fidl::encoding::HandleType<
83219                    fidl::EventPair,
83220                    { fidl::ObjectType::EVENTPAIR.into_raw() },
83221                    49155,
83222                >,
83223                fidl::encoding::DefaultFuchsiaResourceDialect,
83224            >(
83225                self.validity.as_mut().map(
83226                    <fidl::encoding::HandleType<
83227                        fidl::EventPair,
83228                        { fidl::ObjectType::EVENTPAIR.into_raw() },
83229                        49155,
83230                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
83231                ),
83232                encoder,
83233                offset + cur_offset,
83234                depth,
83235            )?;
83236
83237            _prev_end_offset = cur_offset + envelope_size;
83238            if 2 > max_ordinal {
83239                return Ok(());
83240            }
83241
83242            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
83243            // are envelope_size bytes.
83244            let cur_offset: usize = (2 - 1) * envelope_size;
83245
83246            // Zero reserved fields.
83247            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
83248
83249            // Safety:
83250            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
83251            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
83252            //   envelope_size bytes, there is always sufficient room.
83253            fidl::encoding::encode_in_envelope_optional::<
83254                TimestampOption,
83255                fidl::encoding::DefaultFuchsiaResourceDialect,
83256            >(
83257                self.timestamp
83258                    .as_ref()
83259                    .map(<TimestampOption as fidl::encoding::ValueTypeMarker>::borrow),
83260                encoder,
83261                offset + cur_offset,
83262                depth,
83263            )?;
83264
83265            _prev_end_offset = cur_offset + envelope_size;
83266            if 3 > max_ordinal {
83267                return Ok(());
83268            }
83269
83270            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
83271            // are envelope_size bytes.
83272            let cur_offset: usize = (3 - 1) * envelope_size;
83273
83274            // Zero reserved fields.
83275            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
83276
83277            // Safety:
83278            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
83279            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
83280            //   envelope_size bytes, there is always sufficient room.
83281            fidl::encoding::encode_in_envelope_optional::<
83282                CmsgRequests,
83283                fidl::encoding::DefaultFuchsiaResourceDialect,
83284            >(
83285                self.requests
83286                    .as_ref()
83287                    .map(<CmsgRequests as fidl::encoding::ValueTypeMarker>::borrow),
83288                encoder,
83289                offset + cur_offset,
83290                depth,
83291            )?;
83292
83293            _prev_end_offset = cur_offset + envelope_size;
83294
83295            Ok(())
83296        }
83297    }
83298
83299    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
83300        for DatagramSocketRecvMsgPostflightResponse
83301    {
83302        #[inline(always)]
83303        fn new_empty() -> Self {
83304            Self::default()
83305        }
83306
83307        unsafe fn decode(
83308            &mut self,
83309            decoder: &mut fidl::encoding::Decoder<
83310                '_,
83311                fidl::encoding::DefaultFuchsiaResourceDialect,
83312            >,
83313            offset: usize,
83314            mut depth: fidl::encoding::Depth,
83315        ) -> fidl::Result<()> {
83316            decoder.debug_check_bounds::<Self>(offset);
83317            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
83318                None => return Err(fidl::Error::NotNullable),
83319                Some(len) => len,
83320            };
83321            // Calling decoder.out_of_line_offset(0) is not allowed.
83322            if len == 0 {
83323                return Ok(());
83324            };
83325            depth.increment()?;
83326            let envelope_size = 8;
83327            let bytes_len = len * envelope_size;
83328            let offset = decoder.out_of_line_offset(bytes_len)?;
83329            // Decode the envelope for each type.
83330            let mut _next_ordinal_to_read = 0;
83331            let mut next_offset = offset;
83332            let end_offset = offset + bytes_len;
83333            _next_ordinal_to_read += 1;
83334            if next_offset >= end_offset {
83335                return Ok(());
83336            }
83337
83338            // Decode unknown envelopes for gaps in ordinals.
83339            while _next_ordinal_to_read < 1 {
83340                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
83341                _next_ordinal_to_read += 1;
83342                next_offset += envelope_size;
83343            }
83344
83345            let next_out_of_line = decoder.next_out_of_line();
83346            let handles_before = decoder.remaining_handles();
83347            if let Some((inlined, num_bytes, num_handles)) =
83348                fidl::encoding::decode_envelope_header(decoder, next_offset)?
83349            {
83350                let member_inline_size = <fidl::encoding::HandleType<
83351                    fidl::EventPair,
83352                    { fidl::ObjectType::EVENTPAIR.into_raw() },
83353                    49155,
83354                > as fidl::encoding::TypeMarker>::inline_size(
83355                    decoder.context
83356                );
83357                if inlined != (member_inline_size <= 4) {
83358                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
83359                }
83360                let inner_offset;
83361                let mut inner_depth = depth.clone();
83362                if inlined {
83363                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
83364                    inner_offset = next_offset;
83365                } else {
83366                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
83367                    inner_depth.increment()?;
83368                }
83369                let val_ref =
83370                self.validity.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 49155>, fidl::encoding::DefaultFuchsiaResourceDialect));
83371                fidl::decode!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 49155>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
83372                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
83373                {
83374                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
83375                }
83376                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
83377                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
83378                }
83379            }
83380
83381            next_offset += envelope_size;
83382            _next_ordinal_to_read += 1;
83383            if next_offset >= end_offset {
83384                return Ok(());
83385            }
83386
83387            // Decode unknown envelopes for gaps in ordinals.
83388            while _next_ordinal_to_read < 2 {
83389                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
83390                _next_ordinal_to_read += 1;
83391                next_offset += envelope_size;
83392            }
83393
83394            let next_out_of_line = decoder.next_out_of_line();
83395            let handles_before = decoder.remaining_handles();
83396            if let Some((inlined, num_bytes, num_handles)) =
83397                fidl::encoding::decode_envelope_header(decoder, next_offset)?
83398            {
83399                let member_inline_size =
83400                    <TimestampOption as fidl::encoding::TypeMarker>::inline_size(decoder.context);
83401                if inlined != (member_inline_size <= 4) {
83402                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
83403                }
83404                let inner_offset;
83405                let mut inner_depth = depth.clone();
83406                if inlined {
83407                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
83408                    inner_offset = next_offset;
83409                } else {
83410                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
83411                    inner_depth.increment()?;
83412                }
83413                let val_ref = self.timestamp.get_or_insert_with(|| {
83414                    fidl::new_empty!(TimestampOption, fidl::encoding::DefaultFuchsiaResourceDialect)
83415                });
83416                fidl::decode!(
83417                    TimestampOption,
83418                    fidl::encoding::DefaultFuchsiaResourceDialect,
83419                    val_ref,
83420                    decoder,
83421                    inner_offset,
83422                    inner_depth
83423                )?;
83424                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
83425                {
83426                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
83427                }
83428                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
83429                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
83430                }
83431            }
83432
83433            next_offset += envelope_size;
83434            _next_ordinal_to_read += 1;
83435            if next_offset >= end_offset {
83436                return Ok(());
83437            }
83438
83439            // Decode unknown envelopes for gaps in ordinals.
83440            while _next_ordinal_to_read < 3 {
83441                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
83442                _next_ordinal_to_read += 1;
83443                next_offset += envelope_size;
83444            }
83445
83446            let next_out_of_line = decoder.next_out_of_line();
83447            let handles_before = decoder.remaining_handles();
83448            if let Some((inlined, num_bytes, num_handles)) =
83449                fidl::encoding::decode_envelope_header(decoder, next_offset)?
83450            {
83451                let member_inline_size =
83452                    <CmsgRequests as fidl::encoding::TypeMarker>::inline_size(decoder.context);
83453                if inlined != (member_inline_size <= 4) {
83454                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
83455                }
83456                let inner_offset;
83457                let mut inner_depth = depth.clone();
83458                if inlined {
83459                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
83460                    inner_offset = next_offset;
83461                } else {
83462                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
83463                    inner_depth.increment()?;
83464                }
83465                let val_ref = self.requests.get_or_insert_with(|| {
83466                    fidl::new_empty!(CmsgRequests, fidl::encoding::DefaultFuchsiaResourceDialect)
83467                });
83468                fidl::decode!(
83469                    CmsgRequests,
83470                    fidl::encoding::DefaultFuchsiaResourceDialect,
83471                    val_ref,
83472                    decoder,
83473                    inner_offset,
83474                    inner_depth
83475                )?;
83476                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
83477                {
83478                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
83479                }
83480                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
83481                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
83482                }
83483            }
83484
83485            next_offset += envelope_size;
83486
83487            // Decode the remaining unknown envelopes.
83488            while next_offset < end_offset {
83489                _next_ordinal_to_read += 1;
83490                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
83491                next_offset += envelope_size;
83492            }
83493
83494            Ok(())
83495        }
83496    }
83497
83498    impl DatagramSocketSendMsgPreflightResponse {
83499        #[inline(always)]
83500        fn max_ordinal_present(&self) -> u64 {
83501            if let Some(_) = self.maximum_size {
83502                return 3;
83503            }
83504            if let Some(_) = self.validity {
83505                return 2;
83506            }
83507            if let Some(_) = self.to {
83508                return 1;
83509            }
83510            0
83511        }
83512    }
83513
83514    impl fidl::encoding::ResourceTypeMarker for DatagramSocketSendMsgPreflightResponse {
83515        type Borrowed<'a> = &'a mut Self;
83516        fn take_or_borrow<'a>(
83517            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
83518        ) -> Self::Borrowed<'a> {
83519            value
83520        }
83521    }
83522
83523    unsafe impl fidl::encoding::TypeMarker for DatagramSocketSendMsgPreflightResponse {
83524        type Owned = Self;
83525
83526        #[inline(always)]
83527        fn inline_align(_context: fidl::encoding::Context) -> usize {
83528            8
83529        }
83530
83531        #[inline(always)]
83532        fn inline_size(_context: fidl::encoding::Context) -> usize {
83533            16
83534        }
83535    }
83536
83537    unsafe impl
83538        fidl::encoding::Encode<
83539            DatagramSocketSendMsgPreflightResponse,
83540            fidl::encoding::DefaultFuchsiaResourceDialect,
83541        > for &mut DatagramSocketSendMsgPreflightResponse
83542    {
83543        unsafe fn encode(
83544            self,
83545            encoder: &mut fidl::encoding::Encoder<
83546                '_,
83547                fidl::encoding::DefaultFuchsiaResourceDialect,
83548            >,
83549            offset: usize,
83550            mut depth: fidl::encoding::Depth,
83551        ) -> fidl::Result<()> {
83552            encoder.debug_check_bounds::<DatagramSocketSendMsgPreflightResponse>(offset);
83553            // Vector header
83554            let max_ordinal: u64 = self.max_ordinal_present();
83555            encoder.write_num(max_ordinal, offset);
83556            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
83557            // Calling encoder.out_of_line_offset(0) is not allowed.
83558            if max_ordinal == 0 {
83559                return Ok(());
83560            }
83561            depth.increment()?;
83562            let envelope_size = 8;
83563            let bytes_len = max_ordinal as usize * envelope_size;
83564            #[allow(unused_variables)]
83565            let offset = encoder.out_of_line_offset(bytes_len);
83566            let mut _prev_end_offset: usize = 0;
83567            if 1 > max_ordinal {
83568                return Ok(());
83569            }
83570
83571            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
83572            // are envelope_size bytes.
83573            let cur_offset: usize = (1 - 1) * envelope_size;
83574
83575            // Zero reserved fields.
83576            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
83577
83578            // Safety:
83579            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
83580            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
83581            //   envelope_size bytes, there is always sufficient room.
83582            fidl::encoding::encode_in_envelope_optional::<
83583                fidl_fuchsia_net::SocketAddress,
83584                fidl::encoding::DefaultFuchsiaResourceDialect,
83585            >(
83586                self.to.as_ref().map(
83587                    <fidl_fuchsia_net::SocketAddress as fidl::encoding::ValueTypeMarker>::borrow,
83588                ),
83589                encoder,
83590                offset + cur_offset,
83591                depth,
83592            )?;
83593
83594            _prev_end_offset = cur_offset + envelope_size;
83595            if 2 > max_ordinal {
83596                return Ok(());
83597            }
83598
83599            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
83600            // are envelope_size bytes.
83601            let cur_offset: usize = (2 - 1) * envelope_size;
83602
83603            // Zero reserved fields.
83604            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
83605
83606            // Safety:
83607            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
83608            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
83609            //   envelope_size bytes, there is always sufficient room.
83610            fidl::encoding::encode_in_envelope_optional::<
83611                fidl::encoding::Vector<
83612                    fidl::encoding::HandleType<
83613                        fidl::EventPair,
83614                        { fidl::ObjectType::EVENTPAIR.into_raw() },
83615                        49155,
83616                    >,
83617                    63,
83618                >,
83619                fidl::encoding::DefaultFuchsiaResourceDialect,
83620            >(
83621                self.validity.as_mut().map(
83622                    <fidl::encoding::Vector<
83623                        fidl::encoding::HandleType<
83624                            fidl::EventPair,
83625                            { fidl::ObjectType::EVENTPAIR.into_raw() },
83626                            49155,
83627                        >,
83628                        63,
83629                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
83630                ),
83631                encoder,
83632                offset + cur_offset,
83633                depth,
83634            )?;
83635
83636            _prev_end_offset = cur_offset + envelope_size;
83637            if 3 > max_ordinal {
83638                return Ok(());
83639            }
83640
83641            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
83642            // are envelope_size bytes.
83643            let cur_offset: usize = (3 - 1) * envelope_size;
83644
83645            // Zero reserved fields.
83646            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
83647
83648            // Safety:
83649            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
83650            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
83651            //   envelope_size bytes, there is always sufficient room.
83652            fidl::encoding::encode_in_envelope_optional::<
83653                u32,
83654                fidl::encoding::DefaultFuchsiaResourceDialect,
83655            >(
83656                self.maximum_size.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
83657                encoder,
83658                offset + cur_offset,
83659                depth,
83660            )?;
83661
83662            _prev_end_offset = cur_offset + envelope_size;
83663
83664            Ok(())
83665        }
83666    }
83667
83668    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
83669        for DatagramSocketSendMsgPreflightResponse
83670    {
83671        #[inline(always)]
83672        fn new_empty() -> Self {
83673            Self::default()
83674        }
83675
83676        unsafe fn decode(
83677            &mut self,
83678            decoder: &mut fidl::encoding::Decoder<
83679                '_,
83680                fidl::encoding::DefaultFuchsiaResourceDialect,
83681            >,
83682            offset: usize,
83683            mut depth: fidl::encoding::Depth,
83684        ) -> fidl::Result<()> {
83685            decoder.debug_check_bounds::<Self>(offset);
83686            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
83687                None => return Err(fidl::Error::NotNullable),
83688                Some(len) => len,
83689            };
83690            // Calling decoder.out_of_line_offset(0) is not allowed.
83691            if len == 0 {
83692                return Ok(());
83693            };
83694            depth.increment()?;
83695            let envelope_size = 8;
83696            let bytes_len = len * envelope_size;
83697            let offset = decoder.out_of_line_offset(bytes_len)?;
83698            // Decode the envelope for each type.
83699            let mut _next_ordinal_to_read = 0;
83700            let mut next_offset = offset;
83701            let end_offset = offset + bytes_len;
83702            _next_ordinal_to_read += 1;
83703            if next_offset >= end_offset {
83704                return Ok(());
83705            }
83706
83707            // Decode unknown envelopes for gaps in ordinals.
83708            while _next_ordinal_to_read < 1 {
83709                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
83710                _next_ordinal_to_read += 1;
83711                next_offset += envelope_size;
83712            }
83713
83714            let next_out_of_line = decoder.next_out_of_line();
83715            let handles_before = decoder.remaining_handles();
83716            if let Some((inlined, num_bytes, num_handles)) =
83717                fidl::encoding::decode_envelope_header(decoder, next_offset)?
83718            {
83719                let member_inline_size =
83720                    <fidl_fuchsia_net::SocketAddress as fidl::encoding::TypeMarker>::inline_size(
83721                        decoder.context,
83722                    );
83723                if inlined != (member_inline_size <= 4) {
83724                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
83725                }
83726                let inner_offset;
83727                let mut inner_depth = depth.clone();
83728                if inlined {
83729                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
83730                    inner_offset = next_offset;
83731                } else {
83732                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
83733                    inner_depth.increment()?;
83734                }
83735                let val_ref = self.to.get_or_insert_with(|| {
83736                    fidl::new_empty!(
83737                        fidl_fuchsia_net::SocketAddress,
83738                        fidl::encoding::DefaultFuchsiaResourceDialect
83739                    )
83740                });
83741                fidl::decode!(
83742                    fidl_fuchsia_net::SocketAddress,
83743                    fidl::encoding::DefaultFuchsiaResourceDialect,
83744                    val_ref,
83745                    decoder,
83746                    inner_offset,
83747                    inner_depth
83748                )?;
83749                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
83750                {
83751                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
83752                }
83753                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
83754                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
83755                }
83756            }
83757
83758            next_offset += envelope_size;
83759            _next_ordinal_to_read += 1;
83760            if next_offset >= end_offset {
83761                return Ok(());
83762            }
83763
83764            // Decode unknown envelopes for gaps in ordinals.
83765            while _next_ordinal_to_read < 2 {
83766                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
83767                _next_ordinal_to_read += 1;
83768                next_offset += envelope_size;
83769            }
83770
83771            let next_out_of_line = decoder.next_out_of_line();
83772            let handles_before = decoder.remaining_handles();
83773            if let Some((inlined, num_bytes, num_handles)) =
83774                fidl::encoding::decode_envelope_header(decoder, next_offset)?
83775            {
83776                let member_inline_size = <fidl::encoding::Vector<
83777                    fidl::encoding::HandleType<
83778                        fidl::EventPair,
83779                        { fidl::ObjectType::EVENTPAIR.into_raw() },
83780                        49155,
83781                    >,
83782                    63,
83783                > as fidl::encoding::TypeMarker>::inline_size(
83784                    decoder.context
83785                );
83786                if inlined != (member_inline_size <= 4) {
83787                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
83788                }
83789                let inner_offset;
83790                let mut inner_depth = depth.clone();
83791                if inlined {
83792                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
83793                    inner_offset = next_offset;
83794                } else {
83795                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
83796                    inner_depth.increment()?;
83797                }
83798                let val_ref = self.validity.get_or_insert_with(|| {
83799                    fidl::new_empty!(
83800                        fidl::encoding::Vector<
83801                            fidl::encoding::HandleType<
83802                                fidl::EventPair,
83803                                { fidl::ObjectType::EVENTPAIR.into_raw() },
83804                                49155,
83805                            >,
83806                            63,
83807                        >,
83808                        fidl::encoding::DefaultFuchsiaResourceDialect
83809                    )
83810                });
83811                fidl::decode!(
83812                    fidl::encoding::Vector<
83813                        fidl::encoding::HandleType<
83814                            fidl::EventPair,
83815                            { fidl::ObjectType::EVENTPAIR.into_raw() },
83816                            49155,
83817                        >,
83818                        63,
83819                    >,
83820                    fidl::encoding::DefaultFuchsiaResourceDialect,
83821                    val_ref,
83822                    decoder,
83823                    inner_offset,
83824                    inner_depth
83825                )?;
83826                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
83827                {
83828                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
83829                }
83830                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
83831                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
83832                }
83833            }
83834
83835            next_offset += envelope_size;
83836            _next_ordinal_to_read += 1;
83837            if next_offset >= end_offset {
83838                return Ok(());
83839            }
83840
83841            // Decode unknown envelopes for gaps in ordinals.
83842            while _next_ordinal_to_read < 3 {
83843                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
83844                _next_ordinal_to_read += 1;
83845                next_offset += envelope_size;
83846            }
83847
83848            let next_out_of_line = decoder.next_out_of_line();
83849            let handles_before = decoder.remaining_handles();
83850            if let Some((inlined, num_bytes, num_handles)) =
83851                fidl::encoding::decode_envelope_header(decoder, next_offset)?
83852            {
83853                let member_inline_size =
83854                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
83855                if inlined != (member_inline_size <= 4) {
83856                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
83857                }
83858                let inner_offset;
83859                let mut inner_depth = depth.clone();
83860                if inlined {
83861                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
83862                    inner_offset = next_offset;
83863                } else {
83864                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
83865                    inner_depth.increment()?;
83866                }
83867                let val_ref = self.maximum_size.get_or_insert_with(|| {
83868                    fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect)
83869                });
83870                fidl::decode!(
83871                    u32,
83872                    fidl::encoding::DefaultFuchsiaResourceDialect,
83873                    val_ref,
83874                    decoder,
83875                    inner_offset,
83876                    inner_depth
83877                )?;
83878                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
83879                {
83880                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
83881                }
83882                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
83883                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
83884                }
83885            }
83886
83887            next_offset += envelope_size;
83888
83889            // Decode the remaining unknown envelopes.
83890            while next_offset < end_offset {
83891                _next_ordinal_to_read += 1;
83892                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
83893                next_offset += envelope_size;
83894            }
83895
83896            Ok(())
83897        }
83898    }
83899
83900    impl StreamSocketDescribeResponse {
83901        #[inline(always)]
83902        fn max_ordinal_present(&self) -> u64 {
83903            if let Some(_) = self.socket {
83904                return 1;
83905            }
83906            0
83907        }
83908    }
83909
83910    impl fidl::encoding::ResourceTypeMarker for StreamSocketDescribeResponse {
83911        type Borrowed<'a> = &'a mut Self;
83912        fn take_or_borrow<'a>(
83913            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
83914        ) -> Self::Borrowed<'a> {
83915            value
83916        }
83917    }
83918
83919    unsafe impl fidl::encoding::TypeMarker for StreamSocketDescribeResponse {
83920        type Owned = Self;
83921
83922        #[inline(always)]
83923        fn inline_align(_context: fidl::encoding::Context) -> usize {
83924            8
83925        }
83926
83927        #[inline(always)]
83928        fn inline_size(_context: fidl::encoding::Context) -> usize {
83929            16
83930        }
83931    }
83932
83933    unsafe impl
83934        fidl::encoding::Encode<
83935            StreamSocketDescribeResponse,
83936            fidl::encoding::DefaultFuchsiaResourceDialect,
83937        > for &mut StreamSocketDescribeResponse
83938    {
83939        unsafe fn encode(
83940            self,
83941            encoder: &mut fidl::encoding::Encoder<
83942                '_,
83943                fidl::encoding::DefaultFuchsiaResourceDialect,
83944            >,
83945            offset: usize,
83946            mut depth: fidl::encoding::Depth,
83947        ) -> fidl::Result<()> {
83948            encoder.debug_check_bounds::<StreamSocketDescribeResponse>(offset);
83949            // Vector header
83950            let max_ordinal: u64 = self.max_ordinal_present();
83951            encoder.write_num(max_ordinal, offset);
83952            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
83953            // Calling encoder.out_of_line_offset(0) is not allowed.
83954            if max_ordinal == 0 {
83955                return Ok(());
83956            }
83957            depth.increment()?;
83958            let envelope_size = 8;
83959            let bytes_len = max_ordinal as usize * envelope_size;
83960            #[allow(unused_variables)]
83961            let offset = encoder.out_of_line_offset(bytes_len);
83962            let mut _prev_end_offset: usize = 0;
83963            if 1 > max_ordinal {
83964                return Ok(());
83965            }
83966
83967            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
83968            // are envelope_size bytes.
83969            let cur_offset: usize = (1 - 1) * envelope_size;
83970
83971            // Zero reserved fields.
83972            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
83973
83974            // Safety:
83975            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
83976            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
83977            //   envelope_size bytes, there is always sufficient room.
83978            fidl::encoding::encode_in_envelope_optional::<
83979                fidl::encoding::HandleType<
83980                    fidl::Socket,
83981                    { fidl::ObjectType::SOCKET.into_raw() },
83982                    2147483648,
83983                >,
83984                fidl::encoding::DefaultFuchsiaResourceDialect,
83985            >(
83986                self.socket.as_mut().map(
83987                    <fidl::encoding::HandleType<
83988                        fidl::Socket,
83989                        { fidl::ObjectType::SOCKET.into_raw() },
83990                        2147483648,
83991                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
83992                ),
83993                encoder,
83994                offset + cur_offset,
83995                depth,
83996            )?;
83997
83998            _prev_end_offset = cur_offset + envelope_size;
83999
84000            Ok(())
84001        }
84002    }
84003
84004    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
84005        for StreamSocketDescribeResponse
84006    {
84007        #[inline(always)]
84008        fn new_empty() -> Self {
84009            Self::default()
84010        }
84011
84012        unsafe fn decode(
84013            &mut self,
84014            decoder: &mut fidl::encoding::Decoder<
84015                '_,
84016                fidl::encoding::DefaultFuchsiaResourceDialect,
84017            >,
84018            offset: usize,
84019            mut depth: fidl::encoding::Depth,
84020        ) -> fidl::Result<()> {
84021            decoder.debug_check_bounds::<Self>(offset);
84022            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
84023                None => return Err(fidl::Error::NotNullable),
84024                Some(len) => len,
84025            };
84026            // Calling decoder.out_of_line_offset(0) is not allowed.
84027            if len == 0 {
84028                return Ok(());
84029            };
84030            depth.increment()?;
84031            let envelope_size = 8;
84032            let bytes_len = len * envelope_size;
84033            let offset = decoder.out_of_line_offset(bytes_len)?;
84034            // Decode the envelope for each type.
84035            let mut _next_ordinal_to_read = 0;
84036            let mut next_offset = offset;
84037            let end_offset = offset + bytes_len;
84038            _next_ordinal_to_read += 1;
84039            if next_offset >= end_offset {
84040                return Ok(());
84041            }
84042
84043            // Decode unknown envelopes for gaps in ordinals.
84044            while _next_ordinal_to_read < 1 {
84045                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
84046                _next_ordinal_to_read += 1;
84047                next_offset += envelope_size;
84048            }
84049
84050            let next_out_of_line = decoder.next_out_of_line();
84051            let handles_before = decoder.remaining_handles();
84052            if let Some((inlined, num_bytes, num_handles)) =
84053                fidl::encoding::decode_envelope_header(decoder, next_offset)?
84054            {
84055                let member_inline_size = <fidl::encoding::HandleType<
84056                    fidl::Socket,
84057                    { fidl::ObjectType::SOCKET.into_raw() },
84058                    2147483648,
84059                > as fidl::encoding::TypeMarker>::inline_size(
84060                    decoder.context
84061                );
84062                if inlined != (member_inline_size <= 4) {
84063                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
84064                }
84065                let inner_offset;
84066                let mut inner_depth = depth.clone();
84067                if inlined {
84068                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
84069                    inner_offset = next_offset;
84070                } else {
84071                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
84072                    inner_depth.increment()?;
84073                }
84074                let val_ref =
84075                self.socket.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
84076                fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
84077                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
84078                {
84079                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
84080                }
84081                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
84082                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
84083                }
84084            }
84085
84086            next_offset += envelope_size;
84087
84088            // Decode the remaining unknown envelopes.
84089            while next_offset < end_offset {
84090                _next_ordinal_to_read += 1;
84091                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
84092                next_offset += envelope_size;
84093            }
84094
84095            Ok(())
84096        }
84097    }
84098
84099    impl SynchronousDatagramSocketDescribeResponse {
84100        #[inline(always)]
84101        fn max_ordinal_present(&self) -> u64 {
84102            if let Some(_) = self.event {
84103                return 1;
84104            }
84105            0
84106        }
84107    }
84108
84109    impl fidl::encoding::ResourceTypeMarker for SynchronousDatagramSocketDescribeResponse {
84110        type Borrowed<'a> = &'a mut Self;
84111        fn take_or_borrow<'a>(
84112            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
84113        ) -> Self::Borrowed<'a> {
84114            value
84115        }
84116    }
84117
84118    unsafe impl fidl::encoding::TypeMarker for SynchronousDatagramSocketDescribeResponse {
84119        type Owned = Self;
84120
84121        #[inline(always)]
84122        fn inline_align(_context: fidl::encoding::Context) -> usize {
84123            8
84124        }
84125
84126        #[inline(always)]
84127        fn inline_size(_context: fidl::encoding::Context) -> usize {
84128            16
84129        }
84130    }
84131
84132    unsafe impl
84133        fidl::encoding::Encode<
84134            SynchronousDatagramSocketDescribeResponse,
84135            fidl::encoding::DefaultFuchsiaResourceDialect,
84136        > for &mut SynchronousDatagramSocketDescribeResponse
84137    {
84138        unsafe fn encode(
84139            self,
84140            encoder: &mut fidl::encoding::Encoder<
84141                '_,
84142                fidl::encoding::DefaultFuchsiaResourceDialect,
84143            >,
84144            offset: usize,
84145            mut depth: fidl::encoding::Depth,
84146        ) -> fidl::Result<()> {
84147            encoder.debug_check_bounds::<SynchronousDatagramSocketDescribeResponse>(offset);
84148            // Vector header
84149            let max_ordinal: u64 = self.max_ordinal_present();
84150            encoder.write_num(max_ordinal, offset);
84151            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
84152            // Calling encoder.out_of_line_offset(0) is not allowed.
84153            if max_ordinal == 0 {
84154                return Ok(());
84155            }
84156            depth.increment()?;
84157            let envelope_size = 8;
84158            let bytes_len = max_ordinal as usize * envelope_size;
84159            #[allow(unused_variables)]
84160            let offset = encoder.out_of_line_offset(bytes_len);
84161            let mut _prev_end_offset: usize = 0;
84162            if 1 > max_ordinal {
84163                return Ok(());
84164            }
84165
84166            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
84167            // are envelope_size bytes.
84168            let cur_offset: usize = (1 - 1) * envelope_size;
84169
84170            // Zero reserved fields.
84171            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
84172
84173            // Safety:
84174            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
84175            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
84176            //   envelope_size bytes, there is always sufficient room.
84177            fidl::encoding::encode_in_envelope_optional::<
84178                fidl::encoding::HandleType<
84179                    fidl::EventPair,
84180                    { fidl::ObjectType::EVENTPAIR.into_raw() },
84181                    2147483648,
84182                >,
84183                fidl::encoding::DefaultFuchsiaResourceDialect,
84184            >(
84185                self.event.as_mut().map(
84186                    <fidl::encoding::HandleType<
84187                        fidl::EventPair,
84188                        { fidl::ObjectType::EVENTPAIR.into_raw() },
84189                        2147483648,
84190                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
84191                ),
84192                encoder,
84193                offset + cur_offset,
84194                depth,
84195            )?;
84196
84197            _prev_end_offset = cur_offset + envelope_size;
84198
84199            Ok(())
84200        }
84201    }
84202
84203    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
84204        for SynchronousDatagramSocketDescribeResponse
84205    {
84206        #[inline(always)]
84207        fn new_empty() -> Self {
84208            Self::default()
84209        }
84210
84211        unsafe fn decode(
84212            &mut self,
84213            decoder: &mut fidl::encoding::Decoder<
84214                '_,
84215                fidl::encoding::DefaultFuchsiaResourceDialect,
84216            >,
84217            offset: usize,
84218            mut depth: fidl::encoding::Depth,
84219        ) -> fidl::Result<()> {
84220            decoder.debug_check_bounds::<Self>(offset);
84221            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
84222                None => return Err(fidl::Error::NotNullable),
84223                Some(len) => len,
84224            };
84225            // Calling decoder.out_of_line_offset(0) is not allowed.
84226            if len == 0 {
84227                return Ok(());
84228            };
84229            depth.increment()?;
84230            let envelope_size = 8;
84231            let bytes_len = len * envelope_size;
84232            let offset = decoder.out_of_line_offset(bytes_len)?;
84233            // Decode the envelope for each type.
84234            let mut _next_ordinal_to_read = 0;
84235            let mut next_offset = offset;
84236            let end_offset = offset + bytes_len;
84237            _next_ordinal_to_read += 1;
84238            if next_offset >= end_offset {
84239                return Ok(());
84240            }
84241
84242            // Decode unknown envelopes for gaps in ordinals.
84243            while _next_ordinal_to_read < 1 {
84244                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
84245                _next_ordinal_to_read += 1;
84246                next_offset += envelope_size;
84247            }
84248
84249            let next_out_of_line = decoder.next_out_of_line();
84250            let handles_before = decoder.remaining_handles();
84251            if let Some((inlined, num_bytes, num_handles)) =
84252                fidl::encoding::decode_envelope_header(decoder, next_offset)?
84253            {
84254                let member_inline_size = <fidl::encoding::HandleType<
84255                    fidl::EventPair,
84256                    { fidl::ObjectType::EVENTPAIR.into_raw() },
84257                    2147483648,
84258                > as fidl::encoding::TypeMarker>::inline_size(
84259                    decoder.context
84260                );
84261                if inlined != (member_inline_size <= 4) {
84262                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
84263                }
84264                let inner_offset;
84265                let mut inner_depth = depth.clone();
84266                if inlined {
84267                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
84268                    inner_offset = next_offset;
84269                } else {
84270                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
84271                    inner_depth.increment()?;
84272                }
84273                let val_ref =
84274                self.event.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
84275                fidl::decode!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
84276                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
84277                {
84278                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
84279                }
84280                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
84281                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
84282                }
84283            }
84284
84285            next_offset += envelope_size;
84286
84287            // Decode the remaining unknown envelopes.
84288            while next_offset < end_offset {
84289                _next_ordinal_to_read += 1;
84290                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
84291                next_offset += envelope_size;
84292            }
84293
84294            Ok(())
84295        }
84296    }
84297
84298    impl fidl::encoding::ResourceTypeMarker for ProviderDatagramSocketWithOptionsResponse {
84299        type Borrowed<'a> = &'a mut Self;
84300        fn take_or_borrow<'a>(
84301            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
84302        ) -> Self::Borrowed<'a> {
84303            value
84304        }
84305    }
84306
84307    unsafe impl fidl::encoding::TypeMarker for ProviderDatagramSocketWithOptionsResponse {
84308        type Owned = Self;
84309
84310        #[inline(always)]
84311        fn inline_align(_context: fidl::encoding::Context) -> usize {
84312            8
84313        }
84314
84315        #[inline(always)]
84316        fn inline_size(_context: fidl::encoding::Context) -> usize {
84317            16
84318        }
84319    }
84320
84321    unsafe impl
84322        fidl::encoding::Encode<
84323            ProviderDatagramSocketWithOptionsResponse,
84324            fidl::encoding::DefaultFuchsiaResourceDialect,
84325        > for &mut ProviderDatagramSocketWithOptionsResponse
84326    {
84327        #[inline]
84328        unsafe fn encode(
84329            self,
84330            encoder: &mut fidl::encoding::Encoder<
84331                '_,
84332                fidl::encoding::DefaultFuchsiaResourceDialect,
84333            >,
84334            offset: usize,
84335            _depth: fidl::encoding::Depth,
84336        ) -> fidl::Result<()> {
84337            encoder.debug_check_bounds::<ProviderDatagramSocketWithOptionsResponse>(offset);
84338            encoder.write_num::<u64>(self.ordinal(), offset);
84339            match self {
84340            ProviderDatagramSocketWithOptionsResponse::DatagramSocket(ref mut val) => {
84341                fidl::encoding::encode_in_envelope::<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DatagramSocketMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
84342                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DatagramSocketMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
84343                    encoder, offset + 8, _depth
84344                )
84345            }
84346            ProviderDatagramSocketWithOptionsResponse::SynchronousDatagramSocket(ref mut val) => {
84347                fidl::encoding::encode_in_envelope::<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
84348                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
84349                    encoder, offset + 8, _depth
84350                )
84351            }
84352        }
84353        }
84354    }
84355
84356    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
84357        for ProviderDatagramSocketWithOptionsResponse
84358    {
84359        #[inline(always)]
84360        fn new_empty() -> Self {
84361            Self::DatagramSocket(fidl::new_empty!(
84362                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DatagramSocketMarker>>,
84363                fidl::encoding::DefaultFuchsiaResourceDialect
84364            ))
84365        }
84366
84367        #[inline]
84368        unsafe fn decode(
84369            &mut self,
84370            decoder: &mut fidl::encoding::Decoder<
84371                '_,
84372                fidl::encoding::DefaultFuchsiaResourceDialect,
84373            >,
84374            offset: usize,
84375            mut depth: fidl::encoding::Depth,
84376        ) -> fidl::Result<()> {
84377            decoder.debug_check_bounds::<Self>(offset);
84378            #[allow(unused_variables)]
84379            let next_out_of_line = decoder.next_out_of_line();
84380            let handles_before = decoder.remaining_handles();
84381            let (ordinal, inlined, num_bytes, num_handles) =
84382                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
84383
84384            let member_inline_size = match ordinal {
84385            1 => <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DatagramSocketMarker>> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
84386            2 => <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
84387            _ => return Err(fidl::Error::UnknownUnionTag),
84388        };
84389
84390            if inlined != (member_inline_size <= 4) {
84391                return Err(fidl::Error::InvalidInlineBitInEnvelope);
84392            }
84393            let _inner_offset;
84394            if inlined {
84395                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
84396                _inner_offset = offset + 8;
84397            } else {
84398                depth.increment()?;
84399                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
84400            }
84401            match ordinal {
84402                1 => {
84403                    #[allow(irrefutable_let_patterns)]
84404                    if let ProviderDatagramSocketWithOptionsResponse::DatagramSocket(_) = self {
84405                        // Do nothing, read the value into the object
84406                    } else {
84407                        // Initialize `self` to the right variant
84408                        *self = ProviderDatagramSocketWithOptionsResponse::DatagramSocket(
84409                            fidl::new_empty!(
84410                                fidl::encoding::Endpoint<
84411                                    fidl::endpoints::ClientEnd<DatagramSocketMarker>,
84412                                >,
84413                                fidl::encoding::DefaultFuchsiaResourceDialect
84414                            ),
84415                        );
84416                    }
84417                    #[allow(irrefutable_let_patterns)]
84418                    if let ProviderDatagramSocketWithOptionsResponse::DatagramSocket(ref mut val) =
84419                        self
84420                    {
84421                        fidl::decode!(
84422                            fidl::encoding::Endpoint<
84423                                fidl::endpoints::ClientEnd<DatagramSocketMarker>,
84424                            >,
84425                            fidl::encoding::DefaultFuchsiaResourceDialect,
84426                            val,
84427                            decoder,
84428                            _inner_offset,
84429                            depth
84430                        )?;
84431                    } else {
84432                        unreachable!()
84433                    }
84434                }
84435                2 => {
84436                    #[allow(irrefutable_let_patterns)]
84437                    if let ProviderDatagramSocketWithOptionsResponse::SynchronousDatagramSocket(_) =
84438                        self
84439                    {
84440                        // Do nothing, read the value into the object
84441                    } else {
84442                        // Initialize `self` to the right variant
84443                        *self =
84444                            ProviderDatagramSocketWithOptionsResponse::SynchronousDatagramSocket(
84445                                fidl::new_empty!(
84446                                    fidl::encoding::Endpoint<
84447                                        fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
84448                                    >,
84449                                    fidl::encoding::DefaultFuchsiaResourceDialect
84450                                ),
84451                            );
84452                    }
84453                    #[allow(irrefutable_let_patterns)]
84454                    if let ProviderDatagramSocketWithOptionsResponse::SynchronousDatagramSocket(
84455                        ref mut val,
84456                    ) = self
84457                    {
84458                        fidl::decode!(
84459                            fidl::encoding::Endpoint<
84460                                fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
84461                            >,
84462                            fidl::encoding::DefaultFuchsiaResourceDialect,
84463                            val,
84464                            decoder,
84465                            _inner_offset,
84466                            depth
84467                        )?;
84468                    } else {
84469                        unreachable!()
84470                    }
84471                }
84472                ordinal => panic!("unexpected ordinal {:?}", ordinal),
84473            }
84474            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
84475                return Err(fidl::Error::InvalidNumBytesInEnvelope);
84476            }
84477            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
84478                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
84479            }
84480            Ok(())
84481        }
84482    }
84483
84484    impl fidl::encoding::ResourceTypeMarker for ProviderDatagramSocketResponse {
84485        type Borrowed<'a> = &'a mut Self;
84486        fn take_or_borrow<'a>(
84487            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
84488        ) -> Self::Borrowed<'a> {
84489            value
84490        }
84491    }
84492
84493    unsafe impl fidl::encoding::TypeMarker for ProviderDatagramSocketResponse {
84494        type Owned = Self;
84495
84496        #[inline(always)]
84497        fn inline_align(_context: fidl::encoding::Context) -> usize {
84498            8
84499        }
84500
84501        #[inline(always)]
84502        fn inline_size(_context: fidl::encoding::Context) -> usize {
84503            16
84504        }
84505    }
84506
84507    unsafe impl
84508        fidl::encoding::Encode<
84509            ProviderDatagramSocketResponse,
84510            fidl::encoding::DefaultFuchsiaResourceDialect,
84511        > for &mut ProviderDatagramSocketResponse
84512    {
84513        #[inline]
84514        unsafe fn encode(
84515            self,
84516            encoder: &mut fidl::encoding::Encoder<
84517                '_,
84518                fidl::encoding::DefaultFuchsiaResourceDialect,
84519            >,
84520            offset: usize,
84521            _depth: fidl::encoding::Depth,
84522        ) -> fidl::Result<()> {
84523            encoder.debug_check_bounds::<ProviderDatagramSocketResponse>(offset);
84524            encoder.write_num::<u64>(self.ordinal(), offset);
84525            match self {
84526            ProviderDatagramSocketResponse::DatagramSocket(ref mut val) => {
84527                fidl::encoding::encode_in_envelope::<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DatagramSocketMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
84528                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DatagramSocketMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
84529                    encoder, offset + 8, _depth
84530                )
84531            }
84532            ProviderDatagramSocketResponse::SynchronousDatagramSocket(ref mut val) => {
84533                fidl::encoding::encode_in_envelope::<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
84534                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
84535                    encoder, offset + 8, _depth
84536                )
84537            }
84538        }
84539        }
84540    }
84541
84542    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
84543        for ProviderDatagramSocketResponse
84544    {
84545        #[inline(always)]
84546        fn new_empty() -> Self {
84547            Self::DatagramSocket(fidl::new_empty!(
84548                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DatagramSocketMarker>>,
84549                fidl::encoding::DefaultFuchsiaResourceDialect
84550            ))
84551        }
84552
84553        #[inline]
84554        unsafe fn decode(
84555            &mut self,
84556            decoder: &mut fidl::encoding::Decoder<
84557                '_,
84558                fidl::encoding::DefaultFuchsiaResourceDialect,
84559            >,
84560            offset: usize,
84561            mut depth: fidl::encoding::Depth,
84562        ) -> fidl::Result<()> {
84563            decoder.debug_check_bounds::<Self>(offset);
84564            #[allow(unused_variables)]
84565            let next_out_of_line = decoder.next_out_of_line();
84566            let handles_before = decoder.remaining_handles();
84567            let (ordinal, inlined, num_bytes, num_handles) =
84568                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
84569
84570            let member_inline_size = match ordinal {
84571            1 => <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DatagramSocketMarker>> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
84572            2 => <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
84573            _ => return Err(fidl::Error::UnknownUnionTag),
84574        };
84575
84576            if inlined != (member_inline_size <= 4) {
84577                return Err(fidl::Error::InvalidInlineBitInEnvelope);
84578            }
84579            let _inner_offset;
84580            if inlined {
84581                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
84582                _inner_offset = offset + 8;
84583            } else {
84584                depth.increment()?;
84585                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
84586            }
84587            match ordinal {
84588                1 => {
84589                    #[allow(irrefutable_let_patterns)]
84590                    if let ProviderDatagramSocketResponse::DatagramSocket(_) = self {
84591                        // Do nothing, read the value into the object
84592                    } else {
84593                        // Initialize `self` to the right variant
84594                        *self = ProviderDatagramSocketResponse::DatagramSocket(fidl::new_empty!(
84595                            fidl::encoding::Endpoint<
84596                                fidl::endpoints::ClientEnd<DatagramSocketMarker>,
84597                            >,
84598                            fidl::encoding::DefaultFuchsiaResourceDialect
84599                        ));
84600                    }
84601                    #[allow(irrefutable_let_patterns)]
84602                    if let ProviderDatagramSocketResponse::DatagramSocket(ref mut val) = self {
84603                        fidl::decode!(
84604                            fidl::encoding::Endpoint<
84605                                fidl::endpoints::ClientEnd<DatagramSocketMarker>,
84606                            >,
84607                            fidl::encoding::DefaultFuchsiaResourceDialect,
84608                            val,
84609                            decoder,
84610                            _inner_offset,
84611                            depth
84612                        )?;
84613                    } else {
84614                        unreachable!()
84615                    }
84616                }
84617                2 => {
84618                    #[allow(irrefutable_let_patterns)]
84619                    if let ProviderDatagramSocketResponse::SynchronousDatagramSocket(_) = self {
84620                        // Do nothing, read the value into the object
84621                    } else {
84622                        // Initialize `self` to the right variant
84623                        *self = ProviderDatagramSocketResponse::SynchronousDatagramSocket(
84624                            fidl::new_empty!(
84625                                fidl::encoding::Endpoint<
84626                                    fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
84627                                >,
84628                                fidl::encoding::DefaultFuchsiaResourceDialect
84629                            ),
84630                        );
84631                    }
84632                    #[allow(irrefutable_let_patterns)]
84633                    if let ProviderDatagramSocketResponse::SynchronousDatagramSocket(ref mut val) =
84634                        self
84635                    {
84636                        fidl::decode!(
84637                            fidl::encoding::Endpoint<
84638                                fidl::endpoints::ClientEnd<SynchronousDatagramSocketMarker>,
84639                            >,
84640                            fidl::encoding::DefaultFuchsiaResourceDialect,
84641                            val,
84642                            decoder,
84643                            _inner_offset,
84644                            depth
84645                        )?;
84646                    } else {
84647                        unreachable!()
84648                    }
84649                }
84650                ordinal => panic!("unexpected ordinal {:?}", ordinal),
84651            }
84652            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
84653                return Err(fidl::Error::InvalidNumBytesInEnvelope);
84654            }
84655            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
84656                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
84657            }
84658            Ok(())
84659        }
84660    }
84661}