fidl_fidl_test_compatibility/
fidl_fidl_test_compatibility.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_fidl_test_compatibility__common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, PartialEq)]
15pub struct ArraysStruct {
16    pub bools: [bool; 3],
17    pub int8s: [i8; 3],
18    pub int16s: [i16; 3],
19    pub int32s: [i32; 3],
20    pub int64s: [i64; 3],
21    pub uint8s: [u8; 3],
22    pub uint16s: [u16; 3],
23    pub uint32s: [u32; 3],
24    pub uint64s: [u64; 3],
25    pub float32s: [f32; 3],
26    pub float64s: [f64; 3],
27    pub enums: [DefaultEnum; 3],
28    pub bits: [DefaultBits; 3],
29    pub handles: [fidl::Handle; 3],
30    pub nullable_handles: [Option<fidl::Handle>; 3],
31    pub strings: [String; 3],
32    pub nullable_strings: [Option<String>; 3],
33    pub structs: [ThisIsAStruct; 3],
34    pub nullable_structs: [Option<Box<ThisIsAStruct>>; 3],
35    pub unions: [ThisIsAUnion; 3],
36    pub nullable_unions: [Option<Box<ThisIsAUnion>>; 3],
37    pub arrays: [[u32; 3]; 3],
38    pub vectors: [Vec<u32>; 3],
39    pub nullable_vectors: [Option<Vec<u32>>; 3],
40    pub tables: [ThisIsATable; 3],
41    pub xunions: [ThisIsAXunion; 3],
42}
43
44impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ArraysStruct {}
45
46#[derive(Debug, PartialEq)]
47pub struct EchoEchoArraysRequest {
48    pub value: ArraysStruct,
49    pub forward_to_server: String,
50}
51
52impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoArraysRequest {}
53
54#[derive(Debug, PartialEq)]
55pub struct EchoEchoArraysResponse {
56    pub value: ArraysStruct,
57}
58
59impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoArraysResponse {}
60
61#[derive(Debug, PartialEq)]
62pub struct EchoEchoArraysWithErrorRequest {
63    pub value: ArraysStruct,
64    pub result_err: DefaultEnum,
65    pub forward_to_server: String,
66    pub result_variant: RespondWith,
67}
68
69impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
70    for EchoEchoArraysWithErrorRequest
71{
72}
73
74#[derive(Debug, PartialEq)]
75pub struct EchoEchoEventRequest {
76    pub value: Struct,
77}
78
79impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoEventRequest {}
80
81#[derive(Debug, PartialEq)]
82pub struct EchoEchoStructNoRetValRequest {
83    pub value: Struct,
84    pub forward_to_server: String,
85}
86
87impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
88    for EchoEchoStructNoRetValRequest
89{
90}
91
92#[derive(Debug, PartialEq)]
93pub struct EchoEchoStructRequest {
94    pub value: Struct,
95    pub forward_to_server: String,
96}
97
98impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoStructRequest {}
99
100#[derive(Debug, PartialEq)]
101pub struct EchoEchoStructResponse {
102    pub value: Struct,
103}
104
105impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoStructResponse {}
106
107#[derive(Debug, PartialEq)]
108pub struct EchoEchoStructWithErrorRequest {
109    pub value: Struct,
110    pub result_err: DefaultEnum,
111    pub forward_to_server: String,
112    pub result_variant: RespondWith,
113}
114
115impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
116    for EchoEchoStructWithErrorRequest
117{
118}
119
120#[derive(Debug, PartialEq)]
121pub struct EchoEchoTableRequest {
122    pub value: AllTypesTable,
123    pub forward_to_server: String,
124}
125
126impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoTableRequest {}
127
128#[derive(Debug, PartialEq)]
129pub struct EchoEchoTableResponse {
130    pub value: AllTypesTable,
131}
132
133impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoTableResponse {}
134
135#[derive(Debug, PartialEq)]
136pub struct EchoEchoTableWithErrorRequest {
137    pub value: AllTypesTable,
138    pub result_err: DefaultEnum,
139    pub forward_to_server: String,
140    pub result_variant: RespondWith,
141}
142
143impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
144    for EchoEchoTableWithErrorRequest
145{
146}
147
148#[derive(Debug, PartialEq)]
149pub struct EchoEchoVectorsRequest {
150    pub value: VectorsStruct,
151    pub forward_to_server: String,
152}
153
154impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoVectorsRequest {}
155
156#[derive(Debug, PartialEq)]
157pub struct EchoEchoVectorsResponse {
158    pub value: VectorsStruct,
159}
160
161impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoVectorsResponse {}
162
163#[derive(Debug, PartialEq)]
164pub struct EchoEchoVectorsWithErrorRequest {
165    pub value: VectorsStruct,
166    pub result_err: DefaultEnum,
167    pub forward_to_server: String,
168    pub result_variant: RespondWith,
169}
170
171impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
172    for EchoEchoVectorsWithErrorRequest
173{
174}
175
176#[derive(Debug, PartialEq)]
177pub struct EchoEchoXunionsRequest {
178    pub value: Vec<AllTypesXunion>,
179    pub forward_to_server: String,
180}
181
182impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoXunionsRequest {}
183
184#[derive(Debug, PartialEq)]
185pub struct EchoEchoXunionsResponse {
186    pub value: Vec<AllTypesXunion>,
187}
188
189impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoXunionsResponse {}
190
191#[derive(Debug, PartialEq)]
192pub struct EchoEchoXunionsWithErrorRequest {
193    pub value: Vec<AllTypesXunion>,
194    pub result_err: DefaultEnum,
195    pub forward_to_server: String,
196    pub result_variant: RespondWith,
197}
198
199impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
200    for EchoEchoXunionsWithErrorRequest
201{
202}
203
204#[derive(Debug, PartialEq)]
205pub struct EchoEchoArraysWithErrorResponse {
206    pub value: ArraysStruct,
207}
208
209impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
210    for EchoEchoArraysWithErrorResponse
211{
212}
213
214#[derive(Debug, PartialEq)]
215pub struct EchoEchoStructWithErrorResponse {
216    pub value: Struct,
217}
218
219impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
220    for EchoEchoStructWithErrorResponse
221{
222}
223
224#[derive(Debug, PartialEq)]
225pub struct EchoEchoTableWithErrorResponse {
226    pub value: AllTypesTable,
227}
228
229impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
230    for EchoEchoTableWithErrorResponse
231{
232}
233
234#[derive(Debug, PartialEq)]
235pub struct EchoEchoVectorsWithErrorResponse {
236    pub value: VectorsStruct,
237}
238
239impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
240    for EchoEchoVectorsWithErrorResponse
241{
242}
243
244#[derive(Debug, PartialEq)]
245pub struct EchoEchoXunionsWithErrorResponse {
246    pub value: Vec<AllTypesXunion>,
247}
248
249impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
250    for EchoEchoXunionsWithErrorResponse
251{
252}
253
254#[derive(Debug, PartialEq)]
255pub struct Struct {
256    pub primitive_types: PrimitiveTypes,
257    pub default_values: DefaultValues,
258    pub arrays: Arrays,
259    pub arrays_2d: Arrays2d,
260    pub vectors: Vectors,
261    pub handles: Handles,
262    pub strings: Strings,
263    pub default_enum: DefaultEnum,
264    pub i8_enum: I8Enum,
265    pub i16_enum: I16Enum,
266    pub i32_enum: I32Enum,
267    pub i64_enum: I64Enum,
268    pub u8_enum: U8Enum,
269    pub u16_enum: U16Enum,
270    pub u32_enum: U32Enum,
271    pub u64_enum: U64Enum,
272    pub default_bits: DefaultBits,
273    pub u8_bits: U8Bits,
274    pub u16_bits: U16Bits,
275    pub u32_bits: U32Bits,
276    pub u64_bits: U64Bits,
277    pub structs: Structs,
278    pub unions: Unions,
279    pub table: ThisIsATable,
280    pub xunion: ThisIsAXunion,
281    pub b: bool,
282}
283
284impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for Struct {}
285
286#[derive(Debug, PartialEq)]
287pub struct VectorsStruct {
288    pub bools: Vec<bool>,
289    pub int8s: Vec<i8>,
290    pub int16s: Vec<i16>,
291    pub int32s: Vec<i32>,
292    pub int64s: Vec<i64>,
293    pub uint8s: Vec<u8>,
294    pub uint16s: Vec<u16>,
295    pub uint32s: Vec<u32>,
296    pub uint64s: Vec<u64>,
297    pub float32s: Vec<f32>,
298    pub float64s: Vec<f64>,
299    pub enums: Vec<DefaultEnum>,
300    pub bits: Vec<DefaultBits>,
301    pub handles: Vec<fidl::Handle>,
302    pub nullable_handles: Vec<Option<fidl::Handle>>,
303    pub strings: Vec<String>,
304    pub nullable_strings: Vec<Option<String>>,
305    pub structs: Vec<ThisIsAStruct>,
306    pub nullable_structs: Vec<Option<Box<ThisIsAStruct>>>,
307    pub unions: Vec<ThisIsAUnion>,
308    pub nullable_unions: Vec<Option<Box<ThisIsAUnion>>>,
309    pub arrays: Vec<[u32; 3]>,
310    pub vectors: Vec<Vec<u32>>,
311    pub nullable_vectors: Vec<Option<Vec<u32>>>,
312    pub tables: Vec<ThisIsATable>,
313    pub xunions: Vec<ThisIsAXunion>,
314}
315
316impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for VectorsStruct {}
317
318#[derive(Debug, PartialEq, PartialOrd)]
319pub struct Arrays {
320    pub b_0: [bool; 1],
321    pub i8_0: [i8; 1],
322    pub i16_0: [i16; 1],
323    pub i32_0: [i32; 1],
324    pub i64_0: [i64; 1],
325    pub u8_0: [u8; 1],
326    pub u16_0: [u16; 1],
327    pub u32_0: [u32; 1],
328    pub u64_0: [u64; 1],
329    pub f32_0: [f32; 1],
330    pub f64_0: [f64; 1],
331    pub handle_0: [fidl::Handle; 1],
332    pub b_1: [bool; 3],
333    pub i8_1: [i8; 3],
334    pub i16_1: [i16; 3],
335    pub i32_1: [i32; 3],
336    pub i64_1: [i64; 3],
337    pub u8_1: [u8; 3],
338    pub u16_1: [u16; 3],
339    pub u32_1: [u32; 3],
340    pub u64_1: [u64; 3],
341    pub f32_1: [f32; 3],
342    pub f64_1: [f64; 3],
343    pub handle_1: [fidl::Handle; 3],
344}
345
346impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for Arrays {}
347
348#[derive(Debug, PartialEq, PartialOrd)]
349pub struct Arrays2d {
350    pub b: [[bool; 2]; 3],
351    pub i8: [[i8; 2]; 3],
352    pub i16: [[i16; 2]; 3],
353    pub i32: [[i32; 2]; 3],
354    pub i64: [[i64; 2]; 3],
355    pub u8: [[u8; 2]; 3],
356    pub u16: [[u16; 2]; 3],
357    pub u32: [[u32; 2]; 3],
358    pub u64: [[u64; 2]; 3],
359    pub f32: [[f32; 2]; 3],
360    pub f64: [[f64; 2]; 3],
361    pub handle_handle: [[fidl::Handle; 2]; 3],
362}
363
364impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for Arrays2d {}
365
366#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
367pub struct Handles {
368    pub handle_handle: fidl::Handle,
369    pub process_handle: fidl::Process,
370    pub thread_handle: fidl::Thread,
371    pub vmo_handle: fidl::Vmo,
372    pub event_handle: fidl::Event,
373    pub port_handle: fidl::Port,
374    pub socket_handle: fidl::Socket,
375    pub eventpair_handle: fidl::EventPair,
376    pub job_handle: fidl::Job,
377    pub vmar_handle: fidl::Vmar,
378    pub fifo_handle: fidl::Fifo,
379    pub timer_handle: fidl::Timer,
380    pub nullable_handle_handle: Option<fidl::Handle>,
381    pub nullable_process_handle: Option<fidl::Process>,
382    pub nullable_thread_handle: Option<fidl::Thread>,
383    pub nullable_vmo_handle: Option<fidl::Vmo>,
384    pub nullable_channel_handle: Option<fidl::Channel>,
385    pub nullable_event_handle: Option<fidl::Event>,
386    pub nullable_port_handle: Option<fidl::Port>,
387    pub nullable_interrupt_handle: Option<fidl::Interrupt>,
388    pub nullable_log_handle: Option<fidl::DebugLog>,
389    pub nullable_socket_handle: Option<fidl::Socket>,
390    pub nullable_eventpair_handle: Option<fidl::EventPair>,
391    pub nullable_job_handle: Option<fidl::Job>,
392    pub nullable_vmar_handle: Option<fidl::Vmar>,
393    pub nullable_fifo_handle: Option<fidl::Fifo>,
394    pub nullable_timer_handle: Option<fidl::Timer>,
395}
396
397impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for Handles {}
398
399#[derive(Debug, PartialEq, PartialOrd)]
400pub struct Vectors {
401    pub b_0: Vec<bool>,
402    pub i8_0: Vec<i8>,
403    pub i16_0: Vec<i16>,
404    pub i32_0: Vec<i32>,
405    pub i64_0: Vec<i64>,
406    pub u8_0: Vec<u8>,
407    pub u16_0: Vec<u16>,
408    pub u32_0: Vec<u32>,
409    pub u64_0: Vec<u64>,
410    pub f32_0: Vec<f32>,
411    pub f64_0: Vec<f64>,
412    pub handle_0: Vec<fidl::Handle>,
413    pub b_1: Vec<Vec<bool>>,
414    pub i8_1: Vec<Vec<i8>>,
415    pub i16_1: Vec<Vec<i16>>,
416    pub i32_1: Vec<Vec<i32>>,
417    pub i64_1: Vec<Vec<i64>>,
418    pub u8_1: Vec<Vec<u8>>,
419    pub u16_1: Vec<Vec<u16>>,
420    pub u32_1: Vec<Vec<u32>>,
421    pub u64_1: Vec<Vec<u64>>,
422    pub f32_1: Vec<Vec<f32>>,
423    pub f64_1: Vec<Vec<f64>>,
424    pub handle_1: Vec<Vec<fidl::Handle>>,
425    pub b_sized_0: Vec<bool>,
426    pub i8_sized_0: Vec<i8>,
427    pub i16_sized_0: Vec<i16>,
428    pub i32_sized_0: Vec<i32>,
429    pub i64_sized_0: Vec<i64>,
430    pub u8_sized_0: Vec<u8>,
431    pub u16_sized_0: Vec<u16>,
432    pub u32_sized_0: Vec<u32>,
433    pub u64_sized_0: Vec<u64>,
434    pub f32_sized_0: Vec<f32>,
435    pub f64_sized_0: Vec<f64>,
436    pub handle_sized_0: Vec<fidl::Handle>,
437    pub b_sized_1: Vec<bool>,
438    pub i8_sized_1: Vec<i8>,
439    pub i16_sized_1: Vec<i16>,
440    pub i32_sized_1: Vec<i32>,
441    pub i64_sized_1: Vec<i64>,
442    pub u8_sized_1: Vec<u8>,
443    pub u16_sized_1: Vec<u16>,
444    pub u32_sized_1: Vec<u32>,
445    pub u64_sized_1: Vec<u64>,
446    pub f32_sized_1: Vec<f32>,
447    pub f64_sized_1: Vec<f64>,
448    pub handle_sized_1: Vec<fidl::Handle>,
449    pub b_sized_2: Vec<Vec<bool>>,
450    pub i8_sized_2: Vec<Vec<i8>>,
451    pub i16_sized_2: Vec<Vec<i16>>,
452    pub i32_sized_2: Vec<Vec<i32>>,
453    pub i64_sized_2: Vec<Vec<i64>>,
454    pub u8_sized_2: Vec<Vec<u8>>,
455    pub u16_sized_2: Vec<Vec<u16>>,
456    pub u32_sized_2: Vec<Vec<u32>>,
457    pub u64_sized_2: Vec<Vec<u64>>,
458    pub f32_sized_2: Vec<Vec<f32>>,
459    pub f64_sized_2: Vec<Vec<f64>>,
460    pub handle_sized_2: Vec<Vec<fidl::Handle>>,
461    pub b_nullable_0: Option<Vec<bool>>,
462    pub i8_nullable_0: Option<Vec<i8>>,
463    pub i16_nullable_0: Option<Vec<i16>>,
464    pub i32_nullable_0: Option<Vec<i32>>,
465    pub i64_nullable_0: Option<Vec<i64>>,
466    pub u8_nullable_0: Option<Vec<u8>>,
467    pub u16_nullable_0: Option<Vec<u16>>,
468    pub u32_nullable_0: Option<Vec<u32>>,
469    pub u64_nullable_0: Option<Vec<u64>>,
470    pub f32_nullable_0: Option<Vec<f32>>,
471    pub f64_nullable_0: Option<Vec<f64>>,
472    pub handle_nullable_0: Option<Vec<fidl::Handle>>,
473    pub b_nullable_1: Option<Vec<Vec<bool>>>,
474    pub i8_nullable_1: Option<Vec<Vec<i8>>>,
475    pub i16_nullable_1: Option<Vec<Vec<i16>>>,
476    pub i32_nullable_1: Option<Vec<Vec<i32>>>,
477    pub i64_nullable_1: Option<Vec<Vec<i64>>>,
478    pub u8_nullable_1: Option<Vec<Vec<u8>>>,
479    pub u16_nullable_1: Option<Vec<Vec<u16>>>,
480    pub u32_nullable_1: Option<Vec<Vec<u32>>>,
481    pub u64_nullable_1: Option<Vec<Vec<u64>>>,
482    pub f32_nullable_1: Option<Vec<Vec<f32>>>,
483    pub f64_nullable_1: Option<Vec<Vec<f64>>>,
484    pub handle_nullable_1: Option<Vec<Vec<fidl::Handle>>>,
485    pub b_nullable_sized_0: Option<Vec<bool>>,
486    pub i8_nullable_sized_0: Option<Vec<i8>>,
487    pub i16_nullable_sized_0: Option<Vec<i16>>,
488    pub i32_nullable_sized_0: Option<Vec<i32>>,
489    pub i64_nullable_sized_0: Option<Vec<i64>>,
490    pub u8_nullable_sized_0: Option<Vec<u8>>,
491    pub u16_nullable_sized_0: Option<Vec<u16>>,
492    pub u32_nullable_sized_0: Option<Vec<u32>>,
493    pub u64_nullable_sized_0: Option<Vec<u64>>,
494    pub f32_nullable_sized_0: Option<Vec<f32>>,
495    pub f64_nullable_sized_0: Option<Vec<f64>>,
496    pub handle_nullable_sized_0: Option<Vec<fidl::Handle>>,
497    pub b_nullable_sized_1: Option<Vec<bool>>,
498    pub i8_nullable_sized_1: Option<Vec<i8>>,
499    pub i16_nullable_sized_1: Option<Vec<i16>>,
500    pub i32_nullable_sized_1: Option<Vec<i32>>,
501    pub i64_nullable_sized_1: Option<Vec<i64>>,
502    pub u8_nullable_sized_1: Option<Vec<u8>>,
503    pub u16_nullable_sized_1: Option<Vec<u16>>,
504    pub u32_nullable_sized_1: Option<Vec<u32>>,
505    pub u64_nullable_sized_1: Option<Vec<u64>>,
506    pub f32_nullable_sized_1: Option<Vec<f32>>,
507    pub f64_nullable_sized_1: Option<Vec<f64>>,
508    pub handle_nullable_sized_1: Option<Vec<fidl::Handle>>,
509    pub b_nullable_sized_2: Option<Vec<Vec<bool>>>,
510    pub i8_nullable_sized_2: Option<Vec<Vec<i8>>>,
511    pub i16_nullable_sized_2: Option<Vec<Vec<i16>>>,
512    pub i32_nullable_sized_2: Option<Vec<Vec<i32>>>,
513    pub i64_nullable_sized_2: Option<Vec<Vec<i64>>>,
514    pub u8_nullable_sized_2: Option<Vec<Vec<u8>>>,
515    pub u16_nullable_sized_2: Option<Vec<Vec<u16>>>,
516    pub u32_nullable_sized_2: Option<Vec<Vec<u32>>>,
517    pub u64_nullable_sized_2: Option<Vec<Vec<u64>>>,
518    pub f32_nullable_sized_2: Option<Vec<Vec<f32>>>,
519    pub f64_nullable_sized_2: Option<Vec<Vec<f64>>>,
520    pub handle_nullable_sized_2: Option<Vec<Vec<fidl::Handle>>>,
521}
522
523impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for Vectors {}
524
525#[derive(Debug, Default, PartialEq)]
526pub struct AllTypesTable {
527    pub bool_member: Option<bool>,
528    pub int8_member: Option<i8>,
529    pub int16_member: Option<i16>,
530    pub int32_member: Option<i32>,
531    pub int64_member: Option<i64>,
532    pub uint8_member: Option<u8>,
533    pub uint16_member: Option<u16>,
534    pub uint32_member: Option<u32>,
535    pub uint64_member: Option<u64>,
536    pub float32_member: Option<f32>,
537    pub float64_member: Option<f64>,
538    pub enum_member: Option<DefaultEnum>,
539    pub bits_member: Option<DefaultBits>,
540    pub handle_member: Option<fidl::Handle>,
541    pub string_member: Option<String>,
542    pub struct_member: Option<ThisIsAStruct>,
543    pub union_member: Option<ThisIsAUnion>,
544    pub array_member: Option<[u32; 3]>,
545    pub vector_member: Option<Vec<u32>>,
546    pub table_member: Option<ThisIsATable>,
547    pub xunion_member: Option<ThisIsAXunion>,
548    #[doc(hidden)]
549    pub __source_breaking: fidl::marker::SourceBreaking,
550}
551
552impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for AllTypesTable {}
553
554#[derive(Debug)]
555pub enum AllTypesXunion {
556    BoolMember(bool),
557    Int8Member(i8),
558    Int16Member(i16),
559    Int32Member(i32),
560    Int64Member(i64),
561    Uint8Member(u8),
562    Uint16Member(u16),
563    Uint32Member(u32),
564    Uint64Member(u64),
565    Float32Member(f32),
566    Float64Member(f64),
567    EnumMember(DefaultEnum),
568    BitsMember(DefaultBits),
569    HandleMember(fidl::Handle),
570    StringMember(String),
571    StructMember(ThisIsAStruct),
572    UnionMember(ThisIsAUnion),
573    ArrayMember([u32; 3]),
574    VectorMember(Vec<u32>),
575    TableMember(ThisIsATable),
576    XunionMember(ThisIsAXunion),
577    #[doc(hidden)]
578    __SourceBreaking {
579        unknown_ordinal: u64,
580    },
581}
582
583/// Pattern that matches an unknown `AllTypesXunion` member.
584#[macro_export]
585macro_rules! AllTypesXunionUnknown {
586    () => {
587        _
588    };
589}
590
591// Custom PartialEq so that unknown variants are not equal to themselves.
592impl PartialEq for AllTypesXunion {
593    fn eq(&self, other: &Self) -> bool {
594        match (self, other) {
595            (Self::BoolMember(x), Self::BoolMember(y)) => *x == *y,
596            (Self::Int8Member(x), Self::Int8Member(y)) => *x == *y,
597            (Self::Int16Member(x), Self::Int16Member(y)) => *x == *y,
598            (Self::Int32Member(x), Self::Int32Member(y)) => *x == *y,
599            (Self::Int64Member(x), Self::Int64Member(y)) => *x == *y,
600            (Self::Uint8Member(x), Self::Uint8Member(y)) => *x == *y,
601            (Self::Uint16Member(x), Self::Uint16Member(y)) => *x == *y,
602            (Self::Uint32Member(x), Self::Uint32Member(y)) => *x == *y,
603            (Self::Uint64Member(x), Self::Uint64Member(y)) => *x == *y,
604            (Self::Float32Member(x), Self::Float32Member(y)) => *x == *y,
605            (Self::Float64Member(x), Self::Float64Member(y)) => *x == *y,
606            (Self::EnumMember(x), Self::EnumMember(y)) => *x == *y,
607            (Self::BitsMember(x), Self::BitsMember(y)) => *x == *y,
608            (Self::HandleMember(x), Self::HandleMember(y)) => *x == *y,
609            (Self::StringMember(x), Self::StringMember(y)) => *x == *y,
610            (Self::StructMember(x), Self::StructMember(y)) => *x == *y,
611            (Self::UnionMember(x), Self::UnionMember(y)) => *x == *y,
612            (Self::ArrayMember(x), Self::ArrayMember(y)) => *x == *y,
613            (Self::VectorMember(x), Self::VectorMember(y)) => *x == *y,
614            (Self::TableMember(x), Self::TableMember(y)) => *x == *y,
615            (Self::XunionMember(x), Self::XunionMember(y)) => *x == *y,
616            _ => false,
617        }
618    }
619}
620
621impl AllTypesXunion {
622    #[inline]
623    pub fn ordinal(&self) -> u64 {
624        match *self {
625            Self::BoolMember(_) => 1,
626            Self::Int8Member(_) => 2,
627            Self::Int16Member(_) => 3,
628            Self::Int32Member(_) => 4,
629            Self::Int64Member(_) => 5,
630            Self::Uint8Member(_) => 6,
631            Self::Uint16Member(_) => 7,
632            Self::Uint32Member(_) => 8,
633            Self::Uint64Member(_) => 9,
634            Self::Float32Member(_) => 10,
635            Self::Float64Member(_) => 11,
636            Self::EnumMember(_) => 12,
637            Self::BitsMember(_) => 13,
638            Self::HandleMember(_) => 14,
639            Self::StringMember(_) => 15,
640            Self::StructMember(_) => 16,
641            Self::UnionMember(_) => 17,
642            Self::ArrayMember(_) => 18,
643            Self::VectorMember(_) => 19,
644            Self::TableMember(_) => 20,
645            Self::XunionMember(_) => 21,
646            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
647        }
648    }
649
650    #[inline]
651    pub fn unknown_variant_for_testing() -> Self {
652        Self::__SourceBreaking { unknown_ordinal: 0 }
653    }
654
655    #[inline]
656    pub fn is_unknown(&self) -> bool {
657        match self {
658            Self::__SourceBreaking { .. } => true,
659            _ => false,
660        }
661    }
662}
663
664impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for AllTypesXunion {}
665
666#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
667pub struct ConfigMarker;
668
669impl fidl::endpoints::ProtocolMarker for ConfigMarker {
670    type Proxy = ConfigProxy;
671    type RequestStream = ConfigRequestStream;
672    #[cfg(target_os = "fuchsia")]
673    type SynchronousProxy = ConfigSynchronousProxy;
674
675    const DEBUG_NAME: &'static str = "fidl.test.compatibility.Config";
676}
677impl fidl::endpoints::DiscoverableProtocolMarker for ConfigMarker {}
678
679pub trait ConfigProxyInterface: Send + Sync {
680    type GetImplsResponseFut: std::future::Future<Output = Result<Vec<String>, fidl::Error>> + Send;
681    fn r#get_impls(&self) -> Self::GetImplsResponseFut;
682}
683#[derive(Debug)]
684#[cfg(target_os = "fuchsia")]
685pub struct ConfigSynchronousProxy {
686    client: fidl::client::sync::Client,
687}
688
689#[cfg(target_os = "fuchsia")]
690impl fidl::endpoints::SynchronousProxy for ConfigSynchronousProxy {
691    type Proxy = ConfigProxy;
692    type Protocol = ConfigMarker;
693
694    fn from_channel(inner: fidl::Channel) -> Self {
695        Self::new(inner)
696    }
697
698    fn into_channel(self) -> fidl::Channel {
699        self.client.into_channel()
700    }
701
702    fn as_channel(&self) -> &fidl::Channel {
703        self.client.as_channel()
704    }
705}
706
707#[cfg(target_os = "fuchsia")]
708impl ConfigSynchronousProxy {
709    pub fn new(channel: fidl::Channel) -> Self {
710        let protocol_name = <ConfigMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
711        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
712    }
713
714    pub fn into_channel(self) -> fidl::Channel {
715        self.client.into_channel()
716    }
717
718    /// Waits until an event arrives and returns it. It is safe for other
719    /// threads to make concurrent requests while waiting for an event.
720    pub fn wait_for_event(
721        &self,
722        deadline: zx::MonotonicInstant,
723    ) -> Result<ConfigEvent, fidl::Error> {
724        ConfigEvent::decode(self.client.wait_for_event(deadline)?)
725    }
726
727    pub fn r#get_impls(
728        &self,
729        ___deadline: zx::MonotonicInstant,
730    ) -> Result<Vec<String>, fidl::Error> {
731        let _response =
732            self.client.send_query::<fidl::encoding::EmptyPayload, ConfigGetImplsResponse>(
733                (),
734                0x3b360c86a6dbdfe0,
735                fidl::encoding::DynamicFlags::empty(),
736                ___deadline,
737            )?;
738        Ok(_response.impls)
739    }
740}
741
742#[cfg(target_os = "fuchsia")]
743impl From<ConfigSynchronousProxy> for zx::Handle {
744    fn from(value: ConfigSynchronousProxy) -> Self {
745        value.into_channel().into()
746    }
747}
748
749#[cfg(target_os = "fuchsia")]
750impl From<fidl::Channel> for ConfigSynchronousProxy {
751    fn from(value: fidl::Channel) -> Self {
752        Self::new(value)
753    }
754}
755
756#[cfg(target_os = "fuchsia")]
757impl fidl::endpoints::FromClient for ConfigSynchronousProxy {
758    type Protocol = ConfigMarker;
759
760    fn from_client(value: fidl::endpoints::ClientEnd<ConfigMarker>) -> Self {
761        Self::new(value.into_channel())
762    }
763}
764
765#[derive(Debug, Clone)]
766pub struct ConfigProxy {
767    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
768}
769
770impl fidl::endpoints::Proxy for ConfigProxy {
771    type Protocol = ConfigMarker;
772
773    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
774        Self::new(inner)
775    }
776
777    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
778        self.client.into_channel().map_err(|client| Self { client })
779    }
780
781    fn as_channel(&self) -> &::fidl::AsyncChannel {
782        self.client.as_channel()
783    }
784}
785
786impl ConfigProxy {
787    /// Create a new Proxy for fidl.test.compatibility/Config.
788    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
789        let protocol_name = <ConfigMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
790        Self { client: fidl::client::Client::new(channel, protocol_name) }
791    }
792
793    /// Get a Stream of events from the remote end of the protocol.
794    ///
795    /// # Panics
796    ///
797    /// Panics if the event stream was already taken.
798    pub fn take_event_stream(&self) -> ConfigEventStream {
799        ConfigEventStream { event_receiver: self.client.take_event_receiver() }
800    }
801
802    pub fn r#get_impls(
803        &self,
804    ) -> fidl::client::QueryResponseFut<Vec<String>, fidl::encoding::DefaultFuchsiaResourceDialect>
805    {
806        ConfigProxyInterface::r#get_impls(self)
807    }
808}
809
810impl ConfigProxyInterface for ConfigProxy {
811    type GetImplsResponseFut =
812        fidl::client::QueryResponseFut<Vec<String>, fidl::encoding::DefaultFuchsiaResourceDialect>;
813    fn r#get_impls(&self) -> Self::GetImplsResponseFut {
814        fn _decode(
815            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
816        ) -> Result<Vec<String>, fidl::Error> {
817            let _response = fidl::client::decode_transaction_body::<
818                ConfigGetImplsResponse,
819                fidl::encoding::DefaultFuchsiaResourceDialect,
820                0x3b360c86a6dbdfe0,
821            >(_buf?)?;
822            Ok(_response.impls)
823        }
824        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<String>>(
825            (),
826            0x3b360c86a6dbdfe0,
827            fidl::encoding::DynamicFlags::empty(),
828            _decode,
829        )
830    }
831}
832
833pub struct ConfigEventStream {
834    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
835}
836
837impl std::marker::Unpin for ConfigEventStream {}
838
839impl futures::stream::FusedStream for ConfigEventStream {
840    fn is_terminated(&self) -> bool {
841        self.event_receiver.is_terminated()
842    }
843}
844
845impl futures::Stream for ConfigEventStream {
846    type Item = Result<ConfigEvent, fidl::Error>;
847
848    fn poll_next(
849        mut self: std::pin::Pin<&mut Self>,
850        cx: &mut std::task::Context<'_>,
851    ) -> std::task::Poll<Option<Self::Item>> {
852        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
853            &mut self.event_receiver,
854            cx
855        )?) {
856            Some(buf) => std::task::Poll::Ready(Some(ConfigEvent::decode(buf))),
857            None => std::task::Poll::Ready(None),
858        }
859    }
860}
861
862#[derive(Debug)]
863pub enum ConfigEvent {}
864
865impl ConfigEvent {
866    /// Decodes a message buffer as a [`ConfigEvent`].
867    fn decode(
868        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
869    ) -> Result<ConfigEvent, fidl::Error> {
870        let (bytes, _handles) = buf.split_mut();
871        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
872        debug_assert_eq!(tx_header.tx_id, 0);
873        match tx_header.ordinal {
874            _ => Err(fidl::Error::UnknownOrdinal {
875                ordinal: tx_header.ordinal,
876                protocol_name: <ConfigMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
877            }),
878        }
879    }
880}
881
882/// A Stream of incoming requests for fidl.test.compatibility/Config.
883pub struct ConfigRequestStream {
884    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
885    is_terminated: bool,
886}
887
888impl std::marker::Unpin for ConfigRequestStream {}
889
890impl futures::stream::FusedStream for ConfigRequestStream {
891    fn is_terminated(&self) -> bool {
892        self.is_terminated
893    }
894}
895
896impl fidl::endpoints::RequestStream for ConfigRequestStream {
897    type Protocol = ConfigMarker;
898    type ControlHandle = ConfigControlHandle;
899
900    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
901        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
902    }
903
904    fn control_handle(&self) -> Self::ControlHandle {
905        ConfigControlHandle { inner: self.inner.clone() }
906    }
907
908    fn into_inner(
909        self,
910    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
911    {
912        (self.inner, self.is_terminated)
913    }
914
915    fn from_inner(
916        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
917        is_terminated: bool,
918    ) -> Self {
919        Self { inner, is_terminated }
920    }
921}
922
923impl futures::Stream for ConfigRequestStream {
924    type Item = Result<ConfigRequest, fidl::Error>;
925
926    fn poll_next(
927        mut self: std::pin::Pin<&mut Self>,
928        cx: &mut std::task::Context<'_>,
929    ) -> std::task::Poll<Option<Self::Item>> {
930        let this = &mut *self;
931        if this.inner.check_shutdown(cx) {
932            this.is_terminated = true;
933            return std::task::Poll::Ready(None);
934        }
935        if this.is_terminated {
936            panic!("polled ConfigRequestStream after completion");
937        }
938        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
939            |bytes, handles| {
940                match this.inner.channel().read_etc(cx, bytes, handles) {
941                    std::task::Poll::Ready(Ok(())) => {}
942                    std::task::Poll::Pending => return std::task::Poll::Pending,
943                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
944                        this.is_terminated = true;
945                        return std::task::Poll::Ready(None);
946                    }
947                    std::task::Poll::Ready(Err(e)) => {
948                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
949                            e.into(),
950                        ))));
951                    }
952                }
953
954                // A message has been received from the channel
955                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
956
957                std::task::Poll::Ready(Some(match header.ordinal {
958                    0x3b360c86a6dbdfe0 => {
959                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
960                        let mut req = fidl::new_empty!(
961                            fidl::encoding::EmptyPayload,
962                            fidl::encoding::DefaultFuchsiaResourceDialect
963                        );
964                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
965                        let control_handle = ConfigControlHandle { inner: this.inner.clone() };
966                        Ok(ConfigRequest::GetImpls {
967                            responder: ConfigGetImplsResponder {
968                                control_handle: std::mem::ManuallyDrop::new(control_handle),
969                                tx_id: header.tx_id,
970                            },
971                        })
972                    }
973                    _ => Err(fidl::Error::UnknownOrdinal {
974                        ordinal: header.ordinal,
975                        protocol_name:
976                            <ConfigMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
977                    }),
978                }))
979            },
980        )
981    }
982}
983
984#[derive(Debug)]
985pub enum ConfigRequest {
986    GetImpls { responder: ConfigGetImplsResponder },
987}
988
989impl ConfigRequest {
990    #[allow(irrefutable_let_patterns)]
991    pub fn into_get_impls(self) -> Option<(ConfigGetImplsResponder)> {
992        if let ConfigRequest::GetImpls { responder } = self { Some((responder)) } else { None }
993    }
994
995    /// Name of the method defined in FIDL
996    pub fn method_name(&self) -> &'static str {
997        match *self {
998            ConfigRequest::GetImpls { .. } => "get_impls",
999        }
1000    }
1001}
1002
1003#[derive(Debug, Clone)]
1004pub struct ConfigControlHandle {
1005    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1006}
1007
1008impl fidl::endpoints::ControlHandle for ConfigControlHandle {
1009    fn shutdown(&self) {
1010        self.inner.shutdown()
1011    }
1012    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1013        self.inner.shutdown_with_epitaph(status)
1014    }
1015
1016    fn is_closed(&self) -> bool {
1017        self.inner.channel().is_closed()
1018    }
1019    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1020        self.inner.channel().on_closed()
1021    }
1022
1023    #[cfg(target_os = "fuchsia")]
1024    fn signal_peer(
1025        &self,
1026        clear_mask: zx::Signals,
1027        set_mask: zx::Signals,
1028    ) -> Result<(), zx_status::Status> {
1029        use fidl::Peered;
1030        self.inner.channel().signal_peer(clear_mask, set_mask)
1031    }
1032}
1033
1034impl ConfigControlHandle {}
1035
1036#[must_use = "FIDL methods require a response to be sent"]
1037#[derive(Debug)]
1038pub struct ConfigGetImplsResponder {
1039    control_handle: std::mem::ManuallyDrop<ConfigControlHandle>,
1040    tx_id: u32,
1041}
1042
1043/// Set the the channel to be shutdown (see [`ConfigControlHandle::shutdown`])
1044/// if the responder is dropped without sending a response, so that the client
1045/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1046impl std::ops::Drop for ConfigGetImplsResponder {
1047    fn drop(&mut self) {
1048        self.control_handle.shutdown();
1049        // Safety: drops once, never accessed again
1050        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1051    }
1052}
1053
1054impl fidl::endpoints::Responder for ConfigGetImplsResponder {
1055    type ControlHandle = ConfigControlHandle;
1056
1057    fn control_handle(&self) -> &ConfigControlHandle {
1058        &self.control_handle
1059    }
1060
1061    fn drop_without_shutdown(mut self) {
1062        // Safety: drops once, never accessed again due to mem::forget
1063        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1064        // Prevent Drop from running (which would shut down the channel)
1065        std::mem::forget(self);
1066    }
1067}
1068
1069impl ConfigGetImplsResponder {
1070    /// Sends a response to the FIDL transaction.
1071    ///
1072    /// Sets the channel to shutdown if an error occurs.
1073    pub fn send(self, mut impls: &[String]) -> Result<(), fidl::Error> {
1074        let _result = self.send_raw(impls);
1075        if _result.is_err() {
1076            self.control_handle.shutdown();
1077        }
1078        self.drop_without_shutdown();
1079        _result
1080    }
1081
1082    /// Similar to "send" but does not shutdown the channel if an error occurs.
1083    pub fn send_no_shutdown_on_err(self, mut impls: &[String]) -> Result<(), fidl::Error> {
1084        let _result = self.send_raw(impls);
1085        self.drop_without_shutdown();
1086        _result
1087    }
1088
1089    fn send_raw(&self, mut impls: &[String]) -> Result<(), fidl::Error> {
1090        self.control_handle.inner.send::<ConfigGetImplsResponse>(
1091            (impls,),
1092            self.tx_id,
1093            0x3b360c86a6dbdfe0,
1094            fidl::encoding::DynamicFlags::empty(),
1095        )
1096    }
1097}
1098
1099#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
1100pub struct EchoMarker;
1101
1102impl fidl::endpoints::ProtocolMarker for EchoMarker {
1103    type Proxy = EchoProxy;
1104    type RequestStream = EchoRequestStream;
1105    #[cfg(target_os = "fuchsia")]
1106    type SynchronousProxy = EchoSynchronousProxy;
1107
1108    const DEBUG_NAME: &'static str = "fidl.test.compatibility.Echo";
1109}
1110impl fidl::endpoints::DiscoverableProtocolMarker for EchoMarker {}
1111pub type EchoEchoMinimalWithErrorResult = Result<(), u32>;
1112pub type EchoEchoStructWithErrorResult = Result<Struct, DefaultEnum>;
1113pub type EchoEchoArraysWithErrorResult = Result<ArraysStruct, DefaultEnum>;
1114pub type EchoEchoVectorsWithErrorResult = Result<VectorsStruct, DefaultEnum>;
1115pub type EchoEchoTableWithErrorResult = Result<AllTypesTable, DefaultEnum>;
1116pub type EchoEchoXunionsWithErrorResult = Result<Vec<AllTypesXunion>, DefaultEnum>;
1117pub type EchoEchoNamedStructWithErrorResult = Result<fidl_fidl_test_imported::SimpleStruct, u32>;
1118pub type EchoEchoTablePayloadWithErrorResult = Result<ResponseTable, DefaultEnum>;
1119pub type EchoEchoUnionPayloadWithErrorResult = Result<ResponseUnion, DefaultEnum>;
1120
1121pub trait EchoProxyInterface: Send + Sync {
1122    type EchoTableRequestComposedResponseFut: std::future::Future<Output = Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error>>
1123        + Send;
1124    fn r#echo_table_request_composed(
1125        &self,
1126        payload: &fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
1127    ) -> Self::EchoTableRequestComposedResponseFut;
1128    type EchoUnionResponseWithErrorComposedResponseFut: std::future::Future<
1129            Output = Result<
1130                fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
1131                fidl::Error,
1132            >,
1133        > + Send;
1134    fn r#echo_union_response_with_error_composed(
1135        &self,
1136        value: i64,
1137        want_absolute_value: bool,
1138        forward_to_server: &str,
1139        result_err: u32,
1140        result_variant: fidl_fidl_test_imported::WantResponse,
1141    ) -> Self::EchoUnionResponseWithErrorComposedResponseFut;
1142    type EchoMinimalResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
1143    fn r#echo_minimal(&self, forward_to_server: &str) -> Self::EchoMinimalResponseFut;
1144    type EchoMinimalWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoMinimalWithErrorResult, fidl::Error>>
1145        + Send;
1146    fn r#echo_minimal_with_error(
1147        &self,
1148        forward_to_server: &str,
1149        result_variant: RespondWith,
1150    ) -> Self::EchoMinimalWithErrorResponseFut;
1151    fn r#echo_minimal_no_ret_val(&self, forward_to_server: &str) -> Result<(), fidl::Error>;
1152    type EchoStructResponseFut: std::future::Future<Output = Result<Struct, fidl::Error>> + Send;
1153    fn r#echo_struct(&self, value: Struct, forward_to_server: &str) -> Self::EchoStructResponseFut;
1154    type EchoStructWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoStructWithErrorResult, fidl::Error>>
1155        + Send;
1156    fn r#echo_struct_with_error(
1157        &self,
1158        value: Struct,
1159        result_err: DefaultEnum,
1160        forward_to_server: &str,
1161        result_variant: RespondWith,
1162    ) -> Self::EchoStructWithErrorResponseFut;
1163    fn r#echo_struct_no_ret_val(
1164        &self,
1165        value: Struct,
1166        forward_to_server: &str,
1167    ) -> Result<(), fidl::Error>;
1168    type EchoArraysResponseFut: std::future::Future<Output = Result<ArraysStruct, fidl::Error>>
1169        + Send;
1170    fn r#echo_arrays(
1171        &self,
1172        value: ArraysStruct,
1173        forward_to_server: &str,
1174    ) -> Self::EchoArraysResponseFut;
1175    type EchoArraysWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoArraysWithErrorResult, fidl::Error>>
1176        + Send;
1177    fn r#echo_arrays_with_error(
1178        &self,
1179        value: ArraysStruct,
1180        result_err: DefaultEnum,
1181        forward_to_server: &str,
1182        result_variant: RespondWith,
1183    ) -> Self::EchoArraysWithErrorResponseFut;
1184    type EchoVectorsResponseFut: std::future::Future<Output = Result<VectorsStruct, fidl::Error>>
1185        + Send;
1186    fn r#echo_vectors(
1187        &self,
1188        value: VectorsStruct,
1189        forward_to_server: &str,
1190    ) -> Self::EchoVectorsResponseFut;
1191    type EchoVectorsWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoVectorsWithErrorResult, fidl::Error>>
1192        + Send;
1193    fn r#echo_vectors_with_error(
1194        &self,
1195        value: VectorsStruct,
1196        result_err: DefaultEnum,
1197        forward_to_server: &str,
1198        result_variant: RespondWith,
1199    ) -> Self::EchoVectorsWithErrorResponseFut;
1200    type EchoTableResponseFut: std::future::Future<Output = Result<AllTypesTable, fidl::Error>>
1201        + Send;
1202    fn r#echo_table(
1203        &self,
1204        value: AllTypesTable,
1205        forward_to_server: &str,
1206    ) -> Self::EchoTableResponseFut;
1207    type EchoTableWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoTableWithErrorResult, fidl::Error>>
1208        + Send;
1209    fn r#echo_table_with_error(
1210        &self,
1211        value: AllTypesTable,
1212        result_err: DefaultEnum,
1213        forward_to_server: &str,
1214        result_variant: RespondWith,
1215    ) -> Self::EchoTableWithErrorResponseFut;
1216    type EchoXunionsResponseFut: std::future::Future<Output = Result<Vec<AllTypesXunion>, fidl::Error>>
1217        + Send;
1218    fn r#echo_xunions(
1219        &self,
1220        value: Vec<AllTypesXunion>,
1221        forward_to_server: &str,
1222    ) -> Self::EchoXunionsResponseFut;
1223    type EchoXunionsWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoXunionsWithErrorResult, fidl::Error>>
1224        + Send;
1225    fn r#echo_xunions_with_error(
1226        &self,
1227        value: Vec<AllTypesXunion>,
1228        result_err: DefaultEnum,
1229        forward_to_server: &str,
1230        result_variant: RespondWith,
1231    ) -> Self::EchoXunionsWithErrorResponseFut;
1232    type EchoNamedStructResponseFut: std::future::Future<Output = Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error>>
1233        + Send;
1234    fn r#echo_named_struct(
1235        &self,
1236        value: &fidl_fidl_test_imported::SimpleStruct,
1237        forward_to_server: &str,
1238    ) -> Self::EchoNamedStructResponseFut;
1239    type EchoNamedStructWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoNamedStructWithErrorResult, fidl::Error>>
1240        + Send;
1241    fn r#echo_named_struct_with_error(
1242        &self,
1243        value: &fidl_fidl_test_imported::SimpleStruct,
1244        result_err: u32,
1245        forward_to_server: &str,
1246        result_variant: fidl_fidl_test_imported::WantResponse,
1247    ) -> Self::EchoNamedStructWithErrorResponseFut;
1248    fn r#echo_named_struct_no_ret_val(
1249        &self,
1250        value: &fidl_fidl_test_imported::SimpleStruct,
1251        forward_to_server: &str,
1252    ) -> Result<(), fidl::Error>;
1253    type EchoTablePayloadResponseFut: std::future::Future<Output = Result<ResponseTable, fidl::Error>>
1254        + Send;
1255    fn r#echo_table_payload(&self, payload: &RequestTable) -> Self::EchoTablePayloadResponseFut;
1256    type EchoTablePayloadWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoTablePayloadWithErrorResult, fidl::Error>>
1257        + Send;
1258    fn r#echo_table_payload_with_error(
1259        &self,
1260        payload: &EchoEchoTablePayloadWithErrorRequest,
1261    ) -> Self::EchoTablePayloadWithErrorResponseFut;
1262    fn r#echo_table_payload_no_ret_val(&self, payload: &RequestTable) -> Result<(), fidl::Error>;
1263    type EchoUnionPayloadResponseFut: std::future::Future<Output = Result<ResponseUnion, fidl::Error>>
1264        + Send;
1265    fn r#echo_union_payload(&self, payload: &RequestUnion) -> Self::EchoUnionPayloadResponseFut;
1266    type EchoUnionPayloadWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoUnionPayloadWithErrorResult, fidl::Error>>
1267        + Send;
1268    fn r#echo_union_payload_with_error(
1269        &self,
1270        payload: &EchoEchoUnionPayloadWithErrorRequest,
1271    ) -> Self::EchoUnionPayloadWithErrorResponseFut;
1272    fn r#echo_union_payload_no_ret_val(&self, payload: &RequestUnion) -> Result<(), fidl::Error>;
1273}
1274#[derive(Debug)]
1275#[cfg(target_os = "fuchsia")]
1276pub struct EchoSynchronousProxy {
1277    client: fidl::client::sync::Client,
1278}
1279
1280#[cfg(target_os = "fuchsia")]
1281impl fidl::endpoints::SynchronousProxy for EchoSynchronousProxy {
1282    type Proxy = EchoProxy;
1283    type Protocol = EchoMarker;
1284
1285    fn from_channel(inner: fidl::Channel) -> Self {
1286        Self::new(inner)
1287    }
1288
1289    fn into_channel(self) -> fidl::Channel {
1290        self.client.into_channel()
1291    }
1292
1293    fn as_channel(&self) -> &fidl::Channel {
1294        self.client.as_channel()
1295    }
1296}
1297
1298#[cfg(target_os = "fuchsia")]
1299impl EchoSynchronousProxy {
1300    pub fn new(channel: fidl::Channel) -> Self {
1301        let protocol_name = <EchoMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1302        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
1303    }
1304
1305    pub fn into_channel(self) -> fidl::Channel {
1306        self.client.into_channel()
1307    }
1308
1309    /// Waits until an event arrives and returns it. It is safe for other
1310    /// threads to make concurrent requests while waiting for an event.
1311    pub fn wait_for_event(&self, deadline: zx::MonotonicInstant) -> Result<EchoEvent, fidl::Error> {
1312        EchoEvent::decode(self.client.wait_for_event(deadline)?)
1313    }
1314
1315    pub fn r#echo_table_request_composed(
1316        &self,
1317        mut payload: &fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
1318        ___deadline: zx::MonotonicInstant,
1319    ) -> Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error> {
1320        let _response = self.client.send_query::<
1321            fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
1322            fidl_fidl_test_imported::ResponseStruct,
1323        >(
1324            payload,
1325            0x1d545c738c7a8ee,
1326            fidl::encoding::DynamicFlags::empty(),
1327            ___deadline,
1328        )?;
1329        Ok(_response.value)
1330    }
1331
1332    pub fn r#echo_union_response_with_error_composed(
1333        &self,
1334        mut value: i64,
1335        mut want_absolute_value: bool,
1336        mut forward_to_server: &str,
1337        mut result_err: u32,
1338        mut result_variant: fidl_fidl_test_imported::WantResponse,
1339        ___deadline: zx::MonotonicInstant,
1340    ) -> Result<
1341        fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
1342        fidl::Error,
1343    > {
1344        let _response = self.client.send_query::<
1345            fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedRequest,
1346            fidl::encoding::ResultType<fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse, u32>,
1347        >(
1348            (value, want_absolute_value, forward_to_server, result_err, result_variant,),
1349            0x38a67e88d6106443,
1350            fidl::encoding::DynamicFlags::empty(),
1351            ___deadline,
1352        )?;
1353        Ok(_response.map(|x| x))
1354    }
1355
1356    pub fn r#echo_minimal(
1357        &self,
1358        mut forward_to_server: &str,
1359        ___deadline: zx::MonotonicInstant,
1360    ) -> Result<(), fidl::Error> {
1361        let _response =
1362            self.client.send_query::<EchoEchoMinimalRequest, fidl::encoding::EmptyPayload>(
1363                (forward_to_server,),
1364                0x39edd68c837482ec,
1365                fidl::encoding::DynamicFlags::empty(),
1366                ___deadline,
1367            )?;
1368        Ok(_response)
1369    }
1370
1371    pub fn r#echo_minimal_with_error(
1372        &self,
1373        mut forward_to_server: &str,
1374        mut result_variant: RespondWith,
1375        ___deadline: zx::MonotonicInstant,
1376    ) -> Result<EchoEchoMinimalWithErrorResult, fidl::Error> {
1377        let _response = self.client.send_query::<
1378            EchoEchoMinimalWithErrorRequest,
1379            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, u32>,
1380        >(
1381            (forward_to_server, result_variant,),
1382            0x36f4695996e35acc,
1383            fidl::encoding::DynamicFlags::empty(),
1384            ___deadline,
1385        )?;
1386        Ok(_response.map(|x| x))
1387    }
1388
1389    pub fn r#echo_minimal_no_ret_val(
1390        &self,
1391        mut forward_to_server: &str,
1392    ) -> Result<(), fidl::Error> {
1393        self.client.send::<EchoEchoMinimalNoRetValRequest>(
1394            (forward_to_server,),
1395            0x42693c143e2c3694,
1396            fidl::encoding::DynamicFlags::empty(),
1397        )
1398    }
1399
1400    pub fn r#echo_struct(
1401        &self,
1402        mut value: Struct,
1403        mut forward_to_server: &str,
1404        ___deadline: zx::MonotonicInstant,
1405    ) -> Result<Struct, fidl::Error> {
1406        let _response = self.client.send_query::<EchoEchoStructRequest, EchoEchoStructResponse>(
1407            (&mut value, forward_to_server),
1408            0x4c2f85818cc53f37,
1409            fidl::encoding::DynamicFlags::empty(),
1410            ___deadline,
1411        )?;
1412        Ok(_response.value)
1413    }
1414
1415    pub fn r#echo_struct_with_error(
1416        &self,
1417        mut value: Struct,
1418        mut result_err: DefaultEnum,
1419        mut forward_to_server: &str,
1420        mut result_variant: RespondWith,
1421        ___deadline: zx::MonotonicInstant,
1422    ) -> Result<EchoEchoStructWithErrorResult, fidl::Error> {
1423        let _response = self.client.send_query::<
1424            EchoEchoStructWithErrorRequest,
1425            fidl::encoding::ResultType<EchoEchoStructWithErrorResponse, DefaultEnum>,
1426        >(
1427            (&mut value, result_err, forward_to_server, result_variant,),
1428            0x46cb32652c4c0899,
1429            fidl::encoding::DynamicFlags::empty(),
1430            ___deadline,
1431        )?;
1432        Ok(_response.map(|x| x.value))
1433    }
1434
1435    pub fn r#echo_struct_no_ret_val(
1436        &self,
1437        mut value: Struct,
1438        mut forward_to_server: &str,
1439    ) -> Result<(), fidl::Error> {
1440        self.client.send::<EchoEchoStructNoRetValRequest>(
1441            (&mut value, forward_to_server),
1442            0x1f763e602cf5892a,
1443            fidl::encoding::DynamicFlags::empty(),
1444        )
1445    }
1446
1447    pub fn r#echo_arrays(
1448        &self,
1449        mut value: ArraysStruct,
1450        mut forward_to_server: &str,
1451        ___deadline: zx::MonotonicInstant,
1452    ) -> Result<ArraysStruct, fidl::Error> {
1453        let _response = self.client.send_query::<EchoEchoArraysRequest, EchoEchoArraysResponse>(
1454            (&mut value, forward_to_server),
1455            0x1b6019d5611f2470,
1456            fidl::encoding::DynamicFlags::empty(),
1457            ___deadline,
1458        )?;
1459        Ok(_response.value)
1460    }
1461
1462    pub fn r#echo_arrays_with_error(
1463        &self,
1464        mut value: ArraysStruct,
1465        mut result_err: DefaultEnum,
1466        mut forward_to_server: &str,
1467        mut result_variant: RespondWith,
1468        ___deadline: zx::MonotonicInstant,
1469    ) -> Result<EchoEchoArraysWithErrorResult, fidl::Error> {
1470        let _response = self.client.send_query::<
1471            EchoEchoArraysWithErrorRequest,
1472            fidl::encoding::ResultType<EchoEchoArraysWithErrorResponse, DefaultEnum>,
1473        >(
1474            (&mut value, result_err, forward_to_server, result_variant,),
1475            0x6dbf26e67e253afa,
1476            fidl::encoding::DynamicFlags::empty(),
1477            ___deadline,
1478        )?;
1479        Ok(_response.map(|x| x.value))
1480    }
1481
1482    pub fn r#echo_vectors(
1483        &self,
1484        mut value: VectorsStruct,
1485        mut forward_to_server: &str,
1486        ___deadline: zx::MonotonicInstant,
1487    ) -> Result<VectorsStruct, fidl::Error> {
1488        let _response = self.client.send_query::<EchoEchoVectorsRequest, EchoEchoVectorsResponse>(
1489            (&mut value, forward_to_server),
1490            0x1582623f0d9f6e5e,
1491            fidl::encoding::DynamicFlags::empty(),
1492            ___deadline,
1493        )?;
1494        Ok(_response.value)
1495    }
1496
1497    pub fn r#echo_vectors_with_error(
1498        &self,
1499        mut value: VectorsStruct,
1500        mut result_err: DefaultEnum,
1501        mut forward_to_server: &str,
1502        mut result_variant: RespondWith,
1503        ___deadline: zx::MonotonicInstant,
1504    ) -> Result<EchoEchoVectorsWithErrorResult, fidl::Error> {
1505        let _response = self.client.send_query::<
1506            EchoEchoVectorsWithErrorRequest,
1507            fidl::encoding::ResultType<EchoEchoVectorsWithErrorResponse, DefaultEnum>,
1508        >(
1509            (&mut value, result_err, forward_to_server, result_variant,),
1510            0x730f163401e2b3e5,
1511            fidl::encoding::DynamicFlags::empty(),
1512            ___deadline,
1513        )?;
1514        Ok(_response.map(|x| x.value))
1515    }
1516
1517    pub fn r#echo_table(
1518        &self,
1519        mut value: AllTypesTable,
1520        mut forward_to_server: &str,
1521        ___deadline: zx::MonotonicInstant,
1522    ) -> Result<AllTypesTable, fidl::Error> {
1523        let _response = self.client.send_query::<EchoEchoTableRequest, EchoEchoTableResponse>(
1524            (&mut value, forward_to_server),
1525            0x4f1fb0a512f47c4b,
1526            fidl::encoding::DynamicFlags::empty(),
1527            ___deadline,
1528        )?;
1529        Ok(_response.value)
1530    }
1531
1532    pub fn r#echo_table_with_error(
1533        &self,
1534        mut value: AllTypesTable,
1535        mut result_err: DefaultEnum,
1536        mut forward_to_server: &str,
1537        mut result_variant: RespondWith,
1538        ___deadline: zx::MonotonicInstant,
1539    ) -> Result<EchoEchoTableWithErrorResult, fidl::Error> {
1540        let _response = self.client.send_query::<
1541            EchoEchoTableWithErrorRequest,
1542            fidl::encoding::ResultType<EchoEchoTableWithErrorResponse, DefaultEnum>,
1543        >(
1544            (&mut value, result_err, forward_to_server, result_variant,),
1545            0x44e835cb1eb9a931,
1546            fidl::encoding::DynamicFlags::empty(),
1547            ___deadline,
1548        )?;
1549        Ok(_response.map(|x| x.value))
1550    }
1551
1552    pub fn r#echo_xunions(
1553        &self,
1554        mut value: Vec<AllTypesXunion>,
1555        mut forward_to_server: &str,
1556        ___deadline: zx::MonotonicInstant,
1557    ) -> Result<Vec<AllTypesXunion>, fidl::Error> {
1558        let _response = self.client.send_query::<EchoEchoXunionsRequest, EchoEchoXunionsResponse>(
1559            (value.as_mut(), forward_to_server),
1560            0x3dc181909041a583,
1561            fidl::encoding::DynamicFlags::empty(),
1562            ___deadline,
1563        )?;
1564        Ok(_response.value)
1565    }
1566
1567    pub fn r#echo_xunions_with_error(
1568        &self,
1569        mut value: Vec<AllTypesXunion>,
1570        mut result_err: DefaultEnum,
1571        mut forward_to_server: &str,
1572        mut result_variant: RespondWith,
1573        ___deadline: zx::MonotonicInstant,
1574    ) -> Result<EchoEchoXunionsWithErrorResult, fidl::Error> {
1575        let _response = self.client.send_query::<
1576            EchoEchoXunionsWithErrorRequest,
1577            fidl::encoding::ResultType<EchoEchoXunionsWithErrorResponse, DefaultEnum>,
1578        >(
1579            (value.as_mut(), result_err, forward_to_server, result_variant,),
1580            0x75184102667fa766,
1581            fidl::encoding::DynamicFlags::empty(),
1582            ___deadline,
1583        )?;
1584        Ok(_response.map(|x| x.value))
1585    }
1586
1587    pub fn r#echo_named_struct(
1588        &self,
1589        mut value: &fidl_fidl_test_imported::SimpleStruct,
1590        mut forward_to_server: &str,
1591        ___deadline: zx::MonotonicInstant,
1592    ) -> Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error> {
1593        let _response = self.client.send_query::<
1594            fidl_fidl_test_imported::RequestStruct,
1595            fidl_fidl_test_imported::ResponseStruct,
1596        >(
1597            (value, forward_to_server,),
1598            0xf2d4aa9e65f7111,
1599            fidl::encoding::DynamicFlags::empty(),
1600            ___deadline,
1601        )?;
1602        Ok(_response.value)
1603    }
1604
1605    pub fn r#echo_named_struct_with_error(
1606        &self,
1607        mut value: &fidl_fidl_test_imported::SimpleStruct,
1608        mut result_err: u32,
1609        mut forward_to_server: &str,
1610        mut result_variant: fidl_fidl_test_imported::WantResponse,
1611        ___deadline: zx::MonotonicInstant,
1612    ) -> Result<EchoEchoNamedStructWithErrorResult, fidl::Error> {
1613        let _response = self.client.send_query::<
1614            fidl_fidl_test_imported::ErrorableRequestStruct,
1615            fidl::encoding::ResultType<fidl_fidl_test_imported::ResponseStruct, u32>,
1616        >(
1617            (value, result_err, forward_to_server, result_variant,),
1618            0x5766fee9e74442e8,
1619            fidl::encoding::DynamicFlags::empty(),
1620            ___deadline,
1621        )?;
1622        Ok(_response.map(|x| x.value))
1623    }
1624
1625    pub fn r#echo_named_struct_no_ret_val(
1626        &self,
1627        mut value: &fidl_fidl_test_imported::SimpleStruct,
1628        mut forward_to_server: &str,
1629    ) -> Result<(), fidl::Error> {
1630        self.client.send::<fidl_fidl_test_imported::EventTriggeringRequestStruct>(
1631            (value, forward_to_server),
1632            0x3a50bbf7d2113ad7,
1633            fidl::encoding::DynamicFlags::empty(),
1634        )
1635    }
1636
1637    pub fn r#echo_table_payload(
1638        &self,
1639        mut payload: &RequestTable,
1640        ___deadline: zx::MonotonicInstant,
1641    ) -> Result<ResponseTable, fidl::Error> {
1642        let _response = self.client.send_query::<RequestTable, ResponseTable>(
1643            payload,
1644            0x641d98087378c003,
1645            fidl::encoding::DynamicFlags::empty(),
1646            ___deadline,
1647        )?;
1648        Ok(_response)
1649    }
1650
1651    pub fn r#echo_table_payload_with_error(
1652        &self,
1653        mut payload: &EchoEchoTablePayloadWithErrorRequest,
1654        ___deadline: zx::MonotonicInstant,
1655    ) -> Result<EchoEchoTablePayloadWithErrorResult, fidl::Error> {
1656        let _response = self.client.send_query::<
1657            EchoEchoTablePayloadWithErrorRequest,
1658            fidl::encoding::ResultType<ResponseTable, DefaultEnum>,
1659        >(
1660            payload,
1661            0x636ed243761ab66d,
1662            fidl::encoding::DynamicFlags::empty(),
1663            ___deadline,
1664        )?;
1665        Ok(_response.map(|x| x))
1666    }
1667
1668    pub fn r#echo_table_payload_no_ret_val(
1669        &self,
1670        mut payload: &RequestTable,
1671    ) -> Result<(), fidl::Error> {
1672        self.client.send::<RequestTable>(
1673            payload,
1674            0x32961f7d718569f8,
1675            fidl::encoding::DynamicFlags::empty(),
1676        )
1677    }
1678
1679    pub fn r#echo_union_payload(
1680        &self,
1681        mut payload: &RequestUnion,
1682        ___deadline: zx::MonotonicInstant,
1683    ) -> Result<ResponseUnion, fidl::Error> {
1684        let _response = self.client.send_query::<RequestUnion, ResponseUnion>(
1685            payload,
1686            0x66def9e793f10c55,
1687            fidl::encoding::DynamicFlags::empty(),
1688            ___deadline,
1689        )?;
1690        Ok(_response)
1691    }
1692
1693    pub fn r#echo_union_payload_with_error(
1694        &self,
1695        mut payload: &EchoEchoUnionPayloadWithErrorRequest,
1696        ___deadline: zx::MonotonicInstant,
1697    ) -> Result<EchoEchoUnionPayloadWithErrorResult, fidl::Error> {
1698        let _response = self.client.send_query::<
1699            EchoEchoUnionPayloadWithErrorRequest,
1700            fidl::encoding::ResultType<ResponseUnion, DefaultEnum>,
1701        >(
1702            payload,
1703            0x1be890d6e68ef063,
1704            fidl::encoding::DynamicFlags::empty(),
1705            ___deadline,
1706        )?;
1707        Ok(_response.map(|x| x))
1708    }
1709
1710    pub fn r#echo_union_payload_no_ret_val(
1711        &self,
1712        mut payload: &RequestUnion,
1713    ) -> Result<(), fidl::Error> {
1714        self.client.send::<RequestUnion>(
1715            payload,
1716            0x11518bf346430040,
1717            fidl::encoding::DynamicFlags::empty(),
1718        )
1719    }
1720}
1721
1722#[cfg(target_os = "fuchsia")]
1723impl From<EchoSynchronousProxy> for zx::Handle {
1724    fn from(value: EchoSynchronousProxy) -> Self {
1725        value.into_channel().into()
1726    }
1727}
1728
1729#[cfg(target_os = "fuchsia")]
1730impl From<fidl::Channel> for EchoSynchronousProxy {
1731    fn from(value: fidl::Channel) -> Self {
1732        Self::new(value)
1733    }
1734}
1735
1736#[cfg(target_os = "fuchsia")]
1737impl fidl::endpoints::FromClient for EchoSynchronousProxy {
1738    type Protocol = EchoMarker;
1739
1740    fn from_client(value: fidl::endpoints::ClientEnd<EchoMarker>) -> Self {
1741        Self::new(value.into_channel())
1742    }
1743}
1744
1745#[derive(Debug, Clone)]
1746pub struct EchoProxy {
1747    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
1748}
1749
1750impl fidl::endpoints::Proxy for EchoProxy {
1751    type Protocol = EchoMarker;
1752
1753    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
1754        Self::new(inner)
1755    }
1756
1757    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
1758        self.client.into_channel().map_err(|client| Self { client })
1759    }
1760
1761    fn as_channel(&self) -> &::fidl::AsyncChannel {
1762        self.client.as_channel()
1763    }
1764}
1765
1766impl EchoProxy {
1767    /// Create a new Proxy for fidl.test.compatibility/Echo.
1768    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
1769        let protocol_name = <EchoMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1770        Self { client: fidl::client::Client::new(channel, protocol_name) }
1771    }
1772
1773    /// Get a Stream of events from the remote end of the protocol.
1774    ///
1775    /// # Panics
1776    ///
1777    /// Panics if the event stream was already taken.
1778    pub fn take_event_stream(&self) -> EchoEventStream {
1779        EchoEventStream { event_receiver: self.client.take_event_receiver() }
1780    }
1781
1782    pub fn r#echo_table_request_composed(
1783        &self,
1784        mut payload: &fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
1785    ) -> fidl::client::QueryResponseFut<
1786        fidl_fidl_test_imported::SimpleStruct,
1787        fidl::encoding::DefaultFuchsiaResourceDialect,
1788    > {
1789        EchoProxyInterface::r#echo_table_request_composed(self, payload)
1790    }
1791
1792    pub fn r#echo_union_response_with_error_composed(
1793        &self,
1794        mut value: i64,
1795        mut want_absolute_value: bool,
1796        mut forward_to_server: &str,
1797        mut result_err: u32,
1798        mut result_variant: fidl_fidl_test_imported::WantResponse,
1799    ) -> fidl::client::QueryResponseFut<
1800        fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
1801        fidl::encoding::DefaultFuchsiaResourceDialect,
1802    > {
1803        EchoProxyInterface::r#echo_union_response_with_error_composed(
1804            self,
1805            value,
1806            want_absolute_value,
1807            forward_to_server,
1808            result_err,
1809            result_variant,
1810        )
1811    }
1812
1813    pub fn r#echo_minimal(
1814        &self,
1815        mut forward_to_server: &str,
1816    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
1817        EchoProxyInterface::r#echo_minimal(self, forward_to_server)
1818    }
1819
1820    pub fn r#echo_minimal_with_error(
1821        &self,
1822        mut forward_to_server: &str,
1823        mut result_variant: RespondWith,
1824    ) -> fidl::client::QueryResponseFut<
1825        EchoEchoMinimalWithErrorResult,
1826        fidl::encoding::DefaultFuchsiaResourceDialect,
1827    > {
1828        EchoProxyInterface::r#echo_minimal_with_error(self, forward_to_server, result_variant)
1829    }
1830
1831    pub fn r#echo_minimal_no_ret_val(
1832        &self,
1833        mut forward_to_server: &str,
1834    ) -> Result<(), fidl::Error> {
1835        EchoProxyInterface::r#echo_minimal_no_ret_val(self, forward_to_server)
1836    }
1837
1838    pub fn r#echo_struct(
1839        &self,
1840        mut value: Struct,
1841        mut forward_to_server: &str,
1842    ) -> fidl::client::QueryResponseFut<Struct, fidl::encoding::DefaultFuchsiaResourceDialect> {
1843        EchoProxyInterface::r#echo_struct(self, value, forward_to_server)
1844    }
1845
1846    pub fn r#echo_struct_with_error(
1847        &self,
1848        mut value: Struct,
1849        mut result_err: DefaultEnum,
1850        mut forward_to_server: &str,
1851        mut result_variant: RespondWith,
1852    ) -> fidl::client::QueryResponseFut<
1853        EchoEchoStructWithErrorResult,
1854        fidl::encoding::DefaultFuchsiaResourceDialect,
1855    > {
1856        EchoProxyInterface::r#echo_struct_with_error(
1857            self,
1858            value,
1859            result_err,
1860            forward_to_server,
1861            result_variant,
1862        )
1863    }
1864
1865    pub fn r#echo_struct_no_ret_val(
1866        &self,
1867        mut value: Struct,
1868        mut forward_to_server: &str,
1869    ) -> Result<(), fidl::Error> {
1870        EchoProxyInterface::r#echo_struct_no_ret_val(self, value, forward_to_server)
1871    }
1872
1873    pub fn r#echo_arrays(
1874        &self,
1875        mut value: ArraysStruct,
1876        mut forward_to_server: &str,
1877    ) -> fidl::client::QueryResponseFut<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
1878    {
1879        EchoProxyInterface::r#echo_arrays(self, value, forward_to_server)
1880    }
1881
1882    pub fn r#echo_arrays_with_error(
1883        &self,
1884        mut value: ArraysStruct,
1885        mut result_err: DefaultEnum,
1886        mut forward_to_server: &str,
1887        mut result_variant: RespondWith,
1888    ) -> fidl::client::QueryResponseFut<
1889        EchoEchoArraysWithErrorResult,
1890        fidl::encoding::DefaultFuchsiaResourceDialect,
1891    > {
1892        EchoProxyInterface::r#echo_arrays_with_error(
1893            self,
1894            value,
1895            result_err,
1896            forward_to_server,
1897            result_variant,
1898        )
1899    }
1900
1901    pub fn r#echo_vectors(
1902        &self,
1903        mut value: VectorsStruct,
1904        mut forward_to_server: &str,
1905    ) -> fidl::client::QueryResponseFut<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
1906    {
1907        EchoProxyInterface::r#echo_vectors(self, value, forward_to_server)
1908    }
1909
1910    pub fn r#echo_vectors_with_error(
1911        &self,
1912        mut value: VectorsStruct,
1913        mut result_err: DefaultEnum,
1914        mut forward_to_server: &str,
1915        mut result_variant: RespondWith,
1916    ) -> fidl::client::QueryResponseFut<
1917        EchoEchoVectorsWithErrorResult,
1918        fidl::encoding::DefaultFuchsiaResourceDialect,
1919    > {
1920        EchoProxyInterface::r#echo_vectors_with_error(
1921            self,
1922            value,
1923            result_err,
1924            forward_to_server,
1925            result_variant,
1926        )
1927    }
1928
1929    pub fn r#echo_table(
1930        &self,
1931        mut value: AllTypesTable,
1932        mut forward_to_server: &str,
1933    ) -> fidl::client::QueryResponseFut<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>
1934    {
1935        EchoProxyInterface::r#echo_table(self, value, forward_to_server)
1936    }
1937
1938    pub fn r#echo_table_with_error(
1939        &self,
1940        mut value: AllTypesTable,
1941        mut result_err: DefaultEnum,
1942        mut forward_to_server: &str,
1943        mut result_variant: RespondWith,
1944    ) -> fidl::client::QueryResponseFut<
1945        EchoEchoTableWithErrorResult,
1946        fidl::encoding::DefaultFuchsiaResourceDialect,
1947    > {
1948        EchoProxyInterface::r#echo_table_with_error(
1949            self,
1950            value,
1951            result_err,
1952            forward_to_server,
1953            result_variant,
1954        )
1955    }
1956
1957    pub fn r#echo_xunions(
1958        &self,
1959        mut value: Vec<AllTypesXunion>,
1960        mut forward_to_server: &str,
1961    ) -> fidl::client::QueryResponseFut<
1962        Vec<AllTypesXunion>,
1963        fidl::encoding::DefaultFuchsiaResourceDialect,
1964    > {
1965        EchoProxyInterface::r#echo_xunions(self, value, forward_to_server)
1966    }
1967
1968    pub fn r#echo_xunions_with_error(
1969        &self,
1970        mut value: Vec<AllTypesXunion>,
1971        mut result_err: DefaultEnum,
1972        mut forward_to_server: &str,
1973        mut result_variant: RespondWith,
1974    ) -> fidl::client::QueryResponseFut<
1975        EchoEchoXunionsWithErrorResult,
1976        fidl::encoding::DefaultFuchsiaResourceDialect,
1977    > {
1978        EchoProxyInterface::r#echo_xunions_with_error(
1979            self,
1980            value,
1981            result_err,
1982            forward_to_server,
1983            result_variant,
1984        )
1985    }
1986
1987    pub fn r#echo_named_struct(
1988        &self,
1989        mut value: &fidl_fidl_test_imported::SimpleStruct,
1990        mut forward_to_server: &str,
1991    ) -> fidl::client::QueryResponseFut<
1992        fidl_fidl_test_imported::SimpleStruct,
1993        fidl::encoding::DefaultFuchsiaResourceDialect,
1994    > {
1995        EchoProxyInterface::r#echo_named_struct(self, value, forward_to_server)
1996    }
1997
1998    pub fn r#echo_named_struct_with_error(
1999        &self,
2000        mut value: &fidl_fidl_test_imported::SimpleStruct,
2001        mut result_err: u32,
2002        mut forward_to_server: &str,
2003        mut result_variant: fidl_fidl_test_imported::WantResponse,
2004    ) -> fidl::client::QueryResponseFut<
2005        EchoEchoNamedStructWithErrorResult,
2006        fidl::encoding::DefaultFuchsiaResourceDialect,
2007    > {
2008        EchoProxyInterface::r#echo_named_struct_with_error(
2009            self,
2010            value,
2011            result_err,
2012            forward_to_server,
2013            result_variant,
2014        )
2015    }
2016
2017    pub fn r#echo_named_struct_no_ret_val(
2018        &self,
2019        mut value: &fidl_fidl_test_imported::SimpleStruct,
2020        mut forward_to_server: &str,
2021    ) -> Result<(), fidl::Error> {
2022        EchoProxyInterface::r#echo_named_struct_no_ret_val(self, value, forward_to_server)
2023    }
2024
2025    pub fn r#echo_table_payload(
2026        &self,
2027        mut payload: &RequestTable,
2028    ) -> fidl::client::QueryResponseFut<ResponseTable, fidl::encoding::DefaultFuchsiaResourceDialect>
2029    {
2030        EchoProxyInterface::r#echo_table_payload(self, payload)
2031    }
2032
2033    pub fn r#echo_table_payload_with_error(
2034        &self,
2035        mut payload: &EchoEchoTablePayloadWithErrorRequest,
2036    ) -> fidl::client::QueryResponseFut<
2037        EchoEchoTablePayloadWithErrorResult,
2038        fidl::encoding::DefaultFuchsiaResourceDialect,
2039    > {
2040        EchoProxyInterface::r#echo_table_payload_with_error(self, payload)
2041    }
2042
2043    pub fn r#echo_table_payload_no_ret_val(
2044        &self,
2045        mut payload: &RequestTable,
2046    ) -> Result<(), fidl::Error> {
2047        EchoProxyInterface::r#echo_table_payload_no_ret_val(self, payload)
2048    }
2049
2050    pub fn r#echo_union_payload(
2051        &self,
2052        mut payload: &RequestUnion,
2053    ) -> fidl::client::QueryResponseFut<ResponseUnion, fidl::encoding::DefaultFuchsiaResourceDialect>
2054    {
2055        EchoProxyInterface::r#echo_union_payload(self, payload)
2056    }
2057
2058    pub fn r#echo_union_payload_with_error(
2059        &self,
2060        mut payload: &EchoEchoUnionPayloadWithErrorRequest,
2061    ) -> fidl::client::QueryResponseFut<
2062        EchoEchoUnionPayloadWithErrorResult,
2063        fidl::encoding::DefaultFuchsiaResourceDialect,
2064    > {
2065        EchoProxyInterface::r#echo_union_payload_with_error(self, payload)
2066    }
2067
2068    pub fn r#echo_union_payload_no_ret_val(
2069        &self,
2070        mut payload: &RequestUnion,
2071    ) -> Result<(), fidl::Error> {
2072        EchoProxyInterface::r#echo_union_payload_no_ret_val(self, payload)
2073    }
2074}
2075
2076impl EchoProxyInterface for EchoProxy {
2077    type EchoTableRequestComposedResponseFut = fidl::client::QueryResponseFut<
2078        fidl_fidl_test_imported::SimpleStruct,
2079        fidl::encoding::DefaultFuchsiaResourceDialect,
2080    >;
2081    fn r#echo_table_request_composed(
2082        &self,
2083        mut payload: &fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
2084    ) -> Self::EchoTableRequestComposedResponseFut {
2085        fn _decode(
2086            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2087        ) -> Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error> {
2088            let _response = fidl::client::decode_transaction_body::<
2089                fidl_fidl_test_imported::ResponseStruct,
2090                fidl::encoding::DefaultFuchsiaResourceDialect,
2091                0x1d545c738c7a8ee,
2092            >(_buf?)?;
2093            Ok(_response.value)
2094        }
2095        self.client.send_query_and_decode::<
2096            fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
2097            fidl_fidl_test_imported::SimpleStruct,
2098        >(
2099            payload,
2100            0x1d545c738c7a8ee,
2101            fidl::encoding::DynamicFlags::empty(),
2102            _decode,
2103        )
2104    }
2105
2106    type EchoUnionResponseWithErrorComposedResponseFut = fidl::client::QueryResponseFut<
2107        fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
2108        fidl::encoding::DefaultFuchsiaResourceDialect,
2109    >;
2110    fn r#echo_union_response_with_error_composed(
2111        &self,
2112        mut value: i64,
2113        mut want_absolute_value: bool,
2114        mut forward_to_server: &str,
2115        mut result_err: u32,
2116        mut result_variant: fidl_fidl_test_imported::WantResponse,
2117    ) -> Self::EchoUnionResponseWithErrorComposedResponseFut {
2118        fn _decode(
2119            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2120        ) -> Result<
2121            fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
2122            fidl::Error,
2123        > {
2124            let _response = fidl::client::decode_transaction_body::<
2125                fidl::encoding::ResultType<
2126                    fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse,
2127                    u32,
2128                >,
2129                fidl::encoding::DefaultFuchsiaResourceDialect,
2130                0x38a67e88d6106443,
2131            >(_buf?)?;
2132            Ok(_response.map(|x| x))
2133        }
2134        self.client.send_query_and_decode::<
2135            fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedRequest,
2136            fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
2137        >(
2138            (value, want_absolute_value, forward_to_server, result_err, result_variant,),
2139            0x38a67e88d6106443,
2140            fidl::encoding::DynamicFlags::empty(),
2141            _decode,
2142        )
2143    }
2144
2145    type EchoMinimalResponseFut =
2146        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
2147    fn r#echo_minimal(&self, mut forward_to_server: &str) -> Self::EchoMinimalResponseFut {
2148        fn _decode(
2149            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2150        ) -> Result<(), fidl::Error> {
2151            let _response = fidl::client::decode_transaction_body::<
2152                fidl::encoding::EmptyPayload,
2153                fidl::encoding::DefaultFuchsiaResourceDialect,
2154                0x39edd68c837482ec,
2155            >(_buf?)?;
2156            Ok(_response)
2157        }
2158        self.client.send_query_and_decode::<EchoEchoMinimalRequest, ()>(
2159            (forward_to_server,),
2160            0x39edd68c837482ec,
2161            fidl::encoding::DynamicFlags::empty(),
2162            _decode,
2163        )
2164    }
2165
2166    type EchoMinimalWithErrorResponseFut = fidl::client::QueryResponseFut<
2167        EchoEchoMinimalWithErrorResult,
2168        fidl::encoding::DefaultFuchsiaResourceDialect,
2169    >;
2170    fn r#echo_minimal_with_error(
2171        &self,
2172        mut forward_to_server: &str,
2173        mut result_variant: RespondWith,
2174    ) -> Self::EchoMinimalWithErrorResponseFut {
2175        fn _decode(
2176            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2177        ) -> Result<EchoEchoMinimalWithErrorResult, fidl::Error> {
2178            let _response = fidl::client::decode_transaction_body::<
2179                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, u32>,
2180                fidl::encoding::DefaultFuchsiaResourceDialect,
2181                0x36f4695996e35acc,
2182            >(_buf?)?;
2183            Ok(_response.map(|x| x))
2184        }
2185        self.client.send_query_and_decode::<
2186            EchoEchoMinimalWithErrorRequest,
2187            EchoEchoMinimalWithErrorResult,
2188        >(
2189            (forward_to_server, result_variant,),
2190            0x36f4695996e35acc,
2191            fidl::encoding::DynamicFlags::empty(),
2192            _decode,
2193        )
2194    }
2195
2196    fn r#echo_minimal_no_ret_val(&self, mut forward_to_server: &str) -> Result<(), fidl::Error> {
2197        self.client.send::<EchoEchoMinimalNoRetValRequest>(
2198            (forward_to_server,),
2199            0x42693c143e2c3694,
2200            fidl::encoding::DynamicFlags::empty(),
2201        )
2202    }
2203
2204    type EchoStructResponseFut =
2205        fidl::client::QueryResponseFut<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>;
2206    fn r#echo_struct(
2207        &self,
2208        mut value: Struct,
2209        mut forward_to_server: &str,
2210    ) -> Self::EchoStructResponseFut {
2211        fn _decode(
2212            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2213        ) -> Result<Struct, fidl::Error> {
2214            let _response = fidl::client::decode_transaction_body::<
2215                EchoEchoStructResponse,
2216                fidl::encoding::DefaultFuchsiaResourceDialect,
2217                0x4c2f85818cc53f37,
2218            >(_buf?)?;
2219            Ok(_response.value)
2220        }
2221        self.client.send_query_and_decode::<EchoEchoStructRequest, Struct>(
2222            (&mut value, forward_to_server),
2223            0x4c2f85818cc53f37,
2224            fidl::encoding::DynamicFlags::empty(),
2225            _decode,
2226        )
2227    }
2228
2229    type EchoStructWithErrorResponseFut = fidl::client::QueryResponseFut<
2230        EchoEchoStructWithErrorResult,
2231        fidl::encoding::DefaultFuchsiaResourceDialect,
2232    >;
2233    fn r#echo_struct_with_error(
2234        &self,
2235        mut value: Struct,
2236        mut result_err: DefaultEnum,
2237        mut forward_to_server: &str,
2238        mut result_variant: RespondWith,
2239    ) -> Self::EchoStructWithErrorResponseFut {
2240        fn _decode(
2241            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2242        ) -> Result<EchoEchoStructWithErrorResult, fidl::Error> {
2243            let _response = fidl::client::decode_transaction_body::<
2244                fidl::encoding::ResultType<EchoEchoStructWithErrorResponse, DefaultEnum>,
2245                fidl::encoding::DefaultFuchsiaResourceDialect,
2246                0x46cb32652c4c0899,
2247            >(_buf?)?;
2248            Ok(_response.map(|x| x.value))
2249        }
2250        self.client
2251            .send_query_and_decode::<EchoEchoStructWithErrorRequest, EchoEchoStructWithErrorResult>(
2252                (&mut value, result_err, forward_to_server, result_variant),
2253                0x46cb32652c4c0899,
2254                fidl::encoding::DynamicFlags::empty(),
2255                _decode,
2256            )
2257    }
2258
2259    fn r#echo_struct_no_ret_val(
2260        &self,
2261        mut value: Struct,
2262        mut forward_to_server: &str,
2263    ) -> Result<(), fidl::Error> {
2264        self.client.send::<EchoEchoStructNoRetValRequest>(
2265            (&mut value, forward_to_server),
2266            0x1f763e602cf5892a,
2267            fidl::encoding::DynamicFlags::empty(),
2268        )
2269    }
2270
2271    type EchoArraysResponseFut =
2272        fidl::client::QueryResponseFut<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>;
2273    fn r#echo_arrays(
2274        &self,
2275        mut value: ArraysStruct,
2276        mut forward_to_server: &str,
2277    ) -> Self::EchoArraysResponseFut {
2278        fn _decode(
2279            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2280        ) -> Result<ArraysStruct, fidl::Error> {
2281            let _response = fidl::client::decode_transaction_body::<
2282                EchoEchoArraysResponse,
2283                fidl::encoding::DefaultFuchsiaResourceDialect,
2284                0x1b6019d5611f2470,
2285            >(_buf?)?;
2286            Ok(_response.value)
2287        }
2288        self.client.send_query_and_decode::<EchoEchoArraysRequest, ArraysStruct>(
2289            (&mut value, forward_to_server),
2290            0x1b6019d5611f2470,
2291            fidl::encoding::DynamicFlags::empty(),
2292            _decode,
2293        )
2294    }
2295
2296    type EchoArraysWithErrorResponseFut = fidl::client::QueryResponseFut<
2297        EchoEchoArraysWithErrorResult,
2298        fidl::encoding::DefaultFuchsiaResourceDialect,
2299    >;
2300    fn r#echo_arrays_with_error(
2301        &self,
2302        mut value: ArraysStruct,
2303        mut result_err: DefaultEnum,
2304        mut forward_to_server: &str,
2305        mut result_variant: RespondWith,
2306    ) -> Self::EchoArraysWithErrorResponseFut {
2307        fn _decode(
2308            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2309        ) -> Result<EchoEchoArraysWithErrorResult, fidl::Error> {
2310            let _response = fidl::client::decode_transaction_body::<
2311                fidl::encoding::ResultType<EchoEchoArraysWithErrorResponse, DefaultEnum>,
2312                fidl::encoding::DefaultFuchsiaResourceDialect,
2313                0x6dbf26e67e253afa,
2314            >(_buf?)?;
2315            Ok(_response.map(|x| x.value))
2316        }
2317        self.client
2318            .send_query_and_decode::<EchoEchoArraysWithErrorRequest, EchoEchoArraysWithErrorResult>(
2319                (&mut value, result_err, forward_to_server, result_variant),
2320                0x6dbf26e67e253afa,
2321                fidl::encoding::DynamicFlags::empty(),
2322                _decode,
2323            )
2324    }
2325
2326    type EchoVectorsResponseFut = fidl::client::QueryResponseFut<
2327        VectorsStruct,
2328        fidl::encoding::DefaultFuchsiaResourceDialect,
2329    >;
2330    fn r#echo_vectors(
2331        &self,
2332        mut value: VectorsStruct,
2333        mut forward_to_server: &str,
2334    ) -> Self::EchoVectorsResponseFut {
2335        fn _decode(
2336            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2337        ) -> Result<VectorsStruct, fidl::Error> {
2338            let _response = fidl::client::decode_transaction_body::<
2339                EchoEchoVectorsResponse,
2340                fidl::encoding::DefaultFuchsiaResourceDialect,
2341                0x1582623f0d9f6e5e,
2342            >(_buf?)?;
2343            Ok(_response.value)
2344        }
2345        self.client.send_query_and_decode::<EchoEchoVectorsRequest, VectorsStruct>(
2346            (&mut value, forward_to_server),
2347            0x1582623f0d9f6e5e,
2348            fidl::encoding::DynamicFlags::empty(),
2349            _decode,
2350        )
2351    }
2352
2353    type EchoVectorsWithErrorResponseFut = fidl::client::QueryResponseFut<
2354        EchoEchoVectorsWithErrorResult,
2355        fidl::encoding::DefaultFuchsiaResourceDialect,
2356    >;
2357    fn r#echo_vectors_with_error(
2358        &self,
2359        mut value: VectorsStruct,
2360        mut result_err: DefaultEnum,
2361        mut forward_to_server: &str,
2362        mut result_variant: RespondWith,
2363    ) -> Self::EchoVectorsWithErrorResponseFut {
2364        fn _decode(
2365            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2366        ) -> Result<EchoEchoVectorsWithErrorResult, fidl::Error> {
2367            let _response = fidl::client::decode_transaction_body::<
2368                fidl::encoding::ResultType<EchoEchoVectorsWithErrorResponse, DefaultEnum>,
2369                fidl::encoding::DefaultFuchsiaResourceDialect,
2370                0x730f163401e2b3e5,
2371            >(_buf?)?;
2372            Ok(_response.map(|x| x.value))
2373        }
2374        self.client.send_query_and_decode::<
2375            EchoEchoVectorsWithErrorRequest,
2376            EchoEchoVectorsWithErrorResult,
2377        >(
2378            (&mut value, result_err, forward_to_server, result_variant,),
2379            0x730f163401e2b3e5,
2380            fidl::encoding::DynamicFlags::empty(),
2381            _decode,
2382        )
2383    }
2384
2385    type EchoTableResponseFut = fidl::client::QueryResponseFut<
2386        AllTypesTable,
2387        fidl::encoding::DefaultFuchsiaResourceDialect,
2388    >;
2389    fn r#echo_table(
2390        &self,
2391        mut value: AllTypesTable,
2392        mut forward_to_server: &str,
2393    ) -> Self::EchoTableResponseFut {
2394        fn _decode(
2395            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2396        ) -> Result<AllTypesTable, fidl::Error> {
2397            let _response = fidl::client::decode_transaction_body::<
2398                EchoEchoTableResponse,
2399                fidl::encoding::DefaultFuchsiaResourceDialect,
2400                0x4f1fb0a512f47c4b,
2401            >(_buf?)?;
2402            Ok(_response.value)
2403        }
2404        self.client.send_query_and_decode::<EchoEchoTableRequest, AllTypesTable>(
2405            (&mut value, forward_to_server),
2406            0x4f1fb0a512f47c4b,
2407            fidl::encoding::DynamicFlags::empty(),
2408            _decode,
2409        )
2410    }
2411
2412    type EchoTableWithErrorResponseFut = fidl::client::QueryResponseFut<
2413        EchoEchoTableWithErrorResult,
2414        fidl::encoding::DefaultFuchsiaResourceDialect,
2415    >;
2416    fn r#echo_table_with_error(
2417        &self,
2418        mut value: AllTypesTable,
2419        mut result_err: DefaultEnum,
2420        mut forward_to_server: &str,
2421        mut result_variant: RespondWith,
2422    ) -> Self::EchoTableWithErrorResponseFut {
2423        fn _decode(
2424            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2425        ) -> Result<EchoEchoTableWithErrorResult, fidl::Error> {
2426            let _response = fidl::client::decode_transaction_body::<
2427                fidl::encoding::ResultType<EchoEchoTableWithErrorResponse, DefaultEnum>,
2428                fidl::encoding::DefaultFuchsiaResourceDialect,
2429                0x44e835cb1eb9a931,
2430            >(_buf?)?;
2431            Ok(_response.map(|x| x.value))
2432        }
2433        self.client
2434            .send_query_and_decode::<EchoEchoTableWithErrorRequest, EchoEchoTableWithErrorResult>(
2435                (&mut value, result_err, forward_to_server, result_variant),
2436                0x44e835cb1eb9a931,
2437                fidl::encoding::DynamicFlags::empty(),
2438                _decode,
2439            )
2440    }
2441
2442    type EchoXunionsResponseFut = fidl::client::QueryResponseFut<
2443        Vec<AllTypesXunion>,
2444        fidl::encoding::DefaultFuchsiaResourceDialect,
2445    >;
2446    fn r#echo_xunions(
2447        &self,
2448        mut value: Vec<AllTypesXunion>,
2449        mut forward_to_server: &str,
2450    ) -> Self::EchoXunionsResponseFut {
2451        fn _decode(
2452            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2453        ) -> Result<Vec<AllTypesXunion>, fidl::Error> {
2454            let _response = fidl::client::decode_transaction_body::<
2455                EchoEchoXunionsResponse,
2456                fidl::encoding::DefaultFuchsiaResourceDialect,
2457                0x3dc181909041a583,
2458            >(_buf?)?;
2459            Ok(_response.value)
2460        }
2461        self.client.send_query_and_decode::<EchoEchoXunionsRequest, Vec<AllTypesXunion>>(
2462            (value.as_mut(), forward_to_server),
2463            0x3dc181909041a583,
2464            fidl::encoding::DynamicFlags::empty(),
2465            _decode,
2466        )
2467    }
2468
2469    type EchoXunionsWithErrorResponseFut = fidl::client::QueryResponseFut<
2470        EchoEchoXunionsWithErrorResult,
2471        fidl::encoding::DefaultFuchsiaResourceDialect,
2472    >;
2473    fn r#echo_xunions_with_error(
2474        &self,
2475        mut value: Vec<AllTypesXunion>,
2476        mut result_err: DefaultEnum,
2477        mut forward_to_server: &str,
2478        mut result_variant: RespondWith,
2479    ) -> Self::EchoXunionsWithErrorResponseFut {
2480        fn _decode(
2481            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2482        ) -> Result<EchoEchoXunionsWithErrorResult, fidl::Error> {
2483            let _response = fidl::client::decode_transaction_body::<
2484                fidl::encoding::ResultType<EchoEchoXunionsWithErrorResponse, DefaultEnum>,
2485                fidl::encoding::DefaultFuchsiaResourceDialect,
2486                0x75184102667fa766,
2487            >(_buf?)?;
2488            Ok(_response.map(|x| x.value))
2489        }
2490        self.client.send_query_and_decode::<
2491            EchoEchoXunionsWithErrorRequest,
2492            EchoEchoXunionsWithErrorResult,
2493        >(
2494            (value.as_mut(), result_err, forward_to_server, result_variant,),
2495            0x75184102667fa766,
2496            fidl::encoding::DynamicFlags::empty(),
2497            _decode,
2498        )
2499    }
2500
2501    type EchoNamedStructResponseFut = fidl::client::QueryResponseFut<
2502        fidl_fidl_test_imported::SimpleStruct,
2503        fidl::encoding::DefaultFuchsiaResourceDialect,
2504    >;
2505    fn r#echo_named_struct(
2506        &self,
2507        mut value: &fidl_fidl_test_imported::SimpleStruct,
2508        mut forward_to_server: &str,
2509    ) -> Self::EchoNamedStructResponseFut {
2510        fn _decode(
2511            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2512        ) -> Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error> {
2513            let _response = fidl::client::decode_transaction_body::<
2514                fidl_fidl_test_imported::ResponseStruct,
2515                fidl::encoding::DefaultFuchsiaResourceDialect,
2516                0xf2d4aa9e65f7111,
2517            >(_buf?)?;
2518            Ok(_response.value)
2519        }
2520        self.client.send_query_and_decode::<
2521            fidl_fidl_test_imported::RequestStruct,
2522            fidl_fidl_test_imported::SimpleStruct,
2523        >(
2524            (value, forward_to_server,),
2525            0xf2d4aa9e65f7111,
2526            fidl::encoding::DynamicFlags::empty(),
2527            _decode,
2528        )
2529    }
2530
2531    type EchoNamedStructWithErrorResponseFut = fidl::client::QueryResponseFut<
2532        EchoEchoNamedStructWithErrorResult,
2533        fidl::encoding::DefaultFuchsiaResourceDialect,
2534    >;
2535    fn r#echo_named_struct_with_error(
2536        &self,
2537        mut value: &fidl_fidl_test_imported::SimpleStruct,
2538        mut result_err: u32,
2539        mut forward_to_server: &str,
2540        mut result_variant: fidl_fidl_test_imported::WantResponse,
2541    ) -> Self::EchoNamedStructWithErrorResponseFut {
2542        fn _decode(
2543            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2544        ) -> Result<EchoEchoNamedStructWithErrorResult, fidl::Error> {
2545            let _response = fidl::client::decode_transaction_body::<
2546                fidl::encoding::ResultType<fidl_fidl_test_imported::ResponseStruct, u32>,
2547                fidl::encoding::DefaultFuchsiaResourceDialect,
2548                0x5766fee9e74442e8,
2549            >(_buf?)?;
2550            Ok(_response.map(|x| x.value))
2551        }
2552        self.client.send_query_and_decode::<
2553            fidl_fidl_test_imported::ErrorableRequestStruct,
2554            EchoEchoNamedStructWithErrorResult,
2555        >(
2556            (value, result_err, forward_to_server, result_variant,),
2557            0x5766fee9e74442e8,
2558            fidl::encoding::DynamicFlags::empty(),
2559            _decode,
2560        )
2561    }
2562
2563    fn r#echo_named_struct_no_ret_val(
2564        &self,
2565        mut value: &fidl_fidl_test_imported::SimpleStruct,
2566        mut forward_to_server: &str,
2567    ) -> Result<(), fidl::Error> {
2568        self.client.send::<fidl_fidl_test_imported::EventTriggeringRequestStruct>(
2569            (value, forward_to_server),
2570            0x3a50bbf7d2113ad7,
2571            fidl::encoding::DynamicFlags::empty(),
2572        )
2573    }
2574
2575    type EchoTablePayloadResponseFut = fidl::client::QueryResponseFut<
2576        ResponseTable,
2577        fidl::encoding::DefaultFuchsiaResourceDialect,
2578    >;
2579    fn r#echo_table_payload(
2580        &self,
2581        mut payload: &RequestTable,
2582    ) -> Self::EchoTablePayloadResponseFut {
2583        fn _decode(
2584            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2585        ) -> Result<ResponseTable, fidl::Error> {
2586            let _response = fidl::client::decode_transaction_body::<
2587                ResponseTable,
2588                fidl::encoding::DefaultFuchsiaResourceDialect,
2589                0x641d98087378c003,
2590            >(_buf?)?;
2591            Ok(_response)
2592        }
2593        self.client.send_query_and_decode::<RequestTable, ResponseTable>(
2594            payload,
2595            0x641d98087378c003,
2596            fidl::encoding::DynamicFlags::empty(),
2597            _decode,
2598        )
2599    }
2600
2601    type EchoTablePayloadWithErrorResponseFut = fidl::client::QueryResponseFut<
2602        EchoEchoTablePayloadWithErrorResult,
2603        fidl::encoding::DefaultFuchsiaResourceDialect,
2604    >;
2605    fn r#echo_table_payload_with_error(
2606        &self,
2607        mut payload: &EchoEchoTablePayloadWithErrorRequest,
2608    ) -> Self::EchoTablePayloadWithErrorResponseFut {
2609        fn _decode(
2610            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2611        ) -> Result<EchoEchoTablePayloadWithErrorResult, fidl::Error> {
2612            let _response = fidl::client::decode_transaction_body::<
2613                fidl::encoding::ResultType<ResponseTable, DefaultEnum>,
2614                fidl::encoding::DefaultFuchsiaResourceDialect,
2615                0x636ed243761ab66d,
2616            >(_buf?)?;
2617            Ok(_response.map(|x| x))
2618        }
2619        self.client.send_query_and_decode::<
2620            EchoEchoTablePayloadWithErrorRequest,
2621            EchoEchoTablePayloadWithErrorResult,
2622        >(
2623            payload,
2624            0x636ed243761ab66d,
2625            fidl::encoding::DynamicFlags::empty(),
2626            _decode,
2627        )
2628    }
2629
2630    fn r#echo_table_payload_no_ret_val(
2631        &self,
2632        mut payload: &RequestTable,
2633    ) -> Result<(), fidl::Error> {
2634        self.client.send::<RequestTable>(
2635            payload,
2636            0x32961f7d718569f8,
2637            fidl::encoding::DynamicFlags::empty(),
2638        )
2639    }
2640
2641    type EchoUnionPayloadResponseFut = fidl::client::QueryResponseFut<
2642        ResponseUnion,
2643        fidl::encoding::DefaultFuchsiaResourceDialect,
2644    >;
2645    fn r#echo_union_payload(
2646        &self,
2647        mut payload: &RequestUnion,
2648    ) -> Self::EchoUnionPayloadResponseFut {
2649        fn _decode(
2650            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2651        ) -> Result<ResponseUnion, fidl::Error> {
2652            let _response = fidl::client::decode_transaction_body::<
2653                ResponseUnion,
2654                fidl::encoding::DefaultFuchsiaResourceDialect,
2655                0x66def9e793f10c55,
2656            >(_buf?)?;
2657            Ok(_response)
2658        }
2659        self.client.send_query_and_decode::<RequestUnion, ResponseUnion>(
2660            payload,
2661            0x66def9e793f10c55,
2662            fidl::encoding::DynamicFlags::empty(),
2663            _decode,
2664        )
2665    }
2666
2667    type EchoUnionPayloadWithErrorResponseFut = fidl::client::QueryResponseFut<
2668        EchoEchoUnionPayloadWithErrorResult,
2669        fidl::encoding::DefaultFuchsiaResourceDialect,
2670    >;
2671    fn r#echo_union_payload_with_error(
2672        &self,
2673        mut payload: &EchoEchoUnionPayloadWithErrorRequest,
2674    ) -> Self::EchoUnionPayloadWithErrorResponseFut {
2675        fn _decode(
2676            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2677        ) -> Result<EchoEchoUnionPayloadWithErrorResult, fidl::Error> {
2678            let _response = fidl::client::decode_transaction_body::<
2679                fidl::encoding::ResultType<ResponseUnion, DefaultEnum>,
2680                fidl::encoding::DefaultFuchsiaResourceDialect,
2681                0x1be890d6e68ef063,
2682            >(_buf?)?;
2683            Ok(_response.map(|x| x))
2684        }
2685        self.client.send_query_and_decode::<
2686            EchoEchoUnionPayloadWithErrorRequest,
2687            EchoEchoUnionPayloadWithErrorResult,
2688        >(
2689            payload,
2690            0x1be890d6e68ef063,
2691            fidl::encoding::DynamicFlags::empty(),
2692            _decode,
2693        )
2694    }
2695
2696    fn r#echo_union_payload_no_ret_val(
2697        &self,
2698        mut payload: &RequestUnion,
2699    ) -> Result<(), fidl::Error> {
2700        self.client.send::<RequestUnion>(
2701            payload,
2702            0x11518bf346430040,
2703            fidl::encoding::DynamicFlags::empty(),
2704        )
2705    }
2706}
2707
2708pub struct EchoEventStream {
2709    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
2710}
2711
2712impl std::marker::Unpin for EchoEventStream {}
2713
2714impl futures::stream::FusedStream for EchoEventStream {
2715    fn is_terminated(&self) -> bool {
2716        self.event_receiver.is_terminated()
2717    }
2718}
2719
2720impl futures::Stream for EchoEventStream {
2721    type Item = Result<EchoEvent, fidl::Error>;
2722
2723    fn poll_next(
2724        mut self: std::pin::Pin<&mut Self>,
2725        cx: &mut std::task::Context<'_>,
2726    ) -> std::task::Poll<Option<Self::Item>> {
2727        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
2728            &mut self.event_receiver,
2729            cx
2730        )?) {
2731            Some(buf) => std::task::Poll::Ready(Some(EchoEvent::decode(buf))),
2732            None => std::task::Poll::Ready(None),
2733        }
2734    }
2735}
2736
2737#[derive(Debug)]
2738pub enum EchoEvent {
2739    EchoMinimalEvent {},
2740    EchoEvent { value: Struct },
2741    OnEchoNamedEvent { value: fidl_fidl_test_imported::SimpleStruct },
2742    OnEchoTablePayloadEvent { payload: ResponseTable },
2743    OnEchoUnionPayloadEvent { payload: ResponseUnion },
2744}
2745
2746impl EchoEvent {
2747    #[allow(irrefutable_let_patterns)]
2748    pub fn into_echo_minimal_event(self) -> Option<()> {
2749        if let EchoEvent::EchoMinimalEvent {} = self { Some(()) } else { None }
2750    }
2751    #[allow(irrefutable_let_patterns)]
2752    pub fn into_echo_event(self) -> Option<Struct> {
2753        if let EchoEvent::EchoEvent { value } = self { Some((value)) } else { None }
2754    }
2755    #[allow(irrefutable_let_patterns)]
2756    pub fn into_on_echo_named_event(self) -> Option<fidl_fidl_test_imported::SimpleStruct> {
2757        if let EchoEvent::OnEchoNamedEvent { value } = self { Some((value)) } else { None }
2758    }
2759    #[allow(irrefutable_let_patterns)]
2760    pub fn into_on_echo_table_payload_event(self) -> Option<ResponseTable> {
2761        if let EchoEvent::OnEchoTablePayloadEvent { payload } = self {
2762            Some((payload))
2763        } else {
2764            None
2765        }
2766    }
2767    #[allow(irrefutable_let_patterns)]
2768    pub fn into_on_echo_union_payload_event(self) -> Option<ResponseUnion> {
2769        if let EchoEvent::OnEchoUnionPayloadEvent { payload } = self {
2770            Some((payload))
2771        } else {
2772            None
2773        }
2774    }
2775
2776    /// Decodes a message buffer as a [`EchoEvent`].
2777    fn decode(
2778        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
2779    ) -> Result<EchoEvent, fidl::Error> {
2780        let (bytes, _handles) = buf.split_mut();
2781        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
2782        debug_assert_eq!(tx_header.tx_id, 0);
2783        match tx_header.ordinal {
2784            0x273b2029f1a0aee2 => {
2785                let mut out = fidl::new_empty!(
2786                    fidl::encoding::EmptyPayload,
2787                    fidl::encoding::DefaultFuchsiaResourceDialect
2788                );
2789                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&tx_header, _body_bytes, _handles, &mut out)?;
2790                Ok((EchoEvent::EchoMinimalEvent {}))
2791            }
2792            0x1219e12e0450024 => {
2793                let mut out = fidl::new_empty!(
2794                    EchoEchoEventRequest,
2795                    fidl::encoding::DefaultFuchsiaResourceDialect
2796                );
2797                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoEventRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
2798                Ok((EchoEvent::EchoEvent { value: out.value }))
2799            }
2800            0x749ebde83348a374 => {
2801                let mut out = fidl::new_empty!(
2802                    fidl_fidl_test_imported::ResponseStruct,
2803                    fidl::encoding::DefaultFuchsiaResourceDialect
2804                );
2805                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::ResponseStruct>(&tx_header, _body_bytes, _handles, &mut out)?;
2806                Ok((EchoEvent::OnEchoNamedEvent { value: out.value }))
2807            }
2808            0x708dddea1cb98430 => {
2809                let mut out =
2810                    fidl::new_empty!(ResponseTable, fidl::encoding::DefaultFuchsiaResourceDialect);
2811                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ResponseTable>(&tx_header, _body_bytes, _handles, &mut out)?;
2812                Ok((EchoEvent::OnEchoTablePayloadEvent { payload: out }))
2813            }
2814            0x642f4c265a05f4c0 => {
2815                let mut out =
2816                    fidl::new_empty!(ResponseUnion, fidl::encoding::DefaultFuchsiaResourceDialect);
2817                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ResponseUnion>(&tx_header, _body_bytes, _handles, &mut out)?;
2818                Ok((EchoEvent::OnEchoUnionPayloadEvent { payload: out }))
2819            }
2820            _ => Err(fidl::Error::UnknownOrdinal {
2821                ordinal: tx_header.ordinal,
2822                protocol_name: <EchoMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
2823            }),
2824        }
2825    }
2826}
2827
2828/// A Stream of incoming requests for fidl.test.compatibility/Echo.
2829pub struct EchoRequestStream {
2830    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
2831    is_terminated: bool,
2832}
2833
2834impl std::marker::Unpin for EchoRequestStream {}
2835
2836impl futures::stream::FusedStream for EchoRequestStream {
2837    fn is_terminated(&self) -> bool {
2838        self.is_terminated
2839    }
2840}
2841
2842impl fidl::endpoints::RequestStream for EchoRequestStream {
2843    type Protocol = EchoMarker;
2844    type ControlHandle = EchoControlHandle;
2845
2846    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
2847        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
2848    }
2849
2850    fn control_handle(&self) -> Self::ControlHandle {
2851        EchoControlHandle { inner: self.inner.clone() }
2852    }
2853
2854    fn into_inner(
2855        self,
2856    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
2857    {
2858        (self.inner, self.is_terminated)
2859    }
2860
2861    fn from_inner(
2862        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
2863        is_terminated: bool,
2864    ) -> Self {
2865        Self { inner, is_terminated }
2866    }
2867}
2868
2869impl futures::Stream for EchoRequestStream {
2870    type Item = Result<EchoRequest, fidl::Error>;
2871
2872    fn poll_next(
2873        mut self: std::pin::Pin<&mut Self>,
2874        cx: &mut std::task::Context<'_>,
2875    ) -> std::task::Poll<Option<Self::Item>> {
2876        let this = &mut *self;
2877        if this.inner.check_shutdown(cx) {
2878            this.is_terminated = true;
2879            return std::task::Poll::Ready(None);
2880        }
2881        if this.is_terminated {
2882            panic!("polled EchoRequestStream after completion");
2883        }
2884        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
2885            |bytes, handles| {
2886                match this.inner.channel().read_etc(cx, bytes, handles) {
2887                    std::task::Poll::Ready(Ok(())) => {}
2888                    std::task::Poll::Pending => return std::task::Poll::Pending,
2889                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
2890                        this.is_terminated = true;
2891                        return std::task::Poll::Ready(None);
2892                    }
2893                    std::task::Poll::Ready(Err(e)) => {
2894                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
2895                            e.into(),
2896                        ))));
2897                    }
2898                }
2899
2900                // A message has been received from the channel
2901                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
2902
2903                std::task::Poll::Ready(Some(match header.ordinal {
2904                    0x1d545c738c7a8ee => {
2905                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2906                        let mut req = fidl::new_empty!(
2907                            fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
2908                            fidl::encoding::DefaultFuchsiaResourceDialect
2909                        );
2910                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest>(&header, _body_bytes, handles, &mut req)?;
2911                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
2912                        Ok(EchoRequest::EchoTableRequestComposed {
2913                            payload: req,
2914                            responder: EchoEchoTableRequestComposedResponder {
2915                                control_handle: std::mem::ManuallyDrop::new(control_handle),
2916                                tx_id: header.tx_id,
2917                            },
2918                        })
2919                    }
2920                    0x38a67e88d6106443 => {
2921                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2922                        let mut req = fidl::new_empty!(fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
2923                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedRequest>(&header, _body_bytes, handles, &mut req)?;
2924                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
2925                        Ok(EchoRequest::EchoUnionResponseWithErrorComposed {
2926                            value: req.value,
2927                            want_absolute_value: req.want_absolute_value,
2928                            forward_to_server: req.forward_to_server,
2929                            result_err: req.result_err,
2930                            result_variant: req.result_variant,
2931
2932                            responder: EchoEchoUnionResponseWithErrorComposedResponder {
2933                                control_handle: std::mem::ManuallyDrop::new(control_handle),
2934                                tx_id: header.tx_id,
2935                            },
2936                        })
2937                    }
2938                    0x39edd68c837482ec => {
2939                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2940                        let mut req = fidl::new_empty!(
2941                            EchoEchoMinimalRequest,
2942                            fidl::encoding::DefaultFuchsiaResourceDialect
2943                        );
2944                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoMinimalRequest>(&header, _body_bytes, handles, &mut req)?;
2945                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
2946                        Ok(EchoRequest::EchoMinimal {
2947                            forward_to_server: req.forward_to_server,
2948
2949                            responder: EchoEchoMinimalResponder {
2950                                control_handle: std::mem::ManuallyDrop::new(control_handle),
2951                                tx_id: header.tx_id,
2952                            },
2953                        })
2954                    }
2955                    0x36f4695996e35acc => {
2956                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2957                        let mut req = fidl::new_empty!(
2958                            EchoEchoMinimalWithErrorRequest,
2959                            fidl::encoding::DefaultFuchsiaResourceDialect
2960                        );
2961                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoMinimalWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
2962                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
2963                        Ok(EchoRequest::EchoMinimalWithError {
2964                            forward_to_server: req.forward_to_server,
2965                            result_variant: req.result_variant,
2966
2967                            responder: EchoEchoMinimalWithErrorResponder {
2968                                control_handle: std::mem::ManuallyDrop::new(control_handle),
2969                                tx_id: header.tx_id,
2970                            },
2971                        })
2972                    }
2973                    0x42693c143e2c3694 => {
2974                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
2975                        let mut req = fidl::new_empty!(
2976                            EchoEchoMinimalNoRetValRequest,
2977                            fidl::encoding::DefaultFuchsiaResourceDialect
2978                        );
2979                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoMinimalNoRetValRequest>(&header, _body_bytes, handles, &mut req)?;
2980                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
2981                        Ok(EchoRequest::EchoMinimalNoRetVal {
2982                            forward_to_server: req.forward_to_server,
2983
2984                            control_handle,
2985                        })
2986                    }
2987                    0x4c2f85818cc53f37 => {
2988                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2989                        let mut req = fidl::new_empty!(
2990                            EchoEchoStructRequest,
2991                            fidl::encoding::DefaultFuchsiaResourceDialect
2992                        );
2993                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoStructRequest>(&header, _body_bytes, handles, &mut req)?;
2994                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
2995                        Ok(EchoRequest::EchoStruct {
2996                            value: req.value,
2997                            forward_to_server: req.forward_to_server,
2998
2999                            responder: EchoEchoStructResponder {
3000                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3001                                tx_id: header.tx_id,
3002                            },
3003                        })
3004                    }
3005                    0x46cb32652c4c0899 => {
3006                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3007                        let mut req = fidl::new_empty!(
3008                            EchoEchoStructWithErrorRequest,
3009                            fidl::encoding::DefaultFuchsiaResourceDialect
3010                        );
3011                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoStructWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3012                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3013                        Ok(EchoRequest::EchoStructWithError {
3014                            value: req.value,
3015                            result_err: req.result_err,
3016                            forward_to_server: req.forward_to_server,
3017                            result_variant: req.result_variant,
3018
3019                            responder: EchoEchoStructWithErrorResponder {
3020                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3021                                tx_id: header.tx_id,
3022                            },
3023                        })
3024                    }
3025                    0x1f763e602cf5892a => {
3026                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
3027                        let mut req = fidl::new_empty!(
3028                            EchoEchoStructNoRetValRequest,
3029                            fidl::encoding::DefaultFuchsiaResourceDialect
3030                        );
3031                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoStructNoRetValRequest>(&header, _body_bytes, handles, &mut req)?;
3032                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3033                        Ok(EchoRequest::EchoStructNoRetVal {
3034                            value: req.value,
3035                            forward_to_server: req.forward_to_server,
3036
3037                            control_handle,
3038                        })
3039                    }
3040                    0x1b6019d5611f2470 => {
3041                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3042                        let mut req = fidl::new_empty!(
3043                            EchoEchoArraysRequest,
3044                            fidl::encoding::DefaultFuchsiaResourceDialect
3045                        );
3046                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoArraysRequest>(&header, _body_bytes, handles, &mut req)?;
3047                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3048                        Ok(EchoRequest::EchoArrays {
3049                            value: req.value,
3050                            forward_to_server: req.forward_to_server,
3051
3052                            responder: EchoEchoArraysResponder {
3053                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3054                                tx_id: header.tx_id,
3055                            },
3056                        })
3057                    }
3058                    0x6dbf26e67e253afa => {
3059                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3060                        let mut req = fidl::new_empty!(
3061                            EchoEchoArraysWithErrorRequest,
3062                            fidl::encoding::DefaultFuchsiaResourceDialect
3063                        );
3064                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoArraysWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3065                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3066                        Ok(EchoRequest::EchoArraysWithError {
3067                            value: req.value,
3068                            result_err: req.result_err,
3069                            forward_to_server: req.forward_to_server,
3070                            result_variant: req.result_variant,
3071
3072                            responder: EchoEchoArraysWithErrorResponder {
3073                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3074                                tx_id: header.tx_id,
3075                            },
3076                        })
3077                    }
3078                    0x1582623f0d9f6e5e => {
3079                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3080                        let mut req = fidl::new_empty!(
3081                            EchoEchoVectorsRequest,
3082                            fidl::encoding::DefaultFuchsiaResourceDialect
3083                        );
3084                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoVectorsRequest>(&header, _body_bytes, handles, &mut req)?;
3085                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3086                        Ok(EchoRequest::EchoVectors {
3087                            value: req.value,
3088                            forward_to_server: req.forward_to_server,
3089
3090                            responder: EchoEchoVectorsResponder {
3091                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3092                                tx_id: header.tx_id,
3093                            },
3094                        })
3095                    }
3096                    0x730f163401e2b3e5 => {
3097                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3098                        let mut req = fidl::new_empty!(
3099                            EchoEchoVectorsWithErrorRequest,
3100                            fidl::encoding::DefaultFuchsiaResourceDialect
3101                        );
3102                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoVectorsWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3103                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3104                        Ok(EchoRequest::EchoVectorsWithError {
3105                            value: req.value,
3106                            result_err: req.result_err,
3107                            forward_to_server: req.forward_to_server,
3108                            result_variant: req.result_variant,
3109
3110                            responder: EchoEchoVectorsWithErrorResponder {
3111                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3112                                tx_id: header.tx_id,
3113                            },
3114                        })
3115                    }
3116                    0x4f1fb0a512f47c4b => {
3117                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3118                        let mut req = fidl::new_empty!(
3119                            EchoEchoTableRequest,
3120                            fidl::encoding::DefaultFuchsiaResourceDialect
3121                        );
3122                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoTableRequest>(&header, _body_bytes, handles, &mut req)?;
3123                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3124                        Ok(EchoRequest::EchoTable {
3125                            value: req.value,
3126                            forward_to_server: req.forward_to_server,
3127
3128                            responder: EchoEchoTableResponder {
3129                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3130                                tx_id: header.tx_id,
3131                            },
3132                        })
3133                    }
3134                    0x44e835cb1eb9a931 => {
3135                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3136                        let mut req = fidl::new_empty!(
3137                            EchoEchoTableWithErrorRequest,
3138                            fidl::encoding::DefaultFuchsiaResourceDialect
3139                        );
3140                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoTableWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3141                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3142                        Ok(EchoRequest::EchoTableWithError {
3143                            value: req.value,
3144                            result_err: req.result_err,
3145                            forward_to_server: req.forward_to_server,
3146                            result_variant: req.result_variant,
3147
3148                            responder: EchoEchoTableWithErrorResponder {
3149                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3150                                tx_id: header.tx_id,
3151                            },
3152                        })
3153                    }
3154                    0x3dc181909041a583 => {
3155                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3156                        let mut req = fidl::new_empty!(
3157                            EchoEchoXunionsRequest,
3158                            fidl::encoding::DefaultFuchsiaResourceDialect
3159                        );
3160                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoXunionsRequest>(&header, _body_bytes, handles, &mut req)?;
3161                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3162                        Ok(EchoRequest::EchoXunions {
3163                            value: req.value,
3164                            forward_to_server: req.forward_to_server,
3165
3166                            responder: EchoEchoXunionsResponder {
3167                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3168                                tx_id: header.tx_id,
3169                            },
3170                        })
3171                    }
3172                    0x75184102667fa766 => {
3173                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3174                        let mut req = fidl::new_empty!(
3175                            EchoEchoXunionsWithErrorRequest,
3176                            fidl::encoding::DefaultFuchsiaResourceDialect
3177                        );
3178                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoXunionsWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3179                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3180                        Ok(EchoRequest::EchoXunionsWithError {
3181                            value: req.value,
3182                            result_err: req.result_err,
3183                            forward_to_server: req.forward_to_server,
3184                            result_variant: req.result_variant,
3185
3186                            responder: EchoEchoXunionsWithErrorResponder {
3187                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3188                                tx_id: header.tx_id,
3189                            },
3190                        })
3191                    }
3192                    0xf2d4aa9e65f7111 => {
3193                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3194                        let mut req = fidl::new_empty!(
3195                            fidl_fidl_test_imported::RequestStruct,
3196                            fidl::encoding::DefaultFuchsiaResourceDialect
3197                        );
3198                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::RequestStruct>(&header, _body_bytes, handles, &mut req)?;
3199                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3200                        Ok(EchoRequest::EchoNamedStruct {
3201                            value: req.value,
3202                            forward_to_server: req.forward_to_server,
3203
3204                            responder: EchoEchoNamedStructResponder {
3205                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3206                                tx_id: header.tx_id,
3207                            },
3208                        })
3209                    }
3210                    0x5766fee9e74442e8 => {
3211                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3212                        let mut req = fidl::new_empty!(
3213                            fidl_fidl_test_imported::ErrorableRequestStruct,
3214                            fidl::encoding::DefaultFuchsiaResourceDialect
3215                        );
3216                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::ErrorableRequestStruct>(&header, _body_bytes, handles, &mut req)?;
3217                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3218                        Ok(EchoRequest::EchoNamedStructWithError {
3219                            value: req.value,
3220                            result_err: req.result_err,
3221                            forward_to_server: req.forward_to_server,
3222                            result_variant: req.result_variant,
3223
3224                            responder: EchoEchoNamedStructWithErrorResponder {
3225                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3226                                tx_id: header.tx_id,
3227                            },
3228                        })
3229                    }
3230                    0x3a50bbf7d2113ad7 => {
3231                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
3232                        let mut req = fidl::new_empty!(
3233                            fidl_fidl_test_imported::EventTriggeringRequestStruct,
3234                            fidl::encoding::DefaultFuchsiaResourceDialect
3235                        );
3236                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::EventTriggeringRequestStruct>(&header, _body_bytes, handles, &mut req)?;
3237                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3238                        Ok(EchoRequest::EchoNamedStructNoRetVal {
3239                            value: req.value,
3240                            forward_to_server: req.forward_to_server,
3241
3242                            control_handle,
3243                        })
3244                    }
3245                    0x641d98087378c003 => {
3246                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3247                        let mut req = fidl::new_empty!(
3248                            RequestTable,
3249                            fidl::encoding::DefaultFuchsiaResourceDialect
3250                        );
3251                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RequestTable>(&header, _body_bytes, handles, &mut req)?;
3252                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3253                        Ok(EchoRequest::EchoTablePayload {
3254                            payload: req,
3255                            responder: EchoEchoTablePayloadResponder {
3256                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3257                                tx_id: header.tx_id,
3258                            },
3259                        })
3260                    }
3261                    0x636ed243761ab66d => {
3262                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3263                        let mut req = fidl::new_empty!(
3264                            EchoEchoTablePayloadWithErrorRequest,
3265                            fidl::encoding::DefaultFuchsiaResourceDialect
3266                        );
3267                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoTablePayloadWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3268                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3269                        Ok(EchoRequest::EchoTablePayloadWithError {
3270                            payload: req,
3271                            responder: EchoEchoTablePayloadWithErrorResponder {
3272                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3273                                tx_id: header.tx_id,
3274                            },
3275                        })
3276                    }
3277                    0x32961f7d718569f8 => {
3278                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
3279                        let mut req = fidl::new_empty!(
3280                            RequestTable,
3281                            fidl::encoding::DefaultFuchsiaResourceDialect
3282                        );
3283                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RequestTable>(&header, _body_bytes, handles, &mut req)?;
3284                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3285                        Ok(EchoRequest::EchoTablePayloadNoRetVal { payload: req, control_handle })
3286                    }
3287                    0x66def9e793f10c55 => {
3288                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3289                        let mut req = fidl::new_empty!(
3290                            RequestUnion,
3291                            fidl::encoding::DefaultFuchsiaResourceDialect
3292                        );
3293                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RequestUnion>(&header, _body_bytes, handles, &mut req)?;
3294                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3295                        Ok(EchoRequest::EchoUnionPayload {
3296                            payload: req,
3297                            responder: EchoEchoUnionPayloadResponder {
3298                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3299                                tx_id: header.tx_id,
3300                            },
3301                        })
3302                    }
3303                    0x1be890d6e68ef063 => {
3304                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3305                        let mut req = fidl::new_empty!(
3306                            EchoEchoUnionPayloadWithErrorRequest,
3307                            fidl::encoding::DefaultFuchsiaResourceDialect
3308                        );
3309                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoUnionPayloadWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3310                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3311                        Ok(EchoRequest::EchoUnionPayloadWithError {
3312                            payload: req,
3313                            responder: EchoEchoUnionPayloadWithErrorResponder {
3314                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3315                                tx_id: header.tx_id,
3316                            },
3317                        })
3318                    }
3319                    0x11518bf346430040 => {
3320                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
3321                        let mut req = fidl::new_empty!(
3322                            RequestUnion,
3323                            fidl::encoding::DefaultFuchsiaResourceDialect
3324                        );
3325                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RequestUnion>(&header, _body_bytes, handles, &mut req)?;
3326                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3327                        Ok(EchoRequest::EchoUnionPayloadNoRetVal { payload: req, control_handle })
3328                    }
3329                    _ => Err(fidl::Error::UnknownOrdinal {
3330                        ordinal: header.ordinal,
3331                        protocol_name: <EchoMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
3332                    }),
3333                }))
3334            },
3335        )
3336    }
3337}
3338
3339#[derive(Debug)]
3340pub enum EchoRequest {
3341    EchoTableRequestComposed {
3342        payload: fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
3343        responder: EchoEchoTableRequestComposedResponder,
3344    },
3345    EchoUnionResponseWithErrorComposed {
3346        value: i64,
3347        want_absolute_value: bool,
3348        forward_to_server: String,
3349        result_err: u32,
3350        result_variant: fidl_fidl_test_imported::WantResponse,
3351        responder: EchoEchoUnionResponseWithErrorComposedResponder,
3352    },
3353    EchoMinimal {
3354        forward_to_server: String,
3355        responder: EchoEchoMinimalResponder,
3356    },
3357    EchoMinimalWithError {
3358        forward_to_server: String,
3359        result_variant: RespondWith,
3360        responder: EchoEchoMinimalWithErrorResponder,
3361    },
3362    EchoMinimalNoRetVal {
3363        forward_to_server: String,
3364        control_handle: EchoControlHandle,
3365    },
3366    EchoStruct {
3367        value: Struct,
3368        forward_to_server: String,
3369        responder: EchoEchoStructResponder,
3370    },
3371    EchoStructWithError {
3372        value: Struct,
3373        result_err: DefaultEnum,
3374        forward_to_server: String,
3375        result_variant: RespondWith,
3376        responder: EchoEchoStructWithErrorResponder,
3377    },
3378    EchoStructNoRetVal {
3379        value: Struct,
3380        forward_to_server: String,
3381        control_handle: EchoControlHandle,
3382    },
3383    EchoArrays {
3384        value: ArraysStruct,
3385        forward_to_server: String,
3386        responder: EchoEchoArraysResponder,
3387    },
3388    EchoArraysWithError {
3389        value: ArraysStruct,
3390        result_err: DefaultEnum,
3391        forward_to_server: String,
3392        result_variant: RespondWith,
3393        responder: EchoEchoArraysWithErrorResponder,
3394    },
3395    EchoVectors {
3396        value: VectorsStruct,
3397        forward_to_server: String,
3398        responder: EchoEchoVectorsResponder,
3399    },
3400    EchoVectorsWithError {
3401        value: VectorsStruct,
3402        result_err: DefaultEnum,
3403        forward_to_server: String,
3404        result_variant: RespondWith,
3405        responder: EchoEchoVectorsWithErrorResponder,
3406    },
3407    EchoTable {
3408        value: AllTypesTable,
3409        forward_to_server: String,
3410        responder: EchoEchoTableResponder,
3411    },
3412    EchoTableWithError {
3413        value: AllTypesTable,
3414        result_err: DefaultEnum,
3415        forward_to_server: String,
3416        result_variant: RespondWith,
3417        responder: EchoEchoTableWithErrorResponder,
3418    },
3419    EchoXunions {
3420        value: Vec<AllTypesXunion>,
3421        forward_to_server: String,
3422        responder: EchoEchoXunionsResponder,
3423    },
3424    EchoXunionsWithError {
3425        value: Vec<AllTypesXunion>,
3426        result_err: DefaultEnum,
3427        forward_to_server: String,
3428        result_variant: RespondWith,
3429        responder: EchoEchoXunionsWithErrorResponder,
3430    },
3431    EchoNamedStruct {
3432        value: fidl_fidl_test_imported::SimpleStruct,
3433        forward_to_server: String,
3434        responder: EchoEchoNamedStructResponder,
3435    },
3436    EchoNamedStructWithError {
3437        value: fidl_fidl_test_imported::SimpleStruct,
3438        result_err: u32,
3439        forward_to_server: String,
3440        result_variant: fidl_fidl_test_imported::WantResponse,
3441        responder: EchoEchoNamedStructWithErrorResponder,
3442    },
3443    EchoNamedStructNoRetVal {
3444        value: fidl_fidl_test_imported::SimpleStruct,
3445        forward_to_server: String,
3446        control_handle: EchoControlHandle,
3447    },
3448    EchoTablePayload {
3449        payload: RequestTable,
3450        responder: EchoEchoTablePayloadResponder,
3451    },
3452    EchoTablePayloadWithError {
3453        payload: EchoEchoTablePayloadWithErrorRequest,
3454        responder: EchoEchoTablePayloadWithErrorResponder,
3455    },
3456    EchoTablePayloadNoRetVal {
3457        payload: RequestTable,
3458        control_handle: EchoControlHandle,
3459    },
3460    EchoUnionPayload {
3461        payload: RequestUnion,
3462        responder: EchoEchoUnionPayloadResponder,
3463    },
3464    EchoUnionPayloadWithError {
3465        payload: EchoEchoUnionPayloadWithErrorRequest,
3466        responder: EchoEchoUnionPayloadWithErrorResponder,
3467    },
3468    EchoUnionPayloadNoRetVal {
3469        payload: RequestUnion,
3470        control_handle: EchoControlHandle,
3471    },
3472}
3473
3474impl EchoRequest {
3475    #[allow(irrefutable_let_patterns)]
3476    pub fn into_echo_table_request_composed(
3477        self,
3478    ) -> Option<(
3479        fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
3480        EchoEchoTableRequestComposedResponder,
3481    )> {
3482        if let EchoRequest::EchoTableRequestComposed { payload, responder } = self {
3483            Some((payload, responder))
3484        } else {
3485            None
3486        }
3487    }
3488
3489    #[allow(irrefutable_let_patterns)]
3490    pub fn into_echo_union_response_with_error_composed(
3491        self,
3492    ) -> Option<(
3493        i64,
3494        bool,
3495        String,
3496        u32,
3497        fidl_fidl_test_imported::WantResponse,
3498        EchoEchoUnionResponseWithErrorComposedResponder,
3499    )> {
3500        if let EchoRequest::EchoUnionResponseWithErrorComposed {
3501            value,
3502            want_absolute_value,
3503            forward_to_server,
3504            result_err,
3505            result_variant,
3506            responder,
3507        } = self
3508        {
3509            Some((
3510                value,
3511                want_absolute_value,
3512                forward_to_server,
3513                result_err,
3514                result_variant,
3515                responder,
3516            ))
3517        } else {
3518            None
3519        }
3520    }
3521
3522    #[allow(irrefutable_let_patterns)]
3523    pub fn into_echo_minimal(self) -> Option<(String, EchoEchoMinimalResponder)> {
3524        if let EchoRequest::EchoMinimal { forward_to_server, responder } = self {
3525            Some((forward_to_server, responder))
3526        } else {
3527            None
3528        }
3529    }
3530
3531    #[allow(irrefutable_let_patterns)]
3532    pub fn into_echo_minimal_with_error(
3533        self,
3534    ) -> Option<(String, RespondWith, EchoEchoMinimalWithErrorResponder)> {
3535        if let EchoRequest::EchoMinimalWithError { forward_to_server, result_variant, responder } =
3536            self
3537        {
3538            Some((forward_to_server, result_variant, responder))
3539        } else {
3540            None
3541        }
3542    }
3543
3544    #[allow(irrefutable_let_patterns)]
3545    pub fn into_echo_minimal_no_ret_val(self) -> Option<(String, EchoControlHandle)> {
3546        if let EchoRequest::EchoMinimalNoRetVal { forward_to_server, control_handle } = self {
3547            Some((forward_to_server, control_handle))
3548        } else {
3549            None
3550        }
3551    }
3552
3553    #[allow(irrefutable_let_patterns)]
3554    pub fn into_echo_struct(self) -> Option<(Struct, String, EchoEchoStructResponder)> {
3555        if let EchoRequest::EchoStruct { value, forward_to_server, responder } = self {
3556            Some((value, forward_to_server, responder))
3557        } else {
3558            None
3559        }
3560    }
3561
3562    #[allow(irrefutable_let_patterns)]
3563    pub fn into_echo_struct_with_error(
3564        self,
3565    ) -> Option<(Struct, DefaultEnum, String, RespondWith, EchoEchoStructWithErrorResponder)> {
3566        if let EchoRequest::EchoStructWithError {
3567            value,
3568            result_err,
3569            forward_to_server,
3570            result_variant,
3571            responder,
3572        } = self
3573        {
3574            Some((value, result_err, forward_to_server, result_variant, responder))
3575        } else {
3576            None
3577        }
3578    }
3579
3580    #[allow(irrefutable_let_patterns)]
3581    pub fn into_echo_struct_no_ret_val(self) -> Option<(Struct, String, EchoControlHandle)> {
3582        if let EchoRequest::EchoStructNoRetVal { value, forward_to_server, control_handle } = self {
3583            Some((value, forward_to_server, control_handle))
3584        } else {
3585            None
3586        }
3587    }
3588
3589    #[allow(irrefutable_let_patterns)]
3590    pub fn into_echo_arrays(self) -> Option<(ArraysStruct, String, EchoEchoArraysResponder)> {
3591        if let EchoRequest::EchoArrays { value, forward_to_server, responder } = self {
3592            Some((value, forward_to_server, responder))
3593        } else {
3594            None
3595        }
3596    }
3597
3598    #[allow(irrefutable_let_patterns)]
3599    pub fn into_echo_arrays_with_error(
3600        self,
3601    ) -> Option<(ArraysStruct, DefaultEnum, String, RespondWith, EchoEchoArraysWithErrorResponder)>
3602    {
3603        if let EchoRequest::EchoArraysWithError {
3604            value,
3605            result_err,
3606            forward_to_server,
3607            result_variant,
3608            responder,
3609        } = self
3610        {
3611            Some((value, result_err, forward_to_server, result_variant, responder))
3612        } else {
3613            None
3614        }
3615    }
3616
3617    #[allow(irrefutable_let_patterns)]
3618    pub fn into_echo_vectors(self) -> Option<(VectorsStruct, String, EchoEchoVectorsResponder)> {
3619        if let EchoRequest::EchoVectors { value, forward_to_server, responder } = self {
3620            Some((value, forward_to_server, responder))
3621        } else {
3622            None
3623        }
3624    }
3625
3626    #[allow(irrefutable_let_patterns)]
3627    pub fn into_echo_vectors_with_error(
3628        self,
3629    ) -> Option<(VectorsStruct, DefaultEnum, String, RespondWith, EchoEchoVectorsWithErrorResponder)>
3630    {
3631        if let EchoRequest::EchoVectorsWithError {
3632            value,
3633            result_err,
3634            forward_to_server,
3635            result_variant,
3636            responder,
3637        } = self
3638        {
3639            Some((value, result_err, forward_to_server, result_variant, responder))
3640        } else {
3641            None
3642        }
3643    }
3644
3645    #[allow(irrefutable_let_patterns)]
3646    pub fn into_echo_table(self) -> Option<(AllTypesTable, String, EchoEchoTableResponder)> {
3647        if let EchoRequest::EchoTable { value, forward_to_server, responder } = self {
3648            Some((value, forward_to_server, responder))
3649        } else {
3650            None
3651        }
3652    }
3653
3654    #[allow(irrefutable_let_patterns)]
3655    pub fn into_echo_table_with_error(
3656        self,
3657    ) -> Option<(AllTypesTable, DefaultEnum, String, RespondWith, EchoEchoTableWithErrorResponder)>
3658    {
3659        if let EchoRequest::EchoTableWithError {
3660            value,
3661            result_err,
3662            forward_to_server,
3663            result_variant,
3664            responder,
3665        } = self
3666        {
3667            Some((value, result_err, forward_to_server, result_variant, responder))
3668        } else {
3669            None
3670        }
3671    }
3672
3673    #[allow(irrefutable_let_patterns)]
3674    pub fn into_echo_xunions(
3675        self,
3676    ) -> Option<(Vec<AllTypesXunion>, String, EchoEchoXunionsResponder)> {
3677        if let EchoRequest::EchoXunions { value, forward_to_server, responder } = self {
3678            Some((value, forward_to_server, responder))
3679        } else {
3680            None
3681        }
3682    }
3683
3684    #[allow(irrefutable_let_patterns)]
3685    pub fn into_echo_xunions_with_error(
3686        self,
3687    ) -> Option<(
3688        Vec<AllTypesXunion>,
3689        DefaultEnum,
3690        String,
3691        RespondWith,
3692        EchoEchoXunionsWithErrorResponder,
3693    )> {
3694        if let EchoRequest::EchoXunionsWithError {
3695            value,
3696            result_err,
3697            forward_to_server,
3698            result_variant,
3699            responder,
3700        } = self
3701        {
3702            Some((value, result_err, forward_to_server, result_variant, responder))
3703        } else {
3704            None
3705        }
3706    }
3707
3708    #[allow(irrefutable_let_patterns)]
3709    pub fn into_echo_named_struct(
3710        self,
3711    ) -> Option<(fidl_fidl_test_imported::SimpleStruct, String, EchoEchoNamedStructResponder)> {
3712        if let EchoRequest::EchoNamedStruct { value, forward_to_server, responder } = self {
3713            Some((value, forward_to_server, responder))
3714        } else {
3715            None
3716        }
3717    }
3718
3719    #[allow(irrefutable_let_patterns)]
3720    pub fn into_echo_named_struct_with_error(
3721        self,
3722    ) -> Option<(
3723        fidl_fidl_test_imported::SimpleStruct,
3724        u32,
3725        String,
3726        fidl_fidl_test_imported::WantResponse,
3727        EchoEchoNamedStructWithErrorResponder,
3728    )> {
3729        if let EchoRequest::EchoNamedStructWithError {
3730            value,
3731            result_err,
3732            forward_to_server,
3733            result_variant,
3734            responder,
3735        } = self
3736        {
3737            Some((value, result_err, forward_to_server, result_variant, responder))
3738        } else {
3739            None
3740        }
3741    }
3742
3743    #[allow(irrefutable_let_patterns)]
3744    pub fn into_echo_named_struct_no_ret_val(
3745        self,
3746    ) -> Option<(fidl_fidl_test_imported::SimpleStruct, String, EchoControlHandle)> {
3747        if let EchoRequest::EchoNamedStructNoRetVal { value, forward_to_server, control_handle } =
3748            self
3749        {
3750            Some((value, forward_to_server, control_handle))
3751        } else {
3752            None
3753        }
3754    }
3755
3756    #[allow(irrefutable_let_patterns)]
3757    pub fn into_echo_table_payload(self) -> Option<(RequestTable, EchoEchoTablePayloadResponder)> {
3758        if let EchoRequest::EchoTablePayload { payload, responder } = self {
3759            Some((payload, responder))
3760        } else {
3761            None
3762        }
3763    }
3764
3765    #[allow(irrefutable_let_patterns)]
3766    pub fn into_echo_table_payload_with_error(
3767        self,
3768    ) -> Option<(EchoEchoTablePayloadWithErrorRequest, EchoEchoTablePayloadWithErrorResponder)>
3769    {
3770        if let EchoRequest::EchoTablePayloadWithError { payload, responder } = self {
3771            Some((payload, responder))
3772        } else {
3773            None
3774        }
3775    }
3776
3777    #[allow(irrefutable_let_patterns)]
3778    pub fn into_echo_table_payload_no_ret_val(self) -> Option<(RequestTable, EchoControlHandle)> {
3779        if let EchoRequest::EchoTablePayloadNoRetVal { payload, control_handle } = self {
3780            Some((payload, control_handle))
3781        } else {
3782            None
3783        }
3784    }
3785
3786    #[allow(irrefutable_let_patterns)]
3787    pub fn into_echo_union_payload(self) -> Option<(RequestUnion, EchoEchoUnionPayloadResponder)> {
3788        if let EchoRequest::EchoUnionPayload { payload, responder } = self {
3789            Some((payload, responder))
3790        } else {
3791            None
3792        }
3793    }
3794
3795    #[allow(irrefutable_let_patterns)]
3796    pub fn into_echo_union_payload_with_error(
3797        self,
3798    ) -> Option<(EchoEchoUnionPayloadWithErrorRequest, EchoEchoUnionPayloadWithErrorResponder)>
3799    {
3800        if let EchoRequest::EchoUnionPayloadWithError { payload, responder } = self {
3801            Some((payload, responder))
3802        } else {
3803            None
3804        }
3805    }
3806
3807    #[allow(irrefutable_let_patterns)]
3808    pub fn into_echo_union_payload_no_ret_val(self) -> Option<(RequestUnion, EchoControlHandle)> {
3809        if let EchoRequest::EchoUnionPayloadNoRetVal { payload, control_handle } = self {
3810            Some((payload, control_handle))
3811        } else {
3812            None
3813        }
3814    }
3815
3816    /// Name of the method defined in FIDL
3817    pub fn method_name(&self) -> &'static str {
3818        match *self {
3819            EchoRequest::EchoTableRequestComposed { .. } => "echo_table_request_composed",
3820            EchoRequest::EchoUnionResponseWithErrorComposed { .. } => {
3821                "echo_union_response_with_error_composed"
3822            }
3823            EchoRequest::EchoMinimal { .. } => "echo_minimal",
3824            EchoRequest::EchoMinimalWithError { .. } => "echo_minimal_with_error",
3825            EchoRequest::EchoMinimalNoRetVal { .. } => "echo_minimal_no_ret_val",
3826            EchoRequest::EchoStruct { .. } => "echo_struct",
3827            EchoRequest::EchoStructWithError { .. } => "echo_struct_with_error",
3828            EchoRequest::EchoStructNoRetVal { .. } => "echo_struct_no_ret_val",
3829            EchoRequest::EchoArrays { .. } => "echo_arrays",
3830            EchoRequest::EchoArraysWithError { .. } => "echo_arrays_with_error",
3831            EchoRequest::EchoVectors { .. } => "echo_vectors",
3832            EchoRequest::EchoVectorsWithError { .. } => "echo_vectors_with_error",
3833            EchoRequest::EchoTable { .. } => "echo_table",
3834            EchoRequest::EchoTableWithError { .. } => "echo_table_with_error",
3835            EchoRequest::EchoXunions { .. } => "echo_xunions",
3836            EchoRequest::EchoXunionsWithError { .. } => "echo_xunions_with_error",
3837            EchoRequest::EchoNamedStruct { .. } => "echo_named_struct",
3838            EchoRequest::EchoNamedStructWithError { .. } => "echo_named_struct_with_error",
3839            EchoRequest::EchoNamedStructNoRetVal { .. } => "echo_named_struct_no_ret_val",
3840            EchoRequest::EchoTablePayload { .. } => "echo_table_payload",
3841            EchoRequest::EchoTablePayloadWithError { .. } => "echo_table_payload_with_error",
3842            EchoRequest::EchoTablePayloadNoRetVal { .. } => "echo_table_payload_no_ret_val",
3843            EchoRequest::EchoUnionPayload { .. } => "echo_union_payload",
3844            EchoRequest::EchoUnionPayloadWithError { .. } => "echo_union_payload_with_error",
3845            EchoRequest::EchoUnionPayloadNoRetVal { .. } => "echo_union_payload_no_ret_val",
3846        }
3847    }
3848}
3849
3850#[derive(Debug, Clone)]
3851pub struct EchoControlHandle {
3852    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
3853}
3854
3855impl fidl::endpoints::ControlHandle for EchoControlHandle {
3856    fn shutdown(&self) {
3857        self.inner.shutdown()
3858    }
3859    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
3860        self.inner.shutdown_with_epitaph(status)
3861    }
3862
3863    fn is_closed(&self) -> bool {
3864        self.inner.channel().is_closed()
3865    }
3866    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
3867        self.inner.channel().on_closed()
3868    }
3869
3870    #[cfg(target_os = "fuchsia")]
3871    fn signal_peer(
3872        &self,
3873        clear_mask: zx::Signals,
3874        set_mask: zx::Signals,
3875    ) -> Result<(), zx_status::Status> {
3876        use fidl::Peered;
3877        self.inner.channel().signal_peer(clear_mask, set_mask)
3878    }
3879}
3880
3881impl EchoControlHandle {
3882    pub fn send_echo_minimal_event(&self) -> Result<(), fidl::Error> {
3883        self.inner.send::<fidl::encoding::EmptyPayload>(
3884            (),
3885            0,
3886            0x273b2029f1a0aee2,
3887            fidl::encoding::DynamicFlags::empty(),
3888        )
3889    }
3890
3891    pub fn send_echo_event(&self, mut value: Struct) -> Result<(), fidl::Error> {
3892        self.inner.send::<EchoEchoEventRequest>(
3893            (&mut value,),
3894            0,
3895            0x1219e12e0450024,
3896            fidl::encoding::DynamicFlags::empty(),
3897        )
3898    }
3899
3900    pub fn send_on_echo_named_event(
3901        &self,
3902        mut value: &fidl_fidl_test_imported::SimpleStruct,
3903    ) -> Result<(), fidl::Error> {
3904        self.inner.send::<fidl_fidl_test_imported::ResponseStruct>(
3905            (value,),
3906            0,
3907            0x749ebde83348a374,
3908            fidl::encoding::DynamicFlags::empty(),
3909        )
3910    }
3911
3912    pub fn send_on_echo_table_payload_event(
3913        &self,
3914        mut payload: &ResponseTable,
3915    ) -> Result<(), fidl::Error> {
3916        self.inner.send::<ResponseTable>(
3917            payload,
3918            0,
3919            0x708dddea1cb98430,
3920            fidl::encoding::DynamicFlags::empty(),
3921        )
3922    }
3923
3924    pub fn send_on_echo_union_payload_event(
3925        &self,
3926        mut payload: &ResponseUnion,
3927    ) -> Result<(), fidl::Error> {
3928        self.inner.send::<ResponseUnion>(
3929            payload,
3930            0,
3931            0x642f4c265a05f4c0,
3932            fidl::encoding::DynamicFlags::empty(),
3933        )
3934    }
3935}
3936
3937#[must_use = "FIDL methods require a response to be sent"]
3938#[derive(Debug)]
3939pub struct EchoEchoTableRequestComposedResponder {
3940    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
3941    tx_id: u32,
3942}
3943
3944/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
3945/// if the responder is dropped without sending a response, so that the client
3946/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
3947impl std::ops::Drop for EchoEchoTableRequestComposedResponder {
3948    fn drop(&mut self) {
3949        self.control_handle.shutdown();
3950        // Safety: drops once, never accessed again
3951        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3952    }
3953}
3954
3955impl fidl::endpoints::Responder for EchoEchoTableRequestComposedResponder {
3956    type ControlHandle = EchoControlHandle;
3957
3958    fn control_handle(&self) -> &EchoControlHandle {
3959        &self.control_handle
3960    }
3961
3962    fn drop_without_shutdown(mut self) {
3963        // Safety: drops once, never accessed again due to mem::forget
3964        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3965        // Prevent Drop from running (which would shut down the channel)
3966        std::mem::forget(self);
3967    }
3968}
3969
3970impl EchoEchoTableRequestComposedResponder {
3971    /// Sends a response to the FIDL transaction.
3972    ///
3973    /// Sets the channel to shutdown if an error occurs.
3974    pub fn send(
3975        self,
3976        mut value: &fidl_fidl_test_imported::SimpleStruct,
3977    ) -> Result<(), fidl::Error> {
3978        let _result = self.send_raw(value);
3979        if _result.is_err() {
3980            self.control_handle.shutdown();
3981        }
3982        self.drop_without_shutdown();
3983        _result
3984    }
3985
3986    /// Similar to "send" but does not shutdown the channel if an error occurs.
3987    pub fn send_no_shutdown_on_err(
3988        self,
3989        mut value: &fidl_fidl_test_imported::SimpleStruct,
3990    ) -> Result<(), fidl::Error> {
3991        let _result = self.send_raw(value);
3992        self.drop_without_shutdown();
3993        _result
3994    }
3995
3996    fn send_raw(
3997        &self,
3998        mut value: &fidl_fidl_test_imported::SimpleStruct,
3999    ) -> Result<(), fidl::Error> {
4000        self.control_handle.inner.send::<fidl_fidl_test_imported::ResponseStruct>(
4001            (value,),
4002            self.tx_id,
4003            0x1d545c738c7a8ee,
4004            fidl::encoding::DynamicFlags::empty(),
4005        )
4006    }
4007}
4008
4009#[must_use = "FIDL methods require a response to be sent"]
4010#[derive(Debug)]
4011pub struct EchoEchoUnionResponseWithErrorComposedResponder {
4012    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4013    tx_id: u32,
4014}
4015
4016/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4017/// if the responder is dropped without sending a response, so that the client
4018/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4019impl std::ops::Drop for EchoEchoUnionResponseWithErrorComposedResponder {
4020    fn drop(&mut self) {
4021        self.control_handle.shutdown();
4022        // Safety: drops once, never accessed again
4023        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4024    }
4025}
4026
4027impl fidl::endpoints::Responder for EchoEchoUnionResponseWithErrorComposedResponder {
4028    type ControlHandle = EchoControlHandle;
4029
4030    fn control_handle(&self) -> &EchoControlHandle {
4031        &self.control_handle
4032    }
4033
4034    fn drop_without_shutdown(mut self) {
4035        // Safety: drops once, never accessed again due to mem::forget
4036        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4037        // Prevent Drop from running (which would shut down the channel)
4038        std::mem::forget(self);
4039    }
4040}
4041
4042impl EchoEchoUnionResponseWithErrorComposedResponder {
4043    /// Sends a response to the FIDL transaction.
4044    ///
4045    /// Sets the channel to shutdown if an error occurs.
4046    pub fn send(
4047        self,
4048        mut result: Result<
4049            &fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse,
4050            u32,
4051        >,
4052    ) -> Result<(), fidl::Error> {
4053        let _result = self.send_raw(result);
4054        if _result.is_err() {
4055            self.control_handle.shutdown();
4056        }
4057        self.drop_without_shutdown();
4058        _result
4059    }
4060
4061    /// Similar to "send" but does not shutdown the channel if an error occurs.
4062    pub fn send_no_shutdown_on_err(
4063        self,
4064        mut result: Result<
4065            &fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse,
4066            u32,
4067        >,
4068    ) -> Result<(), fidl::Error> {
4069        let _result = self.send_raw(result);
4070        self.drop_without_shutdown();
4071        _result
4072    }
4073
4074    fn send_raw(
4075        &self,
4076        mut result: Result<
4077            &fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse,
4078            u32,
4079        >,
4080    ) -> Result<(), fidl::Error> {
4081        self.control_handle.inner.send::<fidl::encoding::ResultType<
4082            fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse,
4083            u32,
4084        >>(
4085            result,
4086            self.tx_id,
4087            0x38a67e88d6106443,
4088            fidl::encoding::DynamicFlags::empty(),
4089        )
4090    }
4091}
4092
4093#[must_use = "FIDL methods require a response to be sent"]
4094#[derive(Debug)]
4095pub struct EchoEchoMinimalResponder {
4096    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4097    tx_id: u32,
4098}
4099
4100/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4101/// if the responder is dropped without sending a response, so that the client
4102/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4103impl std::ops::Drop for EchoEchoMinimalResponder {
4104    fn drop(&mut self) {
4105        self.control_handle.shutdown();
4106        // Safety: drops once, never accessed again
4107        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4108    }
4109}
4110
4111impl fidl::endpoints::Responder for EchoEchoMinimalResponder {
4112    type ControlHandle = EchoControlHandle;
4113
4114    fn control_handle(&self) -> &EchoControlHandle {
4115        &self.control_handle
4116    }
4117
4118    fn drop_without_shutdown(mut self) {
4119        // Safety: drops once, never accessed again due to mem::forget
4120        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4121        // Prevent Drop from running (which would shut down the channel)
4122        std::mem::forget(self);
4123    }
4124}
4125
4126impl EchoEchoMinimalResponder {
4127    /// Sends a response to the FIDL transaction.
4128    ///
4129    /// Sets the channel to shutdown if an error occurs.
4130    pub fn send(self) -> Result<(), fidl::Error> {
4131        let _result = self.send_raw();
4132        if _result.is_err() {
4133            self.control_handle.shutdown();
4134        }
4135        self.drop_without_shutdown();
4136        _result
4137    }
4138
4139    /// Similar to "send" but does not shutdown the channel if an error occurs.
4140    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
4141        let _result = self.send_raw();
4142        self.drop_without_shutdown();
4143        _result
4144    }
4145
4146    fn send_raw(&self) -> Result<(), fidl::Error> {
4147        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
4148            (),
4149            self.tx_id,
4150            0x39edd68c837482ec,
4151            fidl::encoding::DynamicFlags::empty(),
4152        )
4153    }
4154}
4155
4156#[must_use = "FIDL methods require a response to be sent"]
4157#[derive(Debug)]
4158pub struct EchoEchoMinimalWithErrorResponder {
4159    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4160    tx_id: u32,
4161}
4162
4163/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4164/// if the responder is dropped without sending a response, so that the client
4165/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4166impl std::ops::Drop for EchoEchoMinimalWithErrorResponder {
4167    fn drop(&mut self) {
4168        self.control_handle.shutdown();
4169        // Safety: drops once, never accessed again
4170        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4171    }
4172}
4173
4174impl fidl::endpoints::Responder for EchoEchoMinimalWithErrorResponder {
4175    type ControlHandle = EchoControlHandle;
4176
4177    fn control_handle(&self) -> &EchoControlHandle {
4178        &self.control_handle
4179    }
4180
4181    fn drop_without_shutdown(mut self) {
4182        // Safety: drops once, never accessed again due to mem::forget
4183        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4184        // Prevent Drop from running (which would shut down the channel)
4185        std::mem::forget(self);
4186    }
4187}
4188
4189impl EchoEchoMinimalWithErrorResponder {
4190    /// Sends a response to the FIDL transaction.
4191    ///
4192    /// Sets the channel to shutdown if an error occurs.
4193    pub fn send(self, mut result: Result<(), u32>) -> Result<(), fidl::Error> {
4194        let _result = self.send_raw(result);
4195        if _result.is_err() {
4196            self.control_handle.shutdown();
4197        }
4198        self.drop_without_shutdown();
4199        _result
4200    }
4201
4202    /// Similar to "send" but does not shutdown the channel if an error occurs.
4203    pub fn send_no_shutdown_on_err(self, mut result: Result<(), u32>) -> Result<(), fidl::Error> {
4204        let _result = self.send_raw(result);
4205        self.drop_without_shutdown();
4206        _result
4207    }
4208
4209    fn send_raw(&self, mut result: Result<(), u32>) -> Result<(), fidl::Error> {
4210        self.control_handle
4211            .inner
4212            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, u32>>(
4213                result,
4214                self.tx_id,
4215                0x36f4695996e35acc,
4216                fidl::encoding::DynamicFlags::empty(),
4217            )
4218    }
4219}
4220
4221#[must_use = "FIDL methods require a response to be sent"]
4222#[derive(Debug)]
4223pub struct EchoEchoStructResponder {
4224    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4225    tx_id: u32,
4226}
4227
4228/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4229/// if the responder is dropped without sending a response, so that the client
4230/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4231impl std::ops::Drop for EchoEchoStructResponder {
4232    fn drop(&mut self) {
4233        self.control_handle.shutdown();
4234        // Safety: drops once, never accessed again
4235        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4236    }
4237}
4238
4239impl fidl::endpoints::Responder for EchoEchoStructResponder {
4240    type ControlHandle = EchoControlHandle;
4241
4242    fn control_handle(&self) -> &EchoControlHandle {
4243        &self.control_handle
4244    }
4245
4246    fn drop_without_shutdown(mut self) {
4247        // Safety: drops once, never accessed again due to mem::forget
4248        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4249        // Prevent Drop from running (which would shut down the channel)
4250        std::mem::forget(self);
4251    }
4252}
4253
4254impl EchoEchoStructResponder {
4255    /// Sends a response to the FIDL transaction.
4256    ///
4257    /// Sets the channel to shutdown if an error occurs.
4258    pub fn send(self, mut value: Struct) -> Result<(), fidl::Error> {
4259        let _result = self.send_raw(value);
4260        if _result.is_err() {
4261            self.control_handle.shutdown();
4262        }
4263        self.drop_without_shutdown();
4264        _result
4265    }
4266
4267    /// Similar to "send" but does not shutdown the channel if an error occurs.
4268    pub fn send_no_shutdown_on_err(self, mut value: Struct) -> Result<(), fidl::Error> {
4269        let _result = self.send_raw(value);
4270        self.drop_without_shutdown();
4271        _result
4272    }
4273
4274    fn send_raw(&self, mut value: Struct) -> Result<(), fidl::Error> {
4275        self.control_handle.inner.send::<EchoEchoStructResponse>(
4276            (&mut value,),
4277            self.tx_id,
4278            0x4c2f85818cc53f37,
4279            fidl::encoding::DynamicFlags::empty(),
4280        )
4281    }
4282}
4283
4284#[must_use = "FIDL methods require a response to be sent"]
4285#[derive(Debug)]
4286pub struct EchoEchoStructWithErrorResponder {
4287    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4288    tx_id: u32,
4289}
4290
4291/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4292/// if the responder is dropped without sending a response, so that the client
4293/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4294impl std::ops::Drop for EchoEchoStructWithErrorResponder {
4295    fn drop(&mut self) {
4296        self.control_handle.shutdown();
4297        // Safety: drops once, never accessed again
4298        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4299    }
4300}
4301
4302impl fidl::endpoints::Responder for EchoEchoStructWithErrorResponder {
4303    type ControlHandle = EchoControlHandle;
4304
4305    fn control_handle(&self) -> &EchoControlHandle {
4306        &self.control_handle
4307    }
4308
4309    fn drop_without_shutdown(mut self) {
4310        // Safety: drops once, never accessed again due to mem::forget
4311        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4312        // Prevent Drop from running (which would shut down the channel)
4313        std::mem::forget(self);
4314    }
4315}
4316
4317impl EchoEchoStructWithErrorResponder {
4318    /// Sends a response to the FIDL transaction.
4319    ///
4320    /// Sets the channel to shutdown if an error occurs.
4321    pub fn send(self, mut result: Result<Struct, DefaultEnum>) -> Result<(), fidl::Error> {
4322        let _result = self.send_raw(result);
4323        if _result.is_err() {
4324            self.control_handle.shutdown();
4325        }
4326        self.drop_without_shutdown();
4327        _result
4328    }
4329
4330    /// Similar to "send" but does not shutdown the channel if an error occurs.
4331    pub fn send_no_shutdown_on_err(
4332        self,
4333        mut result: Result<Struct, DefaultEnum>,
4334    ) -> Result<(), fidl::Error> {
4335        let _result = self.send_raw(result);
4336        self.drop_without_shutdown();
4337        _result
4338    }
4339
4340    fn send_raw(&self, mut result: Result<Struct, DefaultEnum>) -> Result<(), fidl::Error> {
4341        self.control_handle.inner.send::<fidl::encoding::ResultType<
4342            EchoEchoStructWithErrorResponse,
4343            DefaultEnum,
4344        >>(
4345            result.as_mut().map_err(|e| *e).map(|value| (value,)),
4346            self.tx_id,
4347            0x46cb32652c4c0899,
4348            fidl::encoding::DynamicFlags::empty(),
4349        )
4350    }
4351}
4352
4353#[must_use = "FIDL methods require a response to be sent"]
4354#[derive(Debug)]
4355pub struct EchoEchoArraysResponder {
4356    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4357    tx_id: u32,
4358}
4359
4360/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4361/// if the responder is dropped without sending a response, so that the client
4362/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4363impl std::ops::Drop for EchoEchoArraysResponder {
4364    fn drop(&mut self) {
4365        self.control_handle.shutdown();
4366        // Safety: drops once, never accessed again
4367        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4368    }
4369}
4370
4371impl fidl::endpoints::Responder for EchoEchoArraysResponder {
4372    type ControlHandle = EchoControlHandle;
4373
4374    fn control_handle(&self) -> &EchoControlHandle {
4375        &self.control_handle
4376    }
4377
4378    fn drop_without_shutdown(mut self) {
4379        // Safety: drops once, never accessed again due to mem::forget
4380        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4381        // Prevent Drop from running (which would shut down the channel)
4382        std::mem::forget(self);
4383    }
4384}
4385
4386impl EchoEchoArraysResponder {
4387    /// Sends a response to the FIDL transaction.
4388    ///
4389    /// Sets the channel to shutdown if an error occurs.
4390    pub fn send(self, mut value: ArraysStruct) -> Result<(), fidl::Error> {
4391        let _result = self.send_raw(value);
4392        if _result.is_err() {
4393            self.control_handle.shutdown();
4394        }
4395        self.drop_without_shutdown();
4396        _result
4397    }
4398
4399    /// Similar to "send" but does not shutdown the channel if an error occurs.
4400    pub fn send_no_shutdown_on_err(self, mut value: ArraysStruct) -> Result<(), fidl::Error> {
4401        let _result = self.send_raw(value);
4402        self.drop_without_shutdown();
4403        _result
4404    }
4405
4406    fn send_raw(&self, mut value: ArraysStruct) -> Result<(), fidl::Error> {
4407        self.control_handle.inner.send::<EchoEchoArraysResponse>(
4408            (&mut value,),
4409            self.tx_id,
4410            0x1b6019d5611f2470,
4411            fidl::encoding::DynamicFlags::empty(),
4412        )
4413    }
4414}
4415
4416#[must_use = "FIDL methods require a response to be sent"]
4417#[derive(Debug)]
4418pub struct EchoEchoArraysWithErrorResponder {
4419    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4420    tx_id: u32,
4421}
4422
4423/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4424/// if the responder is dropped without sending a response, so that the client
4425/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4426impl std::ops::Drop for EchoEchoArraysWithErrorResponder {
4427    fn drop(&mut self) {
4428        self.control_handle.shutdown();
4429        // Safety: drops once, never accessed again
4430        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4431    }
4432}
4433
4434impl fidl::endpoints::Responder for EchoEchoArraysWithErrorResponder {
4435    type ControlHandle = EchoControlHandle;
4436
4437    fn control_handle(&self) -> &EchoControlHandle {
4438        &self.control_handle
4439    }
4440
4441    fn drop_without_shutdown(mut self) {
4442        // Safety: drops once, never accessed again due to mem::forget
4443        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4444        // Prevent Drop from running (which would shut down the channel)
4445        std::mem::forget(self);
4446    }
4447}
4448
4449impl EchoEchoArraysWithErrorResponder {
4450    /// Sends a response to the FIDL transaction.
4451    ///
4452    /// Sets the channel to shutdown if an error occurs.
4453    pub fn send(self, mut result: Result<ArraysStruct, DefaultEnum>) -> Result<(), fidl::Error> {
4454        let _result = self.send_raw(result);
4455        if _result.is_err() {
4456            self.control_handle.shutdown();
4457        }
4458        self.drop_without_shutdown();
4459        _result
4460    }
4461
4462    /// Similar to "send" but does not shutdown the channel if an error occurs.
4463    pub fn send_no_shutdown_on_err(
4464        self,
4465        mut result: Result<ArraysStruct, DefaultEnum>,
4466    ) -> Result<(), fidl::Error> {
4467        let _result = self.send_raw(result);
4468        self.drop_without_shutdown();
4469        _result
4470    }
4471
4472    fn send_raw(&self, mut result: Result<ArraysStruct, DefaultEnum>) -> Result<(), fidl::Error> {
4473        self.control_handle.inner.send::<fidl::encoding::ResultType<
4474            EchoEchoArraysWithErrorResponse,
4475            DefaultEnum,
4476        >>(
4477            result.as_mut().map_err(|e| *e).map(|value| (value,)),
4478            self.tx_id,
4479            0x6dbf26e67e253afa,
4480            fidl::encoding::DynamicFlags::empty(),
4481        )
4482    }
4483}
4484
4485#[must_use = "FIDL methods require a response to be sent"]
4486#[derive(Debug)]
4487pub struct EchoEchoVectorsResponder {
4488    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4489    tx_id: u32,
4490}
4491
4492/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4493/// if the responder is dropped without sending a response, so that the client
4494/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4495impl std::ops::Drop for EchoEchoVectorsResponder {
4496    fn drop(&mut self) {
4497        self.control_handle.shutdown();
4498        // Safety: drops once, never accessed again
4499        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4500    }
4501}
4502
4503impl fidl::endpoints::Responder for EchoEchoVectorsResponder {
4504    type ControlHandle = EchoControlHandle;
4505
4506    fn control_handle(&self) -> &EchoControlHandle {
4507        &self.control_handle
4508    }
4509
4510    fn drop_without_shutdown(mut self) {
4511        // Safety: drops once, never accessed again due to mem::forget
4512        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4513        // Prevent Drop from running (which would shut down the channel)
4514        std::mem::forget(self);
4515    }
4516}
4517
4518impl EchoEchoVectorsResponder {
4519    /// Sends a response to the FIDL transaction.
4520    ///
4521    /// Sets the channel to shutdown if an error occurs.
4522    pub fn send(self, mut value: VectorsStruct) -> Result<(), fidl::Error> {
4523        let _result = self.send_raw(value);
4524        if _result.is_err() {
4525            self.control_handle.shutdown();
4526        }
4527        self.drop_without_shutdown();
4528        _result
4529    }
4530
4531    /// Similar to "send" but does not shutdown the channel if an error occurs.
4532    pub fn send_no_shutdown_on_err(self, mut value: VectorsStruct) -> Result<(), fidl::Error> {
4533        let _result = self.send_raw(value);
4534        self.drop_without_shutdown();
4535        _result
4536    }
4537
4538    fn send_raw(&self, mut value: VectorsStruct) -> Result<(), fidl::Error> {
4539        self.control_handle.inner.send::<EchoEchoVectorsResponse>(
4540            (&mut value,),
4541            self.tx_id,
4542            0x1582623f0d9f6e5e,
4543            fidl::encoding::DynamicFlags::empty(),
4544        )
4545    }
4546}
4547
4548#[must_use = "FIDL methods require a response to be sent"]
4549#[derive(Debug)]
4550pub struct EchoEchoVectorsWithErrorResponder {
4551    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4552    tx_id: u32,
4553}
4554
4555/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4556/// if the responder is dropped without sending a response, so that the client
4557/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4558impl std::ops::Drop for EchoEchoVectorsWithErrorResponder {
4559    fn drop(&mut self) {
4560        self.control_handle.shutdown();
4561        // Safety: drops once, never accessed again
4562        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4563    }
4564}
4565
4566impl fidl::endpoints::Responder for EchoEchoVectorsWithErrorResponder {
4567    type ControlHandle = EchoControlHandle;
4568
4569    fn control_handle(&self) -> &EchoControlHandle {
4570        &self.control_handle
4571    }
4572
4573    fn drop_without_shutdown(mut self) {
4574        // Safety: drops once, never accessed again due to mem::forget
4575        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4576        // Prevent Drop from running (which would shut down the channel)
4577        std::mem::forget(self);
4578    }
4579}
4580
4581impl EchoEchoVectorsWithErrorResponder {
4582    /// Sends a response to the FIDL transaction.
4583    ///
4584    /// Sets the channel to shutdown if an error occurs.
4585    pub fn send(self, mut result: Result<VectorsStruct, DefaultEnum>) -> Result<(), fidl::Error> {
4586        let _result = self.send_raw(result);
4587        if _result.is_err() {
4588            self.control_handle.shutdown();
4589        }
4590        self.drop_without_shutdown();
4591        _result
4592    }
4593
4594    /// Similar to "send" but does not shutdown the channel if an error occurs.
4595    pub fn send_no_shutdown_on_err(
4596        self,
4597        mut result: Result<VectorsStruct, DefaultEnum>,
4598    ) -> Result<(), fidl::Error> {
4599        let _result = self.send_raw(result);
4600        self.drop_without_shutdown();
4601        _result
4602    }
4603
4604    fn send_raw(&self, mut result: Result<VectorsStruct, DefaultEnum>) -> Result<(), fidl::Error> {
4605        self.control_handle.inner.send::<fidl::encoding::ResultType<
4606            EchoEchoVectorsWithErrorResponse,
4607            DefaultEnum,
4608        >>(
4609            result.as_mut().map_err(|e| *e).map(|value| (value,)),
4610            self.tx_id,
4611            0x730f163401e2b3e5,
4612            fidl::encoding::DynamicFlags::empty(),
4613        )
4614    }
4615}
4616
4617#[must_use = "FIDL methods require a response to be sent"]
4618#[derive(Debug)]
4619pub struct EchoEchoTableResponder {
4620    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4621    tx_id: u32,
4622}
4623
4624/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4625/// if the responder is dropped without sending a response, so that the client
4626/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4627impl std::ops::Drop for EchoEchoTableResponder {
4628    fn drop(&mut self) {
4629        self.control_handle.shutdown();
4630        // Safety: drops once, never accessed again
4631        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4632    }
4633}
4634
4635impl fidl::endpoints::Responder for EchoEchoTableResponder {
4636    type ControlHandle = EchoControlHandle;
4637
4638    fn control_handle(&self) -> &EchoControlHandle {
4639        &self.control_handle
4640    }
4641
4642    fn drop_without_shutdown(mut self) {
4643        // Safety: drops once, never accessed again due to mem::forget
4644        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4645        // Prevent Drop from running (which would shut down the channel)
4646        std::mem::forget(self);
4647    }
4648}
4649
4650impl EchoEchoTableResponder {
4651    /// Sends a response to the FIDL transaction.
4652    ///
4653    /// Sets the channel to shutdown if an error occurs.
4654    pub fn send(self, mut value: AllTypesTable) -> Result<(), fidl::Error> {
4655        let _result = self.send_raw(value);
4656        if _result.is_err() {
4657            self.control_handle.shutdown();
4658        }
4659        self.drop_without_shutdown();
4660        _result
4661    }
4662
4663    /// Similar to "send" but does not shutdown the channel if an error occurs.
4664    pub fn send_no_shutdown_on_err(self, mut value: AllTypesTable) -> Result<(), fidl::Error> {
4665        let _result = self.send_raw(value);
4666        self.drop_without_shutdown();
4667        _result
4668    }
4669
4670    fn send_raw(&self, mut value: AllTypesTable) -> Result<(), fidl::Error> {
4671        self.control_handle.inner.send::<EchoEchoTableResponse>(
4672            (&mut value,),
4673            self.tx_id,
4674            0x4f1fb0a512f47c4b,
4675            fidl::encoding::DynamicFlags::empty(),
4676        )
4677    }
4678}
4679
4680#[must_use = "FIDL methods require a response to be sent"]
4681#[derive(Debug)]
4682pub struct EchoEchoTableWithErrorResponder {
4683    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4684    tx_id: u32,
4685}
4686
4687/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4688/// if the responder is dropped without sending a response, so that the client
4689/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4690impl std::ops::Drop for EchoEchoTableWithErrorResponder {
4691    fn drop(&mut self) {
4692        self.control_handle.shutdown();
4693        // Safety: drops once, never accessed again
4694        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4695    }
4696}
4697
4698impl fidl::endpoints::Responder for EchoEchoTableWithErrorResponder {
4699    type ControlHandle = EchoControlHandle;
4700
4701    fn control_handle(&self) -> &EchoControlHandle {
4702        &self.control_handle
4703    }
4704
4705    fn drop_without_shutdown(mut self) {
4706        // Safety: drops once, never accessed again due to mem::forget
4707        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4708        // Prevent Drop from running (which would shut down the channel)
4709        std::mem::forget(self);
4710    }
4711}
4712
4713impl EchoEchoTableWithErrorResponder {
4714    /// Sends a response to the FIDL transaction.
4715    ///
4716    /// Sets the channel to shutdown if an error occurs.
4717    pub fn send(self, mut result: Result<AllTypesTable, DefaultEnum>) -> Result<(), fidl::Error> {
4718        let _result = self.send_raw(result);
4719        if _result.is_err() {
4720            self.control_handle.shutdown();
4721        }
4722        self.drop_without_shutdown();
4723        _result
4724    }
4725
4726    /// Similar to "send" but does not shutdown the channel if an error occurs.
4727    pub fn send_no_shutdown_on_err(
4728        self,
4729        mut result: Result<AllTypesTable, DefaultEnum>,
4730    ) -> Result<(), fidl::Error> {
4731        let _result = self.send_raw(result);
4732        self.drop_without_shutdown();
4733        _result
4734    }
4735
4736    fn send_raw(&self, mut result: Result<AllTypesTable, DefaultEnum>) -> Result<(), fidl::Error> {
4737        self.control_handle.inner.send::<fidl::encoding::ResultType<
4738            EchoEchoTableWithErrorResponse,
4739            DefaultEnum,
4740        >>(
4741            result.as_mut().map_err(|e| *e).map(|value| (value,)),
4742            self.tx_id,
4743            0x44e835cb1eb9a931,
4744            fidl::encoding::DynamicFlags::empty(),
4745        )
4746    }
4747}
4748
4749#[must_use = "FIDL methods require a response to be sent"]
4750#[derive(Debug)]
4751pub struct EchoEchoXunionsResponder {
4752    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4753    tx_id: u32,
4754}
4755
4756/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4757/// if the responder is dropped without sending a response, so that the client
4758/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4759impl std::ops::Drop for EchoEchoXunionsResponder {
4760    fn drop(&mut self) {
4761        self.control_handle.shutdown();
4762        // Safety: drops once, never accessed again
4763        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4764    }
4765}
4766
4767impl fidl::endpoints::Responder for EchoEchoXunionsResponder {
4768    type ControlHandle = EchoControlHandle;
4769
4770    fn control_handle(&self) -> &EchoControlHandle {
4771        &self.control_handle
4772    }
4773
4774    fn drop_without_shutdown(mut self) {
4775        // Safety: drops once, never accessed again due to mem::forget
4776        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4777        // Prevent Drop from running (which would shut down the channel)
4778        std::mem::forget(self);
4779    }
4780}
4781
4782impl EchoEchoXunionsResponder {
4783    /// Sends a response to the FIDL transaction.
4784    ///
4785    /// Sets the channel to shutdown if an error occurs.
4786    pub fn send(self, mut value: Vec<AllTypesXunion>) -> Result<(), fidl::Error> {
4787        let _result = self.send_raw(value);
4788        if _result.is_err() {
4789            self.control_handle.shutdown();
4790        }
4791        self.drop_without_shutdown();
4792        _result
4793    }
4794
4795    /// Similar to "send" but does not shutdown the channel if an error occurs.
4796    pub fn send_no_shutdown_on_err(
4797        self,
4798        mut value: Vec<AllTypesXunion>,
4799    ) -> Result<(), fidl::Error> {
4800        let _result = self.send_raw(value);
4801        self.drop_without_shutdown();
4802        _result
4803    }
4804
4805    fn send_raw(&self, mut value: Vec<AllTypesXunion>) -> Result<(), fidl::Error> {
4806        self.control_handle.inner.send::<EchoEchoXunionsResponse>(
4807            (value.as_mut(),),
4808            self.tx_id,
4809            0x3dc181909041a583,
4810            fidl::encoding::DynamicFlags::empty(),
4811        )
4812    }
4813}
4814
4815#[must_use = "FIDL methods require a response to be sent"]
4816#[derive(Debug)]
4817pub struct EchoEchoXunionsWithErrorResponder {
4818    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4819    tx_id: u32,
4820}
4821
4822/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4823/// if the responder is dropped without sending a response, so that the client
4824/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4825impl std::ops::Drop for EchoEchoXunionsWithErrorResponder {
4826    fn drop(&mut self) {
4827        self.control_handle.shutdown();
4828        // Safety: drops once, never accessed again
4829        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4830    }
4831}
4832
4833impl fidl::endpoints::Responder for EchoEchoXunionsWithErrorResponder {
4834    type ControlHandle = EchoControlHandle;
4835
4836    fn control_handle(&self) -> &EchoControlHandle {
4837        &self.control_handle
4838    }
4839
4840    fn drop_without_shutdown(mut self) {
4841        // Safety: drops once, never accessed again due to mem::forget
4842        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4843        // Prevent Drop from running (which would shut down the channel)
4844        std::mem::forget(self);
4845    }
4846}
4847
4848impl EchoEchoXunionsWithErrorResponder {
4849    /// Sends a response to the FIDL transaction.
4850    ///
4851    /// Sets the channel to shutdown if an error occurs.
4852    pub fn send(
4853        self,
4854        mut result: Result<Vec<AllTypesXunion>, DefaultEnum>,
4855    ) -> Result<(), fidl::Error> {
4856        let _result = self.send_raw(result);
4857        if _result.is_err() {
4858            self.control_handle.shutdown();
4859        }
4860        self.drop_without_shutdown();
4861        _result
4862    }
4863
4864    /// Similar to "send" but does not shutdown the channel if an error occurs.
4865    pub fn send_no_shutdown_on_err(
4866        self,
4867        mut result: Result<Vec<AllTypesXunion>, DefaultEnum>,
4868    ) -> Result<(), fidl::Error> {
4869        let _result = self.send_raw(result);
4870        self.drop_without_shutdown();
4871        _result
4872    }
4873
4874    fn send_raw(
4875        &self,
4876        mut result: Result<Vec<AllTypesXunion>, DefaultEnum>,
4877    ) -> Result<(), fidl::Error> {
4878        self.control_handle.inner.send::<fidl::encoding::ResultType<
4879            EchoEchoXunionsWithErrorResponse,
4880            DefaultEnum,
4881        >>(
4882            result.as_mut().map_err(|e| *e).map(|value| (value.as_mut_slice(),)),
4883            self.tx_id,
4884            0x75184102667fa766,
4885            fidl::encoding::DynamicFlags::empty(),
4886        )
4887    }
4888}
4889
4890#[must_use = "FIDL methods require a response to be sent"]
4891#[derive(Debug)]
4892pub struct EchoEchoNamedStructResponder {
4893    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4894    tx_id: u32,
4895}
4896
4897/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4898/// if the responder is dropped without sending a response, so that the client
4899/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4900impl std::ops::Drop for EchoEchoNamedStructResponder {
4901    fn drop(&mut self) {
4902        self.control_handle.shutdown();
4903        // Safety: drops once, never accessed again
4904        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4905    }
4906}
4907
4908impl fidl::endpoints::Responder for EchoEchoNamedStructResponder {
4909    type ControlHandle = EchoControlHandle;
4910
4911    fn control_handle(&self) -> &EchoControlHandle {
4912        &self.control_handle
4913    }
4914
4915    fn drop_without_shutdown(mut self) {
4916        // Safety: drops once, never accessed again due to mem::forget
4917        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4918        // Prevent Drop from running (which would shut down the channel)
4919        std::mem::forget(self);
4920    }
4921}
4922
4923impl EchoEchoNamedStructResponder {
4924    /// Sends a response to the FIDL transaction.
4925    ///
4926    /// Sets the channel to shutdown if an error occurs.
4927    pub fn send(
4928        self,
4929        mut value: &fidl_fidl_test_imported::SimpleStruct,
4930    ) -> Result<(), fidl::Error> {
4931        let _result = self.send_raw(value);
4932        if _result.is_err() {
4933            self.control_handle.shutdown();
4934        }
4935        self.drop_without_shutdown();
4936        _result
4937    }
4938
4939    /// Similar to "send" but does not shutdown the channel if an error occurs.
4940    pub fn send_no_shutdown_on_err(
4941        self,
4942        mut value: &fidl_fidl_test_imported::SimpleStruct,
4943    ) -> Result<(), fidl::Error> {
4944        let _result = self.send_raw(value);
4945        self.drop_without_shutdown();
4946        _result
4947    }
4948
4949    fn send_raw(
4950        &self,
4951        mut value: &fidl_fidl_test_imported::SimpleStruct,
4952    ) -> Result<(), fidl::Error> {
4953        self.control_handle.inner.send::<fidl_fidl_test_imported::ResponseStruct>(
4954            (value,),
4955            self.tx_id,
4956            0xf2d4aa9e65f7111,
4957            fidl::encoding::DynamicFlags::empty(),
4958        )
4959    }
4960}
4961
4962#[must_use = "FIDL methods require a response to be sent"]
4963#[derive(Debug)]
4964pub struct EchoEchoNamedStructWithErrorResponder {
4965    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4966    tx_id: u32,
4967}
4968
4969/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4970/// if the responder is dropped without sending a response, so that the client
4971/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4972impl std::ops::Drop for EchoEchoNamedStructWithErrorResponder {
4973    fn drop(&mut self) {
4974        self.control_handle.shutdown();
4975        // Safety: drops once, never accessed again
4976        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4977    }
4978}
4979
4980impl fidl::endpoints::Responder for EchoEchoNamedStructWithErrorResponder {
4981    type ControlHandle = EchoControlHandle;
4982
4983    fn control_handle(&self) -> &EchoControlHandle {
4984        &self.control_handle
4985    }
4986
4987    fn drop_without_shutdown(mut self) {
4988        // Safety: drops once, never accessed again due to mem::forget
4989        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4990        // Prevent Drop from running (which would shut down the channel)
4991        std::mem::forget(self);
4992    }
4993}
4994
4995impl EchoEchoNamedStructWithErrorResponder {
4996    /// Sends a response to the FIDL transaction.
4997    ///
4998    /// Sets the channel to shutdown if an error occurs.
4999    pub fn send(
5000        self,
5001        mut result: Result<&fidl_fidl_test_imported::SimpleStruct, u32>,
5002    ) -> Result<(), fidl::Error> {
5003        let _result = self.send_raw(result);
5004        if _result.is_err() {
5005            self.control_handle.shutdown();
5006        }
5007        self.drop_without_shutdown();
5008        _result
5009    }
5010
5011    /// Similar to "send" but does not shutdown the channel if an error occurs.
5012    pub fn send_no_shutdown_on_err(
5013        self,
5014        mut result: Result<&fidl_fidl_test_imported::SimpleStruct, u32>,
5015    ) -> Result<(), fidl::Error> {
5016        let _result = self.send_raw(result);
5017        self.drop_without_shutdown();
5018        _result
5019    }
5020
5021    fn send_raw(
5022        &self,
5023        mut result: Result<&fidl_fidl_test_imported::SimpleStruct, u32>,
5024    ) -> Result<(), fidl::Error> {
5025        self.control_handle.inner.send::<fidl::encoding::ResultType<
5026            fidl_fidl_test_imported::ResponseStruct,
5027            u32,
5028        >>(
5029            result.map(|value| (value,)),
5030            self.tx_id,
5031            0x5766fee9e74442e8,
5032            fidl::encoding::DynamicFlags::empty(),
5033        )
5034    }
5035}
5036
5037#[must_use = "FIDL methods require a response to be sent"]
5038#[derive(Debug)]
5039pub struct EchoEchoTablePayloadResponder {
5040    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
5041    tx_id: u32,
5042}
5043
5044/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
5045/// if the responder is dropped without sending a response, so that the client
5046/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
5047impl std::ops::Drop for EchoEchoTablePayloadResponder {
5048    fn drop(&mut self) {
5049        self.control_handle.shutdown();
5050        // Safety: drops once, never accessed again
5051        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5052    }
5053}
5054
5055impl fidl::endpoints::Responder for EchoEchoTablePayloadResponder {
5056    type ControlHandle = EchoControlHandle;
5057
5058    fn control_handle(&self) -> &EchoControlHandle {
5059        &self.control_handle
5060    }
5061
5062    fn drop_without_shutdown(mut self) {
5063        // Safety: drops once, never accessed again due to mem::forget
5064        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5065        // Prevent Drop from running (which would shut down the channel)
5066        std::mem::forget(self);
5067    }
5068}
5069
5070impl EchoEchoTablePayloadResponder {
5071    /// Sends a response to the FIDL transaction.
5072    ///
5073    /// Sets the channel to shutdown if an error occurs.
5074    pub fn send(self, mut payload: &ResponseTable) -> Result<(), fidl::Error> {
5075        let _result = self.send_raw(payload);
5076        if _result.is_err() {
5077            self.control_handle.shutdown();
5078        }
5079        self.drop_without_shutdown();
5080        _result
5081    }
5082
5083    /// Similar to "send" but does not shutdown the channel if an error occurs.
5084    pub fn send_no_shutdown_on_err(self, mut payload: &ResponseTable) -> Result<(), fidl::Error> {
5085        let _result = self.send_raw(payload);
5086        self.drop_without_shutdown();
5087        _result
5088    }
5089
5090    fn send_raw(&self, mut payload: &ResponseTable) -> Result<(), fidl::Error> {
5091        self.control_handle.inner.send::<ResponseTable>(
5092            payload,
5093            self.tx_id,
5094            0x641d98087378c003,
5095            fidl::encoding::DynamicFlags::empty(),
5096        )
5097    }
5098}
5099
5100#[must_use = "FIDL methods require a response to be sent"]
5101#[derive(Debug)]
5102pub struct EchoEchoTablePayloadWithErrorResponder {
5103    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
5104    tx_id: u32,
5105}
5106
5107/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
5108/// if the responder is dropped without sending a response, so that the client
5109/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
5110impl std::ops::Drop for EchoEchoTablePayloadWithErrorResponder {
5111    fn drop(&mut self) {
5112        self.control_handle.shutdown();
5113        // Safety: drops once, never accessed again
5114        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5115    }
5116}
5117
5118impl fidl::endpoints::Responder for EchoEchoTablePayloadWithErrorResponder {
5119    type ControlHandle = EchoControlHandle;
5120
5121    fn control_handle(&self) -> &EchoControlHandle {
5122        &self.control_handle
5123    }
5124
5125    fn drop_without_shutdown(mut self) {
5126        // Safety: drops once, never accessed again due to mem::forget
5127        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5128        // Prevent Drop from running (which would shut down the channel)
5129        std::mem::forget(self);
5130    }
5131}
5132
5133impl EchoEchoTablePayloadWithErrorResponder {
5134    /// Sends a response to the FIDL transaction.
5135    ///
5136    /// Sets the channel to shutdown if an error occurs.
5137    pub fn send(self, mut result: Result<&ResponseTable, DefaultEnum>) -> Result<(), fidl::Error> {
5138        let _result = self.send_raw(result);
5139        if _result.is_err() {
5140            self.control_handle.shutdown();
5141        }
5142        self.drop_without_shutdown();
5143        _result
5144    }
5145
5146    /// Similar to "send" but does not shutdown the channel if an error occurs.
5147    pub fn send_no_shutdown_on_err(
5148        self,
5149        mut result: Result<&ResponseTable, DefaultEnum>,
5150    ) -> Result<(), fidl::Error> {
5151        let _result = self.send_raw(result);
5152        self.drop_without_shutdown();
5153        _result
5154    }
5155
5156    fn send_raw(&self, mut result: Result<&ResponseTable, DefaultEnum>) -> Result<(), fidl::Error> {
5157        self.control_handle.inner.send::<fidl::encoding::ResultType<ResponseTable, DefaultEnum>>(
5158            result,
5159            self.tx_id,
5160            0x636ed243761ab66d,
5161            fidl::encoding::DynamicFlags::empty(),
5162        )
5163    }
5164}
5165
5166#[must_use = "FIDL methods require a response to be sent"]
5167#[derive(Debug)]
5168pub struct EchoEchoUnionPayloadResponder {
5169    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
5170    tx_id: u32,
5171}
5172
5173/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
5174/// if the responder is dropped without sending a response, so that the client
5175/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
5176impl std::ops::Drop for EchoEchoUnionPayloadResponder {
5177    fn drop(&mut self) {
5178        self.control_handle.shutdown();
5179        // Safety: drops once, never accessed again
5180        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5181    }
5182}
5183
5184impl fidl::endpoints::Responder for EchoEchoUnionPayloadResponder {
5185    type ControlHandle = EchoControlHandle;
5186
5187    fn control_handle(&self) -> &EchoControlHandle {
5188        &self.control_handle
5189    }
5190
5191    fn drop_without_shutdown(mut self) {
5192        // Safety: drops once, never accessed again due to mem::forget
5193        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5194        // Prevent Drop from running (which would shut down the channel)
5195        std::mem::forget(self);
5196    }
5197}
5198
5199impl EchoEchoUnionPayloadResponder {
5200    /// Sends a response to the FIDL transaction.
5201    ///
5202    /// Sets the channel to shutdown if an error occurs.
5203    pub fn send(self, mut payload: &ResponseUnion) -> Result<(), fidl::Error> {
5204        let _result = self.send_raw(payload);
5205        if _result.is_err() {
5206            self.control_handle.shutdown();
5207        }
5208        self.drop_without_shutdown();
5209        _result
5210    }
5211
5212    /// Similar to "send" but does not shutdown the channel if an error occurs.
5213    pub fn send_no_shutdown_on_err(self, mut payload: &ResponseUnion) -> Result<(), fidl::Error> {
5214        let _result = self.send_raw(payload);
5215        self.drop_without_shutdown();
5216        _result
5217    }
5218
5219    fn send_raw(&self, mut payload: &ResponseUnion) -> Result<(), fidl::Error> {
5220        self.control_handle.inner.send::<ResponseUnion>(
5221            payload,
5222            self.tx_id,
5223            0x66def9e793f10c55,
5224            fidl::encoding::DynamicFlags::empty(),
5225        )
5226    }
5227}
5228
5229#[must_use = "FIDL methods require a response to be sent"]
5230#[derive(Debug)]
5231pub struct EchoEchoUnionPayloadWithErrorResponder {
5232    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
5233    tx_id: u32,
5234}
5235
5236/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
5237/// if the responder is dropped without sending a response, so that the client
5238/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
5239impl std::ops::Drop for EchoEchoUnionPayloadWithErrorResponder {
5240    fn drop(&mut self) {
5241        self.control_handle.shutdown();
5242        // Safety: drops once, never accessed again
5243        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5244    }
5245}
5246
5247impl fidl::endpoints::Responder for EchoEchoUnionPayloadWithErrorResponder {
5248    type ControlHandle = EchoControlHandle;
5249
5250    fn control_handle(&self) -> &EchoControlHandle {
5251        &self.control_handle
5252    }
5253
5254    fn drop_without_shutdown(mut self) {
5255        // Safety: drops once, never accessed again due to mem::forget
5256        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5257        // Prevent Drop from running (which would shut down the channel)
5258        std::mem::forget(self);
5259    }
5260}
5261
5262impl EchoEchoUnionPayloadWithErrorResponder {
5263    /// Sends a response to the FIDL transaction.
5264    ///
5265    /// Sets the channel to shutdown if an error occurs.
5266    pub fn send(self, mut result: Result<&ResponseUnion, DefaultEnum>) -> Result<(), fidl::Error> {
5267        let _result = self.send_raw(result);
5268        if _result.is_err() {
5269            self.control_handle.shutdown();
5270        }
5271        self.drop_without_shutdown();
5272        _result
5273    }
5274
5275    /// Similar to "send" but does not shutdown the channel if an error occurs.
5276    pub fn send_no_shutdown_on_err(
5277        self,
5278        mut result: Result<&ResponseUnion, DefaultEnum>,
5279    ) -> Result<(), fidl::Error> {
5280        let _result = self.send_raw(result);
5281        self.drop_without_shutdown();
5282        _result
5283    }
5284
5285    fn send_raw(&self, mut result: Result<&ResponseUnion, DefaultEnum>) -> Result<(), fidl::Error> {
5286        self.control_handle.inner.send::<fidl::encoding::ResultType<ResponseUnion, DefaultEnum>>(
5287            result,
5288            self.tx_id,
5289            0x1be890d6e68ef063,
5290            fidl::encoding::DynamicFlags::empty(),
5291        )
5292    }
5293}
5294
5295mod internal {
5296    use super::*;
5297
5298    impl fidl::encoding::ResourceTypeMarker for ArraysStruct {
5299        type Borrowed<'a> = &'a mut Self;
5300        fn take_or_borrow<'a>(
5301            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
5302        ) -> Self::Borrowed<'a> {
5303            value
5304        }
5305    }
5306
5307    unsafe impl fidl::encoding::TypeMarker for ArraysStruct {
5308        type Owned = Self;
5309
5310        #[inline(always)]
5311        fn inline_align(_context: fidl::encoding::Context) -> usize {
5312            8
5313        }
5314
5315        #[inline(always)]
5316        fn inline_size(_context: fidl::encoding::Context) -> usize {
5317            680
5318        }
5319    }
5320
5321    unsafe impl fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
5322        for &mut ArraysStruct
5323    {
5324        #[inline]
5325        unsafe fn encode(
5326            self,
5327            encoder: &mut fidl::encoding::Encoder<
5328                '_,
5329                fidl::encoding::DefaultFuchsiaResourceDialect,
5330            >,
5331            offset: usize,
5332            _depth: fidl::encoding::Depth,
5333        ) -> fidl::Result<()> {
5334            encoder.debug_check_bounds::<ArraysStruct>(offset);
5335            // Delegate to tuple encoding.
5336            fidl::encoding::Encode::<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
5337                (
5338                    <fidl::encoding::Array<bool, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.bools),
5339                    <fidl::encoding::Array<i8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int8s),
5340                    <fidl::encoding::Array<i16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int16s),
5341                    <fidl::encoding::Array<i32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int32s),
5342                    <fidl::encoding::Array<i64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int64s),
5343                    <fidl::encoding::Array<u8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint8s),
5344                    <fidl::encoding::Array<u16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint16s),
5345                    <fidl::encoding::Array<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint32s),
5346                    <fidl::encoding::Array<u64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint64s),
5347                    <fidl::encoding::Array<f32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.float32s),
5348                    <fidl::encoding::Array<f64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.float64s),
5349                    <fidl::encoding::Array<DefaultEnum, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.enums),
5350                    <fidl::encoding::Array<DefaultBits, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.bits),
5351                    <fidl::encoding::Array<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 3> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handles),
5352                    <fidl::encoding::Array<fidl::encoding::Optional<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>>, 3> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.nullable_handles),
5353                    <fidl::encoding::Array<fidl::encoding::UnboundedString, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.strings),
5354                    <fidl::encoding::Array<fidl::encoding::Optional<fidl::encoding::UnboundedString>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_strings),
5355                    <fidl::encoding::Array<ThisIsAStruct, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.structs),
5356                    <fidl::encoding::Array<fidl::encoding::Boxed<ThisIsAStruct>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_structs),
5357                    <fidl::encoding::Array<ThisIsAUnion, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.unions),
5358                    <fidl::encoding::Array<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_unions),
5359                    <fidl::encoding::Array<fidl::encoding::Array<u32, 3>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.arrays),
5360                    <fidl::encoding::Array<fidl::encoding::UnboundedVector<u32>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.vectors),
5361                    <fidl::encoding::Array<fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_vectors),
5362                    <fidl::encoding::Array<ThisIsATable, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.tables),
5363                    <fidl::encoding::Array<ThisIsAXunion, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.xunions),
5364                ),
5365                encoder, offset, _depth
5366            )
5367        }
5368    }
5369    unsafe impl<
5370        T0: fidl::encoding::Encode<
5371                fidl::encoding::Array<bool, 3>,
5372                fidl::encoding::DefaultFuchsiaResourceDialect,
5373            >,
5374        T1: fidl::encoding::Encode<
5375                fidl::encoding::Array<i8, 3>,
5376                fidl::encoding::DefaultFuchsiaResourceDialect,
5377            >,
5378        T2: fidl::encoding::Encode<
5379                fidl::encoding::Array<i16, 3>,
5380                fidl::encoding::DefaultFuchsiaResourceDialect,
5381            >,
5382        T3: fidl::encoding::Encode<
5383                fidl::encoding::Array<i32, 3>,
5384                fidl::encoding::DefaultFuchsiaResourceDialect,
5385            >,
5386        T4: fidl::encoding::Encode<
5387                fidl::encoding::Array<i64, 3>,
5388                fidl::encoding::DefaultFuchsiaResourceDialect,
5389            >,
5390        T5: fidl::encoding::Encode<
5391                fidl::encoding::Array<u8, 3>,
5392                fidl::encoding::DefaultFuchsiaResourceDialect,
5393            >,
5394        T6: fidl::encoding::Encode<
5395                fidl::encoding::Array<u16, 3>,
5396                fidl::encoding::DefaultFuchsiaResourceDialect,
5397            >,
5398        T7: fidl::encoding::Encode<
5399                fidl::encoding::Array<u32, 3>,
5400                fidl::encoding::DefaultFuchsiaResourceDialect,
5401            >,
5402        T8: fidl::encoding::Encode<
5403                fidl::encoding::Array<u64, 3>,
5404                fidl::encoding::DefaultFuchsiaResourceDialect,
5405            >,
5406        T9: fidl::encoding::Encode<
5407                fidl::encoding::Array<f32, 3>,
5408                fidl::encoding::DefaultFuchsiaResourceDialect,
5409            >,
5410        T10: fidl::encoding::Encode<
5411                fidl::encoding::Array<f64, 3>,
5412                fidl::encoding::DefaultFuchsiaResourceDialect,
5413            >,
5414        T11: fidl::encoding::Encode<
5415                fidl::encoding::Array<DefaultEnum, 3>,
5416                fidl::encoding::DefaultFuchsiaResourceDialect,
5417            >,
5418        T12: fidl::encoding::Encode<
5419                fidl::encoding::Array<DefaultBits, 3>,
5420                fidl::encoding::DefaultFuchsiaResourceDialect,
5421            >,
5422        T13: fidl::encoding::Encode<
5423                fidl::encoding::Array<
5424                    fidl::encoding::HandleType<
5425                        fidl::Handle,
5426                        { fidl::ObjectType::NONE.into_raw() },
5427                        2147483648,
5428                    >,
5429                    3,
5430                >,
5431                fidl::encoding::DefaultFuchsiaResourceDialect,
5432            >,
5433        T14: fidl::encoding::Encode<
5434                fidl::encoding::Array<
5435                    fidl::encoding::Optional<
5436                        fidl::encoding::HandleType<
5437                            fidl::Handle,
5438                            { fidl::ObjectType::NONE.into_raw() },
5439                            2147483648,
5440                        >,
5441                    >,
5442                    3,
5443                >,
5444                fidl::encoding::DefaultFuchsiaResourceDialect,
5445            >,
5446        T15: fidl::encoding::Encode<
5447                fidl::encoding::Array<fidl::encoding::UnboundedString, 3>,
5448                fidl::encoding::DefaultFuchsiaResourceDialect,
5449            >,
5450        T16: fidl::encoding::Encode<
5451                fidl::encoding::Array<fidl::encoding::Optional<fidl::encoding::UnboundedString>, 3>,
5452                fidl::encoding::DefaultFuchsiaResourceDialect,
5453            >,
5454        T17: fidl::encoding::Encode<
5455                fidl::encoding::Array<ThisIsAStruct, 3>,
5456                fidl::encoding::DefaultFuchsiaResourceDialect,
5457            >,
5458        T18: fidl::encoding::Encode<
5459                fidl::encoding::Array<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
5460                fidl::encoding::DefaultFuchsiaResourceDialect,
5461            >,
5462        T19: fidl::encoding::Encode<
5463                fidl::encoding::Array<ThisIsAUnion, 3>,
5464                fidl::encoding::DefaultFuchsiaResourceDialect,
5465            >,
5466        T20: fidl::encoding::Encode<
5467                fidl::encoding::Array<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
5468                fidl::encoding::DefaultFuchsiaResourceDialect,
5469            >,
5470        T21: fidl::encoding::Encode<
5471                fidl::encoding::Array<fidl::encoding::Array<u32, 3>, 3>,
5472                fidl::encoding::DefaultFuchsiaResourceDialect,
5473            >,
5474        T22: fidl::encoding::Encode<
5475                fidl::encoding::Array<fidl::encoding::UnboundedVector<u32>, 3>,
5476                fidl::encoding::DefaultFuchsiaResourceDialect,
5477            >,
5478        T23: fidl::encoding::Encode<
5479                fidl::encoding::Array<
5480                    fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
5481                    3,
5482                >,
5483                fidl::encoding::DefaultFuchsiaResourceDialect,
5484            >,
5485        T24: fidl::encoding::Encode<
5486                fidl::encoding::Array<ThisIsATable, 3>,
5487                fidl::encoding::DefaultFuchsiaResourceDialect,
5488            >,
5489        T25: fidl::encoding::Encode<
5490                fidl::encoding::Array<ThisIsAXunion, 3>,
5491                fidl::encoding::DefaultFuchsiaResourceDialect,
5492            >,
5493    > fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
5494        for (
5495            T0,
5496            T1,
5497            T2,
5498            T3,
5499            T4,
5500            T5,
5501            T6,
5502            T7,
5503            T8,
5504            T9,
5505            T10,
5506            T11,
5507            T12,
5508            T13,
5509            T14,
5510            T15,
5511            T16,
5512            T17,
5513            T18,
5514            T19,
5515            T20,
5516            T21,
5517            T22,
5518            T23,
5519            T24,
5520            T25,
5521        )
5522    {
5523        #[inline]
5524        unsafe fn encode(
5525            self,
5526            encoder: &mut fidl::encoding::Encoder<
5527                '_,
5528                fidl::encoding::DefaultFuchsiaResourceDialect,
5529            >,
5530            offset: usize,
5531            depth: fidl::encoding::Depth,
5532        ) -> fidl::Result<()> {
5533            encoder.debug_check_bounds::<ArraysStruct>(offset);
5534            // Zero out padding regions. There's no need to apply masks
5535            // because the unmasked parts will be overwritten by fields.
5536            unsafe {
5537                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(48);
5538                (ptr as *mut u64).write_unaligned(0);
5539            }
5540            unsafe {
5541                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(56);
5542                (ptr as *mut u64).write_unaligned(0);
5543            }
5544            unsafe {
5545                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(104);
5546                (ptr as *mut u64).write_unaligned(0);
5547            }
5548            unsafe {
5549                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(480);
5550                (ptr as *mut u64).write_unaligned(0);
5551            }
5552            // Write the fields.
5553            self.0.encode(encoder, offset + 0, depth)?;
5554            self.1.encode(encoder, offset + 3, depth)?;
5555            self.2.encode(encoder, offset + 6, depth)?;
5556            self.3.encode(encoder, offset + 12, depth)?;
5557            self.4.encode(encoder, offset + 24, depth)?;
5558            self.5.encode(encoder, offset + 48, depth)?;
5559            self.6.encode(encoder, offset + 52, depth)?;
5560            self.7.encode(encoder, offset + 60, depth)?;
5561            self.8.encode(encoder, offset + 72, depth)?;
5562            self.9.encode(encoder, offset + 96, depth)?;
5563            self.10.encode(encoder, offset + 112, depth)?;
5564            self.11.encode(encoder, offset + 136, depth)?;
5565            self.12.encode(encoder, offset + 148, depth)?;
5566            self.13.encode(encoder, offset + 160, depth)?;
5567            self.14.encode(encoder, offset + 172, depth)?;
5568            self.15.encode(encoder, offset + 184, depth)?;
5569            self.16.encode(encoder, offset + 232, depth)?;
5570            self.17.encode(encoder, offset + 280, depth)?;
5571            self.18.encode(encoder, offset + 328, depth)?;
5572            self.19.encode(encoder, offset + 352, depth)?;
5573            self.20.encode(encoder, offset + 400, depth)?;
5574            self.21.encode(encoder, offset + 448, depth)?;
5575            self.22.encode(encoder, offset + 488, depth)?;
5576            self.23.encode(encoder, offset + 536, depth)?;
5577            self.24.encode(encoder, offset + 584, depth)?;
5578            self.25.encode(encoder, offset + 632, depth)?;
5579            Ok(())
5580        }
5581    }
5582
5583    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for ArraysStruct {
5584        #[inline(always)]
5585        fn new_empty() -> Self {
5586            Self {
5587                bools: fidl::new_empty!(fidl::encoding::Array<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5588                int8s: fidl::new_empty!(fidl::encoding::Array<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5589                int16s: fidl::new_empty!(fidl::encoding::Array<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5590                int32s: fidl::new_empty!(fidl::encoding::Array<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5591                int64s: fidl::new_empty!(fidl::encoding::Array<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5592                uint8s: fidl::new_empty!(fidl::encoding::Array<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5593                uint16s: fidl::new_empty!(fidl::encoding::Array<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5594                uint32s: fidl::new_empty!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5595                uint64s: fidl::new_empty!(fidl::encoding::Array<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5596                float32s: fidl::new_empty!(fidl::encoding::Array<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5597                float64s: fidl::new_empty!(fidl::encoding::Array<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5598                enums: fidl::new_empty!(fidl::encoding::Array<DefaultEnum, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5599                bits: fidl::new_empty!(fidl::encoding::Array<DefaultBits, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5600                handles: fidl::new_empty!(
5601                    fidl::encoding::Array<
5602                        fidl::encoding::HandleType<
5603                            fidl::Handle,
5604                            { fidl::ObjectType::NONE.into_raw() },
5605                            2147483648,
5606                        >,
5607                        3,
5608                    >,
5609                    fidl::encoding::DefaultFuchsiaResourceDialect
5610                ),
5611                nullable_handles: fidl::new_empty!(
5612                    fidl::encoding::Array<
5613                        fidl::encoding::Optional<
5614                            fidl::encoding::HandleType<
5615                                fidl::Handle,
5616                                { fidl::ObjectType::NONE.into_raw() },
5617                                2147483648,
5618                            >,
5619                        >,
5620                        3,
5621                    >,
5622                    fidl::encoding::DefaultFuchsiaResourceDialect
5623                ),
5624                strings: fidl::new_empty!(fidl::encoding::Array<fidl::encoding::UnboundedString, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5625                nullable_strings: fidl::new_empty!(
5626                    fidl::encoding::Array<
5627                        fidl::encoding::Optional<fidl::encoding::UnboundedString>,
5628                        3,
5629                    >,
5630                    fidl::encoding::DefaultFuchsiaResourceDialect
5631                ),
5632                structs: fidl::new_empty!(fidl::encoding::Array<ThisIsAStruct, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5633                nullable_structs: fidl::new_empty!(
5634                    fidl::encoding::Array<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
5635                    fidl::encoding::DefaultFuchsiaResourceDialect
5636                ),
5637                unions: fidl::new_empty!(fidl::encoding::Array<ThisIsAUnion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5638                nullable_unions: fidl::new_empty!(
5639                    fidl::encoding::Array<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
5640                    fidl::encoding::DefaultFuchsiaResourceDialect
5641                ),
5642                arrays: fidl::new_empty!(
5643                    fidl::encoding::Array<fidl::encoding::Array<u32, 3>, 3>,
5644                    fidl::encoding::DefaultFuchsiaResourceDialect
5645                ),
5646                vectors: fidl::new_empty!(
5647                    fidl::encoding::Array<fidl::encoding::UnboundedVector<u32>, 3>,
5648                    fidl::encoding::DefaultFuchsiaResourceDialect
5649                ),
5650                nullable_vectors: fidl::new_empty!(
5651                    fidl::encoding::Array<
5652                        fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
5653                        3,
5654                    >,
5655                    fidl::encoding::DefaultFuchsiaResourceDialect
5656                ),
5657                tables: fidl::new_empty!(fidl::encoding::Array<ThisIsATable, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5658                xunions: fidl::new_empty!(fidl::encoding::Array<ThisIsAXunion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5659            }
5660        }
5661
5662        #[inline]
5663        unsafe fn decode(
5664            &mut self,
5665            decoder: &mut fidl::encoding::Decoder<
5666                '_,
5667                fidl::encoding::DefaultFuchsiaResourceDialect,
5668            >,
5669            offset: usize,
5670            _depth: fidl::encoding::Depth,
5671        ) -> fidl::Result<()> {
5672            decoder.debug_check_bounds::<Self>(offset);
5673            // Verify that padding bytes are zero.
5674            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(48) };
5675            let padval = unsafe { (ptr as *const u64).read_unaligned() };
5676            let mask = 0xff000000u64;
5677            let maskedval = padval & mask;
5678            if maskedval != 0 {
5679                return Err(fidl::Error::NonZeroPadding {
5680                    padding_start: offset + 48 + ((mask as u64).trailing_zeros() / 8) as usize,
5681                });
5682            }
5683            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(56) };
5684            let padval = unsafe { (ptr as *const u64).read_unaligned() };
5685            let mask = 0xffff0000u64;
5686            let maskedval = padval & mask;
5687            if maskedval != 0 {
5688                return Err(fidl::Error::NonZeroPadding {
5689                    padding_start: offset + 56 + ((mask as u64).trailing_zeros() / 8) as usize,
5690                });
5691            }
5692            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(104) };
5693            let padval = unsafe { (ptr as *const u64).read_unaligned() };
5694            let mask = 0xffffffff00000000u64;
5695            let maskedval = padval & mask;
5696            if maskedval != 0 {
5697                return Err(fidl::Error::NonZeroPadding {
5698                    padding_start: offset + 104 + ((mask as u64).trailing_zeros() / 8) as usize,
5699                });
5700            }
5701            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(480) };
5702            let padval = unsafe { (ptr as *const u64).read_unaligned() };
5703            let mask = 0xffffffff00000000u64;
5704            let maskedval = padval & mask;
5705            if maskedval != 0 {
5706                return Err(fidl::Error::NonZeroPadding {
5707                    padding_start: offset + 480 + ((mask as u64).trailing_zeros() / 8) as usize,
5708                });
5709            }
5710            fidl::decode!(fidl::encoding::Array<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.bools, decoder, offset + 0, _depth)?;
5711            fidl::decode!(fidl::encoding::Array<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int8s, decoder, offset + 3, _depth)?;
5712            fidl::decode!(fidl::encoding::Array<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int16s, decoder, offset + 6, _depth)?;
5713            fidl::decode!(fidl::encoding::Array<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int32s, decoder, offset + 12, _depth)?;
5714            fidl::decode!(fidl::encoding::Array<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int64s, decoder, offset + 24, _depth)?;
5715            fidl::decode!(fidl::encoding::Array<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint8s, decoder, offset + 48, _depth)?;
5716            fidl::decode!(fidl::encoding::Array<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint16s, decoder, offset + 52, _depth)?;
5717            fidl::decode!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint32s, decoder, offset + 60, _depth)?;
5718            fidl::decode!(fidl::encoding::Array<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint64s, decoder, offset + 72, _depth)?;
5719            fidl::decode!(fidl::encoding::Array<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.float32s, decoder, offset + 96, _depth)?;
5720            fidl::decode!(fidl::encoding::Array<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.float64s, decoder, offset + 112, _depth)?;
5721            fidl::decode!(fidl::encoding::Array<DefaultEnum, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.enums, decoder, offset + 136, _depth)?;
5722            fidl::decode!(fidl::encoding::Array<DefaultBits, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.bits, decoder, offset + 148, _depth)?;
5723            fidl::decode!(
5724                fidl::encoding::Array<
5725                    fidl::encoding::HandleType<
5726                        fidl::Handle,
5727                        { fidl::ObjectType::NONE.into_raw() },
5728                        2147483648,
5729                    >,
5730                    3,
5731                >,
5732                fidl::encoding::DefaultFuchsiaResourceDialect,
5733                &mut self.handles,
5734                decoder,
5735                offset + 160,
5736                _depth
5737            )?;
5738            fidl::decode!(
5739                fidl::encoding::Array<
5740                    fidl::encoding::Optional<
5741                        fidl::encoding::HandleType<
5742                            fidl::Handle,
5743                            { fidl::ObjectType::NONE.into_raw() },
5744                            2147483648,
5745                        >,
5746                    >,
5747                    3,
5748                >,
5749                fidl::encoding::DefaultFuchsiaResourceDialect,
5750                &mut self.nullable_handles,
5751                decoder,
5752                offset + 172,
5753                _depth
5754            )?;
5755            fidl::decode!(fidl::encoding::Array<fidl::encoding::UnboundedString, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.strings, decoder, offset + 184, _depth)?;
5756            fidl::decode!(
5757                fidl::encoding::Array<fidl::encoding::Optional<fidl::encoding::UnboundedString>, 3>,
5758                fidl::encoding::DefaultFuchsiaResourceDialect,
5759                &mut self.nullable_strings,
5760                decoder,
5761                offset + 232,
5762                _depth
5763            )?;
5764            fidl::decode!(fidl::encoding::Array<ThisIsAStruct, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.structs, decoder, offset + 280, _depth)?;
5765            fidl::decode!(
5766                fidl::encoding::Array<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
5767                fidl::encoding::DefaultFuchsiaResourceDialect,
5768                &mut self.nullable_structs,
5769                decoder,
5770                offset + 328,
5771                _depth
5772            )?;
5773            fidl::decode!(fidl::encoding::Array<ThisIsAUnion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.unions, decoder, offset + 352, _depth)?;
5774            fidl::decode!(
5775                fidl::encoding::Array<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
5776                fidl::encoding::DefaultFuchsiaResourceDialect,
5777                &mut self.nullable_unions,
5778                decoder,
5779                offset + 400,
5780                _depth
5781            )?;
5782            fidl::decode!(
5783                fidl::encoding::Array<fidl::encoding::Array<u32, 3>, 3>,
5784                fidl::encoding::DefaultFuchsiaResourceDialect,
5785                &mut self.arrays,
5786                decoder,
5787                offset + 448,
5788                _depth
5789            )?;
5790            fidl::decode!(
5791                fidl::encoding::Array<fidl::encoding::UnboundedVector<u32>, 3>,
5792                fidl::encoding::DefaultFuchsiaResourceDialect,
5793                &mut self.vectors,
5794                decoder,
5795                offset + 488,
5796                _depth
5797            )?;
5798            fidl::decode!(
5799                fidl::encoding::Array<
5800                    fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
5801                    3,
5802                >,
5803                fidl::encoding::DefaultFuchsiaResourceDialect,
5804                &mut self.nullable_vectors,
5805                decoder,
5806                offset + 536,
5807                _depth
5808            )?;
5809            fidl::decode!(fidl::encoding::Array<ThisIsATable, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.tables, decoder, offset + 584, _depth)?;
5810            fidl::decode!(fidl::encoding::Array<ThisIsAXunion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.xunions, decoder, offset + 632, _depth)?;
5811            Ok(())
5812        }
5813    }
5814
5815    impl fidl::encoding::ResourceTypeMarker for EchoEchoArraysRequest {
5816        type Borrowed<'a> = &'a mut Self;
5817        fn take_or_borrow<'a>(
5818            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
5819        ) -> Self::Borrowed<'a> {
5820            value
5821        }
5822    }
5823
5824    unsafe impl fidl::encoding::TypeMarker for EchoEchoArraysRequest {
5825        type Owned = Self;
5826
5827        #[inline(always)]
5828        fn inline_align(_context: fidl::encoding::Context) -> usize {
5829            8
5830        }
5831
5832        #[inline(always)]
5833        fn inline_size(_context: fidl::encoding::Context) -> usize {
5834            696
5835        }
5836    }
5837
5838    unsafe impl
5839        fidl::encoding::Encode<EchoEchoArraysRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
5840        for &mut EchoEchoArraysRequest
5841    {
5842        #[inline]
5843        unsafe fn encode(
5844            self,
5845            encoder: &mut fidl::encoding::Encoder<
5846                '_,
5847                fidl::encoding::DefaultFuchsiaResourceDialect,
5848            >,
5849            offset: usize,
5850            _depth: fidl::encoding::Depth,
5851        ) -> fidl::Result<()> {
5852            encoder.debug_check_bounds::<EchoEchoArraysRequest>(offset);
5853            // Delegate to tuple encoding.
5854            fidl::encoding::Encode::<
5855                EchoEchoArraysRequest,
5856                fidl::encoding::DefaultFuchsiaResourceDialect,
5857            >::encode(
5858                (
5859                    <ArraysStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
5860                        &mut self.value,
5861                    ),
5862                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
5863                        &self.forward_to_server,
5864                    ),
5865                ),
5866                encoder,
5867                offset,
5868                _depth,
5869            )
5870        }
5871    }
5872    unsafe impl<
5873        T0: fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
5874        T1: fidl::encoding::Encode<
5875                fidl::encoding::UnboundedString,
5876                fidl::encoding::DefaultFuchsiaResourceDialect,
5877            >,
5878    >
5879        fidl::encoding::Encode<EchoEchoArraysRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
5880        for (T0, T1)
5881    {
5882        #[inline]
5883        unsafe fn encode(
5884            self,
5885            encoder: &mut fidl::encoding::Encoder<
5886                '_,
5887                fidl::encoding::DefaultFuchsiaResourceDialect,
5888            >,
5889            offset: usize,
5890            depth: fidl::encoding::Depth,
5891        ) -> fidl::Result<()> {
5892            encoder.debug_check_bounds::<EchoEchoArraysRequest>(offset);
5893            // Zero out padding regions. There's no need to apply masks
5894            // because the unmasked parts will be overwritten by fields.
5895            // Write the fields.
5896            self.0.encode(encoder, offset + 0, depth)?;
5897            self.1.encode(encoder, offset + 680, depth)?;
5898            Ok(())
5899        }
5900    }
5901
5902    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
5903        for EchoEchoArraysRequest
5904    {
5905        #[inline(always)]
5906        fn new_empty() -> Self {
5907            Self {
5908                value: fidl::new_empty!(
5909                    ArraysStruct,
5910                    fidl::encoding::DefaultFuchsiaResourceDialect
5911                ),
5912                forward_to_server: fidl::new_empty!(
5913                    fidl::encoding::UnboundedString,
5914                    fidl::encoding::DefaultFuchsiaResourceDialect
5915                ),
5916            }
5917        }
5918
5919        #[inline]
5920        unsafe fn decode(
5921            &mut self,
5922            decoder: &mut fidl::encoding::Decoder<
5923                '_,
5924                fidl::encoding::DefaultFuchsiaResourceDialect,
5925            >,
5926            offset: usize,
5927            _depth: fidl::encoding::Depth,
5928        ) -> fidl::Result<()> {
5929            decoder.debug_check_bounds::<Self>(offset);
5930            // Verify that padding bytes are zero.
5931            fidl::decode!(
5932                ArraysStruct,
5933                fidl::encoding::DefaultFuchsiaResourceDialect,
5934                &mut self.value,
5935                decoder,
5936                offset + 0,
5937                _depth
5938            )?;
5939            fidl::decode!(
5940                fidl::encoding::UnboundedString,
5941                fidl::encoding::DefaultFuchsiaResourceDialect,
5942                &mut self.forward_to_server,
5943                decoder,
5944                offset + 680,
5945                _depth
5946            )?;
5947            Ok(())
5948        }
5949    }
5950
5951    impl fidl::encoding::ResourceTypeMarker for EchoEchoArraysResponse {
5952        type Borrowed<'a> = &'a mut Self;
5953        fn take_or_borrow<'a>(
5954            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
5955        ) -> Self::Borrowed<'a> {
5956            value
5957        }
5958    }
5959
5960    unsafe impl fidl::encoding::TypeMarker for EchoEchoArraysResponse {
5961        type Owned = Self;
5962
5963        #[inline(always)]
5964        fn inline_align(_context: fidl::encoding::Context) -> usize {
5965            8
5966        }
5967
5968        #[inline(always)]
5969        fn inline_size(_context: fidl::encoding::Context) -> usize {
5970            680
5971        }
5972    }
5973
5974    unsafe impl
5975        fidl::encoding::Encode<
5976            EchoEchoArraysResponse,
5977            fidl::encoding::DefaultFuchsiaResourceDialect,
5978        > for &mut EchoEchoArraysResponse
5979    {
5980        #[inline]
5981        unsafe fn encode(
5982            self,
5983            encoder: &mut fidl::encoding::Encoder<
5984                '_,
5985                fidl::encoding::DefaultFuchsiaResourceDialect,
5986            >,
5987            offset: usize,
5988            _depth: fidl::encoding::Depth,
5989        ) -> fidl::Result<()> {
5990            encoder.debug_check_bounds::<EchoEchoArraysResponse>(offset);
5991            // Delegate to tuple encoding.
5992            fidl::encoding::Encode::<
5993                EchoEchoArraysResponse,
5994                fidl::encoding::DefaultFuchsiaResourceDialect,
5995            >::encode(
5996                (<ArraysStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
5997                    &mut self.value,
5998                ),),
5999                encoder,
6000                offset,
6001                _depth,
6002            )
6003        }
6004    }
6005    unsafe impl<
6006        T0: fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
6007    >
6008        fidl::encoding::Encode<
6009            EchoEchoArraysResponse,
6010            fidl::encoding::DefaultFuchsiaResourceDialect,
6011        > for (T0,)
6012    {
6013        #[inline]
6014        unsafe fn encode(
6015            self,
6016            encoder: &mut fidl::encoding::Encoder<
6017                '_,
6018                fidl::encoding::DefaultFuchsiaResourceDialect,
6019            >,
6020            offset: usize,
6021            depth: fidl::encoding::Depth,
6022        ) -> fidl::Result<()> {
6023            encoder.debug_check_bounds::<EchoEchoArraysResponse>(offset);
6024            // Zero out padding regions. There's no need to apply masks
6025            // because the unmasked parts will be overwritten by fields.
6026            // Write the fields.
6027            self.0.encode(encoder, offset + 0, depth)?;
6028            Ok(())
6029        }
6030    }
6031
6032    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6033        for EchoEchoArraysResponse
6034    {
6035        #[inline(always)]
6036        fn new_empty() -> Self {
6037            Self {
6038                value: fidl::new_empty!(
6039                    ArraysStruct,
6040                    fidl::encoding::DefaultFuchsiaResourceDialect
6041                ),
6042            }
6043        }
6044
6045        #[inline]
6046        unsafe fn decode(
6047            &mut self,
6048            decoder: &mut fidl::encoding::Decoder<
6049                '_,
6050                fidl::encoding::DefaultFuchsiaResourceDialect,
6051            >,
6052            offset: usize,
6053            _depth: fidl::encoding::Depth,
6054        ) -> fidl::Result<()> {
6055            decoder.debug_check_bounds::<Self>(offset);
6056            // Verify that padding bytes are zero.
6057            fidl::decode!(
6058                ArraysStruct,
6059                fidl::encoding::DefaultFuchsiaResourceDialect,
6060                &mut self.value,
6061                decoder,
6062                offset + 0,
6063                _depth
6064            )?;
6065            Ok(())
6066        }
6067    }
6068
6069    impl fidl::encoding::ResourceTypeMarker for EchoEchoArraysWithErrorRequest {
6070        type Borrowed<'a> = &'a mut Self;
6071        fn take_or_borrow<'a>(
6072            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6073        ) -> Self::Borrowed<'a> {
6074            value
6075        }
6076    }
6077
6078    unsafe impl fidl::encoding::TypeMarker for EchoEchoArraysWithErrorRequest {
6079        type Owned = Self;
6080
6081        #[inline(always)]
6082        fn inline_align(_context: fidl::encoding::Context) -> usize {
6083            8
6084        }
6085
6086        #[inline(always)]
6087        fn inline_size(_context: fidl::encoding::Context) -> usize {
6088            712
6089        }
6090    }
6091
6092    unsafe impl
6093        fidl::encoding::Encode<
6094            EchoEchoArraysWithErrorRequest,
6095            fidl::encoding::DefaultFuchsiaResourceDialect,
6096        > for &mut EchoEchoArraysWithErrorRequest
6097    {
6098        #[inline]
6099        unsafe fn encode(
6100            self,
6101            encoder: &mut fidl::encoding::Encoder<
6102                '_,
6103                fidl::encoding::DefaultFuchsiaResourceDialect,
6104            >,
6105            offset: usize,
6106            _depth: fidl::encoding::Depth,
6107        ) -> fidl::Result<()> {
6108            encoder.debug_check_bounds::<EchoEchoArraysWithErrorRequest>(offset);
6109            // Delegate to tuple encoding.
6110            fidl::encoding::Encode::<
6111                EchoEchoArraysWithErrorRequest,
6112                fidl::encoding::DefaultFuchsiaResourceDialect,
6113            >::encode(
6114                (
6115                    <ArraysStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
6116                        &mut self.value,
6117                    ),
6118                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
6119                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
6120                        &self.forward_to_server,
6121                    ),
6122                    <RespondWith as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
6123                ),
6124                encoder,
6125                offset,
6126                _depth,
6127            )
6128        }
6129    }
6130    unsafe impl<
6131        T0: fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
6132        T1: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
6133        T2: fidl::encoding::Encode<
6134                fidl::encoding::UnboundedString,
6135                fidl::encoding::DefaultFuchsiaResourceDialect,
6136            >,
6137        T3: fidl::encoding::Encode<RespondWith, fidl::encoding::DefaultFuchsiaResourceDialect>,
6138    >
6139        fidl::encoding::Encode<
6140            EchoEchoArraysWithErrorRequest,
6141            fidl::encoding::DefaultFuchsiaResourceDialect,
6142        > for (T0, T1, T2, T3)
6143    {
6144        #[inline]
6145        unsafe fn encode(
6146            self,
6147            encoder: &mut fidl::encoding::Encoder<
6148                '_,
6149                fidl::encoding::DefaultFuchsiaResourceDialect,
6150            >,
6151            offset: usize,
6152            depth: fidl::encoding::Depth,
6153        ) -> fidl::Result<()> {
6154            encoder.debug_check_bounds::<EchoEchoArraysWithErrorRequest>(offset);
6155            // Zero out padding regions. There's no need to apply masks
6156            // because the unmasked parts will be overwritten by fields.
6157            unsafe {
6158                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(680);
6159                (ptr as *mut u64).write_unaligned(0);
6160            }
6161            unsafe {
6162                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(704);
6163                (ptr as *mut u64).write_unaligned(0);
6164            }
6165            // Write the fields.
6166            self.0.encode(encoder, offset + 0, depth)?;
6167            self.1.encode(encoder, offset + 680, depth)?;
6168            self.2.encode(encoder, offset + 688, depth)?;
6169            self.3.encode(encoder, offset + 704, depth)?;
6170            Ok(())
6171        }
6172    }
6173
6174    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6175        for EchoEchoArraysWithErrorRequest
6176    {
6177        #[inline(always)]
6178        fn new_empty() -> Self {
6179            Self {
6180                value: fidl::new_empty!(
6181                    ArraysStruct,
6182                    fidl::encoding::DefaultFuchsiaResourceDialect
6183                ),
6184                result_err: fidl::new_empty!(
6185                    DefaultEnum,
6186                    fidl::encoding::DefaultFuchsiaResourceDialect
6187                ),
6188                forward_to_server: fidl::new_empty!(
6189                    fidl::encoding::UnboundedString,
6190                    fidl::encoding::DefaultFuchsiaResourceDialect
6191                ),
6192                result_variant: fidl::new_empty!(
6193                    RespondWith,
6194                    fidl::encoding::DefaultFuchsiaResourceDialect
6195                ),
6196            }
6197        }
6198
6199        #[inline]
6200        unsafe fn decode(
6201            &mut self,
6202            decoder: &mut fidl::encoding::Decoder<
6203                '_,
6204                fidl::encoding::DefaultFuchsiaResourceDialect,
6205            >,
6206            offset: usize,
6207            _depth: fidl::encoding::Depth,
6208        ) -> fidl::Result<()> {
6209            decoder.debug_check_bounds::<Self>(offset);
6210            // Verify that padding bytes are zero.
6211            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(680) };
6212            let padval = unsafe { (ptr as *const u64).read_unaligned() };
6213            let mask = 0xffffffff00000000u64;
6214            let maskedval = padval & mask;
6215            if maskedval != 0 {
6216                return Err(fidl::Error::NonZeroPadding {
6217                    padding_start: offset + 680 + ((mask as u64).trailing_zeros() / 8) as usize,
6218                });
6219            }
6220            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(704) };
6221            let padval = unsafe { (ptr as *const u64).read_unaligned() };
6222            let mask = 0xffffffff00000000u64;
6223            let maskedval = padval & mask;
6224            if maskedval != 0 {
6225                return Err(fidl::Error::NonZeroPadding {
6226                    padding_start: offset + 704 + ((mask as u64).trailing_zeros() / 8) as usize,
6227                });
6228            }
6229            fidl::decode!(
6230                ArraysStruct,
6231                fidl::encoding::DefaultFuchsiaResourceDialect,
6232                &mut self.value,
6233                decoder,
6234                offset + 0,
6235                _depth
6236            )?;
6237            fidl::decode!(
6238                DefaultEnum,
6239                fidl::encoding::DefaultFuchsiaResourceDialect,
6240                &mut self.result_err,
6241                decoder,
6242                offset + 680,
6243                _depth
6244            )?;
6245            fidl::decode!(
6246                fidl::encoding::UnboundedString,
6247                fidl::encoding::DefaultFuchsiaResourceDialect,
6248                &mut self.forward_to_server,
6249                decoder,
6250                offset + 688,
6251                _depth
6252            )?;
6253            fidl::decode!(
6254                RespondWith,
6255                fidl::encoding::DefaultFuchsiaResourceDialect,
6256                &mut self.result_variant,
6257                decoder,
6258                offset + 704,
6259                _depth
6260            )?;
6261            Ok(())
6262        }
6263    }
6264
6265    impl fidl::encoding::ResourceTypeMarker for EchoEchoEventRequest {
6266        type Borrowed<'a> = &'a mut Self;
6267        fn take_or_borrow<'a>(
6268            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6269        ) -> Self::Borrowed<'a> {
6270            value
6271        }
6272    }
6273
6274    unsafe impl fidl::encoding::TypeMarker for EchoEchoEventRequest {
6275        type Owned = Self;
6276
6277        #[inline(always)]
6278        fn inline_align(_context: fidl::encoding::Context) -> usize {
6279            8
6280        }
6281
6282        #[inline(always)]
6283        fn inline_size(_context: fidl::encoding::Context) -> usize {
6284            2912
6285        }
6286    }
6287
6288    unsafe impl
6289        fidl::encoding::Encode<EchoEchoEventRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
6290        for &mut EchoEchoEventRequest
6291    {
6292        #[inline]
6293        unsafe fn encode(
6294            self,
6295            encoder: &mut fidl::encoding::Encoder<
6296                '_,
6297                fidl::encoding::DefaultFuchsiaResourceDialect,
6298            >,
6299            offset: usize,
6300            _depth: fidl::encoding::Depth,
6301        ) -> fidl::Result<()> {
6302            encoder.debug_check_bounds::<EchoEchoEventRequest>(offset);
6303            // Delegate to tuple encoding.
6304            fidl::encoding::Encode::<
6305                EchoEchoEventRequest,
6306                fidl::encoding::DefaultFuchsiaResourceDialect,
6307            >::encode(
6308                (<Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),),
6309                encoder,
6310                offset,
6311                _depth,
6312            )
6313        }
6314    }
6315    unsafe impl<T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>>
6316        fidl::encoding::Encode<EchoEchoEventRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
6317        for (T0,)
6318    {
6319        #[inline]
6320        unsafe fn encode(
6321            self,
6322            encoder: &mut fidl::encoding::Encoder<
6323                '_,
6324                fidl::encoding::DefaultFuchsiaResourceDialect,
6325            >,
6326            offset: usize,
6327            depth: fidl::encoding::Depth,
6328        ) -> fidl::Result<()> {
6329            encoder.debug_check_bounds::<EchoEchoEventRequest>(offset);
6330            // Zero out padding regions. There's no need to apply masks
6331            // because the unmasked parts will be overwritten by fields.
6332            // Write the fields.
6333            self.0.encode(encoder, offset + 0, depth)?;
6334            Ok(())
6335        }
6336    }
6337
6338    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6339        for EchoEchoEventRequest
6340    {
6341        #[inline(always)]
6342        fn new_empty() -> Self {
6343            Self { value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect) }
6344        }
6345
6346        #[inline]
6347        unsafe fn decode(
6348            &mut self,
6349            decoder: &mut fidl::encoding::Decoder<
6350                '_,
6351                fidl::encoding::DefaultFuchsiaResourceDialect,
6352            >,
6353            offset: usize,
6354            _depth: fidl::encoding::Depth,
6355        ) -> fidl::Result<()> {
6356            decoder.debug_check_bounds::<Self>(offset);
6357            // Verify that padding bytes are zero.
6358            fidl::decode!(
6359                Struct,
6360                fidl::encoding::DefaultFuchsiaResourceDialect,
6361                &mut self.value,
6362                decoder,
6363                offset + 0,
6364                _depth
6365            )?;
6366            Ok(())
6367        }
6368    }
6369
6370    impl fidl::encoding::ResourceTypeMarker for EchoEchoStructNoRetValRequest {
6371        type Borrowed<'a> = &'a mut Self;
6372        fn take_or_borrow<'a>(
6373            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6374        ) -> Self::Borrowed<'a> {
6375            value
6376        }
6377    }
6378
6379    unsafe impl fidl::encoding::TypeMarker for EchoEchoStructNoRetValRequest {
6380        type Owned = Self;
6381
6382        #[inline(always)]
6383        fn inline_align(_context: fidl::encoding::Context) -> usize {
6384            8
6385        }
6386
6387        #[inline(always)]
6388        fn inline_size(_context: fidl::encoding::Context) -> usize {
6389            2928
6390        }
6391    }
6392
6393    unsafe impl
6394        fidl::encoding::Encode<
6395            EchoEchoStructNoRetValRequest,
6396            fidl::encoding::DefaultFuchsiaResourceDialect,
6397        > for &mut EchoEchoStructNoRetValRequest
6398    {
6399        #[inline]
6400        unsafe fn encode(
6401            self,
6402            encoder: &mut fidl::encoding::Encoder<
6403                '_,
6404                fidl::encoding::DefaultFuchsiaResourceDialect,
6405            >,
6406            offset: usize,
6407            _depth: fidl::encoding::Depth,
6408        ) -> fidl::Result<()> {
6409            encoder.debug_check_bounds::<EchoEchoStructNoRetValRequest>(offset);
6410            // Delegate to tuple encoding.
6411            fidl::encoding::Encode::<
6412                EchoEchoStructNoRetValRequest,
6413                fidl::encoding::DefaultFuchsiaResourceDialect,
6414            >::encode(
6415                (
6416                    <Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
6417                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
6418                        &self.forward_to_server,
6419                    ),
6420                ),
6421                encoder,
6422                offset,
6423                _depth,
6424            )
6425        }
6426    }
6427    unsafe impl<
6428        T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>,
6429        T1: fidl::encoding::Encode<
6430                fidl::encoding::UnboundedString,
6431                fidl::encoding::DefaultFuchsiaResourceDialect,
6432            >,
6433    >
6434        fidl::encoding::Encode<
6435            EchoEchoStructNoRetValRequest,
6436            fidl::encoding::DefaultFuchsiaResourceDialect,
6437        > for (T0, T1)
6438    {
6439        #[inline]
6440        unsafe fn encode(
6441            self,
6442            encoder: &mut fidl::encoding::Encoder<
6443                '_,
6444                fidl::encoding::DefaultFuchsiaResourceDialect,
6445            >,
6446            offset: usize,
6447            depth: fidl::encoding::Depth,
6448        ) -> fidl::Result<()> {
6449            encoder.debug_check_bounds::<EchoEchoStructNoRetValRequest>(offset);
6450            // Zero out padding regions. There's no need to apply masks
6451            // because the unmasked parts will be overwritten by fields.
6452            // Write the fields.
6453            self.0.encode(encoder, offset + 0, depth)?;
6454            self.1.encode(encoder, offset + 2912, depth)?;
6455            Ok(())
6456        }
6457    }
6458
6459    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6460        for EchoEchoStructNoRetValRequest
6461    {
6462        #[inline(always)]
6463        fn new_empty() -> Self {
6464            Self {
6465                value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect),
6466                forward_to_server: fidl::new_empty!(
6467                    fidl::encoding::UnboundedString,
6468                    fidl::encoding::DefaultFuchsiaResourceDialect
6469                ),
6470            }
6471        }
6472
6473        #[inline]
6474        unsafe fn decode(
6475            &mut self,
6476            decoder: &mut fidl::encoding::Decoder<
6477                '_,
6478                fidl::encoding::DefaultFuchsiaResourceDialect,
6479            >,
6480            offset: usize,
6481            _depth: fidl::encoding::Depth,
6482        ) -> fidl::Result<()> {
6483            decoder.debug_check_bounds::<Self>(offset);
6484            // Verify that padding bytes are zero.
6485            fidl::decode!(
6486                Struct,
6487                fidl::encoding::DefaultFuchsiaResourceDialect,
6488                &mut self.value,
6489                decoder,
6490                offset + 0,
6491                _depth
6492            )?;
6493            fidl::decode!(
6494                fidl::encoding::UnboundedString,
6495                fidl::encoding::DefaultFuchsiaResourceDialect,
6496                &mut self.forward_to_server,
6497                decoder,
6498                offset + 2912,
6499                _depth
6500            )?;
6501            Ok(())
6502        }
6503    }
6504
6505    impl fidl::encoding::ResourceTypeMarker for EchoEchoStructRequest {
6506        type Borrowed<'a> = &'a mut Self;
6507        fn take_or_borrow<'a>(
6508            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6509        ) -> Self::Borrowed<'a> {
6510            value
6511        }
6512    }
6513
6514    unsafe impl fidl::encoding::TypeMarker for EchoEchoStructRequest {
6515        type Owned = Self;
6516
6517        #[inline(always)]
6518        fn inline_align(_context: fidl::encoding::Context) -> usize {
6519            8
6520        }
6521
6522        #[inline(always)]
6523        fn inline_size(_context: fidl::encoding::Context) -> usize {
6524            2928
6525        }
6526    }
6527
6528    unsafe impl
6529        fidl::encoding::Encode<EchoEchoStructRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
6530        for &mut EchoEchoStructRequest
6531    {
6532        #[inline]
6533        unsafe fn encode(
6534            self,
6535            encoder: &mut fidl::encoding::Encoder<
6536                '_,
6537                fidl::encoding::DefaultFuchsiaResourceDialect,
6538            >,
6539            offset: usize,
6540            _depth: fidl::encoding::Depth,
6541        ) -> fidl::Result<()> {
6542            encoder.debug_check_bounds::<EchoEchoStructRequest>(offset);
6543            // Delegate to tuple encoding.
6544            fidl::encoding::Encode::<
6545                EchoEchoStructRequest,
6546                fidl::encoding::DefaultFuchsiaResourceDialect,
6547            >::encode(
6548                (
6549                    <Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
6550                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
6551                        &self.forward_to_server,
6552                    ),
6553                ),
6554                encoder,
6555                offset,
6556                _depth,
6557            )
6558        }
6559    }
6560    unsafe impl<
6561        T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>,
6562        T1: fidl::encoding::Encode<
6563                fidl::encoding::UnboundedString,
6564                fidl::encoding::DefaultFuchsiaResourceDialect,
6565            >,
6566    >
6567        fidl::encoding::Encode<EchoEchoStructRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
6568        for (T0, T1)
6569    {
6570        #[inline]
6571        unsafe fn encode(
6572            self,
6573            encoder: &mut fidl::encoding::Encoder<
6574                '_,
6575                fidl::encoding::DefaultFuchsiaResourceDialect,
6576            >,
6577            offset: usize,
6578            depth: fidl::encoding::Depth,
6579        ) -> fidl::Result<()> {
6580            encoder.debug_check_bounds::<EchoEchoStructRequest>(offset);
6581            // Zero out padding regions. There's no need to apply masks
6582            // because the unmasked parts will be overwritten by fields.
6583            // Write the fields.
6584            self.0.encode(encoder, offset + 0, depth)?;
6585            self.1.encode(encoder, offset + 2912, depth)?;
6586            Ok(())
6587        }
6588    }
6589
6590    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6591        for EchoEchoStructRequest
6592    {
6593        #[inline(always)]
6594        fn new_empty() -> Self {
6595            Self {
6596                value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect),
6597                forward_to_server: fidl::new_empty!(
6598                    fidl::encoding::UnboundedString,
6599                    fidl::encoding::DefaultFuchsiaResourceDialect
6600                ),
6601            }
6602        }
6603
6604        #[inline]
6605        unsafe fn decode(
6606            &mut self,
6607            decoder: &mut fidl::encoding::Decoder<
6608                '_,
6609                fidl::encoding::DefaultFuchsiaResourceDialect,
6610            >,
6611            offset: usize,
6612            _depth: fidl::encoding::Depth,
6613        ) -> fidl::Result<()> {
6614            decoder.debug_check_bounds::<Self>(offset);
6615            // Verify that padding bytes are zero.
6616            fidl::decode!(
6617                Struct,
6618                fidl::encoding::DefaultFuchsiaResourceDialect,
6619                &mut self.value,
6620                decoder,
6621                offset + 0,
6622                _depth
6623            )?;
6624            fidl::decode!(
6625                fidl::encoding::UnboundedString,
6626                fidl::encoding::DefaultFuchsiaResourceDialect,
6627                &mut self.forward_to_server,
6628                decoder,
6629                offset + 2912,
6630                _depth
6631            )?;
6632            Ok(())
6633        }
6634    }
6635
6636    impl fidl::encoding::ResourceTypeMarker for EchoEchoStructResponse {
6637        type Borrowed<'a> = &'a mut Self;
6638        fn take_or_borrow<'a>(
6639            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6640        ) -> Self::Borrowed<'a> {
6641            value
6642        }
6643    }
6644
6645    unsafe impl fidl::encoding::TypeMarker for EchoEchoStructResponse {
6646        type Owned = Self;
6647
6648        #[inline(always)]
6649        fn inline_align(_context: fidl::encoding::Context) -> usize {
6650            8
6651        }
6652
6653        #[inline(always)]
6654        fn inline_size(_context: fidl::encoding::Context) -> usize {
6655            2912
6656        }
6657    }
6658
6659    unsafe impl
6660        fidl::encoding::Encode<
6661            EchoEchoStructResponse,
6662            fidl::encoding::DefaultFuchsiaResourceDialect,
6663        > for &mut EchoEchoStructResponse
6664    {
6665        #[inline]
6666        unsafe fn encode(
6667            self,
6668            encoder: &mut fidl::encoding::Encoder<
6669                '_,
6670                fidl::encoding::DefaultFuchsiaResourceDialect,
6671            >,
6672            offset: usize,
6673            _depth: fidl::encoding::Depth,
6674        ) -> fidl::Result<()> {
6675            encoder.debug_check_bounds::<EchoEchoStructResponse>(offset);
6676            // Delegate to tuple encoding.
6677            fidl::encoding::Encode::<
6678                EchoEchoStructResponse,
6679                fidl::encoding::DefaultFuchsiaResourceDialect,
6680            >::encode(
6681                (<Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),),
6682                encoder,
6683                offset,
6684                _depth,
6685            )
6686        }
6687    }
6688    unsafe impl<T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>>
6689        fidl::encoding::Encode<
6690            EchoEchoStructResponse,
6691            fidl::encoding::DefaultFuchsiaResourceDialect,
6692        > for (T0,)
6693    {
6694        #[inline]
6695        unsafe fn encode(
6696            self,
6697            encoder: &mut fidl::encoding::Encoder<
6698                '_,
6699                fidl::encoding::DefaultFuchsiaResourceDialect,
6700            >,
6701            offset: usize,
6702            depth: fidl::encoding::Depth,
6703        ) -> fidl::Result<()> {
6704            encoder.debug_check_bounds::<EchoEchoStructResponse>(offset);
6705            // Zero out padding regions. There's no need to apply masks
6706            // because the unmasked parts will be overwritten by fields.
6707            // Write the fields.
6708            self.0.encode(encoder, offset + 0, depth)?;
6709            Ok(())
6710        }
6711    }
6712
6713    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6714        for EchoEchoStructResponse
6715    {
6716        #[inline(always)]
6717        fn new_empty() -> Self {
6718            Self { value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect) }
6719        }
6720
6721        #[inline]
6722        unsafe fn decode(
6723            &mut self,
6724            decoder: &mut fidl::encoding::Decoder<
6725                '_,
6726                fidl::encoding::DefaultFuchsiaResourceDialect,
6727            >,
6728            offset: usize,
6729            _depth: fidl::encoding::Depth,
6730        ) -> fidl::Result<()> {
6731            decoder.debug_check_bounds::<Self>(offset);
6732            // Verify that padding bytes are zero.
6733            fidl::decode!(
6734                Struct,
6735                fidl::encoding::DefaultFuchsiaResourceDialect,
6736                &mut self.value,
6737                decoder,
6738                offset + 0,
6739                _depth
6740            )?;
6741            Ok(())
6742        }
6743    }
6744
6745    impl fidl::encoding::ResourceTypeMarker for EchoEchoStructWithErrorRequest {
6746        type Borrowed<'a> = &'a mut Self;
6747        fn take_or_borrow<'a>(
6748            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6749        ) -> Self::Borrowed<'a> {
6750            value
6751        }
6752    }
6753
6754    unsafe impl fidl::encoding::TypeMarker for EchoEchoStructWithErrorRequest {
6755        type Owned = Self;
6756
6757        #[inline(always)]
6758        fn inline_align(_context: fidl::encoding::Context) -> usize {
6759            8
6760        }
6761
6762        #[inline(always)]
6763        fn inline_size(_context: fidl::encoding::Context) -> usize {
6764            2944
6765        }
6766    }
6767
6768    unsafe impl
6769        fidl::encoding::Encode<
6770            EchoEchoStructWithErrorRequest,
6771            fidl::encoding::DefaultFuchsiaResourceDialect,
6772        > for &mut EchoEchoStructWithErrorRequest
6773    {
6774        #[inline]
6775        unsafe fn encode(
6776            self,
6777            encoder: &mut fidl::encoding::Encoder<
6778                '_,
6779                fidl::encoding::DefaultFuchsiaResourceDialect,
6780            >,
6781            offset: usize,
6782            _depth: fidl::encoding::Depth,
6783        ) -> fidl::Result<()> {
6784            encoder.debug_check_bounds::<EchoEchoStructWithErrorRequest>(offset);
6785            // Delegate to tuple encoding.
6786            fidl::encoding::Encode::<
6787                EchoEchoStructWithErrorRequest,
6788                fidl::encoding::DefaultFuchsiaResourceDialect,
6789            >::encode(
6790                (
6791                    <Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
6792                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
6793                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
6794                        &self.forward_to_server,
6795                    ),
6796                    <RespondWith as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
6797                ),
6798                encoder,
6799                offset,
6800                _depth,
6801            )
6802        }
6803    }
6804    unsafe impl<
6805        T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>,
6806        T1: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
6807        T2: fidl::encoding::Encode<
6808                fidl::encoding::UnboundedString,
6809                fidl::encoding::DefaultFuchsiaResourceDialect,
6810            >,
6811        T3: fidl::encoding::Encode<RespondWith, fidl::encoding::DefaultFuchsiaResourceDialect>,
6812    >
6813        fidl::encoding::Encode<
6814            EchoEchoStructWithErrorRequest,
6815            fidl::encoding::DefaultFuchsiaResourceDialect,
6816        > for (T0, T1, T2, T3)
6817    {
6818        #[inline]
6819        unsafe fn encode(
6820            self,
6821            encoder: &mut fidl::encoding::Encoder<
6822                '_,
6823                fidl::encoding::DefaultFuchsiaResourceDialect,
6824            >,
6825            offset: usize,
6826            depth: fidl::encoding::Depth,
6827        ) -> fidl::Result<()> {
6828            encoder.debug_check_bounds::<EchoEchoStructWithErrorRequest>(offset);
6829            // Zero out padding regions. There's no need to apply masks
6830            // because the unmasked parts will be overwritten by fields.
6831            unsafe {
6832                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2912);
6833                (ptr as *mut u64).write_unaligned(0);
6834            }
6835            unsafe {
6836                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2936);
6837                (ptr as *mut u64).write_unaligned(0);
6838            }
6839            // Write the fields.
6840            self.0.encode(encoder, offset + 0, depth)?;
6841            self.1.encode(encoder, offset + 2912, depth)?;
6842            self.2.encode(encoder, offset + 2920, depth)?;
6843            self.3.encode(encoder, offset + 2936, depth)?;
6844            Ok(())
6845        }
6846    }
6847
6848    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6849        for EchoEchoStructWithErrorRequest
6850    {
6851        #[inline(always)]
6852        fn new_empty() -> Self {
6853            Self {
6854                value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect),
6855                result_err: fidl::new_empty!(
6856                    DefaultEnum,
6857                    fidl::encoding::DefaultFuchsiaResourceDialect
6858                ),
6859                forward_to_server: fidl::new_empty!(
6860                    fidl::encoding::UnboundedString,
6861                    fidl::encoding::DefaultFuchsiaResourceDialect
6862                ),
6863                result_variant: fidl::new_empty!(
6864                    RespondWith,
6865                    fidl::encoding::DefaultFuchsiaResourceDialect
6866                ),
6867            }
6868        }
6869
6870        #[inline]
6871        unsafe fn decode(
6872            &mut self,
6873            decoder: &mut fidl::encoding::Decoder<
6874                '_,
6875                fidl::encoding::DefaultFuchsiaResourceDialect,
6876            >,
6877            offset: usize,
6878            _depth: fidl::encoding::Depth,
6879        ) -> fidl::Result<()> {
6880            decoder.debug_check_bounds::<Self>(offset);
6881            // Verify that padding bytes are zero.
6882            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2912) };
6883            let padval = unsafe { (ptr as *const u64).read_unaligned() };
6884            let mask = 0xffffffff00000000u64;
6885            let maskedval = padval & mask;
6886            if maskedval != 0 {
6887                return Err(fidl::Error::NonZeroPadding {
6888                    padding_start: offset + 2912 + ((mask as u64).trailing_zeros() / 8) as usize,
6889                });
6890            }
6891            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2936) };
6892            let padval = unsafe { (ptr as *const u64).read_unaligned() };
6893            let mask = 0xffffffff00000000u64;
6894            let maskedval = padval & mask;
6895            if maskedval != 0 {
6896                return Err(fidl::Error::NonZeroPadding {
6897                    padding_start: offset + 2936 + ((mask as u64).trailing_zeros() / 8) as usize,
6898                });
6899            }
6900            fidl::decode!(
6901                Struct,
6902                fidl::encoding::DefaultFuchsiaResourceDialect,
6903                &mut self.value,
6904                decoder,
6905                offset + 0,
6906                _depth
6907            )?;
6908            fidl::decode!(
6909                DefaultEnum,
6910                fidl::encoding::DefaultFuchsiaResourceDialect,
6911                &mut self.result_err,
6912                decoder,
6913                offset + 2912,
6914                _depth
6915            )?;
6916            fidl::decode!(
6917                fidl::encoding::UnboundedString,
6918                fidl::encoding::DefaultFuchsiaResourceDialect,
6919                &mut self.forward_to_server,
6920                decoder,
6921                offset + 2920,
6922                _depth
6923            )?;
6924            fidl::decode!(
6925                RespondWith,
6926                fidl::encoding::DefaultFuchsiaResourceDialect,
6927                &mut self.result_variant,
6928                decoder,
6929                offset + 2936,
6930                _depth
6931            )?;
6932            Ok(())
6933        }
6934    }
6935
6936    impl fidl::encoding::ResourceTypeMarker for EchoEchoTableRequest {
6937        type Borrowed<'a> = &'a mut Self;
6938        fn take_or_borrow<'a>(
6939            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6940        ) -> Self::Borrowed<'a> {
6941            value
6942        }
6943    }
6944
6945    unsafe impl fidl::encoding::TypeMarker for EchoEchoTableRequest {
6946        type Owned = Self;
6947
6948        #[inline(always)]
6949        fn inline_align(_context: fidl::encoding::Context) -> usize {
6950            8
6951        }
6952
6953        #[inline(always)]
6954        fn inline_size(_context: fidl::encoding::Context) -> usize {
6955            32
6956        }
6957    }
6958
6959    unsafe impl
6960        fidl::encoding::Encode<EchoEchoTableRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
6961        for &mut EchoEchoTableRequest
6962    {
6963        #[inline]
6964        unsafe fn encode(
6965            self,
6966            encoder: &mut fidl::encoding::Encoder<
6967                '_,
6968                fidl::encoding::DefaultFuchsiaResourceDialect,
6969            >,
6970            offset: usize,
6971            _depth: fidl::encoding::Depth,
6972        ) -> fidl::Result<()> {
6973            encoder.debug_check_bounds::<EchoEchoTableRequest>(offset);
6974            // Delegate to tuple encoding.
6975            fidl::encoding::Encode::<
6976                EchoEchoTableRequest,
6977                fidl::encoding::DefaultFuchsiaResourceDialect,
6978            >::encode(
6979                (
6980                    <AllTypesTable as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
6981                        &mut self.value,
6982                    ),
6983                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
6984                        &self.forward_to_server,
6985                    ),
6986                ),
6987                encoder,
6988                offset,
6989                _depth,
6990            )
6991        }
6992    }
6993    unsafe impl<
6994        T0: fidl::encoding::Encode<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>,
6995        T1: fidl::encoding::Encode<
6996                fidl::encoding::UnboundedString,
6997                fidl::encoding::DefaultFuchsiaResourceDialect,
6998            >,
6999    >
7000        fidl::encoding::Encode<EchoEchoTableRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
7001        for (T0, T1)
7002    {
7003        #[inline]
7004        unsafe fn encode(
7005            self,
7006            encoder: &mut fidl::encoding::Encoder<
7007                '_,
7008                fidl::encoding::DefaultFuchsiaResourceDialect,
7009            >,
7010            offset: usize,
7011            depth: fidl::encoding::Depth,
7012        ) -> fidl::Result<()> {
7013            encoder.debug_check_bounds::<EchoEchoTableRequest>(offset);
7014            // Zero out padding regions. There's no need to apply masks
7015            // because the unmasked parts will be overwritten by fields.
7016            // Write the fields.
7017            self.0.encode(encoder, offset + 0, depth)?;
7018            self.1.encode(encoder, offset + 16, depth)?;
7019            Ok(())
7020        }
7021    }
7022
7023    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7024        for EchoEchoTableRequest
7025    {
7026        #[inline(always)]
7027        fn new_empty() -> Self {
7028            Self {
7029                value: fidl::new_empty!(
7030                    AllTypesTable,
7031                    fidl::encoding::DefaultFuchsiaResourceDialect
7032                ),
7033                forward_to_server: fidl::new_empty!(
7034                    fidl::encoding::UnboundedString,
7035                    fidl::encoding::DefaultFuchsiaResourceDialect
7036                ),
7037            }
7038        }
7039
7040        #[inline]
7041        unsafe fn decode(
7042            &mut self,
7043            decoder: &mut fidl::encoding::Decoder<
7044                '_,
7045                fidl::encoding::DefaultFuchsiaResourceDialect,
7046            >,
7047            offset: usize,
7048            _depth: fidl::encoding::Depth,
7049        ) -> fidl::Result<()> {
7050            decoder.debug_check_bounds::<Self>(offset);
7051            // Verify that padding bytes are zero.
7052            fidl::decode!(
7053                AllTypesTable,
7054                fidl::encoding::DefaultFuchsiaResourceDialect,
7055                &mut self.value,
7056                decoder,
7057                offset + 0,
7058                _depth
7059            )?;
7060            fidl::decode!(
7061                fidl::encoding::UnboundedString,
7062                fidl::encoding::DefaultFuchsiaResourceDialect,
7063                &mut self.forward_to_server,
7064                decoder,
7065                offset + 16,
7066                _depth
7067            )?;
7068            Ok(())
7069        }
7070    }
7071
7072    impl fidl::encoding::ResourceTypeMarker for EchoEchoTableResponse {
7073        type Borrowed<'a> = &'a mut Self;
7074        fn take_or_borrow<'a>(
7075            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7076        ) -> Self::Borrowed<'a> {
7077            value
7078        }
7079    }
7080
7081    unsafe impl fidl::encoding::TypeMarker for EchoEchoTableResponse {
7082        type Owned = Self;
7083
7084        #[inline(always)]
7085        fn inline_align(_context: fidl::encoding::Context) -> usize {
7086            8
7087        }
7088
7089        #[inline(always)]
7090        fn inline_size(_context: fidl::encoding::Context) -> usize {
7091            16
7092        }
7093    }
7094
7095    unsafe impl
7096        fidl::encoding::Encode<EchoEchoTableResponse, fidl::encoding::DefaultFuchsiaResourceDialect>
7097        for &mut EchoEchoTableResponse
7098    {
7099        #[inline]
7100        unsafe fn encode(
7101            self,
7102            encoder: &mut fidl::encoding::Encoder<
7103                '_,
7104                fidl::encoding::DefaultFuchsiaResourceDialect,
7105            >,
7106            offset: usize,
7107            _depth: fidl::encoding::Depth,
7108        ) -> fidl::Result<()> {
7109            encoder.debug_check_bounds::<EchoEchoTableResponse>(offset);
7110            // Delegate to tuple encoding.
7111            fidl::encoding::Encode::<
7112                EchoEchoTableResponse,
7113                fidl::encoding::DefaultFuchsiaResourceDialect,
7114            >::encode(
7115                (<AllTypesTable as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7116                    &mut self.value,
7117                ),),
7118                encoder,
7119                offset,
7120                _depth,
7121            )
7122        }
7123    }
7124    unsafe impl<
7125        T0: fidl::encoding::Encode<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>,
7126    >
7127        fidl::encoding::Encode<EchoEchoTableResponse, fidl::encoding::DefaultFuchsiaResourceDialect>
7128        for (T0,)
7129    {
7130        #[inline]
7131        unsafe fn encode(
7132            self,
7133            encoder: &mut fidl::encoding::Encoder<
7134                '_,
7135                fidl::encoding::DefaultFuchsiaResourceDialect,
7136            >,
7137            offset: usize,
7138            depth: fidl::encoding::Depth,
7139        ) -> fidl::Result<()> {
7140            encoder.debug_check_bounds::<EchoEchoTableResponse>(offset);
7141            // Zero out padding regions. There's no need to apply masks
7142            // because the unmasked parts will be overwritten by fields.
7143            // Write the fields.
7144            self.0.encode(encoder, offset + 0, depth)?;
7145            Ok(())
7146        }
7147    }
7148
7149    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7150        for EchoEchoTableResponse
7151    {
7152        #[inline(always)]
7153        fn new_empty() -> Self {
7154            Self {
7155                value: fidl::new_empty!(
7156                    AllTypesTable,
7157                    fidl::encoding::DefaultFuchsiaResourceDialect
7158                ),
7159            }
7160        }
7161
7162        #[inline]
7163        unsafe fn decode(
7164            &mut self,
7165            decoder: &mut fidl::encoding::Decoder<
7166                '_,
7167                fidl::encoding::DefaultFuchsiaResourceDialect,
7168            >,
7169            offset: usize,
7170            _depth: fidl::encoding::Depth,
7171        ) -> fidl::Result<()> {
7172            decoder.debug_check_bounds::<Self>(offset);
7173            // Verify that padding bytes are zero.
7174            fidl::decode!(
7175                AllTypesTable,
7176                fidl::encoding::DefaultFuchsiaResourceDialect,
7177                &mut self.value,
7178                decoder,
7179                offset + 0,
7180                _depth
7181            )?;
7182            Ok(())
7183        }
7184    }
7185
7186    impl fidl::encoding::ResourceTypeMarker for EchoEchoTableWithErrorRequest {
7187        type Borrowed<'a> = &'a mut Self;
7188        fn take_or_borrow<'a>(
7189            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7190        ) -> Self::Borrowed<'a> {
7191            value
7192        }
7193    }
7194
7195    unsafe impl fidl::encoding::TypeMarker for EchoEchoTableWithErrorRequest {
7196        type Owned = Self;
7197
7198        #[inline(always)]
7199        fn inline_align(_context: fidl::encoding::Context) -> usize {
7200            8
7201        }
7202
7203        #[inline(always)]
7204        fn inline_size(_context: fidl::encoding::Context) -> usize {
7205            48
7206        }
7207    }
7208
7209    unsafe impl
7210        fidl::encoding::Encode<
7211            EchoEchoTableWithErrorRequest,
7212            fidl::encoding::DefaultFuchsiaResourceDialect,
7213        > for &mut EchoEchoTableWithErrorRequest
7214    {
7215        #[inline]
7216        unsafe fn encode(
7217            self,
7218            encoder: &mut fidl::encoding::Encoder<
7219                '_,
7220                fidl::encoding::DefaultFuchsiaResourceDialect,
7221            >,
7222            offset: usize,
7223            _depth: fidl::encoding::Depth,
7224        ) -> fidl::Result<()> {
7225            encoder.debug_check_bounds::<EchoEchoTableWithErrorRequest>(offset);
7226            // Delegate to tuple encoding.
7227            fidl::encoding::Encode::<
7228                EchoEchoTableWithErrorRequest,
7229                fidl::encoding::DefaultFuchsiaResourceDialect,
7230            >::encode(
7231                (
7232                    <AllTypesTable as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7233                        &mut self.value,
7234                    ),
7235                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
7236                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
7237                        &self.forward_to_server,
7238                    ),
7239                    <RespondWith as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
7240                ),
7241                encoder,
7242                offset,
7243                _depth,
7244            )
7245        }
7246    }
7247    unsafe impl<
7248        T0: fidl::encoding::Encode<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>,
7249        T1: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
7250        T2: fidl::encoding::Encode<
7251                fidl::encoding::UnboundedString,
7252                fidl::encoding::DefaultFuchsiaResourceDialect,
7253            >,
7254        T3: fidl::encoding::Encode<RespondWith, fidl::encoding::DefaultFuchsiaResourceDialect>,
7255    >
7256        fidl::encoding::Encode<
7257            EchoEchoTableWithErrorRequest,
7258            fidl::encoding::DefaultFuchsiaResourceDialect,
7259        > for (T0, T1, T2, T3)
7260    {
7261        #[inline]
7262        unsafe fn encode(
7263            self,
7264            encoder: &mut fidl::encoding::Encoder<
7265                '_,
7266                fidl::encoding::DefaultFuchsiaResourceDialect,
7267            >,
7268            offset: usize,
7269            depth: fidl::encoding::Depth,
7270        ) -> fidl::Result<()> {
7271            encoder.debug_check_bounds::<EchoEchoTableWithErrorRequest>(offset);
7272            // Zero out padding regions. There's no need to apply masks
7273            // because the unmasked parts will be overwritten by fields.
7274            unsafe {
7275                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
7276                (ptr as *mut u64).write_unaligned(0);
7277            }
7278            unsafe {
7279                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
7280                (ptr as *mut u64).write_unaligned(0);
7281            }
7282            // Write the fields.
7283            self.0.encode(encoder, offset + 0, depth)?;
7284            self.1.encode(encoder, offset + 16, depth)?;
7285            self.2.encode(encoder, offset + 24, depth)?;
7286            self.3.encode(encoder, offset + 40, depth)?;
7287            Ok(())
7288        }
7289    }
7290
7291    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7292        for EchoEchoTableWithErrorRequest
7293    {
7294        #[inline(always)]
7295        fn new_empty() -> Self {
7296            Self {
7297                value: fidl::new_empty!(
7298                    AllTypesTable,
7299                    fidl::encoding::DefaultFuchsiaResourceDialect
7300                ),
7301                result_err: fidl::new_empty!(
7302                    DefaultEnum,
7303                    fidl::encoding::DefaultFuchsiaResourceDialect
7304                ),
7305                forward_to_server: fidl::new_empty!(
7306                    fidl::encoding::UnboundedString,
7307                    fidl::encoding::DefaultFuchsiaResourceDialect
7308                ),
7309                result_variant: fidl::new_empty!(
7310                    RespondWith,
7311                    fidl::encoding::DefaultFuchsiaResourceDialect
7312                ),
7313            }
7314        }
7315
7316        #[inline]
7317        unsafe fn decode(
7318            &mut self,
7319            decoder: &mut fidl::encoding::Decoder<
7320                '_,
7321                fidl::encoding::DefaultFuchsiaResourceDialect,
7322            >,
7323            offset: usize,
7324            _depth: fidl::encoding::Depth,
7325        ) -> fidl::Result<()> {
7326            decoder.debug_check_bounds::<Self>(offset);
7327            // Verify that padding bytes are zero.
7328            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
7329            let padval = unsafe { (ptr as *const u64).read_unaligned() };
7330            let mask = 0xffffffff00000000u64;
7331            let maskedval = padval & mask;
7332            if maskedval != 0 {
7333                return Err(fidl::Error::NonZeroPadding {
7334                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
7335                });
7336            }
7337            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
7338            let padval = unsafe { (ptr as *const u64).read_unaligned() };
7339            let mask = 0xffffffff00000000u64;
7340            let maskedval = padval & mask;
7341            if maskedval != 0 {
7342                return Err(fidl::Error::NonZeroPadding {
7343                    padding_start: offset + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
7344                });
7345            }
7346            fidl::decode!(
7347                AllTypesTable,
7348                fidl::encoding::DefaultFuchsiaResourceDialect,
7349                &mut self.value,
7350                decoder,
7351                offset + 0,
7352                _depth
7353            )?;
7354            fidl::decode!(
7355                DefaultEnum,
7356                fidl::encoding::DefaultFuchsiaResourceDialect,
7357                &mut self.result_err,
7358                decoder,
7359                offset + 16,
7360                _depth
7361            )?;
7362            fidl::decode!(
7363                fidl::encoding::UnboundedString,
7364                fidl::encoding::DefaultFuchsiaResourceDialect,
7365                &mut self.forward_to_server,
7366                decoder,
7367                offset + 24,
7368                _depth
7369            )?;
7370            fidl::decode!(
7371                RespondWith,
7372                fidl::encoding::DefaultFuchsiaResourceDialect,
7373                &mut self.result_variant,
7374                decoder,
7375                offset + 40,
7376                _depth
7377            )?;
7378            Ok(())
7379        }
7380    }
7381
7382    impl fidl::encoding::ResourceTypeMarker for EchoEchoVectorsRequest {
7383        type Borrowed<'a> = &'a mut Self;
7384        fn take_or_borrow<'a>(
7385            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7386        ) -> Self::Borrowed<'a> {
7387            value
7388        }
7389    }
7390
7391    unsafe impl fidl::encoding::TypeMarker for EchoEchoVectorsRequest {
7392        type Owned = Self;
7393
7394        #[inline(always)]
7395        fn inline_align(_context: fidl::encoding::Context) -> usize {
7396            8
7397        }
7398
7399        #[inline(always)]
7400        fn inline_size(_context: fidl::encoding::Context) -> usize {
7401            432
7402        }
7403    }
7404
7405    unsafe impl
7406        fidl::encoding::Encode<
7407            EchoEchoVectorsRequest,
7408            fidl::encoding::DefaultFuchsiaResourceDialect,
7409        > for &mut EchoEchoVectorsRequest
7410    {
7411        #[inline]
7412        unsafe fn encode(
7413            self,
7414            encoder: &mut fidl::encoding::Encoder<
7415                '_,
7416                fidl::encoding::DefaultFuchsiaResourceDialect,
7417            >,
7418            offset: usize,
7419            _depth: fidl::encoding::Depth,
7420        ) -> fidl::Result<()> {
7421            encoder.debug_check_bounds::<EchoEchoVectorsRequest>(offset);
7422            // Delegate to tuple encoding.
7423            fidl::encoding::Encode::<
7424                EchoEchoVectorsRequest,
7425                fidl::encoding::DefaultFuchsiaResourceDialect,
7426            >::encode(
7427                (
7428                    <VectorsStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7429                        &mut self.value,
7430                    ),
7431                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
7432                        &self.forward_to_server,
7433                    ),
7434                ),
7435                encoder,
7436                offset,
7437                _depth,
7438            )
7439        }
7440    }
7441    unsafe impl<
7442        T0: fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
7443        T1: fidl::encoding::Encode<
7444                fidl::encoding::UnboundedString,
7445                fidl::encoding::DefaultFuchsiaResourceDialect,
7446            >,
7447    >
7448        fidl::encoding::Encode<
7449            EchoEchoVectorsRequest,
7450            fidl::encoding::DefaultFuchsiaResourceDialect,
7451        > for (T0, T1)
7452    {
7453        #[inline]
7454        unsafe fn encode(
7455            self,
7456            encoder: &mut fidl::encoding::Encoder<
7457                '_,
7458                fidl::encoding::DefaultFuchsiaResourceDialect,
7459            >,
7460            offset: usize,
7461            depth: fidl::encoding::Depth,
7462        ) -> fidl::Result<()> {
7463            encoder.debug_check_bounds::<EchoEchoVectorsRequest>(offset);
7464            // Zero out padding regions. There's no need to apply masks
7465            // because the unmasked parts will be overwritten by fields.
7466            // Write the fields.
7467            self.0.encode(encoder, offset + 0, depth)?;
7468            self.1.encode(encoder, offset + 416, depth)?;
7469            Ok(())
7470        }
7471    }
7472
7473    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7474        for EchoEchoVectorsRequest
7475    {
7476        #[inline(always)]
7477        fn new_empty() -> Self {
7478            Self {
7479                value: fidl::new_empty!(
7480                    VectorsStruct,
7481                    fidl::encoding::DefaultFuchsiaResourceDialect
7482                ),
7483                forward_to_server: fidl::new_empty!(
7484                    fidl::encoding::UnboundedString,
7485                    fidl::encoding::DefaultFuchsiaResourceDialect
7486                ),
7487            }
7488        }
7489
7490        #[inline]
7491        unsafe fn decode(
7492            &mut self,
7493            decoder: &mut fidl::encoding::Decoder<
7494                '_,
7495                fidl::encoding::DefaultFuchsiaResourceDialect,
7496            >,
7497            offset: usize,
7498            _depth: fidl::encoding::Depth,
7499        ) -> fidl::Result<()> {
7500            decoder.debug_check_bounds::<Self>(offset);
7501            // Verify that padding bytes are zero.
7502            fidl::decode!(
7503                VectorsStruct,
7504                fidl::encoding::DefaultFuchsiaResourceDialect,
7505                &mut self.value,
7506                decoder,
7507                offset + 0,
7508                _depth
7509            )?;
7510            fidl::decode!(
7511                fidl::encoding::UnboundedString,
7512                fidl::encoding::DefaultFuchsiaResourceDialect,
7513                &mut self.forward_to_server,
7514                decoder,
7515                offset + 416,
7516                _depth
7517            )?;
7518            Ok(())
7519        }
7520    }
7521
7522    impl fidl::encoding::ResourceTypeMarker for EchoEchoVectorsResponse {
7523        type Borrowed<'a> = &'a mut Self;
7524        fn take_or_borrow<'a>(
7525            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7526        ) -> Self::Borrowed<'a> {
7527            value
7528        }
7529    }
7530
7531    unsafe impl fidl::encoding::TypeMarker for EchoEchoVectorsResponse {
7532        type Owned = Self;
7533
7534        #[inline(always)]
7535        fn inline_align(_context: fidl::encoding::Context) -> usize {
7536            8
7537        }
7538
7539        #[inline(always)]
7540        fn inline_size(_context: fidl::encoding::Context) -> usize {
7541            416
7542        }
7543    }
7544
7545    unsafe impl
7546        fidl::encoding::Encode<
7547            EchoEchoVectorsResponse,
7548            fidl::encoding::DefaultFuchsiaResourceDialect,
7549        > for &mut EchoEchoVectorsResponse
7550    {
7551        #[inline]
7552        unsafe fn encode(
7553            self,
7554            encoder: &mut fidl::encoding::Encoder<
7555                '_,
7556                fidl::encoding::DefaultFuchsiaResourceDialect,
7557            >,
7558            offset: usize,
7559            _depth: fidl::encoding::Depth,
7560        ) -> fidl::Result<()> {
7561            encoder.debug_check_bounds::<EchoEchoVectorsResponse>(offset);
7562            // Delegate to tuple encoding.
7563            fidl::encoding::Encode::<
7564                EchoEchoVectorsResponse,
7565                fidl::encoding::DefaultFuchsiaResourceDialect,
7566            >::encode(
7567                (<VectorsStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7568                    &mut self.value,
7569                ),),
7570                encoder,
7571                offset,
7572                _depth,
7573            )
7574        }
7575    }
7576    unsafe impl<
7577        T0: fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
7578    >
7579        fidl::encoding::Encode<
7580            EchoEchoVectorsResponse,
7581            fidl::encoding::DefaultFuchsiaResourceDialect,
7582        > for (T0,)
7583    {
7584        #[inline]
7585        unsafe fn encode(
7586            self,
7587            encoder: &mut fidl::encoding::Encoder<
7588                '_,
7589                fidl::encoding::DefaultFuchsiaResourceDialect,
7590            >,
7591            offset: usize,
7592            depth: fidl::encoding::Depth,
7593        ) -> fidl::Result<()> {
7594            encoder.debug_check_bounds::<EchoEchoVectorsResponse>(offset);
7595            // Zero out padding regions. There's no need to apply masks
7596            // because the unmasked parts will be overwritten by fields.
7597            // Write the fields.
7598            self.0.encode(encoder, offset + 0, depth)?;
7599            Ok(())
7600        }
7601    }
7602
7603    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7604        for EchoEchoVectorsResponse
7605    {
7606        #[inline(always)]
7607        fn new_empty() -> Self {
7608            Self {
7609                value: fidl::new_empty!(
7610                    VectorsStruct,
7611                    fidl::encoding::DefaultFuchsiaResourceDialect
7612                ),
7613            }
7614        }
7615
7616        #[inline]
7617        unsafe fn decode(
7618            &mut self,
7619            decoder: &mut fidl::encoding::Decoder<
7620                '_,
7621                fidl::encoding::DefaultFuchsiaResourceDialect,
7622            >,
7623            offset: usize,
7624            _depth: fidl::encoding::Depth,
7625        ) -> fidl::Result<()> {
7626            decoder.debug_check_bounds::<Self>(offset);
7627            // Verify that padding bytes are zero.
7628            fidl::decode!(
7629                VectorsStruct,
7630                fidl::encoding::DefaultFuchsiaResourceDialect,
7631                &mut self.value,
7632                decoder,
7633                offset + 0,
7634                _depth
7635            )?;
7636            Ok(())
7637        }
7638    }
7639
7640    impl fidl::encoding::ResourceTypeMarker for EchoEchoVectorsWithErrorRequest {
7641        type Borrowed<'a> = &'a mut Self;
7642        fn take_or_borrow<'a>(
7643            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7644        ) -> Self::Borrowed<'a> {
7645            value
7646        }
7647    }
7648
7649    unsafe impl fidl::encoding::TypeMarker for EchoEchoVectorsWithErrorRequest {
7650        type Owned = Self;
7651
7652        #[inline(always)]
7653        fn inline_align(_context: fidl::encoding::Context) -> usize {
7654            8
7655        }
7656
7657        #[inline(always)]
7658        fn inline_size(_context: fidl::encoding::Context) -> usize {
7659            448
7660        }
7661    }
7662
7663    unsafe impl
7664        fidl::encoding::Encode<
7665            EchoEchoVectorsWithErrorRequest,
7666            fidl::encoding::DefaultFuchsiaResourceDialect,
7667        > for &mut EchoEchoVectorsWithErrorRequest
7668    {
7669        #[inline]
7670        unsafe fn encode(
7671            self,
7672            encoder: &mut fidl::encoding::Encoder<
7673                '_,
7674                fidl::encoding::DefaultFuchsiaResourceDialect,
7675            >,
7676            offset: usize,
7677            _depth: fidl::encoding::Depth,
7678        ) -> fidl::Result<()> {
7679            encoder.debug_check_bounds::<EchoEchoVectorsWithErrorRequest>(offset);
7680            // Delegate to tuple encoding.
7681            fidl::encoding::Encode::<
7682                EchoEchoVectorsWithErrorRequest,
7683                fidl::encoding::DefaultFuchsiaResourceDialect,
7684            >::encode(
7685                (
7686                    <VectorsStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7687                        &mut self.value,
7688                    ),
7689                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
7690                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
7691                        &self.forward_to_server,
7692                    ),
7693                    <RespondWith as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
7694                ),
7695                encoder,
7696                offset,
7697                _depth,
7698            )
7699        }
7700    }
7701    unsafe impl<
7702        T0: fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
7703        T1: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
7704        T2: fidl::encoding::Encode<
7705                fidl::encoding::UnboundedString,
7706                fidl::encoding::DefaultFuchsiaResourceDialect,
7707            >,
7708        T3: fidl::encoding::Encode<RespondWith, fidl::encoding::DefaultFuchsiaResourceDialect>,
7709    >
7710        fidl::encoding::Encode<
7711            EchoEchoVectorsWithErrorRequest,
7712            fidl::encoding::DefaultFuchsiaResourceDialect,
7713        > for (T0, T1, T2, T3)
7714    {
7715        #[inline]
7716        unsafe fn encode(
7717            self,
7718            encoder: &mut fidl::encoding::Encoder<
7719                '_,
7720                fidl::encoding::DefaultFuchsiaResourceDialect,
7721            >,
7722            offset: usize,
7723            depth: fidl::encoding::Depth,
7724        ) -> fidl::Result<()> {
7725            encoder.debug_check_bounds::<EchoEchoVectorsWithErrorRequest>(offset);
7726            // Zero out padding regions. There's no need to apply masks
7727            // because the unmasked parts will be overwritten by fields.
7728            unsafe {
7729                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(416);
7730                (ptr as *mut u64).write_unaligned(0);
7731            }
7732            unsafe {
7733                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(440);
7734                (ptr as *mut u64).write_unaligned(0);
7735            }
7736            // Write the fields.
7737            self.0.encode(encoder, offset + 0, depth)?;
7738            self.1.encode(encoder, offset + 416, depth)?;
7739            self.2.encode(encoder, offset + 424, depth)?;
7740            self.3.encode(encoder, offset + 440, depth)?;
7741            Ok(())
7742        }
7743    }
7744
7745    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7746        for EchoEchoVectorsWithErrorRequest
7747    {
7748        #[inline(always)]
7749        fn new_empty() -> Self {
7750            Self {
7751                value: fidl::new_empty!(
7752                    VectorsStruct,
7753                    fidl::encoding::DefaultFuchsiaResourceDialect
7754                ),
7755                result_err: fidl::new_empty!(
7756                    DefaultEnum,
7757                    fidl::encoding::DefaultFuchsiaResourceDialect
7758                ),
7759                forward_to_server: fidl::new_empty!(
7760                    fidl::encoding::UnboundedString,
7761                    fidl::encoding::DefaultFuchsiaResourceDialect
7762                ),
7763                result_variant: fidl::new_empty!(
7764                    RespondWith,
7765                    fidl::encoding::DefaultFuchsiaResourceDialect
7766                ),
7767            }
7768        }
7769
7770        #[inline]
7771        unsafe fn decode(
7772            &mut self,
7773            decoder: &mut fidl::encoding::Decoder<
7774                '_,
7775                fidl::encoding::DefaultFuchsiaResourceDialect,
7776            >,
7777            offset: usize,
7778            _depth: fidl::encoding::Depth,
7779        ) -> fidl::Result<()> {
7780            decoder.debug_check_bounds::<Self>(offset);
7781            // Verify that padding bytes are zero.
7782            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(416) };
7783            let padval = unsafe { (ptr as *const u64).read_unaligned() };
7784            let mask = 0xffffffff00000000u64;
7785            let maskedval = padval & mask;
7786            if maskedval != 0 {
7787                return Err(fidl::Error::NonZeroPadding {
7788                    padding_start: offset + 416 + ((mask as u64).trailing_zeros() / 8) as usize,
7789                });
7790            }
7791            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(440) };
7792            let padval = unsafe { (ptr as *const u64).read_unaligned() };
7793            let mask = 0xffffffff00000000u64;
7794            let maskedval = padval & mask;
7795            if maskedval != 0 {
7796                return Err(fidl::Error::NonZeroPadding {
7797                    padding_start: offset + 440 + ((mask as u64).trailing_zeros() / 8) as usize,
7798                });
7799            }
7800            fidl::decode!(
7801                VectorsStruct,
7802                fidl::encoding::DefaultFuchsiaResourceDialect,
7803                &mut self.value,
7804                decoder,
7805                offset + 0,
7806                _depth
7807            )?;
7808            fidl::decode!(
7809                DefaultEnum,
7810                fidl::encoding::DefaultFuchsiaResourceDialect,
7811                &mut self.result_err,
7812                decoder,
7813                offset + 416,
7814                _depth
7815            )?;
7816            fidl::decode!(
7817                fidl::encoding::UnboundedString,
7818                fidl::encoding::DefaultFuchsiaResourceDialect,
7819                &mut self.forward_to_server,
7820                decoder,
7821                offset + 424,
7822                _depth
7823            )?;
7824            fidl::decode!(
7825                RespondWith,
7826                fidl::encoding::DefaultFuchsiaResourceDialect,
7827                &mut self.result_variant,
7828                decoder,
7829                offset + 440,
7830                _depth
7831            )?;
7832            Ok(())
7833        }
7834    }
7835
7836    impl fidl::encoding::ResourceTypeMarker for EchoEchoXunionsRequest {
7837        type Borrowed<'a> = &'a mut Self;
7838        fn take_or_borrow<'a>(
7839            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7840        ) -> Self::Borrowed<'a> {
7841            value
7842        }
7843    }
7844
7845    unsafe impl fidl::encoding::TypeMarker for EchoEchoXunionsRequest {
7846        type Owned = Self;
7847
7848        #[inline(always)]
7849        fn inline_align(_context: fidl::encoding::Context) -> usize {
7850            8
7851        }
7852
7853        #[inline(always)]
7854        fn inline_size(_context: fidl::encoding::Context) -> usize {
7855            32
7856        }
7857    }
7858
7859    unsafe impl
7860        fidl::encoding::Encode<
7861            EchoEchoXunionsRequest,
7862            fidl::encoding::DefaultFuchsiaResourceDialect,
7863        > for &mut EchoEchoXunionsRequest
7864    {
7865        #[inline]
7866        unsafe fn encode(
7867            self,
7868            encoder: &mut fidl::encoding::Encoder<
7869                '_,
7870                fidl::encoding::DefaultFuchsiaResourceDialect,
7871            >,
7872            offset: usize,
7873            _depth: fidl::encoding::Depth,
7874        ) -> fidl::Result<()> {
7875            encoder.debug_check_bounds::<EchoEchoXunionsRequest>(offset);
7876            // Delegate to tuple encoding.
7877            fidl::encoding::Encode::<EchoEchoXunionsRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
7878                (
7879                    <fidl::encoding::UnboundedVector<AllTypesXunion> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
7880                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(&self.forward_to_server),
7881                ),
7882                encoder, offset, _depth
7883            )
7884        }
7885    }
7886    unsafe impl<
7887        T0: fidl::encoding::Encode<
7888                fidl::encoding::UnboundedVector<AllTypesXunion>,
7889                fidl::encoding::DefaultFuchsiaResourceDialect,
7890            >,
7891        T1: fidl::encoding::Encode<
7892                fidl::encoding::UnboundedString,
7893                fidl::encoding::DefaultFuchsiaResourceDialect,
7894            >,
7895    >
7896        fidl::encoding::Encode<
7897            EchoEchoXunionsRequest,
7898            fidl::encoding::DefaultFuchsiaResourceDialect,
7899        > for (T0, T1)
7900    {
7901        #[inline]
7902        unsafe fn encode(
7903            self,
7904            encoder: &mut fidl::encoding::Encoder<
7905                '_,
7906                fidl::encoding::DefaultFuchsiaResourceDialect,
7907            >,
7908            offset: usize,
7909            depth: fidl::encoding::Depth,
7910        ) -> fidl::Result<()> {
7911            encoder.debug_check_bounds::<EchoEchoXunionsRequest>(offset);
7912            // Zero out padding regions. There's no need to apply masks
7913            // because the unmasked parts will be overwritten by fields.
7914            // Write the fields.
7915            self.0.encode(encoder, offset + 0, depth)?;
7916            self.1.encode(encoder, offset + 16, depth)?;
7917            Ok(())
7918        }
7919    }
7920
7921    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7922        for EchoEchoXunionsRequest
7923    {
7924        #[inline(always)]
7925        fn new_empty() -> Self {
7926            Self {
7927                value: fidl::new_empty!(
7928                    fidl::encoding::UnboundedVector<AllTypesXunion>,
7929                    fidl::encoding::DefaultFuchsiaResourceDialect
7930                ),
7931                forward_to_server: fidl::new_empty!(
7932                    fidl::encoding::UnboundedString,
7933                    fidl::encoding::DefaultFuchsiaResourceDialect
7934                ),
7935            }
7936        }
7937
7938        #[inline]
7939        unsafe fn decode(
7940            &mut self,
7941            decoder: &mut fidl::encoding::Decoder<
7942                '_,
7943                fidl::encoding::DefaultFuchsiaResourceDialect,
7944            >,
7945            offset: usize,
7946            _depth: fidl::encoding::Depth,
7947        ) -> fidl::Result<()> {
7948            decoder.debug_check_bounds::<Self>(offset);
7949            // Verify that padding bytes are zero.
7950            fidl::decode!(
7951                fidl::encoding::UnboundedVector<AllTypesXunion>,
7952                fidl::encoding::DefaultFuchsiaResourceDialect,
7953                &mut self.value,
7954                decoder,
7955                offset + 0,
7956                _depth
7957            )?;
7958            fidl::decode!(
7959                fidl::encoding::UnboundedString,
7960                fidl::encoding::DefaultFuchsiaResourceDialect,
7961                &mut self.forward_to_server,
7962                decoder,
7963                offset + 16,
7964                _depth
7965            )?;
7966            Ok(())
7967        }
7968    }
7969
7970    impl fidl::encoding::ResourceTypeMarker for EchoEchoXunionsResponse {
7971        type Borrowed<'a> = &'a mut Self;
7972        fn take_or_borrow<'a>(
7973            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7974        ) -> Self::Borrowed<'a> {
7975            value
7976        }
7977    }
7978
7979    unsafe impl fidl::encoding::TypeMarker for EchoEchoXunionsResponse {
7980        type Owned = Self;
7981
7982        #[inline(always)]
7983        fn inline_align(_context: fidl::encoding::Context) -> usize {
7984            8
7985        }
7986
7987        #[inline(always)]
7988        fn inline_size(_context: fidl::encoding::Context) -> usize {
7989            16
7990        }
7991    }
7992
7993    unsafe impl
7994        fidl::encoding::Encode<
7995            EchoEchoXunionsResponse,
7996            fidl::encoding::DefaultFuchsiaResourceDialect,
7997        > for &mut EchoEchoXunionsResponse
7998    {
7999        #[inline]
8000        unsafe fn encode(
8001            self,
8002            encoder: &mut fidl::encoding::Encoder<
8003                '_,
8004                fidl::encoding::DefaultFuchsiaResourceDialect,
8005            >,
8006            offset: usize,
8007            _depth: fidl::encoding::Depth,
8008        ) -> fidl::Result<()> {
8009            encoder.debug_check_bounds::<EchoEchoXunionsResponse>(offset);
8010            // Delegate to tuple encoding.
8011            fidl::encoding::Encode::<EchoEchoXunionsResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
8012                (
8013                    <fidl::encoding::UnboundedVector<AllTypesXunion> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
8014                ),
8015                encoder, offset, _depth
8016            )
8017        }
8018    }
8019    unsafe impl<
8020        T0: fidl::encoding::Encode<
8021                fidl::encoding::UnboundedVector<AllTypesXunion>,
8022                fidl::encoding::DefaultFuchsiaResourceDialect,
8023            >,
8024    >
8025        fidl::encoding::Encode<
8026            EchoEchoXunionsResponse,
8027            fidl::encoding::DefaultFuchsiaResourceDialect,
8028        > for (T0,)
8029    {
8030        #[inline]
8031        unsafe fn encode(
8032            self,
8033            encoder: &mut fidl::encoding::Encoder<
8034                '_,
8035                fidl::encoding::DefaultFuchsiaResourceDialect,
8036            >,
8037            offset: usize,
8038            depth: fidl::encoding::Depth,
8039        ) -> fidl::Result<()> {
8040            encoder.debug_check_bounds::<EchoEchoXunionsResponse>(offset);
8041            // Zero out padding regions. There's no need to apply masks
8042            // because the unmasked parts will be overwritten by fields.
8043            // Write the fields.
8044            self.0.encode(encoder, offset + 0, depth)?;
8045            Ok(())
8046        }
8047    }
8048
8049    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8050        for EchoEchoXunionsResponse
8051    {
8052        #[inline(always)]
8053        fn new_empty() -> Self {
8054            Self {
8055                value: fidl::new_empty!(
8056                    fidl::encoding::UnboundedVector<AllTypesXunion>,
8057                    fidl::encoding::DefaultFuchsiaResourceDialect
8058                ),
8059            }
8060        }
8061
8062        #[inline]
8063        unsafe fn decode(
8064            &mut self,
8065            decoder: &mut fidl::encoding::Decoder<
8066                '_,
8067                fidl::encoding::DefaultFuchsiaResourceDialect,
8068            >,
8069            offset: usize,
8070            _depth: fidl::encoding::Depth,
8071        ) -> fidl::Result<()> {
8072            decoder.debug_check_bounds::<Self>(offset);
8073            // Verify that padding bytes are zero.
8074            fidl::decode!(
8075                fidl::encoding::UnboundedVector<AllTypesXunion>,
8076                fidl::encoding::DefaultFuchsiaResourceDialect,
8077                &mut self.value,
8078                decoder,
8079                offset + 0,
8080                _depth
8081            )?;
8082            Ok(())
8083        }
8084    }
8085
8086    impl fidl::encoding::ResourceTypeMarker for EchoEchoXunionsWithErrorRequest {
8087        type Borrowed<'a> = &'a mut Self;
8088        fn take_or_borrow<'a>(
8089            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8090        ) -> Self::Borrowed<'a> {
8091            value
8092        }
8093    }
8094
8095    unsafe impl fidl::encoding::TypeMarker for EchoEchoXunionsWithErrorRequest {
8096        type Owned = Self;
8097
8098        #[inline(always)]
8099        fn inline_align(_context: fidl::encoding::Context) -> usize {
8100            8
8101        }
8102
8103        #[inline(always)]
8104        fn inline_size(_context: fidl::encoding::Context) -> usize {
8105            48
8106        }
8107    }
8108
8109    unsafe impl
8110        fidl::encoding::Encode<
8111            EchoEchoXunionsWithErrorRequest,
8112            fidl::encoding::DefaultFuchsiaResourceDialect,
8113        > for &mut EchoEchoXunionsWithErrorRequest
8114    {
8115        #[inline]
8116        unsafe fn encode(
8117            self,
8118            encoder: &mut fidl::encoding::Encoder<
8119                '_,
8120                fidl::encoding::DefaultFuchsiaResourceDialect,
8121            >,
8122            offset: usize,
8123            _depth: fidl::encoding::Depth,
8124        ) -> fidl::Result<()> {
8125            encoder.debug_check_bounds::<EchoEchoXunionsWithErrorRequest>(offset);
8126            // Delegate to tuple encoding.
8127            fidl::encoding::Encode::<EchoEchoXunionsWithErrorRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
8128                (
8129                    <fidl::encoding::UnboundedVector<AllTypesXunion> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
8130                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
8131                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(&self.forward_to_server),
8132                    <RespondWith as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
8133                ),
8134                encoder, offset, _depth
8135            )
8136        }
8137    }
8138    unsafe impl<
8139        T0: fidl::encoding::Encode<
8140                fidl::encoding::UnboundedVector<AllTypesXunion>,
8141                fidl::encoding::DefaultFuchsiaResourceDialect,
8142            >,
8143        T1: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8144        T2: fidl::encoding::Encode<
8145                fidl::encoding::UnboundedString,
8146                fidl::encoding::DefaultFuchsiaResourceDialect,
8147            >,
8148        T3: fidl::encoding::Encode<RespondWith, fidl::encoding::DefaultFuchsiaResourceDialect>,
8149    >
8150        fidl::encoding::Encode<
8151            EchoEchoXunionsWithErrorRequest,
8152            fidl::encoding::DefaultFuchsiaResourceDialect,
8153        > for (T0, T1, T2, T3)
8154    {
8155        #[inline]
8156        unsafe fn encode(
8157            self,
8158            encoder: &mut fidl::encoding::Encoder<
8159                '_,
8160                fidl::encoding::DefaultFuchsiaResourceDialect,
8161            >,
8162            offset: usize,
8163            depth: fidl::encoding::Depth,
8164        ) -> fidl::Result<()> {
8165            encoder.debug_check_bounds::<EchoEchoXunionsWithErrorRequest>(offset);
8166            // Zero out padding regions. There's no need to apply masks
8167            // because the unmasked parts will be overwritten by fields.
8168            unsafe {
8169                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
8170                (ptr as *mut u64).write_unaligned(0);
8171            }
8172            unsafe {
8173                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
8174                (ptr as *mut u64).write_unaligned(0);
8175            }
8176            // Write the fields.
8177            self.0.encode(encoder, offset + 0, depth)?;
8178            self.1.encode(encoder, offset + 16, depth)?;
8179            self.2.encode(encoder, offset + 24, depth)?;
8180            self.3.encode(encoder, offset + 40, depth)?;
8181            Ok(())
8182        }
8183    }
8184
8185    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8186        for EchoEchoXunionsWithErrorRequest
8187    {
8188        #[inline(always)]
8189        fn new_empty() -> Self {
8190            Self {
8191                value: fidl::new_empty!(
8192                    fidl::encoding::UnboundedVector<AllTypesXunion>,
8193                    fidl::encoding::DefaultFuchsiaResourceDialect
8194                ),
8195                result_err: fidl::new_empty!(
8196                    DefaultEnum,
8197                    fidl::encoding::DefaultFuchsiaResourceDialect
8198                ),
8199                forward_to_server: fidl::new_empty!(
8200                    fidl::encoding::UnboundedString,
8201                    fidl::encoding::DefaultFuchsiaResourceDialect
8202                ),
8203                result_variant: fidl::new_empty!(
8204                    RespondWith,
8205                    fidl::encoding::DefaultFuchsiaResourceDialect
8206                ),
8207            }
8208        }
8209
8210        #[inline]
8211        unsafe fn decode(
8212            &mut self,
8213            decoder: &mut fidl::encoding::Decoder<
8214                '_,
8215                fidl::encoding::DefaultFuchsiaResourceDialect,
8216            >,
8217            offset: usize,
8218            _depth: fidl::encoding::Depth,
8219        ) -> fidl::Result<()> {
8220            decoder.debug_check_bounds::<Self>(offset);
8221            // Verify that padding bytes are zero.
8222            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
8223            let padval = unsafe { (ptr as *const u64).read_unaligned() };
8224            let mask = 0xffffffff00000000u64;
8225            let maskedval = padval & mask;
8226            if maskedval != 0 {
8227                return Err(fidl::Error::NonZeroPadding {
8228                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
8229                });
8230            }
8231            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
8232            let padval = unsafe { (ptr as *const u64).read_unaligned() };
8233            let mask = 0xffffffff00000000u64;
8234            let maskedval = padval & mask;
8235            if maskedval != 0 {
8236                return Err(fidl::Error::NonZeroPadding {
8237                    padding_start: offset + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
8238                });
8239            }
8240            fidl::decode!(
8241                fidl::encoding::UnboundedVector<AllTypesXunion>,
8242                fidl::encoding::DefaultFuchsiaResourceDialect,
8243                &mut self.value,
8244                decoder,
8245                offset + 0,
8246                _depth
8247            )?;
8248            fidl::decode!(
8249                DefaultEnum,
8250                fidl::encoding::DefaultFuchsiaResourceDialect,
8251                &mut self.result_err,
8252                decoder,
8253                offset + 16,
8254                _depth
8255            )?;
8256            fidl::decode!(
8257                fidl::encoding::UnboundedString,
8258                fidl::encoding::DefaultFuchsiaResourceDialect,
8259                &mut self.forward_to_server,
8260                decoder,
8261                offset + 24,
8262                _depth
8263            )?;
8264            fidl::decode!(
8265                RespondWith,
8266                fidl::encoding::DefaultFuchsiaResourceDialect,
8267                &mut self.result_variant,
8268                decoder,
8269                offset + 40,
8270                _depth
8271            )?;
8272            Ok(())
8273        }
8274    }
8275
8276    impl fidl::encoding::ResourceTypeMarker for EchoEchoArraysWithErrorResponse {
8277        type Borrowed<'a> = &'a mut Self;
8278        fn take_or_borrow<'a>(
8279            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8280        ) -> Self::Borrowed<'a> {
8281            value
8282        }
8283    }
8284
8285    unsafe impl fidl::encoding::TypeMarker for EchoEchoArraysWithErrorResponse {
8286        type Owned = Self;
8287
8288        #[inline(always)]
8289        fn inline_align(_context: fidl::encoding::Context) -> usize {
8290            8
8291        }
8292
8293        #[inline(always)]
8294        fn inline_size(_context: fidl::encoding::Context) -> usize {
8295            680
8296        }
8297    }
8298
8299    unsafe impl
8300        fidl::encoding::Encode<
8301            EchoEchoArraysWithErrorResponse,
8302            fidl::encoding::DefaultFuchsiaResourceDialect,
8303        > for &mut EchoEchoArraysWithErrorResponse
8304    {
8305        #[inline]
8306        unsafe fn encode(
8307            self,
8308            encoder: &mut fidl::encoding::Encoder<
8309                '_,
8310                fidl::encoding::DefaultFuchsiaResourceDialect,
8311            >,
8312            offset: usize,
8313            _depth: fidl::encoding::Depth,
8314        ) -> fidl::Result<()> {
8315            encoder.debug_check_bounds::<EchoEchoArraysWithErrorResponse>(offset);
8316            // Delegate to tuple encoding.
8317            fidl::encoding::Encode::<
8318                EchoEchoArraysWithErrorResponse,
8319                fidl::encoding::DefaultFuchsiaResourceDialect,
8320            >::encode(
8321                (<ArraysStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8322                    &mut self.value,
8323                ),),
8324                encoder,
8325                offset,
8326                _depth,
8327            )
8328        }
8329    }
8330    unsafe impl<
8331        T0: fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
8332    >
8333        fidl::encoding::Encode<
8334            EchoEchoArraysWithErrorResponse,
8335            fidl::encoding::DefaultFuchsiaResourceDialect,
8336        > for (T0,)
8337    {
8338        #[inline]
8339        unsafe fn encode(
8340            self,
8341            encoder: &mut fidl::encoding::Encoder<
8342                '_,
8343                fidl::encoding::DefaultFuchsiaResourceDialect,
8344            >,
8345            offset: usize,
8346            depth: fidl::encoding::Depth,
8347        ) -> fidl::Result<()> {
8348            encoder.debug_check_bounds::<EchoEchoArraysWithErrorResponse>(offset);
8349            // Zero out padding regions. There's no need to apply masks
8350            // because the unmasked parts will be overwritten by fields.
8351            // Write the fields.
8352            self.0.encode(encoder, offset + 0, depth)?;
8353            Ok(())
8354        }
8355    }
8356
8357    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8358        for EchoEchoArraysWithErrorResponse
8359    {
8360        #[inline(always)]
8361        fn new_empty() -> Self {
8362            Self {
8363                value: fidl::new_empty!(
8364                    ArraysStruct,
8365                    fidl::encoding::DefaultFuchsiaResourceDialect
8366                ),
8367            }
8368        }
8369
8370        #[inline]
8371        unsafe fn decode(
8372            &mut self,
8373            decoder: &mut fidl::encoding::Decoder<
8374                '_,
8375                fidl::encoding::DefaultFuchsiaResourceDialect,
8376            >,
8377            offset: usize,
8378            _depth: fidl::encoding::Depth,
8379        ) -> fidl::Result<()> {
8380            decoder.debug_check_bounds::<Self>(offset);
8381            // Verify that padding bytes are zero.
8382            fidl::decode!(
8383                ArraysStruct,
8384                fidl::encoding::DefaultFuchsiaResourceDialect,
8385                &mut self.value,
8386                decoder,
8387                offset + 0,
8388                _depth
8389            )?;
8390            Ok(())
8391        }
8392    }
8393
8394    impl fidl::encoding::ResourceTypeMarker for EchoEchoStructWithErrorResponse {
8395        type Borrowed<'a> = &'a mut Self;
8396        fn take_or_borrow<'a>(
8397            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8398        ) -> Self::Borrowed<'a> {
8399            value
8400        }
8401    }
8402
8403    unsafe impl fidl::encoding::TypeMarker for EchoEchoStructWithErrorResponse {
8404        type Owned = Self;
8405
8406        #[inline(always)]
8407        fn inline_align(_context: fidl::encoding::Context) -> usize {
8408            8
8409        }
8410
8411        #[inline(always)]
8412        fn inline_size(_context: fidl::encoding::Context) -> usize {
8413            2912
8414        }
8415    }
8416
8417    unsafe impl
8418        fidl::encoding::Encode<
8419            EchoEchoStructWithErrorResponse,
8420            fidl::encoding::DefaultFuchsiaResourceDialect,
8421        > for &mut EchoEchoStructWithErrorResponse
8422    {
8423        #[inline]
8424        unsafe fn encode(
8425            self,
8426            encoder: &mut fidl::encoding::Encoder<
8427                '_,
8428                fidl::encoding::DefaultFuchsiaResourceDialect,
8429            >,
8430            offset: usize,
8431            _depth: fidl::encoding::Depth,
8432        ) -> fidl::Result<()> {
8433            encoder.debug_check_bounds::<EchoEchoStructWithErrorResponse>(offset);
8434            // Delegate to tuple encoding.
8435            fidl::encoding::Encode::<
8436                EchoEchoStructWithErrorResponse,
8437                fidl::encoding::DefaultFuchsiaResourceDialect,
8438            >::encode(
8439                (<Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),),
8440                encoder,
8441                offset,
8442                _depth,
8443            )
8444        }
8445    }
8446    unsafe impl<T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>>
8447        fidl::encoding::Encode<
8448            EchoEchoStructWithErrorResponse,
8449            fidl::encoding::DefaultFuchsiaResourceDialect,
8450        > for (T0,)
8451    {
8452        #[inline]
8453        unsafe fn encode(
8454            self,
8455            encoder: &mut fidl::encoding::Encoder<
8456                '_,
8457                fidl::encoding::DefaultFuchsiaResourceDialect,
8458            >,
8459            offset: usize,
8460            depth: fidl::encoding::Depth,
8461        ) -> fidl::Result<()> {
8462            encoder.debug_check_bounds::<EchoEchoStructWithErrorResponse>(offset);
8463            // Zero out padding regions. There's no need to apply masks
8464            // because the unmasked parts will be overwritten by fields.
8465            // Write the fields.
8466            self.0.encode(encoder, offset + 0, depth)?;
8467            Ok(())
8468        }
8469    }
8470
8471    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8472        for EchoEchoStructWithErrorResponse
8473    {
8474        #[inline(always)]
8475        fn new_empty() -> Self {
8476            Self { value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect) }
8477        }
8478
8479        #[inline]
8480        unsafe fn decode(
8481            &mut self,
8482            decoder: &mut fidl::encoding::Decoder<
8483                '_,
8484                fidl::encoding::DefaultFuchsiaResourceDialect,
8485            >,
8486            offset: usize,
8487            _depth: fidl::encoding::Depth,
8488        ) -> fidl::Result<()> {
8489            decoder.debug_check_bounds::<Self>(offset);
8490            // Verify that padding bytes are zero.
8491            fidl::decode!(
8492                Struct,
8493                fidl::encoding::DefaultFuchsiaResourceDialect,
8494                &mut self.value,
8495                decoder,
8496                offset + 0,
8497                _depth
8498            )?;
8499            Ok(())
8500        }
8501    }
8502
8503    impl fidl::encoding::ResourceTypeMarker for EchoEchoTableWithErrorResponse {
8504        type Borrowed<'a> = &'a mut Self;
8505        fn take_or_borrow<'a>(
8506            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8507        ) -> Self::Borrowed<'a> {
8508            value
8509        }
8510    }
8511
8512    unsafe impl fidl::encoding::TypeMarker for EchoEchoTableWithErrorResponse {
8513        type Owned = Self;
8514
8515        #[inline(always)]
8516        fn inline_align(_context: fidl::encoding::Context) -> usize {
8517            8
8518        }
8519
8520        #[inline(always)]
8521        fn inline_size(_context: fidl::encoding::Context) -> usize {
8522            16
8523        }
8524    }
8525
8526    unsafe impl
8527        fidl::encoding::Encode<
8528            EchoEchoTableWithErrorResponse,
8529            fidl::encoding::DefaultFuchsiaResourceDialect,
8530        > for &mut EchoEchoTableWithErrorResponse
8531    {
8532        #[inline]
8533        unsafe fn encode(
8534            self,
8535            encoder: &mut fidl::encoding::Encoder<
8536                '_,
8537                fidl::encoding::DefaultFuchsiaResourceDialect,
8538            >,
8539            offset: usize,
8540            _depth: fidl::encoding::Depth,
8541        ) -> fidl::Result<()> {
8542            encoder.debug_check_bounds::<EchoEchoTableWithErrorResponse>(offset);
8543            // Delegate to tuple encoding.
8544            fidl::encoding::Encode::<
8545                EchoEchoTableWithErrorResponse,
8546                fidl::encoding::DefaultFuchsiaResourceDialect,
8547            >::encode(
8548                (<AllTypesTable as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8549                    &mut self.value,
8550                ),),
8551                encoder,
8552                offset,
8553                _depth,
8554            )
8555        }
8556    }
8557    unsafe impl<
8558        T0: fidl::encoding::Encode<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>,
8559    >
8560        fidl::encoding::Encode<
8561            EchoEchoTableWithErrorResponse,
8562            fidl::encoding::DefaultFuchsiaResourceDialect,
8563        > for (T0,)
8564    {
8565        #[inline]
8566        unsafe fn encode(
8567            self,
8568            encoder: &mut fidl::encoding::Encoder<
8569                '_,
8570                fidl::encoding::DefaultFuchsiaResourceDialect,
8571            >,
8572            offset: usize,
8573            depth: fidl::encoding::Depth,
8574        ) -> fidl::Result<()> {
8575            encoder.debug_check_bounds::<EchoEchoTableWithErrorResponse>(offset);
8576            // Zero out padding regions. There's no need to apply masks
8577            // because the unmasked parts will be overwritten by fields.
8578            // Write the fields.
8579            self.0.encode(encoder, offset + 0, depth)?;
8580            Ok(())
8581        }
8582    }
8583
8584    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8585        for EchoEchoTableWithErrorResponse
8586    {
8587        #[inline(always)]
8588        fn new_empty() -> Self {
8589            Self {
8590                value: fidl::new_empty!(
8591                    AllTypesTable,
8592                    fidl::encoding::DefaultFuchsiaResourceDialect
8593                ),
8594            }
8595        }
8596
8597        #[inline]
8598        unsafe fn decode(
8599            &mut self,
8600            decoder: &mut fidl::encoding::Decoder<
8601                '_,
8602                fidl::encoding::DefaultFuchsiaResourceDialect,
8603            >,
8604            offset: usize,
8605            _depth: fidl::encoding::Depth,
8606        ) -> fidl::Result<()> {
8607            decoder.debug_check_bounds::<Self>(offset);
8608            // Verify that padding bytes are zero.
8609            fidl::decode!(
8610                AllTypesTable,
8611                fidl::encoding::DefaultFuchsiaResourceDialect,
8612                &mut self.value,
8613                decoder,
8614                offset + 0,
8615                _depth
8616            )?;
8617            Ok(())
8618        }
8619    }
8620
8621    impl fidl::encoding::ResourceTypeMarker for EchoEchoVectorsWithErrorResponse {
8622        type Borrowed<'a> = &'a mut Self;
8623        fn take_or_borrow<'a>(
8624            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8625        ) -> Self::Borrowed<'a> {
8626            value
8627        }
8628    }
8629
8630    unsafe impl fidl::encoding::TypeMarker for EchoEchoVectorsWithErrorResponse {
8631        type Owned = Self;
8632
8633        #[inline(always)]
8634        fn inline_align(_context: fidl::encoding::Context) -> usize {
8635            8
8636        }
8637
8638        #[inline(always)]
8639        fn inline_size(_context: fidl::encoding::Context) -> usize {
8640            416
8641        }
8642    }
8643
8644    unsafe impl
8645        fidl::encoding::Encode<
8646            EchoEchoVectorsWithErrorResponse,
8647            fidl::encoding::DefaultFuchsiaResourceDialect,
8648        > for &mut EchoEchoVectorsWithErrorResponse
8649    {
8650        #[inline]
8651        unsafe fn encode(
8652            self,
8653            encoder: &mut fidl::encoding::Encoder<
8654                '_,
8655                fidl::encoding::DefaultFuchsiaResourceDialect,
8656            >,
8657            offset: usize,
8658            _depth: fidl::encoding::Depth,
8659        ) -> fidl::Result<()> {
8660            encoder.debug_check_bounds::<EchoEchoVectorsWithErrorResponse>(offset);
8661            // Delegate to tuple encoding.
8662            fidl::encoding::Encode::<
8663                EchoEchoVectorsWithErrorResponse,
8664                fidl::encoding::DefaultFuchsiaResourceDialect,
8665            >::encode(
8666                (<VectorsStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8667                    &mut self.value,
8668                ),),
8669                encoder,
8670                offset,
8671                _depth,
8672            )
8673        }
8674    }
8675    unsafe impl<
8676        T0: fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
8677    >
8678        fidl::encoding::Encode<
8679            EchoEchoVectorsWithErrorResponse,
8680            fidl::encoding::DefaultFuchsiaResourceDialect,
8681        > for (T0,)
8682    {
8683        #[inline]
8684        unsafe fn encode(
8685            self,
8686            encoder: &mut fidl::encoding::Encoder<
8687                '_,
8688                fidl::encoding::DefaultFuchsiaResourceDialect,
8689            >,
8690            offset: usize,
8691            depth: fidl::encoding::Depth,
8692        ) -> fidl::Result<()> {
8693            encoder.debug_check_bounds::<EchoEchoVectorsWithErrorResponse>(offset);
8694            // Zero out padding regions. There's no need to apply masks
8695            // because the unmasked parts will be overwritten by fields.
8696            // Write the fields.
8697            self.0.encode(encoder, offset + 0, depth)?;
8698            Ok(())
8699        }
8700    }
8701
8702    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8703        for EchoEchoVectorsWithErrorResponse
8704    {
8705        #[inline(always)]
8706        fn new_empty() -> Self {
8707            Self {
8708                value: fidl::new_empty!(
8709                    VectorsStruct,
8710                    fidl::encoding::DefaultFuchsiaResourceDialect
8711                ),
8712            }
8713        }
8714
8715        #[inline]
8716        unsafe fn decode(
8717            &mut self,
8718            decoder: &mut fidl::encoding::Decoder<
8719                '_,
8720                fidl::encoding::DefaultFuchsiaResourceDialect,
8721            >,
8722            offset: usize,
8723            _depth: fidl::encoding::Depth,
8724        ) -> fidl::Result<()> {
8725            decoder.debug_check_bounds::<Self>(offset);
8726            // Verify that padding bytes are zero.
8727            fidl::decode!(
8728                VectorsStruct,
8729                fidl::encoding::DefaultFuchsiaResourceDialect,
8730                &mut self.value,
8731                decoder,
8732                offset + 0,
8733                _depth
8734            )?;
8735            Ok(())
8736        }
8737    }
8738
8739    impl fidl::encoding::ResourceTypeMarker for EchoEchoXunionsWithErrorResponse {
8740        type Borrowed<'a> = &'a mut Self;
8741        fn take_or_borrow<'a>(
8742            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8743        ) -> Self::Borrowed<'a> {
8744            value
8745        }
8746    }
8747
8748    unsafe impl fidl::encoding::TypeMarker for EchoEchoXunionsWithErrorResponse {
8749        type Owned = Self;
8750
8751        #[inline(always)]
8752        fn inline_align(_context: fidl::encoding::Context) -> usize {
8753            8
8754        }
8755
8756        #[inline(always)]
8757        fn inline_size(_context: fidl::encoding::Context) -> usize {
8758            16
8759        }
8760    }
8761
8762    unsafe impl
8763        fidl::encoding::Encode<
8764            EchoEchoXunionsWithErrorResponse,
8765            fidl::encoding::DefaultFuchsiaResourceDialect,
8766        > for &mut EchoEchoXunionsWithErrorResponse
8767    {
8768        #[inline]
8769        unsafe fn encode(
8770            self,
8771            encoder: &mut fidl::encoding::Encoder<
8772                '_,
8773                fidl::encoding::DefaultFuchsiaResourceDialect,
8774            >,
8775            offset: usize,
8776            _depth: fidl::encoding::Depth,
8777        ) -> fidl::Result<()> {
8778            encoder.debug_check_bounds::<EchoEchoXunionsWithErrorResponse>(offset);
8779            // Delegate to tuple encoding.
8780            fidl::encoding::Encode::<EchoEchoXunionsWithErrorResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
8781                (
8782                    <fidl::encoding::UnboundedVector<AllTypesXunion> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
8783                ),
8784                encoder, offset, _depth
8785            )
8786        }
8787    }
8788    unsafe impl<
8789        T0: fidl::encoding::Encode<
8790                fidl::encoding::UnboundedVector<AllTypesXunion>,
8791                fidl::encoding::DefaultFuchsiaResourceDialect,
8792            >,
8793    >
8794        fidl::encoding::Encode<
8795            EchoEchoXunionsWithErrorResponse,
8796            fidl::encoding::DefaultFuchsiaResourceDialect,
8797        > for (T0,)
8798    {
8799        #[inline]
8800        unsafe fn encode(
8801            self,
8802            encoder: &mut fidl::encoding::Encoder<
8803                '_,
8804                fidl::encoding::DefaultFuchsiaResourceDialect,
8805            >,
8806            offset: usize,
8807            depth: fidl::encoding::Depth,
8808        ) -> fidl::Result<()> {
8809            encoder.debug_check_bounds::<EchoEchoXunionsWithErrorResponse>(offset);
8810            // Zero out padding regions. There's no need to apply masks
8811            // because the unmasked parts will be overwritten by fields.
8812            // Write the fields.
8813            self.0.encode(encoder, offset + 0, depth)?;
8814            Ok(())
8815        }
8816    }
8817
8818    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8819        for EchoEchoXunionsWithErrorResponse
8820    {
8821        #[inline(always)]
8822        fn new_empty() -> Self {
8823            Self {
8824                value: fidl::new_empty!(
8825                    fidl::encoding::UnboundedVector<AllTypesXunion>,
8826                    fidl::encoding::DefaultFuchsiaResourceDialect
8827                ),
8828            }
8829        }
8830
8831        #[inline]
8832        unsafe fn decode(
8833            &mut self,
8834            decoder: &mut fidl::encoding::Decoder<
8835                '_,
8836                fidl::encoding::DefaultFuchsiaResourceDialect,
8837            >,
8838            offset: usize,
8839            _depth: fidl::encoding::Depth,
8840        ) -> fidl::Result<()> {
8841            decoder.debug_check_bounds::<Self>(offset);
8842            // Verify that padding bytes are zero.
8843            fidl::decode!(
8844                fidl::encoding::UnboundedVector<AllTypesXunion>,
8845                fidl::encoding::DefaultFuchsiaResourceDialect,
8846                &mut self.value,
8847                decoder,
8848                offset + 0,
8849                _depth
8850            )?;
8851            Ok(())
8852        }
8853    }
8854
8855    impl fidl::encoding::ResourceTypeMarker for Struct {
8856        type Borrowed<'a> = &'a mut Self;
8857        fn take_or_borrow<'a>(
8858            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8859        ) -> Self::Borrowed<'a> {
8860            value
8861        }
8862    }
8863
8864    unsafe impl fidl::encoding::TypeMarker for Struct {
8865        type Owned = Self;
8866
8867        #[inline(always)]
8868        fn inline_align(_context: fidl::encoding::Context) -> usize {
8869            8
8870        }
8871
8872        #[inline(always)]
8873        fn inline_size(_context: fidl::encoding::Context) -> usize {
8874            2912
8875        }
8876    }
8877
8878    unsafe impl fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>
8879        for &mut Struct
8880    {
8881        #[inline]
8882        unsafe fn encode(
8883            self,
8884            encoder: &mut fidl::encoding::Encoder<
8885                '_,
8886                fidl::encoding::DefaultFuchsiaResourceDialect,
8887            >,
8888            offset: usize,
8889            _depth: fidl::encoding::Depth,
8890        ) -> fidl::Result<()> {
8891            encoder.debug_check_bounds::<Struct>(offset);
8892            // Delegate to tuple encoding.
8893            fidl::encoding::Encode::<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
8894                (
8895                    <PrimitiveTypes as fidl::encoding::ValueTypeMarker>::borrow(
8896                        &self.primitive_types,
8897                    ),
8898                    <DefaultValues as fidl::encoding::ValueTypeMarker>::borrow(
8899                        &self.default_values,
8900                    ),
8901                    <Arrays as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8902                        &mut self.arrays,
8903                    ),
8904                    <Arrays2d as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8905                        &mut self.arrays_2d,
8906                    ),
8907                    <Vectors as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8908                        &mut self.vectors,
8909                    ),
8910                    <Handles as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8911                        &mut self.handles,
8912                    ),
8913                    <Strings as fidl::encoding::ValueTypeMarker>::borrow(&self.strings),
8914                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.default_enum),
8915                    <I8Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_enum),
8916                    <I16Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_enum),
8917                    <I32Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_enum),
8918                    <I64Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_enum),
8919                    <U8Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_enum),
8920                    <U16Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_enum),
8921                    <U32Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_enum),
8922                    <U64Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_enum),
8923                    <DefaultBits as fidl::encoding::ValueTypeMarker>::borrow(&self.default_bits),
8924                    <U8Bits as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_bits),
8925                    <U16Bits as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_bits),
8926                    <U32Bits as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_bits),
8927                    <U64Bits as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_bits),
8928                    <Structs as fidl::encoding::ValueTypeMarker>::borrow(&self.structs),
8929                    <Unions as fidl::encoding::ValueTypeMarker>::borrow(&self.unions),
8930                    <ThisIsATable as fidl::encoding::ValueTypeMarker>::borrow(&self.table),
8931                    <ThisIsAXunion as fidl::encoding::ValueTypeMarker>::borrow(&self.xunion),
8932                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.b),
8933                ),
8934                encoder,
8935                offset,
8936                _depth,
8937            )
8938        }
8939    }
8940    unsafe impl<
8941        T0: fidl::encoding::Encode<PrimitiveTypes, fidl::encoding::DefaultFuchsiaResourceDialect>,
8942        T1: fidl::encoding::Encode<DefaultValues, fidl::encoding::DefaultFuchsiaResourceDialect>,
8943        T2: fidl::encoding::Encode<Arrays, fidl::encoding::DefaultFuchsiaResourceDialect>,
8944        T3: fidl::encoding::Encode<Arrays2d, fidl::encoding::DefaultFuchsiaResourceDialect>,
8945        T4: fidl::encoding::Encode<Vectors, fidl::encoding::DefaultFuchsiaResourceDialect>,
8946        T5: fidl::encoding::Encode<Handles, fidl::encoding::DefaultFuchsiaResourceDialect>,
8947        T6: fidl::encoding::Encode<Strings, fidl::encoding::DefaultFuchsiaResourceDialect>,
8948        T7: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8949        T8: fidl::encoding::Encode<I8Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8950        T9: fidl::encoding::Encode<I16Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8951        T10: fidl::encoding::Encode<I32Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8952        T11: fidl::encoding::Encode<I64Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8953        T12: fidl::encoding::Encode<U8Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8954        T13: fidl::encoding::Encode<U16Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8955        T14: fidl::encoding::Encode<U32Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8956        T15: fidl::encoding::Encode<U64Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8957        T16: fidl::encoding::Encode<DefaultBits, fidl::encoding::DefaultFuchsiaResourceDialect>,
8958        T17: fidl::encoding::Encode<U8Bits, fidl::encoding::DefaultFuchsiaResourceDialect>,
8959        T18: fidl::encoding::Encode<U16Bits, fidl::encoding::DefaultFuchsiaResourceDialect>,
8960        T19: fidl::encoding::Encode<U32Bits, fidl::encoding::DefaultFuchsiaResourceDialect>,
8961        T20: fidl::encoding::Encode<U64Bits, fidl::encoding::DefaultFuchsiaResourceDialect>,
8962        T21: fidl::encoding::Encode<Structs, fidl::encoding::DefaultFuchsiaResourceDialect>,
8963        T22: fidl::encoding::Encode<Unions, fidl::encoding::DefaultFuchsiaResourceDialect>,
8964        T23: fidl::encoding::Encode<ThisIsATable, fidl::encoding::DefaultFuchsiaResourceDialect>,
8965        T24: fidl::encoding::Encode<ThisIsAXunion, fidl::encoding::DefaultFuchsiaResourceDialect>,
8966        T25: fidl::encoding::Encode<bool, fidl::encoding::DefaultFuchsiaResourceDialect>,
8967    > fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>
8968        for (
8969            T0,
8970            T1,
8971            T2,
8972            T3,
8973            T4,
8974            T5,
8975            T6,
8976            T7,
8977            T8,
8978            T9,
8979            T10,
8980            T11,
8981            T12,
8982            T13,
8983            T14,
8984            T15,
8985            T16,
8986            T17,
8987            T18,
8988            T19,
8989            T20,
8990            T21,
8991            T22,
8992            T23,
8993            T24,
8994            T25,
8995        )
8996    {
8997        #[inline]
8998        unsafe fn encode(
8999            self,
9000            encoder: &mut fidl::encoding::Encoder<
9001                '_,
9002                fidl::encoding::DefaultFuchsiaResourceDialect,
9003            >,
9004            offset: usize,
9005            depth: fidl::encoding::Depth,
9006        ) -> fidl::Result<()> {
9007            encoder.debug_check_bounds::<Struct>(offset);
9008            // Zero out padding regions. There's no need to apply masks
9009            // because the unmasked parts will be overwritten by fields.
9010            unsafe {
9011                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2640);
9012                (ptr as *mut u64).write_unaligned(0);
9013            }
9014            unsafe {
9015                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2744);
9016                (ptr as *mut u64).write_unaligned(0);
9017            }
9018            unsafe {
9019                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2752);
9020                (ptr as *mut u64).write_unaligned(0);
9021            }
9022            unsafe {
9023                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2768);
9024                (ptr as *mut u64).write_unaligned(0);
9025            }
9026            unsafe {
9027                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2784);
9028                (ptr as *mut u64).write_unaligned(0);
9029            }
9030            unsafe {
9031                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2792);
9032                (ptr as *mut u64).write_unaligned(0);
9033            }
9034            unsafe {
9035                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2904);
9036                (ptr as *mut u64).write_unaligned(0);
9037            }
9038            // Write the fields.
9039            self.0.encode(encoder, offset + 0, depth)?;
9040            self.1.encode(encoder, offset + 48, depth)?;
9041            self.2.encode(encoder, offset + 120, depth)?;
9042            self.3.encode(encoder, offset + 328, depth)?;
9043            self.4.encode(encoder, offset + 616, depth)?;
9044            self.5.encode(encoder, offset + 2536, depth)?;
9045            self.6.encode(encoder, offset + 2648, depth)?;
9046            self.7.encode(encoder, offset + 2744, depth)?;
9047            self.8.encode(encoder, offset + 2748, depth)?;
9048            self.9.encode(encoder, offset + 2750, depth)?;
9049            self.10.encode(encoder, offset + 2752, depth)?;
9050            self.11.encode(encoder, offset + 2760, depth)?;
9051            self.12.encode(encoder, offset + 2768, depth)?;
9052            self.13.encode(encoder, offset + 2770, depth)?;
9053            self.14.encode(encoder, offset + 2772, depth)?;
9054            self.15.encode(encoder, offset + 2776, depth)?;
9055            self.16.encode(encoder, offset + 2784, depth)?;
9056            self.17.encode(encoder, offset + 2788, depth)?;
9057            self.18.encode(encoder, offset + 2790, depth)?;
9058            self.19.encode(encoder, offset + 2792, depth)?;
9059            self.20.encode(encoder, offset + 2800, depth)?;
9060            self.21.encode(encoder, offset + 2808, depth)?;
9061            self.22.encode(encoder, offset + 2840, depth)?;
9062            self.23.encode(encoder, offset + 2872, depth)?;
9063            self.24.encode(encoder, offset + 2888, depth)?;
9064            self.25.encode(encoder, offset + 2904, depth)?;
9065            Ok(())
9066        }
9067    }
9068
9069    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Struct {
9070        #[inline(always)]
9071        fn new_empty() -> Self {
9072            Self {
9073                primitive_types: fidl::new_empty!(
9074                    PrimitiveTypes,
9075                    fidl::encoding::DefaultFuchsiaResourceDialect
9076                ),
9077                default_values: fidl::new_empty!(
9078                    DefaultValues,
9079                    fidl::encoding::DefaultFuchsiaResourceDialect
9080                ),
9081                arrays: fidl::new_empty!(Arrays, fidl::encoding::DefaultFuchsiaResourceDialect),
9082                arrays_2d: fidl::new_empty!(
9083                    Arrays2d,
9084                    fidl::encoding::DefaultFuchsiaResourceDialect
9085                ),
9086                vectors: fidl::new_empty!(Vectors, fidl::encoding::DefaultFuchsiaResourceDialect),
9087                handles: fidl::new_empty!(Handles, fidl::encoding::DefaultFuchsiaResourceDialect),
9088                strings: fidl::new_empty!(Strings, fidl::encoding::DefaultFuchsiaResourceDialect),
9089                default_enum: fidl::new_empty!(
9090                    DefaultEnum,
9091                    fidl::encoding::DefaultFuchsiaResourceDialect
9092                ),
9093                i8_enum: fidl::new_empty!(I8Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9094                i16_enum: fidl::new_empty!(I16Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9095                i32_enum: fidl::new_empty!(I32Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9096                i64_enum: fidl::new_empty!(I64Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9097                u8_enum: fidl::new_empty!(U8Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9098                u16_enum: fidl::new_empty!(U16Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9099                u32_enum: fidl::new_empty!(U32Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9100                u64_enum: fidl::new_empty!(U64Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9101                default_bits: fidl::new_empty!(
9102                    DefaultBits,
9103                    fidl::encoding::DefaultFuchsiaResourceDialect
9104                ),
9105                u8_bits: fidl::new_empty!(U8Bits, fidl::encoding::DefaultFuchsiaResourceDialect),
9106                u16_bits: fidl::new_empty!(U16Bits, fidl::encoding::DefaultFuchsiaResourceDialect),
9107                u32_bits: fidl::new_empty!(U32Bits, fidl::encoding::DefaultFuchsiaResourceDialect),
9108                u64_bits: fidl::new_empty!(U64Bits, fidl::encoding::DefaultFuchsiaResourceDialect),
9109                structs: fidl::new_empty!(Structs, fidl::encoding::DefaultFuchsiaResourceDialect),
9110                unions: fidl::new_empty!(Unions, fidl::encoding::DefaultFuchsiaResourceDialect),
9111                table: fidl::new_empty!(
9112                    ThisIsATable,
9113                    fidl::encoding::DefaultFuchsiaResourceDialect
9114                ),
9115                xunion: fidl::new_empty!(
9116                    ThisIsAXunion,
9117                    fidl::encoding::DefaultFuchsiaResourceDialect
9118                ),
9119                b: fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect),
9120            }
9121        }
9122
9123        #[inline]
9124        unsafe fn decode(
9125            &mut self,
9126            decoder: &mut fidl::encoding::Decoder<
9127                '_,
9128                fidl::encoding::DefaultFuchsiaResourceDialect,
9129            >,
9130            offset: usize,
9131            _depth: fidl::encoding::Depth,
9132        ) -> fidl::Result<()> {
9133            decoder.debug_check_bounds::<Self>(offset);
9134            // Verify that padding bytes are zero.
9135            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2640) };
9136            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9137            let mask = 0xffffffff00000000u64;
9138            let maskedval = padval & mask;
9139            if maskedval != 0 {
9140                return Err(fidl::Error::NonZeroPadding {
9141                    padding_start: offset + 2640 + ((mask as u64).trailing_zeros() / 8) as usize,
9142                });
9143            }
9144            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2744) };
9145            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9146            let mask = 0xff0000000000u64;
9147            let maskedval = padval & mask;
9148            if maskedval != 0 {
9149                return Err(fidl::Error::NonZeroPadding {
9150                    padding_start: offset + 2744 + ((mask as u64).trailing_zeros() / 8) as usize,
9151                });
9152            }
9153            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2752) };
9154            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9155            let mask = 0xffffffff00000000u64;
9156            let maskedval = padval & mask;
9157            if maskedval != 0 {
9158                return Err(fidl::Error::NonZeroPadding {
9159                    padding_start: offset + 2752 + ((mask as u64).trailing_zeros() / 8) as usize,
9160                });
9161            }
9162            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2768) };
9163            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9164            let mask = 0xff00u64;
9165            let maskedval = padval & mask;
9166            if maskedval != 0 {
9167                return Err(fidl::Error::NonZeroPadding {
9168                    padding_start: offset + 2768 + ((mask as u64).trailing_zeros() / 8) as usize,
9169                });
9170            }
9171            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2784) };
9172            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9173            let mask = 0xff0000000000u64;
9174            let maskedval = padval & mask;
9175            if maskedval != 0 {
9176                return Err(fidl::Error::NonZeroPadding {
9177                    padding_start: offset + 2784 + ((mask as u64).trailing_zeros() / 8) as usize,
9178                });
9179            }
9180            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2792) };
9181            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9182            let mask = 0xffffffff00000000u64;
9183            let maskedval = padval & mask;
9184            if maskedval != 0 {
9185                return Err(fidl::Error::NonZeroPadding {
9186                    padding_start: offset + 2792 + ((mask as u64).trailing_zeros() / 8) as usize,
9187                });
9188            }
9189            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2904) };
9190            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9191            let mask = 0xffffffffffffff00u64;
9192            let maskedval = padval & mask;
9193            if maskedval != 0 {
9194                return Err(fidl::Error::NonZeroPadding {
9195                    padding_start: offset + 2904 + ((mask as u64).trailing_zeros() / 8) as usize,
9196                });
9197            }
9198            fidl::decode!(
9199                PrimitiveTypes,
9200                fidl::encoding::DefaultFuchsiaResourceDialect,
9201                &mut self.primitive_types,
9202                decoder,
9203                offset + 0,
9204                _depth
9205            )?;
9206            fidl::decode!(
9207                DefaultValues,
9208                fidl::encoding::DefaultFuchsiaResourceDialect,
9209                &mut self.default_values,
9210                decoder,
9211                offset + 48,
9212                _depth
9213            )?;
9214            fidl::decode!(
9215                Arrays,
9216                fidl::encoding::DefaultFuchsiaResourceDialect,
9217                &mut self.arrays,
9218                decoder,
9219                offset + 120,
9220                _depth
9221            )?;
9222            fidl::decode!(
9223                Arrays2d,
9224                fidl::encoding::DefaultFuchsiaResourceDialect,
9225                &mut self.arrays_2d,
9226                decoder,
9227                offset + 328,
9228                _depth
9229            )?;
9230            fidl::decode!(
9231                Vectors,
9232                fidl::encoding::DefaultFuchsiaResourceDialect,
9233                &mut self.vectors,
9234                decoder,
9235                offset + 616,
9236                _depth
9237            )?;
9238            fidl::decode!(
9239                Handles,
9240                fidl::encoding::DefaultFuchsiaResourceDialect,
9241                &mut self.handles,
9242                decoder,
9243                offset + 2536,
9244                _depth
9245            )?;
9246            fidl::decode!(
9247                Strings,
9248                fidl::encoding::DefaultFuchsiaResourceDialect,
9249                &mut self.strings,
9250                decoder,
9251                offset + 2648,
9252                _depth
9253            )?;
9254            fidl::decode!(
9255                DefaultEnum,
9256                fidl::encoding::DefaultFuchsiaResourceDialect,
9257                &mut self.default_enum,
9258                decoder,
9259                offset + 2744,
9260                _depth
9261            )?;
9262            fidl::decode!(
9263                I8Enum,
9264                fidl::encoding::DefaultFuchsiaResourceDialect,
9265                &mut self.i8_enum,
9266                decoder,
9267                offset + 2748,
9268                _depth
9269            )?;
9270            fidl::decode!(
9271                I16Enum,
9272                fidl::encoding::DefaultFuchsiaResourceDialect,
9273                &mut self.i16_enum,
9274                decoder,
9275                offset + 2750,
9276                _depth
9277            )?;
9278            fidl::decode!(
9279                I32Enum,
9280                fidl::encoding::DefaultFuchsiaResourceDialect,
9281                &mut self.i32_enum,
9282                decoder,
9283                offset + 2752,
9284                _depth
9285            )?;
9286            fidl::decode!(
9287                I64Enum,
9288                fidl::encoding::DefaultFuchsiaResourceDialect,
9289                &mut self.i64_enum,
9290                decoder,
9291                offset + 2760,
9292                _depth
9293            )?;
9294            fidl::decode!(
9295                U8Enum,
9296                fidl::encoding::DefaultFuchsiaResourceDialect,
9297                &mut self.u8_enum,
9298                decoder,
9299                offset + 2768,
9300                _depth
9301            )?;
9302            fidl::decode!(
9303                U16Enum,
9304                fidl::encoding::DefaultFuchsiaResourceDialect,
9305                &mut self.u16_enum,
9306                decoder,
9307                offset + 2770,
9308                _depth
9309            )?;
9310            fidl::decode!(
9311                U32Enum,
9312                fidl::encoding::DefaultFuchsiaResourceDialect,
9313                &mut self.u32_enum,
9314                decoder,
9315                offset + 2772,
9316                _depth
9317            )?;
9318            fidl::decode!(
9319                U64Enum,
9320                fidl::encoding::DefaultFuchsiaResourceDialect,
9321                &mut self.u64_enum,
9322                decoder,
9323                offset + 2776,
9324                _depth
9325            )?;
9326            fidl::decode!(
9327                DefaultBits,
9328                fidl::encoding::DefaultFuchsiaResourceDialect,
9329                &mut self.default_bits,
9330                decoder,
9331                offset + 2784,
9332                _depth
9333            )?;
9334            fidl::decode!(
9335                U8Bits,
9336                fidl::encoding::DefaultFuchsiaResourceDialect,
9337                &mut self.u8_bits,
9338                decoder,
9339                offset + 2788,
9340                _depth
9341            )?;
9342            fidl::decode!(
9343                U16Bits,
9344                fidl::encoding::DefaultFuchsiaResourceDialect,
9345                &mut self.u16_bits,
9346                decoder,
9347                offset + 2790,
9348                _depth
9349            )?;
9350            fidl::decode!(
9351                U32Bits,
9352                fidl::encoding::DefaultFuchsiaResourceDialect,
9353                &mut self.u32_bits,
9354                decoder,
9355                offset + 2792,
9356                _depth
9357            )?;
9358            fidl::decode!(
9359                U64Bits,
9360                fidl::encoding::DefaultFuchsiaResourceDialect,
9361                &mut self.u64_bits,
9362                decoder,
9363                offset + 2800,
9364                _depth
9365            )?;
9366            fidl::decode!(
9367                Structs,
9368                fidl::encoding::DefaultFuchsiaResourceDialect,
9369                &mut self.structs,
9370                decoder,
9371                offset + 2808,
9372                _depth
9373            )?;
9374            fidl::decode!(
9375                Unions,
9376                fidl::encoding::DefaultFuchsiaResourceDialect,
9377                &mut self.unions,
9378                decoder,
9379                offset + 2840,
9380                _depth
9381            )?;
9382            fidl::decode!(
9383                ThisIsATable,
9384                fidl::encoding::DefaultFuchsiaResourceDialect,
9385                &mut self.table,
9386                decoder,
9387                offset + 2872,
9388                _depth
9389            )?;
9390            fidl::decode!(
9391                ThisIsAXunion,
9392                fidl::encoding::DefaultFuchsiaResourceDialect,
9393                &mut self.xunion,
9394                decoder,
9395                offset + 2888,
9396                _depth
9397            )?;
9398            fidl::decode!(
9399                bool,
9400                fidl::encoding::DefaultFuchsiaResourceDialect,
9401                &mut self.b,
9402                decoder,
9403                offset + 2904,
9404                _depth
9405            )?;
9406            Ok(())
9407        }
9408    }
9409
9410    impl fidl::encoding::ResourceTypeMarker for VectorsStruct {
9411        type Borrowed<'a> = &'a mut Self;
9412        fn take_or_borrow<'a>(
9413            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
9414        ) -> Self::Borrowed<'a> {
9415            value
9416        }
9417    }
9418
9419    unsafe impl fidl::encoding::TypeMarker for VectorsStruct {
9420        type Owned = Self;
9421
9422        #[inline(always)]
9423        fn inline_align(_context: fidl::encoding::Context) -> usize {
9424            8
9425        }
9426
9427        #[inline(always)]
9428        fn inline_size(_context: fidl::encoding::Context) -> usize {
9429            416
9430        }
9431    }
9432
9433    unsafe impl fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
9434        for &mut VectorsStruct
9435    {
9436        #[inline]
9437        unsafe fn encode(
9438            self,
9439            encoder: &mut fidl::encoding::Encoder<
9440                '_,
9441                fidl::encoding::DefaultFuchsiaResourceDialect,
9442            >,
9443            offset: usize,
9444            _depth: fidl::encoding::Depth,
9445        ) -> fidl::Result<()> {
9446            encoder.debug_check_bounds::<VectorsStruct>(offset);
9447            // Delegate to tuple encoding.
9448            fidl::encoding::Encode::<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
9449                (
9450                    <fidl::encoding::Vector<bool, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.bools),
9451                    <fidl::encoding::Vector<i8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int8s),
9452                    <fidl::encoding::Vector<i16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int16s),
9453                    <fidl::encoding::Vector<i32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int32s),
9454                    <fidl::encoding::Vector<i64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int64s),
9455                    <fidl::encoding::Vector<u8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint8s),
9456                    <fidl::encoding::Vector<u16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint16s),
9457                    <fidl::encoding::Vector<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint32s),
9458                    <fidl::encoding::Vector<u64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint64s),
9459                    <fidl::encoding::Vector<f32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.float32s),
9460                    <fidl::encoding::Vector<f64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.float64s),
9461                    <fidl::encoding::Vector<DefaultEnum, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.enums),
9462                    <fidl::encoding::Vector<DefaultBits, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.bits),
9463                    <fidl::encoding::Vector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 3> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handles),
9464                    <fidl::encoding::Vector<fidl::encoding::Optional<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>>, 3> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.nullable_handles),
9465                    <fidl::encoding::Vector<fidl::encoding::UnboundedString, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.strings),
9466                    <fidl::encoding::Vector<fidl::encoding::Optional<fidl::encoding::UnboundedString>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_strings),
9467                    <fidl::encoding::Vector<ThisIsAStruct, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.structs),
9468                    <fidl::encoding::Vector<fidl::encoding::Boxed<ThisIsAStruct>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_structs),
9469                    <fidl::encoding::Vector<ThisIsAUnion, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.unions),
9470                    <fidl::encoding::Vector<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_unions),
9471                    <fidl::encoding::Vector<fidl::encoding::Array<u32, 3>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.arrays),
9472                    <fidl::encoding::Vector<fidl::encoding::UnboundedVector<u32>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.vectors),
9473                    <fidl::encoding::Vector<fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_vectors),
9474                    <fidl::encoding::Vector<ThisIsATable, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.tables),
9475                    <fidl::encoding::Vector<ThisIsAXunion, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.xunions),
9476                ),
9477                encoder, offset, _depth
9478            )
9479        }
9480    }
9481    unsafe impl<
9482        T0: fidl::encoding::Encode<
9483                fidl::encoding::Vector<bool, 3>,
9484                fidl::encoding::DefaultFuchsiaResourceDialect,
9485            >,
9486        T1: fidl::encoding::Encode<
9487                fidl::encoding::Vector<i8, 3>,
9488                fidl::encoding::DefaultFuchsiaResourceDialect,
9489            >,
9490        T2: fidl::encoding::Encode<
9491                fidl::encoding::Vector<i16, 3>,
9492                fidl::encoding::DefaultFuchsiaResourceDialect,
9493            >,
9494        T3: fidl::encoding::Encode<
9495                fidl::encoding::Vector<i32, 3>,
9496                fidl::encoding::DefaultFuchsiaResourceDialect,
9497            >,
9498        T4: fidl::encoding::Encode<
9499                fidl::encoding::Vector<i64, 3>,
9500                fidl::encoding::DefaultFuchsiaResourceDialect,
9501            >,
9502        T5: fidl::encoding::Encode<
9503                fidl::encoding::Vector<u8, 3>,
9504                fidl::encoding::DefaultFuchsiaResourceDialect,
9505            >,
9506        T6: fidl::encoding::Encode<
9507                fidl::encoding::Vector<u16, 3>,
9508                fidl::encoding::DefaultFuchsiaResourceDialect,
9509            >,
9510        T7: fidl::encoding::Encode<
9511                fidl::encoding::Vector<u32, 3>,
9512                fidl::encoding::DefaultFuchsiaResourceDialect,
9513            >,
9514        T8: fidl::encoding::Encode<
9515                fidl::encoding::Vector<u64, 3>,
9516                fidl::encoding::DefaultFuchsiaResourceDialect,
9517            >,
9518        T9: fidl::encoding::Encode<
9519                fidl::encoding::Vector<f32, 3>,
9520                fidl::encoding::DefaultFuchsiaResourceDialect,
9521            >,
9522        T10: fidl::encoding::Encode<
9523                fidl::encoding::Vector<f64, 3>,
9524                fidl::encoding::DefaultFuchsiaResourceDialect,
9525            >,
9526        T11: fidl::encoding::Encode<
9527                fidl::encoding::Vector<DefaultEnum, 3>,
9528                fidl::encoding::DefaultFuchsiaResourceDialect,
9529            >,
9530        T12: fidl::encoding::Encode<
9531                fidl::encoding::Vector<DefaultBits, 3>,
9532                fidl::encoding::DefaultFuchsiaResourceDialect,
9533            >,
9534        T13: fidl::encoding::Encode<
9535                fidl::encoding::Vector<
9536                    fidl::encoding::HandleType<
9537                        fidl::Handle,
9538                        { fidl::ObjectType::NONE.into_raw() },
9539                        2147483648,
9540                    >,
9541                    3,
9542                >,
9543                fidl::encoding::DefaultFuchsiaResourceDialect,
9544            >,
9545        T14: fidl::encoding::Encode<
9546                fidl::encoding::Vector<
9547                    fidl::encoding::Optional<
9548                        fidl::encoding::HandleType<
9549                            fidl::Handle,
9550                            { fidl::ObjectType::NONE.into_raw() },
9551                            2147483648,
9552                        >,
9553                    >,
9554                    3,
9555                >,
9556                fidl::encoding::DefaultFuchsiaResourceDialect,
9557            >,
9558        T15: fidl::encoding::Encode<
9559                fidl::encoding::Vector<fidl::encoding::UnboundedString, 3>,
9560                fidl::encoding::DefaultFuchsiaResourceDialect,
9561            >,
9562        T16: fidl::encoding::Encode<
9563                fidl::encoding::Vector<
9564                    fidl::encoding::Optional<fidl::encoding::UnboundedString>,
9565                    3,
9566                >,
9567                fidl::encoding::DefaultFuchsiaResourceDialect,
9568            >,
9569        T17: fidl::encoding::Encode<
9570                fidl::encoding::Vector<ThisIsAStruct, 3>,
9571                fidl::encoding::DefaultFuchsiaResourceDialect,
9572            >,
9573        T18: fidl::encoding::Encode<
9574                fidl::encoding::Vector<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
9575                fidl::encoding::DefaultFuchsiaResourceDialect,
9576            >,
9577        T19: fidl::encoding::Encode<
9578                fidl::encoding::Vector<ThisIsAUnion, 3>,
9579                fidl::encoding::DefaultFuchsiaResourceDialect,
9580            >,
9581        T20: fidl::encoding::Encode<
9582                fidl::encoding::Vector<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
9583                fidl::encoding::DefaultFuchsiaResourceDialect,
9584            >,
9585        T21: fidl::encoding::Encode<
9586                fidl::encoding::Vector<fidl::encoding::Array<u32, 3>, 3>,
9587                fidl::encoding::DefaultFuchsiaResourceDialect,
9588            >,
9589        T22: fidl::encoding::Encode<
9590                fidl::encoding::Vector<fidl::encoding::UnboundedVector<u32>, 3>,
9591                fidl::encoding::DefaultFuchsiaResourceDialect,
9592            >,
9593        T23: fidl::encoding::Encode<
9594                fidl::encoding::Vector<
9595                    fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
9596                    3,
9597                >,
9598                fidl::encoding::DefaultFuchsiaResourceDialect,
9599            >,
9600        T24: fidl::encoding::Encode<
9601                fidl::encoding::Vector<ThisIsATable, 3>,
9602                fidl::encoding::DefaultFuchsiaResourceDialect,
9603            >,
9604        T25: fidl::encoding::Encode<
9605                fidl::encoding::Vector<ThisIsAXunion, 3>,
9606                fidl::encoding::DefaultFuchsiaResourceDialect,
9607            >,
9608    > fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
9609        for (
9610            T0,
9611            T1,
9612            T2,
9613            T3,
9614            T4,
9615            T5,
9616            T6,
9617            T7,
9618            T8,
9619            T9,
9620            T10,
9621            T11,
9622            T12,
9623            T13,
9624            T14,
9625            T15,
9626            T16,
9627            T17,
9628            T18,
9629            T19,
9630            T20,
9631            T21,
9632            T22,
9633            T23,
9634            T24,
9635            T25,
9636        )
9637    {
9638        #[inline]
9639        unsafe fn encode(
9640            self,
9641            encoder: &mut fidl::encoding::Encoder<
9642                '_,
9643                fidl::encoding::DefaultFuchsiaResourceDialect,
9644            >,
9645            offset: usize,
9646            depth: fidl::encoding::Depth,
9647        ) -> fidl::Result<()> {
9648            encoder.debug_check_bounds::<VectorsStruct>(offset);
9649            // Zero out padding regions. There's no need to apply masks
9650            // because the unmasked parts will be overwritten by fields.
9651            // Write the fields.
9652            self.0.encode(encoder, offset + 0, depth)?;
9653            self.1.encode(encoder, offset + 16, depth)?;
9654            self.2.encode(encoder, offset + 32, depth)?;
9655            self.3.encode(encoder, offset + 48, depth)?;
9656            self.4.encode(encoder, offset + 64, depth)?;
9657            self.5.encode(encoder, offset + 80, depth)?;
9658            self.6.encode(encoder, offset + 96, depth)?;
9659            self.7.encode(encoder, offset + 112, depth)?;
9660            self.8.encode(encoder, offset + 128, depth)?;
9661            self.9.encode(encoder, offset + 144, depth)?;
9662            self.10.encode(encoder, offset + 160, depth)?;
9663            self.11.encode(encoder, offset + 176, depth)?;
9664            self.12.encode(encoder, offset + 192, depth)?;
9665            self.13.encode(encoder, offset + 208, depth)?;
9666            self.14.encode(encoder, offset + 224, depth)?;
9667            self.15.encode(encoder, offset + 240, depth)?;
9668            self.16.encode(encoder, offset + 256, depth)?;
9669            self.17.encode(encoder, offset + 272, depth)?;
9670            self.18.encode(encoder, offset + 288, depth)?;
9671            self.19.encode(encoder, offset + 304, depth)?;
9672            self.20.encode(encoder, offset + 320, depth)?;
9673            self.21.encode(encoder, offset + 336, depth)?;
9674            self.22.encode(encoder, offset + 352, depth)?;
9675            self.23.encode(encoder, offset + 368, depth)?;
9676            self.24.encode(encoder, offset + 384, depth)?;
9677            self.25.encode(encoder, offset + 400, depth)?;
9678            Ok(())
9679        }
9680    }
9681
9682    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for VectorsStruct {
9683        #[inline(always)]
9684        fn new_empty() -> Self {
9685            Self {
9686                bools: fidl::new_empty!(fidl::encoding::Vector<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9687                int8s: fidl::new_empty!(fidl::encoding::Vector<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9688                int16s: fidl::new_empty!(fidl::encoding::Vector<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9689                int32s: fidl::new_empty!(fidl::encoding::Vector<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9690                int64s: fidl::new_empty!(fidl::encoding::Vector<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9691                uint8s: fidl::new_empty!(fidl::encoding::Vector<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9692                uint16s: fidl::new_empty!(fidl::encoding::Vector<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9693                uint32s: fidl::new_empty!(fidl::encoding::Vector<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9694                uint64s: fidl::new_empty!(fidl::encoding::Vector<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9695                float32s: fidl::new_empty!(fidl::encoding::Vector<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9696                float64s: fidl::new_empty!(fidl::encoding::Vector<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9697                enums: fidl::new_empty!(fidl::encoding::Vector<DefaultEnum, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9698                bits: fidl::new_empty!(fidl::encoding::Vector<DefaultBits, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9699                handles: fidl::new_empty!(
9700                    fidl::encoding::Vector<
9701                        fidl::encoding::HandleType<
9702                            fidl::Handle,
9703                            { fidl::ObjectType::NONE.into_raw() },
9704                            2147483648,
9705                        >,
9706                        3,
9707                    >,
9708                    fidl::encoding::DefaultFuchsiaResourceDialect
9709                ),
9710                nullable_handles: fidl::new_empty!(
9711                    fidl::encoding::Vector<
9712                        fidl::encoding::Optional<
9713                            fidl::encoding::HandleType<
9714                                fidl::Handle,
9715                                { fidl::ObjectType::NONE.into_raw() },
9716                                2147483648,
9717                            >,
9718                        >,
9719                        3,
9720                    >,
9721                    fidl::encoding::DefaultFuchsiaResourceDialect
9722                ),
9723                strings: fidl::new_empty!(fidl::encoding::Vector<fidl::encoding::UnboundedString, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9724                nullable_strings: fidl::new_empty!(
9725                    fidl::encoding::Vector<
9726                        fidl::encoding::Optional<fidl::encoding::UnboundedString>,
9727                        3,
9728                    >,
9729                    fidl::encoding::DefaultFuchsiaResourceDialect
9730                ),
9731                structs: fidl::new_empty!(fidl::encoding::Vector<ThisIsAStruct, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9732                nullable_structs: fidl::new_empty!(
9733                    fidl::encoding::Vector<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
9734                    fidl::encoding::DefaultFuchsiaResourceDialect
9735                ),
9736                unions: fidl::new_empty!(fidl::encoding::Vector<ThisIsAUnion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9737                nullable_unions: fidl::new_empty!(
9738                    fidl::encoding::Vector<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
9739                    fidl::encoding::DefaultFuchsiaResourceDialect
9740                ),
9741                arrays: fidl::new_empty!(
9742                    fidl::encoding::Vector<fidl::encoding::Array<u32, 3>, 3>,
9743                    fidl::encoding::DefaultFuchsiaResourceDialect
9744                ),
9745                vectors: fidl::new_empty!(
9746                    fidl::encoding::Vector<fidl::encoding::UnboundedVector<u32>, 3>,
9747                    fidl::encoding::DefaultFuchsiaResourceDialect
9748                ),
9749                nullable_vectors: fidl::new_empty!(
9750                    fidl::encoding::Vector<
9751                        fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
9752                        3,
9753                    >,
9754                    fidl::encoding::DefaultFuchsiaResourceDialect
9755                ),
9756                tables: fidl::new_empty!(fidl::encoding::Vector<ThisIsATable, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9757                xunions: fidl::new_empty!(fidl::encoding::Vector<ThisIsAXunion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9758            }
9759        }
9760
9761        #[inline]
9762        unsafe fn decode(
9763            &mut self,
9764            decoder: &mut fidl::encoding::Decoder<
9765                '_,
9766                fidl::encoding::DefaultFuchsiaResourceDialect,
9767            >,
9768            offset: usize,
9769            _depth: fidl::encoding::Depth,
9770        ) -> fidl::Result<()> {
9771            decoder.debug_check_bounds::<Self>(offset);
9772            // Verify that padding bytes are zero.
9773            fidl::decode!(fidl::encoding::Vector<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.bools, decoder, offset + 0, _depth)?;
9774            fidl::decode!(fidl::encoding::Vector<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int8s, decoder, offset + 16, _depth)?;
9775            fidl::decode!(fidl::encoding::Vector<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int16s, decoder, offset + 32, _depth)?;
9776            fidl::decode!(fidl::encoding::Vector<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int32s, decoder, offset + 48, _depth)?;
9777            fidl::decode!(fidl::encoding::Vector<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int64s, decoder, offset + 64, _depth)?;
9778            fidl::decode!(fidl::encoding::Vector<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint8s, decoder, offset + 80, _depth)?;
9779            fidl::decode!(fidl::encoding::Vector<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint16s, decoder, offset + 96, _depth)?;
9780            fidl::decode!(fidl::encoding::Vector<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint32s, decoder, offset + 112, _depth)?;
9781            fidl::decode!(fidl::encoding::Vector<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint64s, decoder, offset + 128, _depth)?;
9782            fidl::decode!(fidl::encoding::Vector<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.float32s, decoder, offset + 144, _depth)?;
9783            fidl::decode!(fidl::encoding::Vector<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.float64s, decoder, offset + 160, _depth)?;
9784            fidl::decode!(fidl::encoding::Vector<DefaultEnum, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.enums, decoder, offset + 176, _depth)?;
9785            fidl::decode!(fidl::encoding::Vector<DefaultBits, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.bits, decoder, offset + 192, _depth)?;
9786            fidl::decode!(
9787                fidl::encoding::Vector<
9788                    fidl::encoding::HandleType<
9789                        fidl::Handle,
9790                        { fidl::ObjectType::NONE.into_raw() },
9791                        2147483648,
9792                    >,
9793                    3,
9794                >,
9795                fidl::encoding::DefaultFuchsiaResourceDialect,
9796                &mut self.handles,
9797                decoder,
9798                offset + 208,
9799                _depth
9800            )?;
9801            fidl::decode!(
9802                fidl::encoding::Vector<
9803                    fidl::encoding::Optional<
9804                        fidl::encoding::HandleType<
9805                            fidl::Handle,
9806                            { fidl::ObjectType::NONE.into_raw() },
9807                            2147483648,
9808                        >,
9809                    >,
9810                    3,
9811                >,
9812                fidl::encoding::DefaultFuchsiaResourceDialect,
9813                &mut self.nullable_handles,
9814                decoder,
9815                offset + 224,
9816                _depth
9817            )?;
9818            fidl::decode!(fidl::encoding::Vector<fidl::encoding::UnboundedString, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.strings, decoder, offset + 240, _depth)?;
9819            fidl::decode!(
9820                fidl::encoding::Vector<
9821                    fidl::encoding::Optional<fidl::encoding::UnboundedString>,
9822                    3,
9823                >,
9824                fidl::encoding::DefaultFuchsiaResourceDialect,
9825                &mut self.nullable_strings,
9826                decoder,
9827                offset + 256,
9828                _depth
9829            )?;
9830            fidl::decode!(fidl::encoding::Vector<ThisIsAStruct, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.structs, decoder, offset + 272, _depth)?;
9831            fidl::decode!(
9832                fidl::encoding::Vector<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
9833                fidl::encoding::DefaultFuchsiaResourceDialect,
9834                &mut self.nullable_structs,
9835                decoder,
9836                offset + 288,
9837                _depth
9838            )?;
9839            fidl::decode!(fidl::encoding::Vector<ThisIsAUnion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.unions, decoder, offset + 304, _depth)?;
9840            fidl::decode!(
9841                fidl::encoding::Vector<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
9842                fidl::encoding::DefaultFuchsiaResourceDialect,
9843                &mut self.nullable_unions,
9844                decoder,
9845                offset + 320,
9846                _depth
9847            )?;
9848            fidl::decode!(
9849                fidl::encoding::Vector<fidl::encoding::Array<u32, 3>, 3>,
9850                fidl::encoding::DefaultFuchsiaResourceDialect,
9851                &mut self.arrays,
9852                decoder,
9853                offset + 336,
9854                _depth
9855            )?;
9856            fidl::decode!(
9857                fidl::encoding::Vector<fidl::encoding::UnboundedVector<u32>, 3>,
9858                fidl::encoding::DefaultFuchsiaResourceDialect,
9859                &mut self.vectors,
9860                decoder,
9861                offset + 352,
9862                _depth
9863            )?;
9864            fidl::decode!(
9865                fidl::encoding::Vector<
9866                    fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
9867                    3,
9868                >,
9869                fidl::encoding::DefaultFuchsiaResourceDialect,
9870                &mut self.nullable_vectors,
9871                decoder,
9872                offset + 368,
9873                _depth
9874            )?;
9875            fidl::decode!(fidl::encoding::Vector<ThisIsATable, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.tables, decoder, offset + 384, _depth)?;
9876            fidl::decode!(fidl::encoding::Vector<ThisIsAXunion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.xunions, decoder, offset + 400, _depth)?;
9877            Ok(())
9878        }
9879    }
9880
9881    impl fidl::encoding::ResourceTypeMarker for Arrays {
9882        type Borrowed<'a> = &'a mut Self;
9883        fn take_or_borrow<'a>(
9884            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
9885        ) -> Self::Borrowed<'a> {
9886            value
9887        }
9888    }
9889
9890    unsafe impl fidl::encoding::TypeMarker for Arrays {
9891        type Owned = Self;
9892
9893        #[inline(always)]
9894        fn inline_align(_context: fidl::encoding::Context) -> usize {
9895            8
9896        }
9897
9898        #[inline(always)]
9899        fn inline_size(_context: fidl::encoding::Context) -> usize {
9900            208
9901        }
9902    }
9903
9904    unsafe impl fidl::encoding::Encode<Arrays, fidl::encoding::DefaultFuchsiaResourceDialect>
9905        for &mut Arrays
9906    {
9907        #[inline]
9908        unsafe fn encode(
9909            self,
9910            encoder: &mut fidl::encoding::Encoder<
9911                '_,
9912                fidl::encoding::DefaultFuchsiaResourceDialect,
9913            >,
9914            offset: usize,
9915            _depth: fidl::encoding::Depth,
9916        ) -> fidl::Result<()> {
9917            encoder.debug_check_bounds::<Arrays>(offset);
9918            // Delegate to tuple encoding.
9919            fidl::encoding::Encode::<Arrays, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
9920                (
9921                    <fidl::encoding::Array<bool, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9922                        &self.b_0,
9923                    ),
9924                    <fidl::encoding::Array<i8, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9925                        &self.i8_0,
9926                    ),
9927                    <fidl::encoding::Array<i16, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9928                        &self.i16_0,
9929                    ),
9930                    <fidl::encoding::Array<i32, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9931                        &self.i32_0,
9932                    ),
9933                    <fidl::encoding::Array<i64, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9934                        &self.i64_0,
9935                    ),
9936                    <fidl::encoding::Array<u8, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9937                        &self.u8_0,
9938                    ),
9939                    <fidl::encoding::Array<u16, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9940                        &self.u16_0,
9941                    ),
9942                    <fidl::encoding::Array<u32, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9943                        &self.u32_0,
9944                    ),
9945                    <fidl::encoding::Array<u64, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9946                        &self.u64_0,
9947                    ),
9948                    <fidl::encoding::Array<f32, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9949                        &self.f32_0,
9950                    ),
9951                    <fidl::encoding::Array<f64, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9952                        &self.f64_0,
9953                    ),
9954                    <fidl::encoding::Array<
9955                        fidl::encoding::HandleType<
9956                            fidl::Handle,
9957                            { fidl::ObjectType::NONE.into_raw() },
9958                            2147483648,
9959                        >,
9960                        1,
9961                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
9962                        &mut self.handle_0
9963                    ),
9964                    <fidl::encoding::Array<bool, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9965                        &self.b_1,
9966                    ),
9967                    <fidl::encoding::Array<i8, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9968                        &self.i8_1,
9969                    ),
9970                    <fidl::encoding::Array<i16, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9971                        &self.i16_1,
9972                    ),
9973                    <fidl::encoding::Array<i32, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9974                        &self.i32_1,
9975                    ),
9976                    <fidl::encoding::Array<i64, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9977                        &self.i64_1,
9978                    ),
9979                    <fidl::encoding::Array<u8, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9980                        &self.u8_1,
9981                    ),
9982                    <fidl::encoding::Array<u16, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9983                        &self.u16_1,
9984                    ),
9985                    <fidl::encoding::Array<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9986                        &self.u32_1,
9987                    ),
9988                    <fidl::encoding::Array<u64, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9989                        &self.u64_1,
9990                    ),
9991                    <fidl::encoding::Array<f32, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9992                        &self.f32_1,
9993                    ),
9994                    <fidl::encoding::Array<f64, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9995                        &self.f64_1,
9996                    ),
9997                    <fidl::encoding::Array<
9998                        fidl::encoding::HandleType<
9999                            fidl::Handle,
10000                            { fidl::ObjectType::NONE.into_raw() },
10001                            2147483648,
10002                        >,
10003                        3,
10004                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10005                        &mut self.handle_1
10006                    ),
10007                ),
10008                encoder,
10009                offset,
10010                _depth,
10011            )
10012        }
10013    }
10014    unsafe impl<
10015        T0: fidl::encoding::Encode<
10016                fidl::encoding::Array<bool, 1>,
10017                fidl::encoding::DefaultFuchsiaResourceDialect,
10018            >,
10019        T1: fidl::encoding::Encode<
10020                fidl::encoding::Array<i8, 1>,
10021                fidl::encoding::DefaultFuchsiaResourceDialect,
10022            >,
10023        T2: fidl::encoding::Encode<
10024                fidl::encoding::Array<i16, 1>,
10025                fidl::encoding::DefaultFuchsiaResourceDialect,
10026            >,
10027        T3: fidl::encoding::Encode<
10028                fidl::encoding::Array<i32, 1>,
10029                fidl::encoding::DefaultFuchsiaResourceDialect,
10030            >,
10031        T4: fidl::encoding::Encode<
10032                fidl::encoding::Array<i64, 1>,
10033                fidl::encoding::DefaultFuchsiaResourceDialect,
10034            >,
10035        T5: fidl::encoding::Encode<
10036                fidl::encoding::Array<u8, 1>,
10037                fidl::encoding::DefaultFuchsiaResourceDialect,
10038            >,
10039        T6: fidl::encoding::Encode<
10040                fidl::encoding::Array<u16, 1>,
10041                fidl::encoding::DefaultFuchsiaResourceDialect,
10042            >,
10043        T7: fidl::encoding::Encode<
10044                fidl::encoding::Array<u32, 1>,
10045                fidl::encoding::DefaultFuchsiaResourceDialect,
10046            >,
10047        T8: fidl::encoding::Encode<
10048                fidl::encoding::Array<u64, 1>,
10049                fidl::encoding::DefaultFuchsiaResourceDialect,
10050            >,
10051        T9: fidl::encoding::Encode<
10052                fidl::encoding::Array<f32, 1>,
10053                fidl::encoding::DefaultFuchsiaResourceDialect,
10054            >,
10055        T10: fidl::encoding::Encode<
10056                fidl::encoding::Array<f64, 1>,
10057                fidl::encoding::DefaultFuchsiaResourceDialect,
10058            >,
10059        T11: fidl::encoding::Encode<
10060                fidl::encoding::Array<
10061                    fidl::encoding::HandleType<
10062                        fidl::Handle,
10063                        { fidl::ObjectType::NONE.into_raw() },
10064                        2147483648,
10065                    >,
10066                    1,
10067                >,
10068                fidl::encoding::DefaultFuchsiaResourceDialect,
10069            >,
10070        T12: fidl::encoding::Encode<
10071                fidl::encoding::Array<bool, 3>,
10072                fidl::encoding::DefaultFuchsiaResourceDialect,
10073            >,
10074        T13: fidl::encoding::Encode<
10075                fidl::encoding::Array<i8, 3>,
10076                fidl::encoding::DefaultFuchsiaResourceDialect,
10077            >,
10078        T14: fidl::encoding::Encode<
10079                fidl::encoding::Array<i16, 3>,
10080                fidl::encoding::DefaultFuchsiaResourceDialect,
10081            >,
10082        T15: fidl::encoding::Encode<
10083                fidl::encoding::Array<i32, 3>,
10084                fidl::encoding::DefaultFuchsiaResourceDialect,
10085            >,
10086        T16: fidl::encoding::Encode<
10087                fidl::encoding::Array<i64, 3>,
10088                fidl::encoding::DefaultFuchsiaResourceDialect,
10089            >,
10090        T17: fidl::encoding::Encode<
10091                fidl::encoding::Array<u8, 3>,
10092                fidl::encoding::DefaultFuchsiaResourceDialect,
10093            >,
10094        T18: fidl::encoding::Encode<
10095                fidl::encoding::Array<u16, 3>,
10096                fidl::encoding::DefaultFuchsiaResourceDialect,
10097            >,
10098        T19: fidl::encoding::Encode<
10099                fidl::encoding::Array<u32, 3>,
10100                fidl::encoding::DefaultFuchsiaResourceDialect,
10101            >,
10102        T20: fidl::encoding::Encode<
10103                fidl::encoding::Array<u64, 3>,
10104                fidl::encoding::DefaultFuchsiaResourceDialect,
10105            >,
10106        T21: fidl::encoding::Encode<
10107                fidl::encoding::Array<f32, 3>,
10108                fidl::encoding::DefaultFuchsiaResourceDialect,
10109            >,
10110        T22: fidl::encoding::Encode<
10111                fidl::encoding::Array<f64, 3>,
10112                fidl::encoding::DefaultFuchsiaResourceDialect,
10113            >,
10114        T23: fidl::encoding::Encode<
10115                fidl::encoding::Array<
10116                    fidl::encoding::HandleType<
10117                        fidl::Handle,
10118                        { fidl::ObjectType::NONE.into_raw() },
10119                        2147483648,
10120                    >,
10121                    3,
10122                >,
10123                fidl::encoding::DefaultFuchsiaResourceDialect,
10124            >,
10125    > fidl::encoding::Encode<Arrays, fidl::encoding::DefaultFuchsiaResourceDialect>
10126        for (
10127            T0,
10128            T1,
10129            T2,
10130            T3,
10131            T4,
10132            T5,
10133            T6,
10134            T7,
10135            T8,
10136            T9,
10137            T10,
10138            T11,
10139            T12,
10140            T13,
10141            T14,
10142            T15,
10143            T16,
10144            T17,
10145            T18,
10146            T19,
10147            T20,
10148            T21,
10149            T22,
10150            T23,
10151        )
10152    {
10153        #[inline]
10154        unsafe fn encode(
10155            self,
10156            encoder: &mut fidl::encoding::Encoder<
10157                '_,
10158                fidl::encoding::DefaultFuchsiaResourceDialect,
10159            >,
10160            offset: usize,
10161            depth: fidl::encoding::Depth,
10162        ) -> fidl::Result<()> {
10163            encoder.debug_check_bounds::<Arrays>(offset);
10164            // Zero out padding regions. There's no need to apply masks
10165            // because the unmasked parts will be overwritten by fields.
10166            unsafe {
10167                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
10168                (ptr as *mut u64).write_unaligned(0);
10169            }
10170            unsafe {
10171                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
10172                (ptr as *mut u64).write_unaligned(0);
10173            }
10174            unsafe {
10175                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(72);
10176                (ptr as *mut u64).write_unaligned(0);
10177            }
10178            unsafe {
10179                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(104);
10180                (ptr as *mut u64).write_unaligned(0);
10181            }
10182            unsafe {
10183                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(112);
10184                (ptr as *mut u64).write_unaligned(0);
10185            }
10186            unsafe {
10187                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(160);
10188                (ptr as *mut u64).write_unaligned(0);
10189            }
10190            unsafe {
10191                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(200);
10192                (ptr as *mut u64).write_unaligned(0);
10193            }
10194            // Write the fields.
10195            self.0.encode(encoder, offset + 0, depth)?;
10196            self.1.encode(encoder, offset + 1, depth)?;
10197            self.2.encode(encoder, offset + 2, depth)?;
10198            self.3.encode(encoder, offset + 4, depth)?;
10199            self.4.encode(encoder, offset + 8, depth)?;
10200            self.5.encode(encoder, offset + 16, depth)?;
10201            self.6.encode(encoder, offset + 18, depth)?;
10202            self.7.encode(encoder, offset + 20, depth)?;
10203            self.8.encode(encoder, offset + 24, depth)?;
10204            self.9.encode(encoder, offset + 32, depth)?;
10205            self.10.encode(encoder, offset + 40, depth)?;
10206            self.11.encode(encoder, offset + 48, depth)?;
10207            self.12.encode(encoder, offset + 52, depth)?;
10208            self.13.encode(encoder, offset + 55, depth)?;
10209            self.14.encode(encoder, offset + 58, depth)?;
10210            self.15.encode(encoder, offset + 64, depth)?;
10211            self.16.encode(encoder, offset + 80, depth)?;
10212            self.17.encode(encoder, offset + 104, depth)?;
10213            self.18.encode(encoder, offset + 108, depth)?;
10214            self.19.encode(encoder, offset + 116, depth)?;
10215            self.20.encode(encoder, offset + 128, depth)?;
10216            self.21.encode(encoder, offset + 152, depth)?;
10217            self.22.encode(encoder, offset + 168, depth)?;
10218            self.23.encode(encoder, offset + 192, depth)?;
10219            Ok(())
10220        }
10221    }
10222
10223    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Arrays {
10224        #[inline(always)]
10225        fn new_empty() -> Self {
10226            Self {
10227                b_0: fidl::new_empty!(fidl::encoding::Array<bool, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10228                i8_0: fidl::new_empty!(fidl::encoding::Array<i8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10229                i16_0: fidl::new_empty!(fidl::encoding::Array<i16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10230                i32_0: fidl::new_empty!(fidl::encoding::Array<i32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10231                i64_0: fidl::new_empty!(fidl::encoding::Array<i64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10232                u8_0: fidl::new_empty!(fidl::encoding::Array<u8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10233                u16_0: fidl::new_empty!(fidl::encoding::Array<u16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10234                u32_0: fidl::new_empty!(fidl::encoding::Array<u32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10235                u64_0: fidl::new_empty!(fidl::encoding::Array<u64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10236                f32_0: fidl::new_empty!(fidl::encoding::Array<f32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10237                f64_0: fidl::new_empty!(fidl::encoding::Array<f64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10238                handle_0: fidl::new_empty!(
10239                    fidl::encoding::Array<
10240                        fidl::encoding::HandleType<
10241                            fidl::Handle,
10242                            { fidl::ObjectType::NONE.into_raw() },
10243                            2147483648,
10244                        >,
10245                        1,
10246                    >,
10247                    fidl::encoding::DefaultFuchsiaResourceDialect
10248                ),
10249                b_1: fidl::new_empty!(fidl::encoding::Array<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10250                i8_1: fidl::new_empty!(fidl::encoding::Array<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10251                i16_1: fidl::new_empty!(fidl::encoding::Array<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10252                i32_1: fidl::new_empty!(fidl::encoding::Array<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10253                i64_1: fidl::new_empty!(fidl::encoding::Array<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10254                u8_1: fidl::new_empty!(fidl::encoding::Array<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10255                u16_1: fidl::new_empty!(fidl::encoding::Array<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10256                u32_1: fidl::new_empty!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10257                u64_1: fidl::new_empty!(fidl::encoding::Array<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10258                f32_1: fidl::new_empty!(fidl::encoding::Array<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10259                f64_1: fidl::new_empty!(fidl::encoding::Array<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10260                handle_1: fidl::new_empty!(
10261                    fidl::encoding::Array<
10262                        fidl::encoding::HandleType<
10263                            fidl::Handle,
10264                            { fidl::ObjectType::NONE.into_raw() },
10265                            2147483648,
10266                        >,
10267                        3,
10268                    >,
10269                    fidl::encoding::DefaultFuchsiaResourceDialect
10270                ),
10271            }
10272        }
10273
10274        #[inline]
10275        unsafe fn decode(
10276            &mut self,
10277            decoder: &mut fidl::encoding::Decoder<
10278                '_,
10279                fidl::encoding::DefaultFuchsiaResourceDialect,
10280            >,
10281            offset: usize,
10282            _depth: fidl::encoding::Depth,
10283        ) -> fidl::Result<()> {
10284            decoder.debug_check_bounds::<Self>(offset);
10285            // Verify that padding bytes are zero.
10286            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
10287            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10288            let mask = 0xff00u64;
10289            let maskedval = padval & mask;
10290            if maskedval != 0 {
10291                return Err(fidl::Error::NonZeroPadding {
10292                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
10293                });
10294            }
10295            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
10296            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10297            let mask = 0xffffffff00000000u64;
10298            let maskedval = padval & mask;
10299            if maskedval != 0 {
10300                return Err(fidl::Error::NonZeroPadding {
10301                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
10302                });
10303            }
10304            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(72) };
10305            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10306            let mask = 0xffffffff00000000u64;
10307            let maskedval = padval & mask;
10308            if maskedval != 0 {
10309                return Err(fidl::Error::NonZeroPadding {
10310                    padding_start: offset + 72 + ((mask as u64).trailing_zeros() / 8) as usize,
10311                });
10312            }
10313            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(104) };
10314            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10315            let mask = 0xff000000u64;
10316            let maskedval = padval & mask;
10317            if maskedval != 0 {
10318                return Err(fidl::Error::NonZeroPadding {
10319                    padding_start: offset + 104 + ((mask as u64).trailing_zeros() / 8) as usize,
10320                });
10321            }
10322            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(112) };
10323            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10324            let mask = 0xffff0000u64;
10325            let maskedval = padval & mask;
10326            if maskedval != 0 {
10327                return Err(fidl::Error::NonZeroPadding {
10328                    padding_start: offset + 112 + ((mask as u64).trailing_zeros() / 8) as usize,
10329                });
10330            }
10331            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(160) };
10332            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10333            let mask = 0xffffffff00000000u64;
10334            let maskedval = padval & mask;
10335            if maskedval != 0 {
10336                return Err(fidl::Error::NonZeroPadding {
10337                    padding_start: offset + 160 + ((mask as u64).trailing_zeros() / 8) as usize,
10338                });
10339            }
10340            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(200) };
10341            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10342            let mask = 0xffffffff00000000u64;
10343            let maskedval = padval & mask;
10344            if maskedval != 0 {
10345                return Err(fidl::Error::NonZeroPadding {
10346                    padding_start: offset + 200 + ((mask as u64).trailing_zeros() / 8) as usize,
10347                });
10348            }
10349            fidl::decode!(fidl::encoding::Array<bool, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.b_0, decoder, offset + 0, _depth)?;
10350            fidl::decode!(fidl::encoding::Array<i8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i8_0, decoder, offset + 1, _depth)?;
10351            fidl::decode!(fidl::encoding::Array<i16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i16_0, decoder, offset + 2, _depth)?;
10352            fidl::decode!(fidl::encoding::Array<i32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i32_0, decoder, offset + 4, _depth)?;
10353            fidl::decode!(fidl::encoding::Array<i64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i64_0, decoder, offset + 8, _depth)?;
10354            fidl::decode!(fidl::encoding::Array<u8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u8_0, decoder, offset + 16, _depth)?;
10355            fidl::decode!(fidl::encoding::Array<u16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u16_0, decoder, offset + 18, _depth)?;
10356            fidl::decode!(fidl::encoding::Array<u32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u32_0, decoder, offset + 20, _depth)?;
10357            fidl::decode!(fidl::encoding::Array<u64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u64_0, decoder, offset + 24, _depth)?;
10358            fidl::decode!(fidl::encoding::Array<f32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f32_0, decoder, offset + 32, _depth)?;
10359            fidl::decode!(fidl::encoding::Array<f64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f64_0, decoder, offset + 40, _depth)?;
10360            fidl::decode!(
10361                fidl::encoding::Array<
10362                    fidl::encoding::HandleType<
10363                        fidl::Handle,
10364                        { fidl::ObjectType::NONE.into_raw() },
10365                        2147483648,
10366                    >,
10367                    1,
10368                >,
10369                fidl::encoding::DefaultFuchsiaResourceDialect,
10370                &mut self.handle_0,
10371                decoder,
10372                offset + 48,
10373                _depth
10374            )?;
10375            fidl::decode!(fidl::encoding::Array<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.b_1, decoder, offset + 52, _depth)?;
10376            fidl::decode!(fidl::encoding::Array<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i8_1, decoder, offset + 55, _depth)?;
10377            fidl::decode!(fidl::encoding::Array<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i16_1, decoder, offset + 58, _depth)?;
10378            fidl::decode!(fidl::encoding::Array<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i32_1, decoder, offset + 64, _depth)?;
10379            fidl::decode!(fidl::encoding::Array<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i64_1, decoder, offset + 80, _depth)?;
10380            fidl::decode!(fidl::encoding::Array<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u8_1, decoder, offset + 104, _depth)?;
10381            fidl::decode!(fidl::encoding::Array<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u16_1, decoder, offset + 108, _depth)?;
10382            fidl::decode!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u32_1, decoder, offset + 116, _depth)?;
10383            fidl::decode!(fidl::encoding::Array<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u64_1, decoder, offset + 128, _depth)?;
10384            fidl::decode!(fidl::encoding::Array<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f32_1, decoder, offset + 152, _depth)?;
10385            fidl::decode!(fidl::encoding::Array<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f64_1, decoder, offset + 168, _depth)?;
10386            fidl::decode!(
10387                fidl::encoding::Array<
10388                    fidl::encoding::HandleType<
10389                        fidl::Handle,
10390                        { fidl::ObjectType::NONE.into_raw() },
10391                        2147483648,
10392                    >,
10393                    3,
10394                >,
10395                fidl::encoding::DefaultFuchsiaResourceDialect,
10396                &mut self.handle_1,
10397                decoder,
10398                offset + 192,
10399                _depth
10400            )?;
10401            Ok(())
10402        }
10403    }
10404
10405    impl fidl::encoding::ResourceTypeMarker for Arrays2d {
10406        type Borrowed<'a> = &'a mut Self;
10407        fn take_or_borrow<'a>(
10408            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
10409        ) -> Self::Borrowed<'a> {
10410            value
10411        }
10412    }
10413
10414    unsafe impl fidl::encoding::TypeMarker for Arrays2d {
10415        type Owned = Self;
10416
10417        #[inline(always)]
10418        fn inline_align(_context: fidl::encoding::Context) -> usize {
10419            8
10420        }
10421
10422        #[inline(always)]
10423        fn inline_size(_context: fidl::encoding::Context) -> usize {
10424            288
10425        }
10426    }
10427
10428    unsafe impl fidl::encoding::Encode<Arrays2d, fidl::encoding::DefaultFuchsiaResourceDialect>
10429        for &mut Arrays2d
10430    {
10431        #[inline]
10432        unsafe fn encode(
10433            self,
10434            encoder: &mut fidl::encoding::Encoder<
10435                '_,
10436                fidl::encoding::DefaultFuchsiaResourceDialect,
10437            >,
10438            offset: usize,
10439            _depth: fidl::encoding::Depth,
10440        ) -> fidl::Result<()> {
10441            encoder.debug_check_bounds::<Arrays2d>(offset);
10442            // Delegate to tuple encoding.
10443            fidl::encoding::Encode::<Arrays2d, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
10444                (
10445                    <fidl::encoding::Array<fidl::encoding::Array<bool, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.b),
10446                    <fidl::encoding::Array<fidl::encoding::Array<i8, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8),
10447                    <fidl::encoding::Array<fidl::encoding::Array<i16, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16),
10448                    <fidl::encoding::Array<fidl::encoding::Array<i32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32),
10449                    <fidl::encoding::Array<fidl::encoding::Array<i64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64),
10450                    <fidl::encoding::Array<fidl::encoding::Array<u8, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8),
10451                    <fidl::encoding::Array<fidl::encoding::Array<u16, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16),
10452                    <fidl::encoding::Array<fidl::encoding::Array<u32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32),
10453                    <fidl::encoding::Array<fidl::encoding::Array<u64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64),
10454                    <fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32),
10455                    <fidl::encoding::Array<fidl::encoding::Array<f64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64),
10456                    <fidl::encoding::Array<fidl::encoding::Array<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 2>, 3> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_handle),
10457                ),
10458                encoder, offset, _depth
10459            )
10460        }
10461    }
10462    unsafe impl<
10463        T0: fidl::encoding::Encode<
10464                fidl::encoding::Array<fidl::encoding::Array<bool, 2>, 3>,
10465                fidl::encoding::DefaultFuchsiaResourceDialect,
10466            >,
10467        T1: fidl::encoding::Encode<
10468                fidl::encoding::Array<fidl::encoding::Array<i8, 2>, 3>,
10469                fidl::encoding::DefaultFuchsiaResourceDialect,
10470            >,
10471        T2: fidl::encoding::Encode<
10472                fidl::encoding::Array<fidl::encoding::Array<i16, 2>, 3>,
10473                fidl::encoding::DefaultFuchsiaResourceDialect,
10474            >,
10475        T3: fidl::encoding::Encode<
10476                fidl::encoding::Array<fidl::encoding::Array<i32, 2>, 3>,
10477                fidl::encoding::DefaultFuchsiaResourceDialect,
10478            >,
10479        T4: fidl::encoding::Encode<
10480                fidl::encoding::Array<fidl::encoding::Array<i64, 2>, 3>,
10481                fidl::encoding::DefaultFuchsiaResourceDialect,
10482            >,
10483        T5: fidl::encoding::Encode<
10484                fidl::encoding::Array<fidl::encoding::Array<u8, 2>, 3>,
10485                fidl::encoding::DefaultFuchsiaResourceDialect,
10486            >,
10487        T6: fidl::encoding::Encode<
10488                fidl::encoding::Array<fidl::encoding::Array<u16, 2>, 3>,
10489                fidl::encoding::DefaultFuchsiaResourceDialect,
10490            >,
10491        T7: fidl::encoding::Encode<
10492                fidl::encoding::Array<fidl::encoding::Array<u32, 2>, 3>,
10493                fidl::encoding::DefaultFuchsiaResourceDialect,
10494            >,
10495        T8: fidl::encoding::Encode<
10496                fidl::encoding::Array<fidl::encoding::Array<u64, 2>, 3>,
10497                fidl::encoding::DefaultFuchsiaResourceDialect,
10498            >,
10499        T9: fidl::encoding::Encode<
10500                fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 3>,
10501                fidl::encoding::DefaultFuchsiaResourceDialect,
10502            >,
10503        T10: fidl::encoding::Encode<
10504                fidl::encoding::Array<fidl::encoding::Array<f64, 2>, 3>,
10505                fidl::encoding::DefaultFuchsiaResourceDialect,
10506            >,
10507        T11: fidl::encoding::Encode<
10508                fidl::encoding::Array<
10509                    fidl::encoding::Array<
10510                        fidl::encoding::HandleType<
10511                            fidl::Handle,
10512                            { fidl::ObjectType::NONE.into_raw() },
10513                            2147483648,
10514                        >,
10515                        2,
10516                    >,
10517                    3,
10518                >,
10519                fidl::encoding::DefaultFuchsiaResourceDialect,
10520            >,
10521    > fidl::encoding::Encode<Arrays2d, fidl::encoding::DefaultFuchsiaResourceDialect>
10522        for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
10523    {
10524        #[inline]
10525        unsafe fn encode(
10526            self,
10527            encoder: &mut fidl::encoding::Encoder<
10528                '_,
10529                fidl::encoding::DefaultFuchsiaResourceDialect,
10530            >,
10531            offset: usize,
10532            depth: fidl::encoding::Depth,
10533        ) -> fidl::Result<()> {
10534            encoder.debug_check_bounds::<Arrays2d>(offset);
10535            // Zero out padding regions. There's no need to apply masks
10536            // because the unmasked parts will be overwritten by fields.
10537            unsafe {
10538                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(112);
10539                (ptr as *mut u64).write_unaligned(0);
10540            }
10541            unsafe {
10542                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(136);
10543                (ptr as *mut u64).write_unaligned(0);
10544            }
10545            // Write the fields.
10546            self.0.encode(encoder, offset + 0, depth)?;
10547            self.1.encode(encoder, offset + 6, depth)?;
10548            self.2.encode(encoder, offset + 12, depth)?;
10549            self.3.encode(encoder, offset + 24, depth)?;
10550            self.4.encode(encoder, offset + 48, depth)?;
10551            self.5.encode(encoder, offset + 96, depth)?;
10552            self.6.encode(encoder, offset + 102, depth)?;
10553            self.7.encode(encoder, offset + 116, depth)?;
10554            self.8.encode(encoder, offset + 144, depth)?;
10555            self.9.encode(encoder, offset + 192, depth)?;
10556            self.10.encode(encoder, offset + 216, depth)?;
10557            self.11.encode(encoder, offset + 264, depth)?;
10558            Ok(())
10559        }
10560    }
10561
10562    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Arrays2d {
10563        #[inline(always)]
10564        fn new_empty() -> Self {
10565            Self {
10566                b: fidl::new_empty!(
10567                    fidl::encoding::Array<fidl::encoding::Array<bool, 2>, 3>,
10568                    fidl::encoding::DefaultFuchsiaResourceDialect
10569                ),
10570                i8: fidl::new_empty!(
10571                    fidl::encoding::Array<fidl::encoding::Array<i8, 2>, 3>,
10572                    fidl::encoding::DefaultFuchsiaResourceDialect
10573                ),
10574                i16: fidl::new_empty!(
10575                    fidl::encoding::Array<fidl::encoding::Array<i16, 2>, 3>,
10576                    fidl::encoding::DefaultFuchsiaResourceDialect
10577                ),
10578                i32: fidl::new_empty!(
10579                    fidl::encoding::Array<fidl::encoding::Array<i32, 2>, 3>,
10580                    fidl::encoding::DefaultFuchsiaResourceDialect
10581                ),
10582                i64: fidl::new_empty!(
10583                    fidl::encoding::Array<fidl::encoding::Array<i64, 2>, 3>,
10584                    fidl::encoding::DefaultFuchsiaResourceDialect
10585                ),
10586                u8: fidl::new_empty!(
10587                    fidl::encoding::Array<fidl::encoding::Array<u8, 2>, 3>,
10588                    fidl::encoding::DefaultFuchsiaResourceDialect
10589                ),
10590                u16: fidl::new_empty!(
10591                    fidl::encoding::Array<fidl::encoding::Array<u16, 2>, 3>,
10592                    fidl::encoding::DefaultFuchsiaResourceDialect
10593                ),
10594                u32: fidl::new_empty!(
10595                    fidl::encoding::Array<fidl::encoding::Array<u32, 2>, 3>,
10596                    fidl::encoding::DefaultFuchsiaResourceDialect
10597                ),
10598                u64: fidl::new_empty!(
10599                    fidl::encoding::Array<fidl::encoding::Array<u64, 2>, 3>,
10600                    fidl::encoding::DefaultFuchsiaResourceDialect
10601                ),
10602                f32: fidl::new_empty!(
10603                    fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 3>,
10604                    fidl::encoding::DefaultFuchsiaResourceDialect
10605                ),
10606                f64: fidl::new_empty!(
10607                    fidl::encoding::Array<fidl::encoding::Array<f64, 2>, 3>,
10608                    fidl::encoding::DefaultFuchsiaResourceDialect
10609                ),
10610                handle_handle: fidl::new_empty!(
10611                    fidl::encoding::Array<
10612                        fidl::encoding::Array<
10613                            fidl::encoding::HandleType<
10614                                fidl::Handle,
10615                                { fidl::ObjectType::NONE.into_raw() },
10616                                2147483648,
10617                            >,
10618                            2,
10619                        >,
10620                        3,
10621                    >,
10622                    fidl::encoding::DefaultFuchsiaResourceDialect
10623                ),
10624            }
10625        }
10626
10627        #[inline]
10628        unsafe fn decode(
10629            &mut self,
10630            decoder: &mut fidl::encoding::Decoder<
10631                '_,
10632                fidl::encoding::DefaultFuchsiaResourceDialect,
10633            >,
10634            offset: usize,
10635            _depth: fidl::encoding::Depth,
10636        ) -> fidl::Result<()> {
10637            decoder.debug_check_bounds::<Self>(offset);
10638            // Verify that padding bytes are zero.
10639            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(112) };
10640            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10641            let mask = 0xffff0000u64;
10642            let maskedval = padval & mask;
10643            if maskedval != 0 {
10644                return Err(fidl::Error::NonZeroPadding {
10645                    padding_start: offset + 112 + ((mask as u64).trailing_zeros() / 8) as usize,
10646                });
10647            }
10648            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(136) };
10649            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10650            let mask = 0xffffffff00000000u64;
10651            let maskedval = padval & mask;
10652            if maskedval != 0 {
10653                return Err(fidl::Error::NonZeroPadding {
10654                    padding_start: offset + 136 + ((mask as u64).trailing_zeros() / 8) as usize,
10655                });
10656            }
10657            fidl::decode!(
10658                fidl::encoding::Array<fidl::encoding::Array<bool, 2>, 3>,
10659                fidl::encoding::DefaultFuchsiaResourceDialect,
10660                &mut self.b,
10661                decoder,
10662                offset + 0,
10663                _depth
10664            )?;
10665            fidl::decode!(
10666                fidl::encoding::Array<fidl::encoding::Array<i8, 2>, 3>,
10667                fidl::encoding::DefaultFuchsiaResourceDialect,
10668                &mut self.i8,
10669                decoder,
10670                offset + 6,
10671                _depth
10672            )?;
10673            fidl::decode!(
10674                fidl::encoding::Array<fidl::encoding::Array<i16, 2>, 3>,
10675                fidl::encoding::DefaultFuchsiaResourceDialect,
10676                &mut self.i16,
10677                decoder,
10678                offset + 12,
10679                _depth
10680            )?;
10681            fidl::decode!(
10682                fidl::encoding::Array<fidl::encoding::Array<i32, 2>, 3>,
10683                fidl::encoding::DefaultFuchsiaResourceDialect,
10684                &mut self.i32,
10685                decoder,
10686                offset + 24,
10687                _depth
10688            )?;
10689            fidl::decode!(
10690                fidl::encoding::Array<fidl::encoding::Array<i64, 2>, 3>,
10691                fidl::encoding::DefaultFuchsiaResourceDialect,
10692                &mut self.i64,
10693                decoder,
10694                offset + 48,
10695                _depth
10696            )?;
10697            fidl::decode!(
10698                fidl::encoding::Array<fidl::encoding::Array<u8, 2>, 3>,
10699                fidl::encoding::DefaultFuchsiaResourceDialect,
10700                &mut self.u8,
10701                decoder,
10702                offset + 96,
10703                _depth
10704            )?;
10705            fidl::decode!(
10706                fidl::encoding::Array<fidl::encoding::Array<u16, 2>, 3>,
10707                fidl::encoding::DefaultFuchsiaResourceDialect,
10708                &mut self.u16,
10709                decoder,
10710                offset + 102,
10711                _depth
10712            )?;
10713            fidl::decode!(
10714                fidl::encoding::Array<fidl::encoding::Array<u32, 2>, 3>,
10715                fidl::encoding::DefaultFuchsiaResourceDialect,
10716                &mut self.u32,
10717                decoder,
10718                offset + 116,
10719                _depth
10720            )?;
10721            fidl::decode!(
10722                fidl::encoding::Array<fidl::encoding::Array<u64, 2>, 3>,
10723                fidl::encoding::DefaultFuchsiaResourceDialect,
10724                &mut self.u64,
10725                decoder,
10726                offset + 144,
10727                _depth
10728            )?;
10729            fidl::decode!(
10730                fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 3>,
10731                fidl::encoding::DefaultFuchsiaResourceDialect,
10732                &mut self.f32,
10733                decoder,
10734                offset + 192,
10735                _depth
10736            )?;
10737            fidl::decode!(
10738                fidl::encoding::Array<fidl::encoding::Array<f64, 2>, 3>,
10739                fidl::encoding::DefaultFuchsiaResourceDialect,
10740                &mut self.f64,
10741                decoder,
10742                offset + 216,
10743                _depth
10744            )?;
10745            fidl::decode!(
10746                fidl::encoding::Array<
10747                    fidl::encoding::Array<
10748                        fidl::encoding::HandleType<
10749                            fidl::Handle,
10750                            { fidl::ObjectType::NONE.into_raw() },
10751                            2147483648,
10752                        >,
10753                        2,
10754                    >,
10755                    3,
10756                >,
10757                fidl::encoding::DefaultFuchsiaResourceDialect,
10758                &mut self.handle_handle,
10759                decoder,
10760                offset + 264,
10761                _depth
10762            )?;
10763            Ok(())
10764        }
10765    }
10766
10767    impl fidl::encoding::ResourceTypeMarker for Handles {
10768        type Borrowed<'a> = &'a mut Self;
10769        fn take_or_borrow<'a>(
10770            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
10771        ) -> Self::Borrowed<'a> {
10772            value
10773        }
10774    }
10775
10776    unsafe impl fidl::encoding::TypeMarker for Handles {
10777        type Owned = Self;
10778
10779        #[inline(always)]
10780        fn inline_align(_context: fidl::encoding::Context) -> usize {
10781            4
10782        }
10783
10784        #[inline(always)]
10785        fn inline_size(_context: fidl::encoding::Context) -> usize {
10786            108
10787        }
10788    }
10789
10790    unsafe impl fidl::encoding::Encode<Handles, fidl::encoding::DefaultFuchsiaResourceDialect>
10791        for &mut Handles
10792    {
10793        #[inline]
10794        unsafe fn encode(
10795            self,
10796            encoder: &mut fidl::encoding::Encoder<
10797                '_,
10798                fidl::encoding::DefaultFuchsiaResourceDialect,
10799            >,
10800            offset: usize,
10801            _depth: fidl::encoding::Depth,
10802        ) -> fidl::Result<()> {
10803            encoder.debug_check_bounds::<Handles>(offset);
10804            // Delegate to tuple encoding.
10805            fidl::encoding::Encode::<Handles, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
10806                (
10807                    <fidl::encoding::HandleType<
10808                        fidl::Handle,
10809                        { fidl::ObjectType::NONE.into_raw() },
10810                        2147483648,
10811                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10812                        &mut self.handle_handle,
10813                    ),
10814                    <fidl::encoding::HandleType<
10815                        fidl::Process,
10816                        { fidl::ObjectType::PROCESS.into_raw() },
10817                        2147483648,
10818                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10819                        &mut self.process_handle,
10820                    ),
10821                    <fidl::encoding::HandleType<
10822                        fidl::Thread,
10823                        { fidl::ObjectType::THREAD.into_raw() },
10824                        2147483648,
10825                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10826                        &mut self.thread_handle,
10827                    ),
10828                    <fidl::encoding::HandleType<
10829                        fidl::Vmo,
10830                        { fidl::ObjectType::VMO.into_raw() },
10831                        2147483648,
10832                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10833                        &mut self.vmo_handle
10834                    ),
10835                    <fidl::encoding::HandleType<
10836                        fidl::Event,
10837                        { fidl::ObjectType::EVENT.into_raw() },
10838                        2147483648,
10839                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10840                        &mut self.event_handle,
10841                    ),
10842                    <fidl::encoding::HandleType<
10843                        fidl::Port,
10844                        { fidl::ObjectType::PORT.into_raw() },
10845                        2147483648,
10846                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10847                        &mut self.port_handle
10848                    ),
10849                    <fidl::encoding::HandleType<
10850                        fidl::Socket,
10851                        { fidl::ObjectType::SOCKET.into_raw() },
10852                        2147483648,
10853                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10854                        &mut self.socket_handle,
10855                    ),
10856                    <fidl::encoding::HandleType<
10857                        fidl::EventPair,
10858                        { fidl::ObjectType::EVENTPAIR.into_raw() },
10859                        2147483648,
10860                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10861                        &mut self.eventpair_handle,
10862                    ),
10863                    <fidl::encoding::HandleType<
10864                        fidl::Job,
10865                        { fidl::ObjectType::JOB.into_raw() },
10866                        2147483648,
10867                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10868                        &mut self.job_handle
10869                    ),
10870                    <fidl::encoding::HandleType<
10871                        fidl::Vmar,
10872                        { fidl::ObjectType::VMAR.into_raw() },
10873                        2147483648,
10874                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10875                        &mut self.vmar_handle
10876                    ),
10877                    <fidl::encoding::HandleType<
10878                        fidl::Fifo,
10879                        { fidl::ObjectType::FIFO.into_raw() },
10880                        2147483648,
10881                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10882                        &mut self.fifo_handle
10883                    ),
10884                    <fidl::encoding::HandleType<
10885                        fidl::Timer,
10886                        { fidl::ObjectType::TIMER.into_raw() },
10887                        2147483648,
10888                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10889                        &mut self.timer_handle,
10890                    ),
10891                    <fidl::encoding::Optional<
10892                        fidl::encoding::HandleType<
10893                            fidl::Handle,
10894                            { fidl::ObjectType::NONE.into_raw() },
10895                            2147483648,
10896                        >,
10897                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10898                        &mut self.nullable_handle_handle,
10899                    ),
10900                    <fidl::encoding::Optional<
10901                        fidl::encoding::HandleType<
10902                            fidl::Process,
10903                            { fidl::ObjectType::PROCESS.into_raw() },
10904                            2147483648,
10905                        >,
10906                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10907                        &mut self.nullable_process_handle,
10908                    ),
10909                    <fidl::encoding::Optional<
10910                        fidl::encoding::HandleType<
10911                            fidl::Thread,
10912                            { fidl::ObjectType::THREAD.into_raw() },
10913                            2147483648,
10914                        >,
10915                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10916                        &mut self.nullable_thread_handle,
10917                    ),
10918                    <fidl::encoding::Optional<
10919                        fidl::encoding::HandleType<
10920                            fidl::Vmo,
10921                            { fidl::ObjectType::VMO.into_raw() },
10922                            2147483648,
10923                        >,
10924                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10925                        &mut self.nullable_vmo_handle,
10926                    ),
10927                    <fidl::encoding::Optional<
10928                        fidl::encoding::HandleType<
10929                            fidl::Channel,
10930                            { fidl::ObjectType::CHANNEL.into_raw() },
10931                            2147483648,
10932                        >,
10933                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10934                        &mut self.nullable_channel_handle,
10935                    ),
10936                    <fidl::encoding::Optional<
10937                        fidl::encoding::HandleType<
10938                            fidl::Event,
10939                            { fidl::ObjectType::EVENT.into_raw() },
10940                            2147483648,
10941                        >,
10942                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10943                        &mut self.nullable_event_handle,
10944                    ),
10945                    <fidl::encoding::Optional<
10946                        fidl::encoding::HandleType<
10947                            fidl::Port,
10948                            { fidl::ObjectType::PORT.into_raw() },
10949                            2147483648,
10950                        >,
10951                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10952                        &mut self.nullable_port_handle,
10953                    ),
10954                    <fidl::encoding::Optional<
10955                        fidl::encoding::HandleType<
10956                            fidl::Interrupt,
10957                            { fidl::ObjectType::INTERRUPT.into_raw() },
10958                            2147483648,
10959                        >,
10960                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10961                        &mut self.nullable_interrupt_handle,
10962                    ),
10963                    <fidl::encoding::Optional<
10964                        fidl::encoding::HandleType<
10965                            fidl::DebugLog,
10966                            { fidl::ObjectType::DEBUGLOG.into_raw() },
10967                            2147483648,
10968                        >,
10969                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10970                        &mut self.nullable_log_handle,
10971                    ),
10972                    <fidl::encoding::Optional<
10973                        fidl::encoding::HandleType<
10974                            fidl::Socket,
10975                            { fidl::ObjectType::SOCKET.into_raw() },
10976                            2147483648,
10977                        >,
10978                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10979                        &mut self.nullable_socket_handle,
10980                    ),
10981                    <fidl::encoding::Optional<
10982                        fidl::encoding::HandleType<
10983                            fidl::EventPair,
10984                            { fidl::ObjectType::EVENTPAIR.into_raw() },
10985                            2147483648,
10986                        >,
10987                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10988                        &mut self.nullable_eventpair_handle,
10989                    ),
10990                    <fidl::encoding::Optional<
10991                        fidl::encoding::HandleType<
10992                            fidl::Job,
10993                            { fidl::ObjectType::JOB.into_raw() },
10994                            2147483648,
10995                        >,
10996                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10997                        &mut self.nullable_job_handle,
10998                    ),
10999                    <fidl::encoding::Optional<
11000                        fidl::encoding::HandleType<
11001                            fidl::Vmar,
11002                            { fidl::ObjectType::VMAR.into_raw() },
11003                            2147483648,
11004                        >,
11005                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
11006                        &mut self.nullable_vmar_handle,
11007                    ),
11008                    <fidl::encoding::Optional<
11009                        fidl::encoding::HandleType<
11010                            fidl::Fifo,
11011                            { fidl::ObjectType::FIFO.into_raw() },
11012                            2147483648,
11013                        >,
11014                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
11015                        &mut self.nullable_fifo_handle,
11016                    ),
11017                    <fidl::encoding::Optional<
11018                        fidl::encoding::HandleType<
11019                            fidl::Timer,
11020                            { fidl::ObjectType::TIMER.into_raw() },
11021                            2147483648,
11022                        >,
11023                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
11024                        &mut self.nullable_timer_handle,
11025                    ),
11026                ),
11027                encoder,
11028                offset,
11029                _depth,
11030            )
11031        }
11032    }
11033    unsafe impl<
11034        T0: fidl::encoding::Encode<
11035                fidl::encoding::HandleType<
11036                    fidl::Handle,
11037                    { fidl::ObjectType::NONE.into_raw() },
11038                    2147483648,
11039                >,
11040                fidl::encoding::DefaultFuchsiaResourceDialect,
11041            >,
11042        T1: fidl::encoding::Encode<
11043                fidl::encoding::HandleType<
11044                    fidl::Process,
11045                    { fidl::ObjectType::PROCESS.into_raw() },
11046                    2147483648,
11047                >,
11048                fidl::encoding::DefaultFuchsiaResourceDialect,
11049            >,
11050        T2: fidl::encoding::Encode<
11051                fidl::encoding::HandleType<
11052                    fidl::Thread,
11053                    { fidl::ObjectType::THREAD.into_raw() },
11054                    2147483648,
11055                >,
11056                fidl::encoding::DefaultFuchsiaResourceDialect,
11057            >,
11058        T3: fidl::encoding::Encode<
11059                fidl::encoding::HandleType<
11060                    fidl::Vmo,
11061                    { fidl::ObjectType::VMO.into_raw() },
11062                    2147483648,
11063                >,
11064                fidl::encoding::DefaultFuchsiaResourceDialect,
11065            >,
11066        T4: fidl::encoding::Encode<
11067                fidl::encoding::HandleType<
11068                    fidl::Event,
11069                    { fidl::ObjectType::EVENT.into_raw() },
11070                    2147483648,
11071                >,
11072                fidl::encoding::DefaultFuchsiaResourceDialect,
11073            >,
11074        T5: fidl::encoding::Encode<
11075                fidl::encoding::HandleType<
11076                    fidl::Port,
11077                    { fidl::ObjectType::PORT.into_raw() },
11078                    2147483648,
11079                >,
11080                fidl::encoding::DefaultFuchsiaResourceDialect,
11081            >,
11082        T6: fidl::encoding::Encode<
11083                fidl::encoding::HandleType<
11084                    fidl::Socket,
11085                    { fidl::ObjectType::SOCKET.into_raw() },
11086                    2147483648,
11087                >,
11088                fidl::encoding::DefaultFuchsiaResourceDialect,
11089            >,
11090        T7: fidl::encoding::Encode<
11091                fidl::encoding::HandleType<
11092                    fidl::EventPair,
11093                    { fidl::ObjectType::EVENTPAIR.into_raw() },
11094                    2147483648,
11095                >,
11096                fidl::encoding::DefaultFuchsiaResourceDialect,
11097            >,
11098        T8: fidl::encoding::Encode<
11099                fidl::encoding::HandleType<
11100                    fidl::Job,
11101                    { fidl::ObjectType::JOB.into_raw() },
11102                    2147483648,
11103                >,
11104                fidl::encoding::DefaultFuchsiaResourceDialect,
11105            >,
11106        T9: fidl::encoding::Encode<
11107                fidl::encoding::HandleType<
11108                    fidl::Vmar,
11109                    { fidl::ObjectType::VMAR.into_raw() },
11110                    2147483648,
11111                >,
11112                fidl::encoding::DefaultFuchsiaResourceDialect,
11113            >,
11114        T10: fidl::encoding::Encode<
11115                fidl::encoding::HandleType<
11116                    fidl::Fifo,
11117                    { fidl::ObjectType::FIFO.into_raw() },
11118                    2147483648,
11119                >,
11120                fidl::encoding::DefaultFuchsiaResourceDialect,
11121            >,
11122        T11: fidl::encoding::Encode<
11123                fidl::encoding::HandleType<
11124                    fidl::Timer,
11125                    { fidl::ObjectType::TIMER.into_raw() },
11126                    2147483648,
11127                >,
11128                fidl::encoding::DefaultFuchsiaResourceDialect,
11129            >,
11130        T12: fidl::encoding::Encode<
11131                fidl::encoding::Optional<
11132                    fidl::encoding::HandleType<
11133                        fidl::Handle,
11134                        { fidl::ObjectType::NONE.into_raw() },
11135                        2147483648,
11136                    >,
11137                >,
11138                fidl::encoding::DefaultFuchsiaResourceDialect,
11139            >,
11140        T13: fidl::encoding::Encode<
11141                fidl::encoding::Optional<
11142                    fidl::encoding::HandleType<
11143                        fidl::Process,
11144                        { fidl::ObjectType::PROCESS.into_raw() },
11145                        2147483648,
11146                    >,
11147                >,
11148                fidl::encoding::DefaultFuchsiaResourceDialect,
11149            >,
11150        T14: fidl::encoding::Encode<
11151                fidl::encoding::Optional<
11152                    fidl::encoding::HandleType<
11153                        fidl::Thread,
11154                        { fidl::ObjectType::THREAD.into_raw() },
11155                        2147483648,
11156                    >,
11157                >,
11158                fidl::encoding::DefaultFuchsiaResourceDialect,
11159            >,
11160        T15: fidl::encoding::Encode<
11161                fidl::encoding::Optional<
11162                    fidl::encoding::HandleType<
11163                        fidl::Vmo,
11164                        { fidl::ObjectType::VMO.into_raw() },
11165                        2147483648,
11166                    >,
11167                >,
11168                fidl::encoding::DefaultFuchsiaResourceDialect,
11169            >,
11170        T16: fidl::encoding::Encode<
11171                fidl::encoding::Optional<
11172                    fidl::encoding::HandleType<
11173                        fidl::Channel,
11174                        { fidl::ObjectType::CHANNEL.into_raw() },
11175                        2147483648,
11176                    >,
11177                >,
11178                fidl::encoding::DefaultFuchsiaResourceDialect,
11179            >,
11180        T17: fidl::encoding::Encode<
11181                fidl::encoding::Optional<
11182                    fidl::encoding::HandleType<
11183                        fidl::Event,
11184                        { fidl::ObjectType::EVENT.into_raw() },
11185                        2147483648,
11186                    >,
11187                >,
11188                fidl::encoding::DefaultFuchsiaResourceDialect,
11189            >,
11190        T18: fidl::encoding::Encode<
11191                fidl::encoding::Optional<
11192                    fidl::encoding::HandleType<
11193                        fidl::Port,
11194                        { fidl::ObjectType::PORT.into_raw() },
11195                        2147483648,
11196                    >,
11197                >,
11198                fidl::encoding::DefaultFuchsiaResourceDialect,
11199            >,
11200        T19: fidl::encoding::Encode<
11201                fidl::encoding::Optional<
11202                    fidl::encoding::HandleType<
11203                        fidl::Interrupt,
11204                        { fidl::ObjectType::INTERRUPT.into_raw() },
11205                        2147483648,
11206                    >,
11207                >,
11208                fidl::encoding::DefaultFuchsiaResourceDialect,
11209            >,
11210        T20: fidl::encoding::Encode<
11211                fidl::encoding::Optional<
11212                    fidl::encoding::HandleType<
11213                        fidl::DebugLog,
11214                        { fidl::ObjectType::DEBUGLOG.into_raw() },
11215                        2147483648,
11216                    >,
11217                >,
11218                fidl::encoding::DefaultFuchsiaResourceDialect,
11219            >,
11220        T21: fidl::encoding::Encode<
11221                fidl::encoding::Optional<
11222                    fidl::encoding::HandleType<
11223                        fidl::Socket,
11224                        { fidl::ObjectType::SOCKET.into_raw() },
11225                        2147483648,
11226                    >,
11227                >,
11228                fidl::encoding::DefaultFuchsiaResourceDialect,
11229            >,
11230        T22: fidl::encoding::Encode<
11231                fidl::encoding::Optional<
11232                    fidl::encoding::HandleType<
11233                        fidl::EventPair,
11234                        { fidl::ObjectType::EVENTPAIR.into_raw() },
11235                        2147483648,
11236                    >,
11237                >,
11238                fidl::encoding::DefaultFuchsiaResourceDialect,
11239            >,
11240        T23: fidl::encoding::Encode<
11241                fidl::encoding::Optional<
11242                    fidl::encoding::HandleType<
11243                        fidl::Job,
11244                        { fidl::ObjectType::JOB.into_raw() },
11245                        2147483648,
11246                    >,
11247                >,
11248                fidl::encoding::DefaultFuchsiaResourceDialect,
11249            >,
11250        T24: fidl::encoding::Encode<
11251                fidl::encoding::Optional<
11252                    fidl::encoding::HandleType<
11253                        fidl::Vmar,
11254                        { fidl::ObjectType::VMAR.into_raw() },
11255                        2147483648,
11256                    >,
11257                >,
11258                fidl::encoding::DefaultFuchsiaResourceDialect,
11259            >,
11260        T25: fidl::encoding::Encode<
11261                fidl::encoding::Optional<
11262                    fidl::encoding::HandleType<
11263                        fidl::Fifo,
11264                        { fidl::ObjectType::FIFO.into_raw() },
11265                        2147483648,
11266                    >,
11267                >,
11268                fidl::encoding::DefaultFuchsiaResourceDialect,
11269            >,
11270        T26: fidl::encoding::Encode<
11271                fidl::encoding::Optional<
11272                    fidl::encoding::HandleType<
11273                        fidl::Timer,
11274                        { fidl::ObjectType::TIMER.into_raw() },
11275                        2147483648,
11276                    >,
11277                >,
11278                fidl::encoding::DefaultFuchsiaResourceDialect,
11279            >,
11280    > fidl::encoding::Encode<Handles, fidl::encoding::DefaultFuchsiaResourceDialect>
11281        for (
11282            T0,
11283            T1,
11284            T2,
11285            T3,
11286            T4,
11287            T5,
11288            T6,
11289            T7,
11290            T8,
11291            T9,
11292            T10,
11293            T11,
11294            T12,
11295            T13,
11296            T14,
11297            T15,
11298            T16,
11299            T17,
11300            T18,
11301            T19,
11302            T20,
11303            T21,
11304            T22,
11305            T23,
11306            T24,
11307            T25,
11308            T26,
11309        )
11310    {
11311        #[inline]
11312        unsafe fn encode(
11313            self,
11314            encoder: &mut fidl::encoding::Encoder<
11315                '_,
11316                fidl::encoding::DefaultFuchsiaResourceDialect,
11317            >,
11318            offset: usize,
11319            depth: fidl::encoding::Depth,
11320        ) -> fidl::Result<()> {
11321            encoder.debug_check_bounds::<Handles>(offset);
11322            // Zero out padding regions. There's no need to apply masks
11323            // because the unmasked parts will be overwritten by fields.
11324            // Write the fields.
11325            self.0.encode(encoder, offset + 0, depth)?;
11326            self.1.encode(encoder, offset + 4, depth)?;
11327            self.2.encode(encoder, offset + 8, depth)?;
11328            self.3.encode(encoder, offset + 12, depth)?;
11329            self.4.encode(encoder, offset + 16, depth)?;
11330            self.5.encode(encoder, offset + 20, depth)?;
11331            self.6.encode(encoder, offset + 24, depth)?;
11332            self.7.encode(encoder, offset + 28, depth)?;
11333            self.8.encode(encoder, offset + 32, depth)?;
11334            self.9.encode(encoder, offset + 36, depth)?;
11335            self.10.encode(encoder, offset + 40, depth)?;
11336            self.11.encode(encoder, offset + 44, depth)?;
11337            self.12.encode(encoder, offset + 48, depth)?;
11338            self.13.encode(encoder, offset + 52, depth)?;
11339            self.14.encode(encoder, offset + 56, depth)?;
11340            self.15.encode(encoder, offset + 60, depth)?;
11341            self.16.encode(encoder, offset + 64, depth)?;
11342            self.17.encode(encoder, offset + 68, depth)?;
11343            self.18.encode(encoder, offset + 72, depth)?;
11344            self.19.encode(encoder, offset + 76, depth)?;
11345            self.20.encode(encoder, offset + 80, depth)?;
11346            self.21.encode(encoder, offset + 84, depth)?;
11347            self.22.encode(encoder, offset + 88, depth)?;
11348            self.23.encode(encoder, offset + 92, depth)?;
11349            self.24.encode(encoder, offset + 96, depth)?;
11350            self.25.encode(encoder, offset + 100, depth)?;
11351            self.26.encode(encoder, offset + 104, depth)?;
11352            Ok(())
11353        }
11354    }
11355
11356    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Handles {
11357        #[inline(always)]
11358        fn new_empty() -> Self {
11359            Self {
11360                handle_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11361                process_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Process, { fidl::ObjectType::PROCESS.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11362                thread_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Thread, { fidl::ObjectType::THREAD.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11363                vmo_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11364                event_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11365                port_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Port, { fidl::ObjectType::PORT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11366                socket_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11367                eventpair_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11368                job_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Job, { fidl::ObjectType::JOB.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11369                vmar_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmar, { fidl::ObjectType::VMAR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11370                fifo_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Fifo, { fidl::ObjectType::FIFO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11371                timer_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Timer, { fidl::ObjectType::TIMER.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11372                nullable_handle_handle: fidl::new_empty!(
11373                    fidl::encoding::Optional<
11374                        fidl::encoding::HandleType<
11375                            fidl::Handle,
11376                            { fidl::ObjectType::NONE.into_raw() },
11377                            2147483648,
11378                        >,
11379                    >,
11380                    fidl::encoding::DefaultFuchsiaResourceDialect
11381                ),
11382                nullable_process_handle: fidl::new_empty!(
11383                    fidl::encoding::Optional<
11384                        fidl::encoding::HandleType<
11385                            fidl::Process,
11386                            { fidl::ObjectType::PROCESS.into_raw() },
11387                            2147483648,
11388                        >,
11389                    >,
11390                    fidl::encoding::DefaultFuchsiaResourceDialect
11391                ),
11392                nullable_thread_handle: fidl::new_empty!(
11393                    fidl::encoding::Optional<
11394                        fidl::encoding::HandleType<
11395                            fidl::Thread,
11396                            { fidl::ObjectType::THREAD.into_raw() },
11397                            2147483648,
11398                        >,
11399                    >,
11400                    fidl::encoding::DefaultFuchsiaResourceDialect
11401                ),
11402                nullable_vmo_handle: fidl::new_empty!(
11403                    fidl::encoding::Optional<
11404                        fidl::encoding::HandleType<
11405                            fidl::Vmo,
11406                            { fidl::ObjectType::VMO.into_raw() },
11407                            2147483648,
11408                        >,
11409                    >,
11410                    fidl::encoding::DefaultFuchsiaResourceDialect
11411                ),
11412                nullable_channel_handle: fidl::new_empty!(
11413                    fidl::encoding::Optional<
11414                        fidl::encoding::HandleType<
11415                            fidl::Channel,
11416                            { fidl::ObjectType::CHANNEL.into_raw() },
11417                            2147483648,
11418                        >,
11419                    >,
11420                    fidl::encoding::DefaultFuchsiaResourceDialect
11421                ),
11422                nullable_event_handle: fidl::new_empty!(
11423                    fidl::encoding::Optional<
11424                        fidl::encoding::HandleType<
11425                            fidl::Event,
11426                            { fidl::ObjectType::EVENT.into_raw() },
11427                            2147483648,
11428                        >,
11429                    >,
11430                    fidl::encoding::DefaultFuchsiaResourceDialect
11431                ),
11432                nullable_port_handle: fidl::new_empty!(
11433                    fidl::encoding::Optional<
11434                        fidl::encoding::HandleType<
11435                            fidl::Port,
11436                            { fidl::ObjectType::PORT.into_raw() },
11437                            2147483648,
11438                        >,
11439                    >,
11440                    fidl::encoding::DefaultFuchsiaResourceDialect
11441                ),
11442                nullable_interrupt_handle: fidl::new_empty!(
11443                    fidl::encoding::Optional<
11444                        fidl::encoding::HandleType<
11445                            fidl::Interrupt,
11446                            { fidl::ObjectType::INTERRUPT.into_raw() },
11447                            2147483648,
11448                        >,
11449                    >,
11450                    fidl::encoding::DefaultFuchsiaResourceDialect
11451                ),
11452                nullable_log_handle: fidl::new_empty!(
11453                    fidl::encoding::Optional<
11454                        fidl::encoding::HandleType<
11455                            fidl::DebugLog,
11456                            { fidl::ObjectType::DEBUGLOG.into_raw() },
11457                            2147483648,
11458                        >,
11459                    >,
11460                    fidl::encoding::DefaultFuchsiaResourceDialect
11461                ),
11462                nullable_socket_handle: fidl::new_empty!(
11463                    fidl::encoding::Optional<
11464                        fidl::encoding::HandleType<
11465                            fidl::Socket,
11466                            { fidl::ObjectType::SOCKET.into_raw() },
11467                            2147483648,
11468                        >,
11469                    >,
11470                    fidl::encoding::DefaultFuchsiaResourceDialect
11471                ),
11472                nullable_eventpair_handle: fidl::new_empty!(
11473                    fidl::encoding::Optional<
11474                        fidl::encoding::HandleType<
11475                            fidl::EventPair,
11476                            { fidl::ObjectType::EVENTPAIR.into_raw() },
11477                            2147483648,
11478                        >,
11479                    >,
11480                    fidl::encoding::DefaultFuchsiaResourceDialect
11481                ),
11482                nullable_job_handle: fidl::new_empty!(
11483                    fidl::encoding::Optional<
11484                        fidl::encoding::HandleType<
11485                            fidl::Job,
11486                            { fidl::ObjectType::JOB.into_raw() },
11487                            2147483648,
11488                        >,
11489                    >,
11490                    fidl::encoding::DefaultFuchsiaResourceDialect
11491                ),
11492                nullable_vmar_handle: fidl::new_empty!(
11493                    fidl::encoding::Optional<
11494                        fidl::encoding::HandleType<
11495                            fidl::Vmar,
11496                            { fidl::ObjectType::VMAR.into_raw() },
11497                            2147483648,
11498                        >,
11499                    >,
11500                    fidl::encoding::DefaultFuchsiaResourceDialect
11501                ),
11502                nullable_fifo_handle: fidl::new_empty!(
11503                    fidl::encoding::Optional<
11504                        fidl::encoding::HandleType<
11505                            fidl::Fifo,
11506                            { fidl::ObjectType::FIFO.into_raw() },
11507                            2147483648,
11508                        >,
11509                    >,
11510                    fidl::encoding::DefaultFuchsiaResourceDialect
11511                ),
11512                nullable_timer_handle: fidl::new_empty!(
11513                    fidl::encoding::Optional<
11514                        fidl::encoding::HandleType<
11515                            fidl::Timer,
11516                            { fidl::ObjectType::TIMER.into_raw() },
11517                            2147483648,
11518                        >,
11519                    >,
11520                    fidl::encoding::DefaultFuchsiaResourceDialect
11521                ),
11522            }
11523        }
11524
11525        #[inline]
11526        unsafe fn decode(
11527            &mut self,
11528            decoder: &mut fidl::encoding::Decoder<
11529                '_,
11530                fidl::encoding::DefaultFuchsiaResourceDialect,
11531            >,
11532            offset: usize,
11533            _depth: fidl::encoding::Depth,
11534        ) -> fidl::Result<()> {
11535            decoder.debug_check_bounds::<Self>(offset);
11536            // Verify that padding bytes are zero.
11537            fidl::decode!(fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.handle_handle, decoder, offset + 0, _depth)?;
11538            fidl::decode!(fidl::encoding::HandleType<fidl::Process, { fidl::ObjectType::PROCESS.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.process_handle, decoder, offset + 4, _depth)?;
11539            fidl::decode!(fidl::encoding::HandleType<fidl::Thread, { fidl::ObjectType::THREAD.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.thread_handle, decoder, offset + 8, _depth)?;
11540            fidl::decode!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.vmo_handle, decoder, offset + 12, _depth)?;
11541            fidl::decode!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.event_handle, decoder, offset + 16, _depth)?;
11542            fidl::decode!(fidl::encoding::HandleType<fidl::Port, { fidl::ObjectType::PORT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.port_handle, decoder, offset + 20, _depth)?;
11543            fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.socket_handle, decoder, offset + 24, _depth)?;
11544            fidl::decode!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.eventpair_handle, decoder, offset + 28, _depth)?;
11545            fidl::decode!(fidl::encoding::HandleType<fidl::Job, { fidl::ObjectType::JOB.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.job_handle, decoder, offset + 32, _depth)?;
11546            fidl::decode!(fidl::encoding::HandleType<fidl::Vmar, { fidl::ObjectType::VMAR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.vmar_handle, decoder, offset + 36, _depth)?;
11547            fidl::decode!(fidl::encoding::HandleType<fidl::Fifo, { fidl::ObjectType::FIFO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.fifo_handle, decoder, offset + 40, _depth)?;
11548            fidl::decode!(fidl::encoding::HandleType<fidl::Timer, { fidl::ObjectType::TIMER.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.timer_handle, decoder, offset + 44, _depth)?;
11549            fidl::decode!(
11550                fidl::encoding::Optional<
11551                    fidl::encoding::HandleType<
11552                        fidl::Handle,
11553                        { fidl::ObjectType::NONE.into_raw() },
11554                        2147483648,
11555                    >,
11556                >,
11557                fidl::encoding::DefaultFuchsiaResourceDialect,
11558                &mut self.nullable_handle_handle,
11559                decoder,
11560                offset + 48,
11561                _depth
11562            )?;
11563            fidl::decode!(
11564                fidl::encoding::Optional<
11565                    fidl::encoding::HandleType<
11566                        fidl::Process,
11567                        { fidl::ObjectType::PROCESS.into_raw() },
11568                        2147483648,
11569                    >,
11570                >,
11571                fidl::encoding::DefaultFuchsiaResourceDialect,
11572                &mut self.nullable_process_handle,
11573                decoder,
11574                offset + 52,
11575                _depth
11576            )?;
11577            fidl::decode!(
11578                fidl::encoding::Optional<
11579                    fidl::encoding::HandleType<
11580                        fidl::Thread,
11581                        { fidl::ObjectType::THREAD.into_raw() },
11582                        2147483648,
11583                    >,
11584                >,
11585                fidl::encoding::DefaultFuchsiaResourceDialect,
11586                &mut self.nullable_thread_handle,
11587                decoder,
11588                offset + 56,
11589                _depth
11590            )?;
11591            fidl::decode!(
11592                fidl::encoding::Optional<
11593                    fidl::encoding::HandleType<
11594                        fidl::Vmo,
11595                        { fidl::ObjectType::VMO.into_raw() },
11596                        2147483648,
11597                    >,
11598                >,
11599                fidl::encoding::DefaultFuchsiaResourceDialect,
11600                &mut self.nullable_vmo_handle,
11601                decoder,
11602                offset + 60,
11603                _depth
11604            )?;
11605            fidl::decode!(
11606                fidl::encoding::Optional<
11607                    fidl::encoding::HandleType<
11608                        fidl::Channel,
11609                        { fidl::ObjectType::CHANNEL.into_raw() },
11610                        2147483648,
11611                    >,
11612                >,
11613                fidl::encoding::DefaultFuchsiaResourceDialect,
11614                &mut self.nullable_channel_handle,
11615                decoder,
11616                offset + 64,
11617                _depth
11618            )?;
11619            fidl::decode!(
11620                fidl::encoding::Optional<
11621                    fidl::encoding::HandleType<
11622                        fidl::Event,
11623                        { fidl::ObjectType::EVENT.into_raw() },
11624                        2147483648,
11625                    >,
11626                >,
11627                fidl::encoding::DefaultFuchsiaResourceDialect,
11628                &mut self.nullable_event_handle,
11629                decoder,
11630                offset + 68,
11631                _depth
11632            )?;
11633            fidl::decode!(
11634                fidl::encoding::Optional<
11635                    fidl::encoding::HandleType<
11636                        fidl::Port,
11637                        { fidl::ObjectType::PORT.into_raw() },
11638                        2147483648,
11639                    >,
11640                >,
11641                fidl::encoding::DefaultFuchsiaResourceDialect,
11642                &mut self.nullable_port_handle,
11643                decoder,
11644                offset + 72,
11645                _depth
11646            )?;
11647            fidl::decode!(
11648                fidl::encoding::Optional<
11649                    fidl::encoding::HandleType<
11650                        fidl::Interrupt,
11651                        { fidl::ObjectType::INTERRUPT.into_raw() },
11652                        2147483648,
11653                    >,
11654                >,
11655                fidl::encoding::DefaultFuchsiaResourceDialect,
11656                &mut self.nullable_interrupt_handle,
11657                decoder,
11658                offset + 76,
11659                _depth
11660            )?;
11661            fidl::decode!(
11662                fidl::encoding::Optional<
11663                    fidl::encoding::HandleType<
11664                        fidl::DebugLog,
11665                        { fidl::ObjectType::DEBUGLOG.into_raw() },
11666                        2147483648,
11667                    >,
11668                >,
11669                fidl::encoding::DefaultFuchsiaResourceDialect,
11670                &mut self.nullable_log_handle,
11671                decoder,
11672                offset + 80,
11673                _depth
11674            )?;
11675            fidl::decode!(
11676                fidl::encoding::Optional<
11677                    fidl::encoding::HandleType<
11678                        fidl::Socket,
11679                        { fidl::ObjectType::SOCKET.into_raw() },
11680                        2147483648,
11681                    >,
11682                >,
11683                fidl::encoding::DefaultFuchsiaResourceDialect,
11684                &mut self.nullable_socket_handle,
11685                decoder,
11686                offset + 84,
11687                _depth
11688            )?;
11689            fidl::decode!(
11690                fidl::encoding::Optional<
11691                    fidl::encoding::HandleType<
11692                        fidl::EventPair,
11693                        { fidl::ObjectType::EVENTPAIR.into_raw() },
11694                        2147483648,
11695                    >,
11696                >,
11697                fidl::encoding::DefaultFuchsiaResourceDialect,
11698                &mut self.nullable_eventpair_handle,
11699                decoder,
11700                offset + 88,
11701                _depth
11702            )?;
11703            fidl::decode!(
11704                fidl::encoding::Optional<
11705                    fidl::encoding::HandleType<
11706                        fidl::Job,
11707                        { fidl::ObjectType::JOB.into_raw() },
11708                        2147483648,
11709                    >,
11710                >,
11711                fidl::encoding::DefaultFuchsiaResourceDialect,
11712                &mut self.nullable_job_handle,
11713                decoder,
11714                offset + 92,
11715                _depth
11716            )?;
11717            fidl::decode!(
11718                fidl::encoding::Optional<
11719                    fidl::encoding::HandleType<
11720                        fidl::Vmar,
11721                        { fidl::ObjectType::VMAR.into_raw() },
11722                        2147483648,
11723                    >,
11724                >,
11725                fidl::encoding::DefaultFuchsiaResourceDialect,
11726                &mut self.nullable_vmar_handle,
11727                decoder,
11728                offset + 96,
11729                _depth
11730            )?;
11731            fidl::decode!(
11732                fidl::encoding::Optional<
11733                    fidl::encoding::HandleType<
11734                        fidl::Fifo,
11735                        { fidl::ObjectType::FIFO.into_raw() },
11736                        2147483648,
11737                    >,
11738                >,
11739                fidl::encoding::DefaultFuchsiaResourceDialect,
11740                &mut self.nullable_fifo_handle,
11741                decoder,
11742                offset + 100,
11743                _depth
11744            )?;
11745            fidl::decode!(
11746                fidl::encoding::Optional<
11747                    fidl::encoding::HandleType<
11748                        fidl::Timer,
11749                        { fidl::ObjectType::TIMER.into_raw() },
11750                        2147483648,
11751                    >,
11752                >,
11753                fidl::encoding::DefaultFuchsiaResourceDialect,
11754                &mut self.nullable_timer_handle,
11755                decoder,
11756                offset + 104,
11757                _depth
11758            )?;
11759            Ok(())
11760        }
11761    }
11762
11763    impl fidl::encoding::ResourceTypeMarker for Vectors {
11764        type Borrowed<'a> = &'a mut Self;
11765        fn take_or_borrow<'a>(
11766            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
11767        ) -> Self::Borrowed<'a> {
11768            value
11769        }
11770    }
11771
11772    unsafe impl fidl::encoding::TypeMarker for Vectors {
11773        type Owned = Self;
11774
11775        #[inline(always)]
11776        fn inline_align(_context: fidl::encoding::Context) -> usize {
11777            8
11778        }
11779
11780        #[inline(always)]
11781        fn inline_size(_context: fidl::encoding::Context) -> usize {
11782            1920
11783        }
11784    }
11785
11786    unsafe impl fidl::encoding::Encode<Vectors, fidl::encoding::DefaultFuchsiaResourceDialect>
11787        for &mut Vectors
11788    {
11789        #[inline]
11790        unsafe fn encode(
11791            self,
11792            encoder: &mut fidl::encoding::Encoder<
11793                '_,
11794                fidl::encoding::DefaultFuchsiaResourceDialect,
11795            >,
11796            offset: usize,
11797            _depth: fidl::encoding::Depth,
11798        ) -> fidl::Result<()> {
11799            encoder.debug_check_bounds::<Vectors>(offset);
11800            // Delegate to tuple encoding.
11801            fidl::encoding::Encode::<Vectors, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
11802                (
11803                    <fidl::encoding::UnboundedVector<bool> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_0),
11804                    <fidl::encoding::UnboundedVector<i8> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_0),
11805                    <fidl::encoding::UnboundedVector<i16> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_0),
11806                    <fidl::encoding::UnboundedVector<i32> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_0),
11807                    <fidl::encoding::UnboundedVector<i64> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_0),
11808                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_0),
11809                    <fidl::encoding::UnboundedVector<u16> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_0),
11810                    <fidl::encoding::UnboundedVector<u32> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_0),
11811                    <fidl::encoding::UnboundedVector<u64> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_0),
11812                    <fidl::encoding::UnboundedVector<f32> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_0),
11813                    <fidl::encoding::UnboundedVector<f64> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_0),
11814                    <fidl::encoding::UnboundedVector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_0),
11815                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_1),
11816                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_1),
11817                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_1),
11818                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_1),
11819                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_1),
11820                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_1),
11821                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_1),
11822                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_1),
11823                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_1),
11824                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_1),
11825                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_1),
11826                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 2>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_1),
11827                    <fidl::encoding::Vector<bool, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_sized_0),
11828                    <fidl::encoding::Vector<i8, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_sized_0),
11829                    <fidl::encoding::Vector<i16, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_sized_0),
11830                    <fidl::encoding::Vector<i32, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_sized_0),
11831                    <fidl::encoding::Vector<i64, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_sized_0),
11832                    <fidl::encoding::Vector<u8, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_sized_0),
11833                    <fidl::encoding::Vector<u16, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_sized_0),
11834                    <fidl::encoding::Vector<u32, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_sized_0),
11835                    <fidl::encoding::Vector<u64, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_sized_0),
11836                    <fidl::encoding::Vector<f32, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_sized_0),
11837                    <fidl::encoding::Vector<f64, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_sized_0),
11838                    <fidl::encoding::Vector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 1> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_sized_0),
11839                    <fidl::encoding::Vector<bool, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_sized_1),
11840                    <fidl::encoding::Vector<i8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_sized_1),
11841                    <fidl::encoding::Vector<i16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_sized_1),
11842                    <fidl::encoding::Vector<i32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_sized_1),
11843                    <fidl::encoding::Vector<i64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_sized_1),
11844                    <fidl::encoding::Vector<u8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_sized_1),
11845                    <fidl::encoding::Vector<u16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_sized_1),
11846                    <fidl::encoding::Vector<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_sized_1),
11847                    <fidl::encoding::Vector<u64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_sized_1),
11848                    <fidl::encoding::Vector<f32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_sized_1),
11849                    <fidl::encoding::Vector<f64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_sized_1),
11850                    <fidl::encoding::Vector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 3> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_sized_1),
11851                    <fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_sized_2),
11852                    <fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_sized_2),
11853                    <fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_sized_2),
11854                    <fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_sized_2),
11855                    <fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_sized_2),
11856                    <fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_sized_2),
11857                    <fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_sized_2),
11858                    <fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_sized_2),
11859                    <fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_sized_2),
11860                    <fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_sized_2),
11861                    <fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_sized_2),
11862                    <fidl::encoding::Vector<fidl::encoding::Vector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 2>, 3> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_sized_2),
11863                    <fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_nullable_0),
11864                    <fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_nullable_0),
11865                    <fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_nullable_0),
11866                    <fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_nullable_0),
11867                    <fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_nullable_0),
11868                    <fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_nullable_0),
11869                    <fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_nullable_0),
11870                    <fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_nullable_0),
11871                    <fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_nullable_0),
11872                    <fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_nullable_0),
11873                    <fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_nullable_0),
11874                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 1>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_nullable_0),
11875                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_nullable_1),
11876                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_nullable_1),
11877                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_nullable_1),
11878                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_nullable_1),
11879                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_nullable_1),
11880                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_nullable_1),
11881                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_nullable_1),
11882                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_nullable_1),
11883                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_nullable_1),
11884                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_nullable_1),
11885                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_nullable_1),
11886                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 2>>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_nullable_1),
11887                    <fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_nullable_sized_0),
11888                    <fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_nullable_sized_0),
11889                    <fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_nullable_sized_0),
11890                    <fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_nullable_sized_0),
11891                    <fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_nullable_sized_0),
11892                    <fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_nullable_sized_0),
11893                    <fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_nullable_sized_0),
11894                    <fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_nullable_sized_0),
11895                    <fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_nullable_sized_0),
11896                    <fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_nullable_sized_0),
11897                    <fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_nullable_sized_0),
11898                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 1>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_nullable_sized_0),
11899                    <fidl::encoding::Optional<fidl::encoding::Vector<bool, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_nullable_sized_1),
11900                    <fidl::encoding::Optional<fidl::encoding::Vector<i8, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_nullable_sized_1),
11901                    <fidl::encoding::Optional<fidl::encoding::Vector<i16, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_nullable_sized_1),
11902                    <fidl::encoding::Optional<fidl::encoding::Vector<i32, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_nullable_sized_1),
11903                    <fidl::encoding::Optional<fidl::encoding::Vector<i64, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_nullable_sized_1),
11904                    <fidl::encoding::Optional<fidl::encoding::Vector<u8, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_nullable_sized_1),
11905                    <fidl::encoding::Optional<fidl::encoding::Vector<u16, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_nullable_sized_1),
11906                    <fidl::encoding::Optional<fidl::encoding::Vector<u32, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_nullable_sized_1),
11907                    <fidl::encoding::Optional<fidl::encoding::Vector<u64, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_nullable_sized_1),
11908                    <fidl::encoding::Optional<fidl::encoding::Vector<f32, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_nullable_sized_1),
11909                    <fidl::encoding::Optional<fidl::encoding::Vector<f64, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_nullable_sized_1),
11910                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 3>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_nullable_sized_1),
11911                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_nullable_sized_2),
11912                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_nullable_sized_2),
11913                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_nullable_sized_2),
11914                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_nullable_sized_2),
11915                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_nullable_sized_2),
11916                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_nullable_sized_2),
11917                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_nullable_sized_2),
11918                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_nullable_sized_2),
11919                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_nullable_sized_2),
11920                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_nullable_sized_2),
11921                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_nullable_sized_2),
11922                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 2>, 3>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_nullable_sized_2),
11923                ),
11924                encoder, offset, _depth
11925            )
11926        }
11927    }
11928    unsafe impl<
11929        T0: fidl::encoding::Encode<
11930                fidl::encoding::UnboundedVector<bool>,
11931                fidl::encoding::DefaultFuchsiaResourceDialect,
11932            >,
11933        T1: fidl::encoding::Encode<
11934                fidl::encoding::UnboundedVector<i8>,
11935                fidl::encoding::DefaultFuchsiaResourceDialect,
11936            >,
11937        T2: fidl::encoding::Encode<
11938                fidl::encoding::UnboundedVector<i16>,
11939                fidl::encoding::DefaultFuchsiaResourceDialect,
11940            >,
11941        T3: fidl::encoding::Encode<
11942                fidl::encoding::UnboundedVector<i32>,
11943                fidl::encoding::DefaultFuchsiaResourceDialect,
11944            >,
11945        T4: fidl::encoding::Encode<
11946                fidl::encoding::UnboundedVector<i64>,
11947                fidl::encoding::DefaultFuchsiaResourceDialect,
11948            >,
11949        T5: fidl::encoding::Encode<
11950                fidl::encoding::UnboundedVector<u8>,
11951                fidl::encoding::DefaultFuchsiaResourceDialect,
11952            >,
11953        T6: fidl::encoding::Encode<
11954                fidl::encoding::UnboundedVector<u16>,
11955                fidl::encoding::DefaultFuchsiaResourceDialect,
11956            >,
11957        T7: fidl::encoding::Encode<
11958                fidl::encoding::UnboundedVector<u32>,
11959                fidl::encoding::DefaultFuchsiaResourceDialect,
11960            >,
11961        T8: fidl::encoding::Encode<
11962                fidl::encoding::UnboundedVector<u64>,
11963                fidl::encoding::DefaultFuchsiaResourceDialect,
11964            >,
11965        T9: fidl::encoding::Encode<
11966                fidl::encoding::UnboundedVector<f32>,
11967                fidl::encoding::DefaultFuchsiaResourceDialect,
11968            >,
11969        T10: fidl::encoding::Encode<
11970                fidl::encoding::UnboundedVector<f64>,
11971                fidl::encoding::DefaultFuchsiaResourceDialect,
11972            >,
11973        T11: fidl::encoding::Encode<
11974                fidl::encoding::UnboundedVector<
11975                    fidl::encoding::HandleType<
11976                        fidl::Handle,
11977                        { fidl::ObjectType::NONE.into_raw() },
11978                        2147483648,
11979                    >,
11980                >,
11981                fidl::encoding::DefaultFuchsiaResourceDialect,
11982            >,
11983        T12: fidl::encoding::Encode<
11984                fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
11985                fidl::encoding::DefaultFuchsiaResourceDialect,
11986            >,
11987        T13: fidl::encoding::Encode<
11988                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
11989                fidl::encoding::DefaultFuchsiaResourceDialect,
11990            >,
11991        T14: fidl::encoding::Encode<
11992                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
11993                fidl::encoding::DefaultFuchsiaResourceDialect,
11994            >,
11995        T15: fidl::encoding::Encode<
11996                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
11997                fidl::encoding::DefaultFuchsiaResourceDialect,
11998            >,
11999        T16: fidl::encoding::Encode<
12000                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
12001                fidl::encoding::DefaultFuchsiaResourceDialect,
12002            >,
12003        T17: fidl::encoding::Encode<
12004                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
12005                fidl::encoding::DefaultFuchsiaResourceDialect,
12006            >,
12007        T18: fidl::encoding::Encode<
12008                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
12009                fidl::encoding::DefaultFuchsiaResourceDialect,
12010            >,
12011        T19: fidl::encoding::Encode<
12012                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
12013                fidl::encoding::DefaultFuchsiaResourceDialect,
12014            >,
12015        T20: fidl::encoding::Encode<
12016                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
12017                fidl::encoding::DefaultFuchsiaResourceDialect,
12018            >,
12019        T21: fidl::encoding::Encode<
12020                fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
12021                fidl::encoding::DefaultFuchsiaResourceDialect,
12022            >,
12023        T22: fidl::encoding::Encode<
12024                fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
12025                fidl::encoding::DefaultFuchsiaResourceDialect,
12026            >,
12027        T23: fidl::encoding::Encode<
12028                fidl::encoding::UnboundedVector<
12029                    fidl::encoding::Vector<
12030                        fidl::encoding::HandleType<
12031                            fidl::Handle,
12032                            { fidl::ObjectType::NONE.into_raw() },
12033                            2147483648,
12034                        >,
12035                        2,
12036                    >,
12037                >,
12038                fidl::encoding::DefaultFuchsiaResourceDialect,
12039            >,
12040        T24: fidl::encoding::Encode<
12041                fidl::encoding::Vector<bool, 1>,
12042                fidl::encoding::DefaultFuchsiaResourceDialect,
12043            >,
12044        T25: fidl::encoding::Encode<
12045                fidl::encoding::Vector<i8, 1>,
12046                fidl::encoding::DefaultFuchsiaResourceDialect,
12047            >,
12048        T26: fidl::encoding::Encode<
12049                fidl::encoding::Vector<i16, 1>,
12050                fidl::encoding::DefaultFuchsiaResourceDialect,
12051            >,
12052        T27: fidl::encoding::Encode<
12053                fidl::encoding::Vector<i32, 1>,
12054                fidl::encoding::DefaultFuchsiaResourceDialect,
12055            >,
12056        T28: fidl::encoding::Encode<
12057                fidl::encoding::Vector<i64, 1>,
12058                fidl::encoding::DefaultFuchsiaResourceDialect,
12059            >,
12060        T29: fidl::encoding::Encode<
12061                fidl::encoding::Vector<u8, 1>,
12062                fidl::encoding::DefaultFuchsiaResourceDialect,
12063            >,
12064        T30: fidl::encoding::Encode<
12065                fidl::encoding::Vector<u16, 1>,
12066                fidl::encoding::DefaultFuchsiaResourceDialect,
12067            >,
12068        T31: fidl::encoding::Encode<
12069                fidl::encoding::Vector<u32, 1>,
12070                fidl::encoding::DefaultFuchsiaResourceDialect,
12071            >,
12072        T32: fidl::encoding::Encode<
12073                fidl::encoding::Vector<u64, 1>,
12074                fidl::encoding::DefaultFuchsiaResourceDialect,
12075            >,
12076        T33: fidl::encoding::Encode<
12077                fidl::encoding::Vector<f32, 1>,
12078                fidl::encoding::DefaultFuchsiaResourceDialect,
12079            >,
12080        T34: fidl::encoding::Encode<
12081                fidl::encoding::Vector<f64, 1>,
12082                fidl::encoding::DefaultFuchsiaResourceDialect,
12083            >,
12084        T35: fidl::encoding::Encode<
12085                fidl::encoding::Vector<
12086                    fidl::encoding::HandleType<
12087                        fidl::Handle,
12088                        { fidl::ObjectType::NONE.into_raw() },
12089                        2147483648,
12090                    >,
12091                    1,
12092                >,
12093                fidl::encoding::DefaultFuchsiaResourceDialect,
12094            >,
12095        T36: fidl::encoding::Encode<
12096                fidl::encoding::Vector<bool, 3>,
12097                fidl::encoding::DefaultFuchsiaResourceDialect,
12098            >,
12099        T37: fidl::encoding::Encode<
12100                fidl::encoding::Vector<i8, 3>,
12101                fidl::encoding::DefaultFuchsiaResourceDialect,
12102            >,
12103        T38: fidl::encoding::Encode<
12104                fidl::encoding::Vector<i16, 3>,
12105                fidl::encoding::DefaultFuchsiaResourceDialect,
12106            >,
12107        T39: fidl::encoding::Encode<
12108                fidl::encoding::Vector<i32, 3>,
12109                fidl::encoding::DefaultFuchsiaResourceDialect,
12110            >,
12111        T40: fidl::encoding::Encode<
12112                fidl::encoding::Vector<i64, 3>,
12113                fidl::encoding::DefaultFuchsiaResourceDialect,
12114            >,
12115        T41: fidl::encoding::Encode<
12116                fidl::encoding::Vector<u8, 3>,
12117                fidl::encoding::DefaultFuchsiaResourceDialect,
12118            >,
12119        T42: fidl::encoding::Encode<
12120                fidl::encoding::Vector<u16, 3>,
12121                fidl::encoding::DefaultFuchsiaResourceDialect,
12122            >,
12123        T43: fidl::encoding::Encode<
12124                fidl::encoding::Vector<u32, 3>,
12125                fidl::encoding::DefaultFuchsiaResourceDialect,
12126            >,
12127        T44: fidl::encoding::Encode<
12128                fidl::encoding::Vector<u64, 3>,
12129                fidl::encoding::DefaultFuchsiaResourceDialect,
12130            >,
12131        T45: fidl::encoding::Encode<
12132                fidl::encoding::Vector<f32, 3>,
12133                fidl::encoding::DefaultFuchsiaResourceDialect,
12134            >,
12135        T46: fidl::encoding::Encode<
12136                fidl::encoding::Vector<f64, 3>,
12137                fidl::encoding::DefaultFuchsiaResourceDialect,
12138            >,
12139        T47: fidl::encoding::Encode<
12140                fidl::encoding::Vector<
12141                    fidl::encoding::HandleType<
12142                        fidl::Handle,
12143                        { fidl::ObjectType::NONE.into_raw() },
12144                        2147483648,
12145                    >,
12146                    3,
12147                >,
12148                fidl::encoding::DefaultFuchsiaResourceDialect,
12149            >,
12150        T48: fidl::encoding::Encode<
12151                fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
12152                fidl::encoding::DefaultFuchsiaResourceDialect,
12153            >,
12154        T49: fidl::encoding::Encode<
12155                fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>,
12156                fidl::encoding::DefaultFuchsiaResourceDialect,
12157            >,
12158        T50: fidl::encoding::Encode<
12159                fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>,
12160                fidl::encoding::DefaultFuchsiaResourceDialect,
12161            >,
12162        T51: fidl::encoding::Encode<
12163                fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>,
12164                fidl::encoding::DefaultFuchsiaResourceDialect,
12165            >,
12166        T52: fidl::encoding::Encode<
12167                fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>,
12168                fidl::encoding::DefaultFuchsiaResourceDialect,
12169            >,
12170        T53: fidl::encoding::Encode<
12171                fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>,
12172                fidl::encoding::DefaultFuchsiaResourceDialect,
12173            >,
12174        T54: fidl::encoding::Encode<
12175                fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>,
12176                fidl::encoding::DefaultFuchsiaResourceDialect,
12177            >,
12178        T55: fidl::encoding::Encode<
12179                fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>,
12180                fidl::encoding::DefaultFuchsiaResourceDialect,
12181            >,
12182        T56: fidl::encoding::Encode<
12183                fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>,
12184                fidl::encoding::DefaultFuchsiaResourceDialect,
12185            >,
12186        T57: fidl::encoding::Encode<
12187                fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>,
12188                fidl::encoding::DefaultFuchsiaResourceDialect,
12189            >,
12190        T58: fidl::encoding::Encode<
12191                fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>,
12192                fidl::encoding::DefaultFuchsiaResourceDialect,
12193            >,
12194        T59: fidl::encoding::Encode<
12195                fidl::encoding::Vector<
12196                    fidl::encoding::Vector<
12197                        fidl::encoding::HandleType<
12198                            fidl::Handle,
12199                            { fidl::ObjectType::NONE.into_raw() },
12200                            2147483648,
12201                        >,
12202                        2,
12203                    >,
12204                    3,
12205                >,
12206                fidl::encoding::DefaultFuchsiaResourceDialect,
12207            >,
12208        T60: fidl::encoding::Encode<
12209                fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
12210                fidl::encoding::DefaultFuchsiaResourceDialect,
12211            >,
12212        T61: fidl::encoding::Encode<
12213                fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
12214                fidl::encoding::DefaultFuchsiaResourceDialect,
12215            >,
12216        T62: fidl::encoding::Encode<
12217                fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
12218                fidl::encoding::DefaultFuchsiaResourceDialect,
12219            >,
12220        T63: fidl::encoding::Encode<
12221                fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
12222                fidl::encoding::DefaultFuchsiaResourceDialect,
12223            >,
12224        T64: fidl::encoding::Encode<
12225                fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
12226                fidl::encoding::DefaultFuchsiaResourceDialect,
12227            >,
12228        T65: fidl::encoding::Encode<
12229                fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
12230                fidl::encoding::DefaultFuchsiaResourceDialect,
12231            >,
12232        T66: fidl::encoding::Encode<
12233                fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
12234                fidl::encoding::DefaultFuchsiaResourceDialect,
12235            >,
12236        T67: fidl::encoding::Encode<
12237                fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
12238                fidl::encoding::DefaultFuchsiaResourceDialect,
12239            >,
12240        T68: fidl::encoding::Encode<
12241                fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
12242                fidl::encoding::DefaultFuchsiaResourceDialect,
12243            >,
12244        T69: fidl::encoding::Encode<
12245                fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
12246                fidl::encoding::DefaultFuchsiaResourceDialect,
12247            >,
12248        T70: fidl::encoding::Encode<
12249                fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
12250                fidl::encoding::DefaultFuchsiaResourceDialect,
12251            >,
12252        T71: fidl::encoding::Encode<
12253                fidl::encoding::Optional<
12254                    fidl::encoding::Vector<
12255                        fidl::encoding::HandleType<
12256                            fidl::Handle,
12257                            { fidl::ObjectType::NONE.into_raw() },
12258                            2147483648,
12259                        >,
12260                        1,
12261                    >,
12262                >,
12263                fidl::encoding::DefaultFuchsiaResourceDialect,
12264            >,
12265        T72: fidl::encoding::Encode<
12266                fidl::encoding::Optional<
12267                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
12268                >,
12269                fidl::encoding::DefaultFuchsiaResourceDialect,
12270            >,
12271        T73: fidl::encoding::Encode<
12272                fidl::encoding::Optional<
12273                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
12274                >,
12275                fidl::encoding::DefaultFuchsiaResourceDialect,
12276            >,
12277        T74: fidl::encoding::Encode<
12278                fidl::encoding::Optional<
12279                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
12280                >,
12281                fidl::encoding::DefaultFuchsiaResourceDialect,
12282            >,
12283        T75: fidl::encoding::Encode<
12284                fidl::encoding::Optional<
12285                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
12286                >,
12287                fidl::encoding::DefaultFuchsiaResourceDialect,
12288            >,
12289        T76: fidl::encoding::Encode<
12290                fidl::encoding::Optional<
12291                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
12292                >,
12293                fidl::encoding::DefaultFuchsiaResourceDialect,
12294            >,
12295        T77: fidl::encoding::Encode<
12296                fidl::encoding::Optional<
12297                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
12298                >,
12299                fidl::encoding::DefaultFuchsiaResourceDialect,
12300            >,
12301        T78: fidl::encoding::Encode<
12302                fidl::encoding::Optional<
12303                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
12304                >,
12305                fidl::encoding::DefaultFuchsiaResourceDialect,
12306            >,
12307        T79: fidl::encoding::Encode<
12308                fidl::encoding::Optional<
12309                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
12310                >,
12311                fidl::encoding::DefaultFuchsiaResourceDialect,
12312            >,
12313        T80: fidl::encoding::Encode<
12314                fidl::encoding::Optional<
12315                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
12316                >,
12317                fidl::encoding::DefaultFuchsiaResourceDialect,
12318            >,
12319        T81: fidl::encoding::Encode<
12320                fidl::encoding::Optional<
12321                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
12322                >,
12323                fidl::encoding::DefaultFuchsiaResourceDialect,
12324            >,
12325        T82: fidl::encoding::Encode<
12326                fidl::encoding::Optional<
12327                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
12328                >,
12329                fidl::encoding::DefaultFuchsiaResourceDialect,
12330            >,
12331        T83: fidl::encoding::Encode<
12332                fidl::encoding::Optional<
12333                    fidl::encoding::UnboundedVector<
12334                        fidl::encoding::Vector<
12335                            fidl::encoding::HandleType<
12336                                fidl::Handle,
12337                                { fidl::ObjectType::NONE.into_raw() },
12338                                2147483648,
12339                            >,
12340                            2,
12341                        >,
12342                    >,
12343                >,
12344                fidl::encoding::DefaultFuchsiaResourceDialect,
12345            >,
12346        T84: fidl::encoding::Encode<
12347                fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
12348                fidl::encoding::DefaultFuchsiaResourceDialect,
12349            >,
12350        T85: fidl::encoding::Encode<
12351                fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
12352                fidl::encoding::DefaultFuchsiaResourceDialect,
12353            >,
12354        T86: fidl::encoding::Encode<
12355                fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
12356                fidl::encoding::DefaultFuchsiaResourceDialect,
12357            >,
12358        T87: fidl::encoding::Encode<
12359                fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
12360                fidl::encoding::DefaultFuchsiaResourceDialect,
12361            >,
12362        T88: fidl::encoding::Encode<
12363                fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
12364                fidl::encoding::DefaultFuchsiaResourceDialect,
12365            >,
12366        T89: fidl::encoding::Encode<
12367                fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
12368                fidl::encoding::DefaultFuchsiaResourceDialect,
12369            >,
12370        T90: fidl::encoding::Encode<
12371                fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
12372                fidl::encoding::DefaultFuchsiaResourceDialect,
12373            >,
12374        T91: fidl::encoding::Encode<
12375                fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
12376                fidl::encoding::DefaultFuchsiaResourceDialect,
12377            >,
12378        T92: fidl::encoding::Encode<
12379                fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
12380                fidl::encoding::DefaultFuchsiaResourceDialect,
12381            >,
12382        T93: fidl::encoding::Encode<
12383                fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
12384                fidl::encoding::DefaultFuchsiaResourceDialect,
12385            >,
12386        T94: fidl::encoding::Encode<
12387                fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
12388                fidl::encoding::DefaultFuchsiaResourceDialect,
12389            >,
12390        T95: fidl::encoding::Encode<
12391                fidl::encoding::Optional<
12392                    fidl::encoding::Vector<
12393                        fidl::encoding::HandleType<
12394                            fidl::Handle,
12395                            { fidl::ObjectType::NONE.into_raw() },
12396                            2147483648,
12397                        >,
12398                        1,
12399                    >,
12400                >,
12401                fidl::encoding::DefaultFuchsiaResourceDialect,
12402            >,
12403        T96: fidl::encoding::Encode<
12404                fidl::encoding::Optional<fidl::encoding::Vector<bool, 3>>,
12405                fidl::encoding::DefaultFuchsiaResourceDialect,
12406            >,
12407        T97: fidl::encoding::Encode<
12408                fidl::encoding::Optional<fidl::encoding::Vector<i8, 3>>,
12409                fidl::encoding::DefaultFuchsiaResourceDialect,
12410            >,
12411        T98: fidl::encoding::Encode<
12412                fidl::encoding::Optional<fidl::encoding::Vector<i16, 3>>,
12413                fidl::encoding::DefaultFuchsiaResourceDialect,
12414            >,
12415        T99: fidl::encoding::Encode<
12416                fidl::encoding::Optional<fidl::encoding::Vector<i32, 3>>,
12417                fidl::encoding::DefaultFuchsiaResourceDialect,
12418            >,
12419        T100: fidl::encoding::Encode<
12420                fidl::encoding::Optional<fidl::encoding::Vector<i64, 3>>,
12421                fidl::encoding::DefaultFuchsiaResourceDialect,
12422            >,
12423        T101: fidl::encoding::Encode<
12424                fidl::encoding::Optional<fidl::encoding::Vector<u8, 3>>,
12425                fidl::encoding::DefaultFuchsiaResourceDialect,
12426            >,
12427        T102: fidl::encoding::Encode<
12428                fidl::encoding::Optional<fidl::encoding::Vector<u16, 3>>,
12429                fidl::encoding::DefaultFuchsiaResourceDialect,
12430            >,
12431        T103: fidl::encoding::Encode<
12432                fidl::encoding::Optional<fidl::encoding::Vector<u32, 3>>,
12433                fidl::encoding::DefaultFuchsiaResourceDialect,
12434            >,
12435        T104: fidl::encoding::Encode<
12436                fidl::encoding::Optional<fidl::encoding::Vector<u64, 3>>,
12437                fidl::encoding::DefaultFuchsiaResourceDialect,
12438            >,
12439        T105: fidl::encoding::Encode<
12440                fidl::encoding::Optional<fidl::encoding::Vector<f32, 3>>,
12441                fidl::encoding::DefaultFuchsiaResourceDialect,
12442            >,
12443        T106: fidl::encoding::Encode<
12444                fidl::encoding::Optional<fidl::encoding::Vector<f64, 3>>,
12445                fidl::encoding::DefaultFuchsiaResourceDialect,
12446            >,
12447        T107: fidl::encoding::Encode<
12448                fidl::encoding::Optional<
12449                    fidl::encoding::Vector<
12450                        fidl::encoding::HandleType<
12451                            fidl::Handle,
12452                            { fidl::ObjectType::NONE.into_raw() },
12453                            2147483648,
12454                        >,
12455                        3,
12456                    >,
12457                >,
12458                fidl::encoding::DefaultFuchsiaResourceDialect,
12459            >,
12460        T108: fidl::encoding::Encode<
12461                fidl::encoding::Optional<
12462                    fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
12463                >,
12464                fidl::encoding::DefaultFuchsiaResourceDialect,
12465            >,
12466        T109: fidl::encoding::Encode<
12467                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>>,
12468                fidl::encoding::DefaultFuchsiaResourceDialect,
12469            >,
12470        T110: fidl::encoding::Encode<
12471                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>>,
12472                fidl::encoding::DefaultFuchsiaResourceDialect,
12473            >,
12474        T111: fidl::encoding::Encode<
12475                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>>,
12476                fidl::encoding::DefaultFuchsiaResourceDialect,
12477            >,
12478        T112: fidl::encoding::Encode<
12479                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>>,
12480                fidl::encoding::DefaultFuchsiaResourceDialect,
12481            >,
12482        T113: fidl::encoding::Encode<
12483                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>>,
12484                fidl::encoding::DefaultFuchsiaResourceDialect,
12485            >,
12486        T114: fidl::encoding::Encode<
12487                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>>,
12488                fidl::encoding::DefaultFuchsiaResourceDialect,
12489            >,
12490        T115: fidl::encoding::Encode<
12491                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>>,
12492                fidl::encoding::DefaultFuchsiaResourceDialect,
12493            >,
12494        T116: fidl::encoding::Encode<
12495                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>>,
12496                fidl::encoding::DefaultFuchsiaResourceDialect,
12497            >,
12498        T117: fidl::encoding::Encode<
12499                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>>,
12500                fidl::encoding::DefaultFuchsiaResourceDialect,
12501            >,
12502        T118: fidl::encoding::Encode<
12503                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>>,
12504                fidl::encoding::DefaultFuchsiaResourceDialect,
12505            >,
12506        T119: fidl::encoding::Encode<
12507                fidl::encoding::Optional<
12508                    fidl::encoding::Vector<
12509                        fidl::encoding::Vector<
12510                            fidl::encoding::HandleType<
12511                                fidl::Handle,
12512                                { fidl::ObjectType::NONE.into_raw() },
12513                                2147483648,
12514                            >,
12515                            2,
12516                        >,
12517                        3,
12518                    >,
12519                >,
12520                fidl::encoding::DefaultFuchsiaResourceDialect,
12521            >,
12522    > fidl::encoding::Encode<Vectors, fidl::encoding::DefaultFuchsiaResourceDialect>
12523        for (
12524            T0,
12525            T1,
12526            T2,
12527            T3,
12528            T4,
12529            T5,
12530            T6,
12531            T7,
12532            T8,
12533            T9,
12534            T10,
12535            T11,
12536            T12,
12537            T13,
12538            T14,
12539            T15,
12540            T16,
12541            T17,
12542            T18,
12543            T19,
12544            T20,
12545            T21,
12546            T22,
12547            T23,
12548            T24,
12549            T25,
12550            T26,
12551            T27,
12552            T28,
12553            T29,
12554            T30,
12555            T31,
12556            T32,
12557            T33,
12558            T34,
12559            T35,
12560            T36,
12561            T37,
12562            T38,
12563            T39,
12564            T40,
12565            T41,
12566            T42,
12567            T43,
12568            T44,
12569            T45,
12570            T46,
12571            T47,
12572            T48,
12573            T49,
12574            T50,
12575            T51,
12576            T52,
12577            T53,
12578            T54,
12579            T55,
12580            T56,
12581            T57,
12582            T58,
12583            T59,
12584            T60,
12585            T61,
12586            T62,
12587            T63,
12588            T64,
12589            T65,
12590            T66,
12591            T67,
12592            T68,
12593            T69,
12594            T70,
12595            T71,
12596            T72,
12597            T73,
12598            T74,
12599            T75,
12600            T76,
12601            T77,
12602            T78,
12603            T79,
12604            T80,
12605            T81,
12606            T82,
12607            T83,
12608            T84,
12609            T85,
12610            T86,
12611            T87,
12612            T88,
12613            T89,
12614            T90,
12615            T91,
12616            T92,
12617            T93,
12618            T94,
12619            T95,
12620            T96,
12621            T97,
12622            T98,
12623            T99,
12624            T100,
12625            T101,
12626            T102,
12627            T103,
12628            T104,
12629            T105,
12630            T106,
12631            T107,
12632            T108,
12633            T109,
12634            T110,
12635            T111,
12636            T112,
12637            T113,
12638            T114,
12639            T115,
12640            T116,
12641            T117,
12642            T118,
12643            T119,
12644        )
12645    {
12646        #[inline]
12647        unsafe fn encode(
12648            self,
12649            encoder: &mut fidl::encoding::Encoder<
12650                '_,
12651                fidl::encoding::DefaultFuchsiaResourceDialect,
12652            >,
12653            offset: usize,
12654            depth: fidl::encoding::Depth,
12655        ) -> fidl::Result<()> {
12656            encoder.debug_check_bounds::<Vectors>(offset);
12657            // Zero out padding regions. There's no need to apply masks
12658            // because the unmasked parts will be overwritten by fields.
12659            // Write the fields.
12660            self.0.encode(encoder, offset + 0, depth)?;
12661            self.1.encode(encoder, offset + 16, depth)?;
12662            self.2.encode(encoder, offset + 32, depth)?;
12663            self.3.encode(encoder, offset + 48, depth)?;
12664            self.4.encode(encoder, offset + 64, depth)?;
12665            self.5.encode(encoder, offset + 80, depth)?;
12666            self.6.encode(encoder, offset + 96, depth)?;
12667            self.7.encode(encoder, offset + 112, depth)?;
12668            self.8.encode(encoder, offset + 128, depth)?;
12669            self.9.encode(encoder, offset + 144, depth)?;
12670            self.10.encode(encoder, offset + 160, depth)?;
12671            self.11.encode(encoder, offset + 176, depth)?;
12672            self.12.encode(encoder, offset + 192, depth)?;
12673            self.13.encode(encoder, offset + 208, depth)?;
12674            self.14.encode(encoder, offset + 224, depth)?;
12675            self.15.encode(encoder, offset + 240, depth)?;
12676            self.16.encode(encoder, offset + 256, depth)?;
12677            self.17.encode(encoder, offset + 272, depth)?;
12678            self.18.encode(encoder, offset + 288, depth)?;
12679            self.19.encode(encoder, offset + 304, depth)?;
12680            self.20.encode(encoder, offset + 320, depth)?;
12681            self.21.encode(encoder, offset + 336, depth)?;
12682            self.22.encode(encoder, offset + 352, depth)?;
12683            self.23.encode(encoder, offset + 368, depth)?;
12684            self.24.encode(encoder, offset + 384, depth)?;
12685            self.25.encode(encoder, offset + 400, depth)?;
12686            self.26.encode(encoder, offset + 416, depth)?;
12687            self.27.encode(encoder, offset + 432, depth)?;
12688            self.28.encode(encoder, offset + 448, depth)?;
12689            self.29.encode(encoder, offset + 464, depth)?;
12690            self.30.encode(encoder, offset + 480, depth)?;
12691            self.31.encode(encoder, offset + 496, depth)?;
12692            self.32.encode(encoder, offset + 512, depth)?;
12693            self.33.encode(encoder, offset + 528, depth)?;
12694            self.34.encode(encoder, offset + 544, depth)?;
12695            self.35.encode(encoder, offset + 560, depth)?;
12696            self.36.encode(encoder, offset + 576, depth)?;
12697            self.37.encode(encoder, offset + 592, depth)?;
12698            self.38.encode(encoder, offset + 608, depth)?;
12699            self.39.encode(encoder, offset + 624, depth)?;
12700            self.40.encode(encoder, offset + 640, depth)?;
12701            self.41.encode(encoder, offset + 656, depth)?;
12702            self.42.encode(encoder, offset + 672, depth)?;
12703            self.43.encode(encoder, offset + 688, depth)?;
12704            self.44.encode(encoder, offset + 704, depth)?;
12705            self.45.encode(encoder, offset + 720, depth)?;
12706            self.46.encode(encoder, offset + 736, depth)?;
12707            self.47.encode(encoder, offset + 752, depth)?;
12708            self.48.encode(encoder, offset + 768, depth)?;
12709            self.49.encode(encoder, offset + 784, depth)?;
12710            self.50.encode(encoder, offset + 800, depth)?;
12711            self.51.encode(encoder, offset + 816, depth)?;
12712            self.52.encode(encoder, offset + 832, depth)?;
12713            self.53.encode(encoder, offset + 848, depth)?;
12714            self.54.encode(encoder, offset + 864, depth)?;
12715            self.55.encode(encoder, offset + 880, depth)?;
12716            self.56.encode(encoder, offset + 896, depth)?;
12717            self.57.encode(encoder, offset + 912, depth)?;
12718            self.58.encode(encoder, offset + 928, depth)?;
12719            self.59.encode(encoder, offset + 944, depth)?;
12720            self.60.encode(encoder, offset + 960, depth)?;
12721            self.61.encode(encoder, offset + 976, depth)?;
12722            self.62.encode(encoder, offset + 992, depth)?;
12723            self.63.encode(encoder, offset + 1008, depth)?;
12724            self.64.encode(encoder, offset + 1024, depth)?;
12725            self.65.encode(encoder, offset + 1040, depth)?;
12726            self.66.encode(encoder, offset + 1056, depth)?;
12727            self.67.encode(encoder, offset + 1072, depth)?;
12728            self.68.encode(encoder, offset + 1088, depth)?;
12729            self.69.encode(encoder, offset + 1104, depth)?;
12730            self.70.encode(encoder, offset + 1120, depth)?;
12731            self.71.encode(encoder, offset + 1136, depth)?;
12732            self.72.encode(encoder, offset + 1152, depth)?;
12733            self.73.encode(encoder, offset + 1168, depth)?;
12734            self.74.encode(encoder, offset + 1184, depth)?;
12735            self.75.encode(encoder, offset + 1200, depth)?;
12736            self.76.encode(encoder, offset + 1216, depth)?;
12737            self.77.encode(encoder, offset + 1232, depth)?;
12738            self.78.encode(encoder, offset + 1248, depth)?;
12739            self.79.encode(encoder, offset + 1264, depth)?;
12740            self.80.encode(encoder, offset + 1280, depth)?;
12741            self.81.encode(encoder, offset + 1296, depth)?;
12742            self.82.encode(encoder, offset + 1312, depth)?;
12743            self.83.encode(encoder, offset + 1328, depth)?;
12744            self.84.encode(encoder, offset + 1344, depth)?;
12745            self.85.encode(encoder, offset + 1360, depth)?;
12746            self.86.encode(encoder, offset + 1376, depth)?;
12747            self.87.encode(encoder, offset + 1392, depth)?;
12748            self.88.encode(encoder, offset + 1408, depth)?;
12749            self.89.encode(encoder, offset + 1424, depth)?;
12750            self.90.encode(encoder, offset + 1440, depth)?;
12751            self.91.encode(encoder, offset + 1456, depth)?;
12752            self.92.encode(encoder, offset + 1472, depth)?;
12753            self.93.encode(encoder, offset + 1488, depth)?;
12754            self.94.encode(encoder, offset + 1504, depth)?;
12755            self.95.encode(encoder, offset + 1520, depth)?;
12756            self.96.encode(encoder, offset + 1536, depth)?;
12757            self.97.encode(encoder, offset + 1552, depth)?;
12758            self.98.encode(encoder, offset + 1568, depth)?;
12759            self.99.encode(encoder, offset + 1584, depth)?;
12760            self.100.encode(encoder, offset + 1600, depth)?;
12761            self.101.encode(encoder, offset + 1616, depth)?;
12762            self.102.encode(encoder, offset + 1632, depth)?;
12763            self.103.encode(encoder, offset + 1648, depth)?;
12764            self.104.encode(encoder, offset + 1664, depth)?;
12765            self.105.encode(encoder, offset + 1680, depth)?;
12766            self.106.encode(encoder, offset + 1696, depth)?;
12767            self.107.encode(encoder, offset + 1712, depth)?;
12768            self.108.encode(encoder, offset + 1728, depth)?;
12769            self.109.encode(encoder, offset + 1744, depth)?;
12770            self.110.encode(encoder, offset + 1760, depth)?;
12771            self.111.encode(encoder, offset + 1776, depth)?;
12772            self.112.encode(encoder, offset + 1792, depth)?;
12773            self.113.encode(encoder, offset + 1808, depth)?;
12774            self.114.encode(encoder, offset + 1824, depth)?;
12775            self.115.encode(encoder, offset + 1840, depth)?;
12776            self.116.encode(encoder, offset + 1856, depth)?;
12777            self.117.encode(encoder, offset + 1872, depth)?;
12778            self.118.encode(encoder, offset + 1888, depth)?;
12779            self.119.encode(encoder, offset + 1904, depth)?;
12780            Ok(())
12781        }
12782    }
12783
12784    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Vectors {
12785        #[inline(always)]
12786        fn new_empty() -> Self {
12787            Self {
12788                b_0: fidl::new_empty!(
12789                    fidl::encoding::UnboundedVector<bool>,
12790                    fidl::encoding::DefaultFuchsiaResourceDialect
12791                ),
12792                i8_0: fidl::new_empty!(
12793                    fidl::encoding::UnboundedVector<i8>,
12794                    fidl::encoding::DefaultFuchsiaResourceDialect
12795                ),
12796                i16_0: fidl::new_empty!(
12797                    fidl::encoding::UnboundedVector<i16>,
12798                    fidl::encoding::DefaultFuchsiaResourceDialect
12799                ),
12800                i32_0: fidl::new_empty!(
12801                    fidl::encoding::UnboundedVector<i32>,
12802                    fidl::encoding::DefaultFuchsiaResourceDialect
12803                ),
12804                i64_0: fidl::new_empty!(
12805                    fidl::encoding::UnboundedVector<i64>,
12806                    fidl::encoding::DefaultFuchsiaResourceDialect
12807                ),
12808                u8_0: fidl::new_empty!(
12809                    fidl::encoding::UnboundedVector<u8>,
12810                    fidl::encoding::DefaultFuchsiaResourceDialect
12811                ),
12812                u16_0: fidl::new_empty!(
12813                    fidl::encoding::UnboundedVector<u16>,
12814                    fidl::encoding::DefaultFuchsiaResourceDialect
12815                ),
12816                u32_0: fidl::new_empty!(
12817                    fidl::encoding::UnboundedVector<u32>,
12818                    fidl::encoding::DefaultFuchsiaResourceDialect
12819                ),
12820                u64_0: fidl::new_empty!(
12821                    fidl::encoding::UnboundedVector<u64>,
12822                    fidl::encoding::DefaultFuchsiaResourceDialect
12823                ),
12824                f32_0: fidl::new_empty!(
12825                    fidl::encoding::UnboundedVector<f32>,
12826                    fidl::encoding::DefaultFuchsiaResourceDialect
12827                ),
12828                f64_0: fidl::new_empty!(
12829                    fidl::encoding::UnboundedVector<f64>,
12830                    fidl::encoding::DefaultFuchsiaResourceDialect
12831                ),
12832                handle_0: fidl::new_empty!(
12833                    fidl::encoding::UnboundedVector<
12834                        fidl::encoding::HandleType<
12835                            fidl::Handle,
12836                            { fidl::ObjectType::NONE.into_raw() },
12837                            2147483648,
12838                        >,
12839                    >,
12840                    fidl::encoding::DefaultFuchsiaResourceDialect
12841                ),
12842                b_1: fidl::new_empty!(
12843                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
12844                    fidl::encoding::DefaultFuchsiaResourceDialect
12845                ),
12846                i8_1: fidl::new_empty!(
12847                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
12848                    fidl::encoding::DefaultFuchsiaResourceDialect
12849                ),
12850                i16_1: fidl::new_empty!(
12851                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
12852                    fidl::encoding::DefaultFuchsiaResourceDialect
12853                ),
12854                i32_1: fidl::new_empty!(
12855                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
12856                    fidl::encoding::DefaultFuchsiaResourceDialect
12857                ),
12858                i64_1: fidl::new_empty!(
12859                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
12860                    fidl::encoding::DefaultFuchsiaResourceDialect
12861                ),
12862                u8_1: fidl::new_empty!(
12863                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
12864                    fidl::encoding::DefaultFuchsiaResourceDialect
12865                ),
12866                u16_1: fidl::new_empty!(
12867                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
12868                    fidl::encoding::DefaultFuchsiaResourceDialect
12869                ),
12870                u32_1: fidl::new_empty!(
12871                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
12872                    fidl::encoding::DefaultFuchsiaResourceDialect
12873                ),
12874                u64_1: fidl::new_empty!(
12875                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
12876                    fidl::encoding::DefaultFuchsiaResourceDialect
12877                ),
12878                f32_1: fidl::new_empty!(
12879                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
12880                    fidl::encoding::DefaultFuchsiaResourceDialect
12881                ),
12882                f64_1: fidl::new_empty!(
12883                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
12884                    fidl::encoding::DefaultFuchsiaResourceDialect
12885                ),
12886                handle_1: fidl::new_empty!(
12887                    fidl::encoding::UnboundedVector<
12888                        fidl::encoding::Vector<
12889                            fidl::encoding::HandleType<
12890                                fidl::Handle,
12891                                { fidl::ObjectType::NONE.into_raw() },
12892                                2147483648,
12893                            >,
12894                            2,
12895                        >,
12896                    >,
12897                    fidl::encoding::DefaultFuchsiaResourceDialect
12898                ),
12899                b_sized_0: fidl::new_empty!(fidl::encoding::Vector<bool, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12900                i8_sized_0: fidl::new_empty!(fidl::encoding::Vector<i8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12901                i16_sized_0: fidl::new_empty!(fidl::encoding::Vector<i16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12902                i32_sized_0: fidl::new_empty!(fidl::encoding::Vector<i32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12903                i64_sized_0: fidl::new_empty!(fidl::encoding::Vector<i64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12904                u8_sized_0: fidl::new_empty!(fidl::encoding::Vector<u8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12905                u16_sized_0: fidl::new_empty!(fidl::encoding::Vector<u16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12906                u32_sized_0: fidl::new_empty!(fidl::encoding::Vector<u32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12907                u64_sized_0: fidl::new_empty!(fidl::encoding::Vector<u64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12908                f32_sized_0: fidl::new_empty!(fidl::encoding::Vector<f32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12909                f64_sized_0: fidl::new_empty!(fidl::encoding::Vector<f64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12910                handle_sized_0: fidl::new_empty!(
12911                    fidl::encoding::Vector<
12912                        fidl::encoding::HandleType<
12913                            fidl::Handle,
12914                            { fidl::ObjectType::NONE.into_raw() },
12915                            2147483648,
12916                        >,
12917                        1,
12918                    >,
12919                    fidl::encoding::DefaultFuchsiaResourceDialect
12920                ),
12921                b_sized_1: fidl::new_empty!(fidl::encoding::Vector<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12922                i8_sized_1: fidl::new_empty!(fidl::encoding::Vector<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12923                i16_sized_1: fidl::new_empty!(fidl::encoding::Vector<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12924                i32_sized_1: fidl::new_empty!(fidl::encoding::Vector<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12925                i64_sized_1: fidl::new_empty!(fidl::encoding::Vector<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12926                u8_sized_1: fidl::new_empty!(fidl::encoding::Vector<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12927                u16_sized_1: fidl::new_empty!(fidl::encoding::Vector<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12928                u32_sized_1: fidl::new_empty!(fidl::encoding::Vector<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12929                u64_sized_1: fidl::new_empty!(fidl::encoding::Vector<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12930                f32_sized_1: fidl::new_empty!(fidl::encoding::Vector<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12931                f64_sized_1: fidl::new_empty!(fidl::encoding::Vector<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12932                handle_sized_1: fidl::new_empty!(
12933                    fidl::encoding::Vector<
12934                        fidl::encoding::HandleType<
12935                            fidl::Handle,
12936                            { fidl::ObjectType::NONE.into_raw() },
12937                            2147483648,
12938                        >,
12939                        3,
12940                    >,
12941                    fidl::encoding::DefaultFuchsiaResourceDialect
12942                ),
12943                b_sized_2: fidl::new_empty!(
12944                    fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
12945                    fidl::encoding::DefaultFuchsiaResourceDialect
12946                ),
12947                i8_sized_2: fidl::new_empty!(
12948                    fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>,
12949                    fidl::encoding::DefaultFuchsiaResourceDialect
12950                ),
12951                i16_sized_2: fidl::new_empty!(
12952                    fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>,
12953                    fidl::encoding::DefaultFuchsiaResourceDialect
12954                ),
12955                i32_sized_2: fidl::new_empty!(
12956                    fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>,
12957                    fidl::encoding::DefaultFuchsiaResourceDialect
12958                ),
12959                i64_sized_2: fidl::new_empty!(
12960                    fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>,
12961                    fidl::encoding::DefaultFuchsiaResourceDialect
12962                ),
12963                u8_sized_2: fidl::new_empty!(
12964                    fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>,
12965                    fidl::encoding::DefaultFuchsiaResourceDialect
12966                ),
12967                u16_sized_2: fidl::new_empty!(
12968                    fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>,
12969                    fidl::encoding::DefaultFuchsiaResourceDialect
12970                ),
12971                u32_sized_2: fidl::new_empty!(
12972                    fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>,
12973                    fidl::encoding::DefaultFuchsiaResourceDialect
12974                ),
12975                u64_sized_2: fidl::new_empty!(
12976                    fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>,
12977                    fidl::encoding::DefaultFuchsiaResourceDialect
12978                ),
12979                f32_sized_2: fidl::new_empty!(
12980                    fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>,
12981                    fidl::encoding::DefaultFuchsiaResourceDialect
12982                ),
12983                f64_sized_2: fidl::new_empty!(
12984                    fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>,
12985                    fidl::encoding::DefaultFuchsiaResourceDialect
12986                ),
12987                handle_sized_2: fidl::new_empty!(
12988                    fidl::encoding::Vector<
12989                        fidl::encoding::Vector<
12990                            fidl::encoding::HandleType<
12991                                fidl::Handle,
12992                                { fidl::ObjectType::NONE.into_raw() },
12993                                2147483648,
12994                            >,
12995                            2,
12996                        >,
12997                        3,
12998                    >,
12999                    fidl::encoding::DefaultFuchsiaResourceDialect
13000                ),
13001                b_nullable_0: fidl::new_empty!(
13002                    fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
13003                    fidl::encoding::DefaultFuchsiaResourceDialect
13004                ),
13005                i8_nullable_0: fidl::new_empty!(
13006                    fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
13007                    fidl::encoding::DefaultFuchsiaResourceDialect
13008                ),
13009                i16_nullable_0: fidl::new_empty!(
13010                    fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
13011                    fidl::encoding::DefaultFuchsiaResourceDialect
13012                ),
13013                i32_nullable_0: fidl::new_empty!(
13014                    fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
13015                    fidl::encoding::DefaultFuchsiaResourceDialect
13016                ),
13017                i64_nullable_0: fidl::new_empty!(
13018                    fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
13019                    fidl::encoding::DefaultFuchsiaResourceDialect
13020                ),
13021                u8_nullable_0: fidl::new_empty!(
13022                    fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
13023                    fidl::encoding::DefaultFuchsiaResourceDialect
13024                ),
13025                u16_nullable_0: fidl::new_empty!(
13026                    fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
13027                    fidl::encoding::DefaultFuchsiaResourceDialect
13028                ),
13029                u32_nullable_0: fidl::new_empty!(
13030                    fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
13031                    fidl::encoding::DefaultFuchsiaResourceDialect
13032                ),
13033                u64_nullable_0: fidl::new_empty!(
13034                    fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
13035                    fidl::encoding::DefaultFuchsiaResourceDialect
13036                ),
13037                f32_nullable_0: fidl::new_empty!(
13038                    fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
13039                    fidl::encoding::DefaultFuchsiaResourceDialect
13040                ),
13041                f64_nullable_0: fidl::new_empty!(
13042                    fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
13043                    fidl::encoding::DefaultFuchsiaResourceDialect
13044                ),
13045                handle_nullable_0: fidl::new_empty!(
13046                    fidl::encoding::Optional<
13047                        fidl::encoding::Vector<
13048                            fidl::encoding::HandleType<
13049                                fidl::Handle,
13050                                { fidl::ObjectType::NONE.into_raw() },
13051                                2147483648,
13052                            >,
13053                            1,
13054                        >,
13055                    >,
13056                    fidl::encoding::DefaultFuchsiaResourceDialect
13057                ),
13058                b_nullable_1: fidl::new_empty!(
13059                    fidl::encoding::Optional<
13060                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
13061                    >,
13062                    fidl::encoding::DefaultFuchsiaResourceDialect
13063                ),
13064                i8_nullable_1: fidl::new_empty!(
13065                    fidl::encoding::Optional<
13066                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
13067                    >,
13068                    fidl::encoding::DefaultFuchsiaResourceDialect
13069                ),
13070                i16_nullable_1: fidl::new_empty!(
13071                    fidl::encoding::Optional<
13072                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
13073                    >,
13074                    fidl::encoding::DefaultFuchsiaResourceDialect
13075                ),
13076                i32_nullable_1: fidl::new_empty!(
13077                    fidl::encoding::Optional<
13078                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
13079                    >,
13080                    fidl::encoding::DefaultFuchsiaResourceDialect
13081                ),
13082                i64_nullable_1: fidl::new_empty!(
13083                    fidl::encoding::Optional<
13084                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
13085                    >,
13086                    fidl::encoding::DefaultFuchsiaResourceDialect
13087                ),
13088                u8_nullable_1: fidl::new_empty!(
13089                    fidl::encoding::Optional<
13090                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
13091                    >,
13092                    fidl::encoding::DefaultFuchsiaResourceDialect
13093                ),
13094                u16_nullable_1: fidl::new_empty!(
13095                    fidl::encoding::Optional<
13096                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
13097                    >,
13098                    fidl::encoding::DefaultFuchsiaResourceDialect
13099                ),
13100                u32_nullable_1: fidl::new_empty!(
13101                    fidl::encoding::Optional<
13102                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
13103                    >,
13104                    fidl::encoding::DefaultFuchsiaResourceDialect
13105                ),
13106                u64_nullable_1: fidl::new_empty!(
13107                    fidl::encoding::Optional<
13108                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
13109                    >,
13110                    fidl::encoding::DefaultFuchsiaResourceDialect
13111                ),
13112                f32_nullable_1: fidl::new_empty!(
13113                    fidl::encoding::Optional<
13114                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
13115                    >,
13116                    fidl::encoding::DefaultFuchsiaResourceDialect
13117                ),
13118                f64_nullable_1: fidl::new_empty!(
13119                    fidl::encoding::Optional<
13120                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
13121                    >,
13122                    fidl::encoding::DefaultFuchsiaResourceDialect
13123                ),
13124                handle_nullable_1: fidl::new_empty!(
13125                    fidl::encoding::Optional<
13126                        fidl::encoding::UnboundedVector<
13127                            fidl::encoding::Vector<
13128                                fidl::encoding::HandleType<
13129                                    fidl::Handle,
13130                                    { fidl::ObjectType::NONE.into_raw() },
13131                                    2147483648,
13132                                >,
13133                                2,
13134                            >,
13135                        >,
13136                    >,
13137                    fidl::encoding::DefaultFuchsiaResourceDialect
13138                ),
13139                b_nullable_sized_0: fidl::new_empty!(
13140                    fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
13141                    fidl::encoding::DefaultFuchsiaResourceDialect
13142                ),
13143                i8_nullable_sized_0: fidl::new_empty!(
13144                    fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
13145                    fidl::encoding::DefaultFuchsiaResourceDialect
13146                ),
13147                i16_nullable_sized_0: fidl::new_empty!(
13148                    fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
13149                    fidl::encoding::DefaultFuchsiaResourceDialect
13150                ),
13151                i32_nullable_sized_0: fidl::new_empty!(
13152                    fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
13153                    fidl::encoding::DefaultFuchsiaResourceDialect
13154                ),
13155                i64_nullable_sized_0: fidl::new_empty!(
13156                    fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
13157                    fidl::encoding::DefaultFuchsiaResourceDialect
13158                ),
13159                u8_nullable_sized_0: fidl::new_empty!(
13160                    fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
13161                    fidl::encoding::DefaultFuchsiaResourceDialect
13162                ),
13163                u16_nullable_sized_0: fidl::new_empty!(
13164                    fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
13165                    fidl::encoding::DefaultFuchsiaResourceDialect
13166                ),
13167                u32_nullable_sized_0: fidl::new_empty!(
13168                    fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
13169                    fidl::encoding::DefaultFuchsiaResourceDialect
13170                ),
13171                u64_nullable_sized_0: fidl::new_empty!(
13172                    fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
13173                    fidl::encoding::DefaultFuchsiaResourceDialect
13174                ),
13175                f32_nullable_sized_0: fidl::new_empty!(
13176                    fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
13177                    fidl::encoding::DefaultFuchsiaResourceDialect
13178                ),
13179                f64_nullable_sized_0: fidl::new_empty!(
13180                    fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
13181                    fidl::encoding::DefaultFuchsiaResourceDialect
13182                ),
13183                handle_nullable_sized_0: fidl::new_empty!(
13184                    fidl::encoding::Optional<
13185                        fidl::encoding::Vector<
13186                            fidl::encoding::HandleType<
13187                                fidl::Handle,
13188                                { fidl::ObjectType::NONE.into_raw() },
13189                                2147483648,
13190                            >,
13191                            1,
13192                        >,
13193                    >,
13194                    fidl::encoding::DefaultFuchsiaResourceDialect
13195                ),
13196                b_nullable_sized_1: fidl::new_empty!(
13197                    fidl::encoding::Optional<fidl::encoding::Vector<bool, 3>>,
13198                    fidl::encoding::DefaultFuchsiaResourceDialect
13199                ),
13200                i8_nullable_sized_1: fidl::new_empty!(
13201                    fidl::encoding::Optional<fidl::encoding::Vector<i8, 3>>,
13202                    fidl::encoding::DefaultFuchsiaResourceDialect
13203                ),
13204                i16_nullable_sized_1: fidl::new_empty!(
13205                    fidl::encoding::Optional<fidl::encoding::Vector<i16, 3>>,
13206                    fidl::encoding::DefaultFuchsiaResourceDialect
13207                ),
13208                i32_nullable_sized_1: fidl::new_empty!(
13209                    fidl::encoding::Optional<fidl::encoding::Vector<i32, 3>>,
13210                    fidl::encoding::DefaultFuchsiaResourceDialect
13211                ),
13212                i64_nullable_sized_1: fidl::new_empty!(
13213                    fidl::encoding::Optional<fidl::encoding::Vector<i64, 3>>,
13214                    fidl::encoding::DefaultFuchsiaResourceDialect
13215                ),
13216                u8_nullable_sized_1: fidl::new_empty!(
13217                    fidl::encoding::Optional<fidl::encoding::Vector<u8, 3>>,
13218                    fidl::encoding::DefaultFuchsiaResourceDialect
13219                ),
13220                u16_nullable_sized_1: fidl::new_empty!(
13221                    fidl::encoding::Optional<fidl::encoding::Vector<u16, 3>>,
13222                    fidl::encoding::DefaultFuchsiaResourceDialect
13223                ),
13224                u32_nullable_sized_1: fidl::new_empty!(
13225                    fidl::encoding::Optional<fidl::encoding::Vector<u32, 3>>,
13226                    fidl::encoding::DefaultFuchsiaResourceDialect
13227                ),
13228                u64_nullable_sized_1: fidl::new_empty!(
13229                    fidl::encoding::Optional<fidl::encoding::Vector<u64, 3>>,
13230                    fidl::encoding::DefaultFuchsiaResourceDialect
13231                ),
13232                f32_nullable_sized_1: fidl::new_empty!(
13233                    fidl::encoding::Optional<fidl::encoding::Vector<f32, 3>>,
13234                    fidl::encoding::DefaultFuchsiaResourceDialect
13235                ),
13236                f64_nullable_sized_1: fidl::new_empty!(
13237                    fidl::encoding::Optional<fidl::encoding::Vector<f64, 3>>,
13238                    fidl::encoding::DefaultFuchsiaResourceDialect
13239                ),
13240                handle_nullable_sized_1: fidl::new_empty!(
13241                    fidl::encoding::Optional<
13242                        fidl::encoding::Vector<
13243                            fidl::encoding::HandleType<
13244                                fidl::Handle,
13245                                { fidl::ObjectType::NONE.into_raw() },
13246                                2147483648,
13247                            >,
13248                            3,
13249                        >,
13250                    >,
13251                    fidl::encoding::DefaultFuchsiaResourceDialect
13252                ),
13253                b_nullable_sized_2: fidl::new_empty!(
13254                    fidl::encoding::Optional<
13255                        fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
13256                    >,
13257                    fidl::encoding::DefaultFuchsiaResourceDialect
13258                ),
13259                i8_nullable_sized_2: fidl::new_empty!(
13260                    fidl::encoding::Optional<
13261                        fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>,
13262                    >,
13263                    fidl::encoding::DefaultFuchsiaResourceDialect
13264                ),
13265                i16_nullable_sized_2: fidl::new_empty!(
13266                    fidl::encoding::Optional<
13267                        fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>,
13268                    >,
13269                    fidl::encoding::DefaultFuchsiaResourceDialect
13270                ),
13271                i32_nullable_sized_2: fidl::new_empty!(
13272                    fidl::encoding::Optional<
13273                        fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>,
13274                    >,
13275                    fidl::encoding::DefaultFuchsiaResourceDialect
13276                ),
13277                i64_nullable_sized_2: fidl::new_empty!(
13278                    fidl::encoding::Optional<
13279                        fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>,
13280                    >,
13281                    fidl::encoding::DefaultFuchsiaResourceDialect
13282                ),
13283                u8_nullable_sized_2: fidl::new_empty!(
13284                    fidl::encoding::Optional<
13285                        fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>,
13286                    >,
13287                    fidl::encoding::DefaultFuchsiaResourceDialect
13288                ),
13289                u16_nullable_sized_2: fidl::new_empty!(
13290                    fidl::encoding::Optional<
13291                        fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>,
13292                    >,
13293                    fidl::encoding::DefaultFuchsiaResourceDialect
13294                ),
13295                u32_nullable_sized_2: fidl::new_empty!(
13296                    fidl::encoding::Optional<
13297                        fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>,
13298                    >,
13299                    fidl::encoding::DefaultFuchsiaResourceDialect
13300                ),
13301                u64_nullable_sized_2: fidl::new_empty!(
13302                    fidl::encoding::Optional<
13303                        fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>,
13304                    >,
13305                    fidl::encoding::DefaultFuchsiaResourceDialect
13306                ),
13307                f32_nullable_sized_2: fidl::new_empty!(
13308                    fidl::encoding::Optional<
13309                        fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>,
13310                    >,
13311                    fidl::encoding::DefaultFuchsiaResourceDialect
13312                ),
13313                f64_nullable_sized_2: fidl::new_empty!(
13314                    fidl::encoding::Optional<
13315                        fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>,
13316                    >,
13317                    fidl::encoding::DefaultFuchsiaResourceDialect
13318                ),
13319                handle_nullable_sized_2: fidl::new_empty!(
13320                    fidl::encoding::Optional<
13321                        fidl::encoding::Vector<
13322                            fidl::encoding::Vector<
13323                                fidl::encoding::HandleType<
13324                                    fidl::Handle,
13325                                    { fidl::ObjectType::NONE.into_raw() },
13326                                    2147483648,
13327                                >,
13328                                2,
13329                            >,
13330                            3,
13331                        >,
13332                    >,
13333                    fidl::encoding::DefaultFuchsiaResourceDialect
13334                ),
13335            }
13336        }
13337
13338        #[inline]
13339        unsafe fn decode(
13340            &mut self,
13341            decoder: &mut fidl::encoding::Decoder<
13342                '_,
13343                fidl::encoding::DefaultFuchsiaResourceDialect,
13344            >,
13345            offset: usize,
13346            _depth: fidl::encoding::Depth,
13347        ) -> fidl::Result<()> {
13348            decoder.debug_check_bounds::<Self>(offset);
13349            // Verify that padding bytes are zero.
13350            fidl::decode!(
13351                fidl::encoding::UnboundedVector<bool>,
13352                fidl::encoding::DefaultFuchsiaResourceDialect,
13353                &mut self.b_0,
13354                decoder,
13355                offset + 0,
13356                _depth
13357            )?;
13358            fidl::decode!(
13359                fidl::encoding::UnboundedVector<i8>,
13360                fidl::encoding::DefaultFuchsiaResourceDialect,
13361                &mut self.i8_0,
13362                decoder,
13363                offset + 16,
13364                _depth
13365            )?;
13366            fidl::decode!(
13367                fidl::encoding::UnboundedVector<i16>,
13368                fidl::encoding::DefaultFuchsiaResourceDialect,
13369                &mut self.i16_0,
13370                decoder,
13371                offset + 32,
13372                _depth
13373            )?;
13374            fidl::decode!(
13375                fidl::encoding::UnboundedVector<i32>,
13376                fidl::encoding::DefaultFuchsiaResourceDialect,
13377                &mut self.i32_0,
13378                decoder,
13379                offset + 48,
13380                _depth
13381            )?;
13382            fidl::decode!(
13383                fidl::encoding::UnboundedVector<i64>,
13384                fidl::encoding::DefaultFuchsiaResourceDialect,
13385                &mut self.i64_0,
13386                decoder,
13387                offset + 64,
13388                _depth
13389            )?;
13390            fidl::decode!(
13391                fidl::encoding::UnboundedVector<u8>,
13392                fidl::encoding::DefaultFuchsiaResourceDialect,
13393                &mut self.u8_0,
13394                decoder,
13395                offset + 80,
13396                _depth
13397            )?;
13398            fidl::decode!(
13399                fidl::encoding::UnboundedVector<u16>,
13400                fidl::encoding::DefaultFuchsiaResourceDialect,
13401                &mut self.u16_0,
13402                decoder,
13403                offset + 96,
13404                _depth
13405            )?;
13406            fidl::decode!(
13407                fidl::encoding::UnboundedVector<u32>,
13408                fidl::encoding::DefaultFuchsiaResourceDialect,
13409                &mut self.u32_0,
13410                decoder,
13411                offset + 112,
13412                _depth
13413            )?;
13414            fidl::decode!(
13415                fidl::encoding::UnboundedVector<u64>,
13416                fidl::encoding::DefaultFuchsiaResourceDialect,
13417                &mut self.u64_0,
13418                decoder,
13419                offset + 128,
13420                _depth
13421            )?;
13422            fidl::decode!(
13423                fidl::encoding::UnboundedVector<f32>,
13424                fidl::encoding::DefaultFuchsiaResourceDialect,
13425                &mut self.f32_0,
13426                decoder,
13427                offset + 144,
13428                _depth
13429            )?;
13430            fidl::decode!(
13431                fidl::encoding::UnboundedVector<f64>,
13432                fidl::encoding::DefaultFuchsiaResourceDialect,
13433                &mut self.f64_0,
13434                decoder,
13435                offset + 160,
13436                _depth
13437            )?;
13438            fidl::decode!(
13439                fidl::encoding::UnboundedVector<
13440                    fidl::encoding::HandleType<
13441                        fidl::Handle,
13442                        { fidl::ObjectType::NONE.into_raw() },
13443                        2147483648,
13444                    >,
13445                >,
13446                fidl::encoding::DefaultFuchsiaResourceDialect,
13447                &mut self.handle_0,
13448                decoder,
13449                offset + 176,
13450                _depth
13451            )?;
13452            fidl::decode!(
13453                fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
13454                fidl::encoding::DefaultFuchsiaResourceDialect,
13455                &mut self.b_1,
13456                decoder,
13457                offset + 192,
13458                _depth
13459            )?;
13460            fidl::decode!(
13461                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
13462                fidl::encoding::DefaultFuchsiaResourceDialect,
13463                &mut self.i8_1,
13464                decoder,
13465                offset + 208,
13466                _depth
13467            )?;
13468            fidl::decode!(
13469                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
13470                fidl::encoding::DefaultFuchsiaResourceDialect,
13471                &mut self.i16_1,
13472                decoder,
13473                offset + 224,
13474                _depth
13475            )?;
13476            fidl::decode!(
13477                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
13478                fidl::encoding::DefaultFuchsiaResourceDialect,
13479                &mut self.i32_1,
13480                decoder,
13481                offset + 240,
13482                _depth
13483            )?;
13484            fidl::decode!(
13485                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
13486                fidl::encoding::DefaultFuchsiaResourceDialect,
13487                &mut self.i64_1,
13488                decoder,
13489                offset + 256,
13490                _depth
13491            )?;
13492            fidl::decode!(
13493                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
13494                fidl::encoding::DefaultFuchsiaResourceDialect,
13495                &mut self.u8_1,
13496                decoder,
13497                offset + 272,
13498                _depth
13499            )?;
13500            fidl::decode!(
13501                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
13502                fidl::encoding::DefaultFuchsiaResourceDialect,
13503                &mut self.u16_1,
13504                decoder,
13505                offset + 288,
13506                _depth
13507            )?;
13508            fidl::decode!(
13509                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
13510                fidl::encoding::DefaultFuchsiaResourceDialect,
13511                &mut self.u32_1,
13512                decoder,
13513                offset + 304,
13514                _depth
13515            )?;
13516            fidl::decode!(
13517                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
13518                fidl::encoding::DefaultFuchsiaResourceDialect,
13519                &mut self.u64_1,
13520                decoder,
13521                offset + 320,
13522                _depth
13523            )?;
13524            fidl::decode!(
13525                fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
13526                fidl::encoding::DefaultFuchsiaResourceDialect,
13527                &mut self.f32_1,
13528                decoder,
13529                offset + 336,
13530                _depth
13531            )?;
13532            fidl::decode!(
13533                fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
13534                fidl::encoding::DefaultFuchsiaResourceDialect,
13535                &mut self.f64_1,
13536                decoder,
13537                offset + 352,
13538                _depth
13539            )?;
13540            fidl::decode!(
13541                fidl::encoding::UnboundedVector<
13542                    fidl::encoding::Vector<
13543                        fidl::encoding::HandleType<
13544                            fidl::Handle,
13545                            { fidl::ObjectType::NONE.into_raw() },
13546                            2147483648,
13547                        >,
13548                        2,
13549                    >,
13550                >,
13551                fidl::encoding::DefaultFuchsiaResourceDialect,
13552                &mut self.handle_1,
13553                decoder,
13554                offset + 368,
13555                _depth
13556            )?;
13557            fidl::decode!(fidl::encoding::Vector<bool, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.b_sized_0, decoder, offset + 384, _depth)?;
13558            fidl::decode!(fidl::encoding::Vector<i8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i8_sized_0, decoder, offset + 400, _depth)?;
13559            fidl::decode!(fidl::encoding::Vector<i16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i16_sized_0, decoder, offset + 416, _depth)?;
13560            fidl::decode!(fidl::encoding::Vector<i32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i32_sized_0, decoder, offset + 432, _depth)?;
13561            fidl::decode!(fidl::encoding::Vector<i64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i64_sized_0, decoder, offset + 448, _depth)?;
13562            fidl::decode!(fidl::encoding::Vector<u8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u8_sized_0, decoder, offset + 464, _depth)?;
13563            fidl::decode!(fidl::encoding::Vector<u16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u16_sized_0, decoder, offset + 480, _depth)?;
13564            fidl::decode!(fidl::encoding::Vector<u32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u32_sized_0, decoder, offset + 496, _depth)?;
13565            fidl::decode!(fidl::encoding::Vector<u64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u64_sized_0, decoder, offset + 512, _depth)?;
13566            fidl::decode!(fidl::encoding::Vector<f32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f32_sized_0, decoder, offset + 528, _depth)?;
13567            fidl::decode!(fidl::encoding::Vector<f64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f64_sized_0, decoder, offset + 544, _depth)?;
13568            fidl::decode!(
13569                fidl::encoding::Vector<
13570                    fidl::encoding::HandleType<
13571                        fidl::Handle,
13572                        { fidl::ObjectType::NONE.into_raw() },
13573                        2147483648,
13574                    >,
13575                    1,
13576                >,
13577                fidl::encoding::DefaultFuchsiaResourceDialect,
13578                &mut self.handle_sized_0,
13579                decoder,
13580                offset + 560,
13581                _depth
13582            )?;
13583            fidl::decode!(fidl::encoding::Vector<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.b_sized_1, decoder, offset + 576, _depth)?;
13584            fidl::decode!(fidl::encoding::Vector<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i8_sized_1, decoder, offset + 592, _depth)?;
13585            fidl::decode!(fidl::encoding::Vector<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i16_sized_1, decoder, offset + 608, _depth)?;
13586            fidl::decode!(fidl::encoding::Vector<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i32_sized_1, decoder, offset + 624, _depth)?;
13587            fidl::decode!(fidl::encoding::Vector<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i64_sized_1, decoder, offset + 640, _depth)?;
13588            fidl::decode!(fidl::encoding::Vector<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u8_sized_1, decoder, offset + 656, _depth)?;
13589            fidl::decode!(fidl::encoding::Vector<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u16_sized_1, decoder, offset + 672, _depth)?;
13590            fidl::decode!(fidl::encoding::Vector<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u32_sized_1, decoder, offset + 688, _depth)?;
13591            fidl::decode!(fidl::encoding::Vector<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u64_sized_1, decoder, offset + 704, _depth)?;
13592            fidl::decode!(fidl::encoding::Vector<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f32_sized_1, decoder, offset + 720, _depth)?;
13593            fidl::decode!(fidl::encoding::Vector<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f64_sized_1, decoder, offset + 736, _depth)?;
13594            fidl::decode!(
13595                fidl::encoding::Vector<
13596                    fidl::encoding::HandleType<
13597                        fidl::Handle,
13598                        { fidl::ObjectType::NONE.into_raw() },
13599                        2147483648,
13600                    >,
13601                    3,
13602                >,
13603                fidl::encoding::DefaultFuchsiaResourceDialect,
13604                &mut self.handle_sized_1,
13605                decoder,
13606                offset + 752,
13607                _depth
13608            )?;
13609            fidl::decode!(
13610                fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
13611                fidl::encoding::DefaultFuchsiaResourceDialect,
13612                &mut self.b_sized_2,
13613                decoder,
13614                offset + 768,
13615                _depth
13616            )?;
13617            fidl::decode!(
13618                fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>,
13619                fidl::encoding::DefaultFuchsiaResourceDialect,
13620                &mut self.i8_sized_2,
13621                decoder,
13622                offset + 784,
13623                _depth
13624            )?;
13625            fidl::decode!(
13626                fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>,
13627                fidl::encoding::DefaultFuchsiaResourceDialect,
13628                &mut self.i16_sized_2,
13629                decoder,
13630                offset + 800,
13631                _depth
13632            )?;
13633            fidl::decode!(
13634                fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>,
13635                fidl::encoding::DefaultFuchsiaResourceDialect,
13636                &mut self.i32_sized_2,
13637                decoder,
13638                offset + 816,
13639                _depth
13640            )?;
13641            fidl::decode!(
13642                fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>,
13643                fidl::encoding::DefaultFuchsiaResourceDialect,
13644                &mut self.i64_sized_2,
13645                decoder,
13646                offset + 832,
13647                _depth
13648            )?;
13649            fidl::decode!(
13650                fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>,
13651                fidl::encoding::DefaultFuchsiaResourceDialect,
13652                &mut self.u8_sized_2,
13653                decoder,
13654                offset + 848,
13655                _depth
13656            )?;
13657            fidl::decode!(
13658                fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>,
13659                fidl::encoding::DefaultFuchsiaResourceDialect,
13660                &mut self.u16_sized_2,
13661                decoder,
13662                offset + 864,
13663                _depth
13664            )?;
13665            fidl::decode!(
13666                fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>,
13667                fidl::encoding::DefaultFuchsiaResourceDialect,
13668                &mut self.u32_sized_2,
13669                decoder,
13670                offset + 880,
13671                _depth
13672            )?;
13673            fidl::decode!(
13674                fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>,
13675                fidl::encoding::DefaultFuchsiaResourceDialect,
13676                &mut self.u64_sized_2,
13677                decoder,
13678                offset + 896,
13679                _depth
13680            )?;
13681            fidl::decode!(
13682                fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>,
13683                fidl::encoding::DefaultFuchsiaResourceDialect,
13684                &mut self.f32_sized_2,
13685                decoder,
13686                offset + 912,
13687                _depth
13688            )?;
13689            fidl::decode!(
13690                fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>,
13691                fidl::encoding::DefaultFuchsiaResourceDialect,
13692                &mut self.f64_sized_2,
13693                decoder,
13694                offset + 928,
13695                _depth
13696            )?;
13697            fidl::decode!(
13698                fidl::encoding::Vector<
13699                    fidl::encoding::Vector<
13700                        fidl::encoding::HandleType<
13701                            fidl::Handle,
13702                            { fidl::ObjectType::NONE.into_raw() },
13703                            2147483648,
13704                        >,
13705                        2,
13706                    >,
13707                    3,
13708                >,
13709                fidl::encoding::DefaultFuchsiaResourceDialect,
13710                &mut self.handle_sized_2,
13711                decoder,
13712                offset + 944,
13713                _depth
13714            )?;
13715            fidl::decode!(
13716                fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
13717                fidl::encoding::DefaultFuchsiaResourceDialect,
13718                &mut self.b_nullable_0,
13719                decoder,
13720                offset + 960,
13721                _depth
13722            )?;
13723            fidl::decode!(
13724                fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
13725                fidl::encoding::DefaultFuchsiaResourceDialect,
13726                &mut self.i8_nullable_0,
13727                decoder,
13728                offset + 976,
13729                _depth
13730            )?;
13731            fidl::decode!(
13732                fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
13733                fidl::encoding::DefaultFuchsiaResourceDialect,
13734                &mut self.i16_nullable_0,
13735                decoder,
13736                offset + 992,
13737                _depth
13738            )?;
13739            fidl::decode!(
13740                fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
13741                fidl::encoding::DefaultFuchsiaResourceDialect,
13742                &mut self.i32_nullable_0,
13743                decoder,
13744                offset + 1008,
13745                _depth
13746            )?;
13747            fidl::decode!(
13748                fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
13749                fidl::encoding::DefaultFuchsiaResourceDialect,
13750                &mut self.i64_nullable_0,
13751                decoder,
13752                offset + 1024,
13753                _depth
13754            )?;
13755            fidl::decode!(
13756                fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
13757                fidl::encoding::DefaultFuchsiaResourceDialect,
13758                &mut self.u8_nullable_0,
13759                decoder,
13760                offset + 1040,
13761                _depth
13762            )?;
13763            fidl::decode!(
13764                fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
13765                fidl::encoding::DefaultFuchsiaResourceDialect,
13766                &mut self.u16_nullable_0,
13767                decoder,
13768                offset + 1056,
13769                _depth
13770            )?;
13771            fidl::decode!(
13772                fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
13773                fidl::encoding::DefaultFuchsiaResourceDialect,
13774                &mut self.u32_nullable_0,
13775                decoder,
13776                offset + 1072,
13777                _depth
13778            )?;
13779            fidl::decode!(
13780                fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
13781                fidl::encoding::DefaultFuchsiaResourceDialect,
13782                &mut self.u64_nullable_0,
13783                decoder,
13784                offset + 1088,
13785                _depth
13786            )?;
13787            fidl::decode!(
13788                fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
13789                fidl::encoding::DefaultFuchsiaResourceDialect,
13790                &mut self.f32_nullable_0,
13791                decoder,
13792                offset + 1104,
13793                _depth
13794            )?;
13795            fidl::decode!(
13796                fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
13797                fidl::encoding::DefaultFuchsiaResourceDialect,
13798                &mut self.f64_nullable_0,
13799                decoder,
13800                offset + 1120,
13801                _depth
13802            )?;
13803            fidl::decode!(
13804                fidl::encoding::Optional<
13805                    fidl::encoding::Vector<
13806                        fidl::encoding::HandleType<
13807                            fidl::Handle,
13808                            { fidl::ObjectType::NONE.into_raw() },
13809                            2147483648,
13810                        >,
13811                        1,
13812                    >,
13813                >,
13814                fidl::encoding::DefaultFuchsiaResourceDialect,
13815                &mut self.handle_nullable_0,
13816                decoder,
13817                offset + 1136,
13818                _depth
13819            )?;
13820            fidl::decode!(
13821                fidl::encoding::Optional<
13822                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
13823                >,
13824                fidl::encoding::DefaultFuchsiaResourceDialect,
13825                &mut self.b_nullable_1,
13826                decoder,
13827                offset + 1152,
13828                _depth
13829            )?;
13830            fidl::decode!(
13831                fidl::encoding::Optional<
13832                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
13833                >,
13834                fidl::encoding::DefaultFuchsiaResourceDialect,
13835                &mut self.i8_nullable_1,
13836                decoder,
13837                offset + 1168,
13838                _depth
13839            )?;
13840            fidl::decode!(
13841                fidl::encoding::Optional<
13842                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
13843                >,
13844                fidl::encoding::DefaultFuchsiaResourceDialect,
13845                &mut self.i16_nullable_1,
13846                decoder,
13847                offset + 1184,
13848                _depth
13849            )?;
13850            fidl::decode!(
13851                fidl::encoding::Optional<
13852                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
13853                >,
13854                fidl::encoding::DefaultFuchsiaResourceDialect,
13855                &mut self.i32_nullable_1,
13856                decoder,
13857                offset + 1200,
13858                _depth
13859            )?;
13860            fidl::decode!(
13861                fidl::encoding::Optional<
13862                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
13863                >,
13864                fidl::encoding::DefaultFuchsiaResourceDialect,
13865                &mut self.i64_nullable_1,
13866                decoder,
13867                offset + 1216,
13868                _depth
13869            )?;
13870            fidl::decode!(
13871                fidl::encoding::Optional<
13872                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
13873                >,
13874                fidl::encoding::DefaultFuchsiaResourceDialect,
13875                &mut self.u8_nullable_1,
13876                decoder,
13877                offset + 1232,
13878                _depth
13879            )?;
13880            fidl::decode!(
13881                fidl::encoding::Optional<
13882                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
13883                >,
13884                fidl::encoding::DefaultFuchsiaResourceDialect,
13885                &mut self.u16_nullable_1,
13886                decoder,
13887                offset + 1248,
13888                _depth
13889            )?;
13890            fidl::decode!(
13891                fidl::encoding::Optional<
13892                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
13893                >,
13894                fidl::encoding::DefaultFuchsiaResourceDialect,
13895                &mut self.u32_nullable_1,
13896                decoder,
13897                offset + 1264,
13898                _depth
13899            )?;
13900            fidl::decode!(
13901                fidl::encoding::Optional<
13902                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
13903                >,
13904                fidl::encoding::DefaultFuchsiaResourceDialect,
13905                &mut self.u64_nullable_1,
13906                decoder,
13907                offset + 1280,
13908                _depth
13909            )?;
13910            fidl::decode!(
13911                fidl::encoding::Optional<
13912                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
13913                >,
13914                fidl::encoding::DefaultFuchsiaResourceDialect,
13915                &mut self.f32_nullable_1,
13916                decoder,
13917                offset + 1296,
13918                _depth
13919            )?;
13920            fidl::decode!(
13921                fidl::encoding::Optional<
13922                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
13923                >,
13924                fidl::encoding::DefaultFuchsiaResourceDialect,
13925                &mut self.f64_nullable_1,
13926                decoder,
13927                offset + 1312,
13928                _depth
13929            )?;
13930            fidl::decode!(
13931                fidl::encoding::Optional<
13932                    fidl::encoding::UnboundedVector<
13933                        fidl::encoding::Vector<
13934                            fidl::encoding::HandleType<
13935                                fidl::Handle,
13936                                { fidl::ObjectType::NONE.into_raw() },
13937                                2147483648,
13938                            >,
13939                            2,
13940                        >,
13941                    >,
13942                >,
13943                fidl::encoding::DefaultFuchsiaResourceDialect,
13944                &mut self.handle_nullable_1,
13945                decoder,
13946                offset + 1328,
13947                _depth
13948            )?;
13949            fidl::decode!(
13950                fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
13951                fidl::encoding::DefaultFuchsiaResourceDialect,
13952                &mut self.b_nullable_sized_0,
13953                decoder,
13954                offset + 1344,
13955                _depth
13956            )?;
13957            fidl::decode!(
13958                fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
13959                fidl::encoding::DefaultFuchsiaResourceDialect,
13960                &mut self.i8_nullable_sized_0,
13961                decoder,
13962                offset + 1360,
13963                _depth
13964            )?;
13965            fidl::decode!(
13966                fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
13967                fidl::encoding::DefaultFuchsiaResourceDialect,
13968                &mut self.i16_nullable_sized_0,
13969                decoder,
13970                offset + 1376,
13971                _depth
13972            )?;
13973            fidl::decode!(
13974                fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
13975                fidl::encoding::DefaultFuchsiaResourceDialect,
13976                &mut self.i32_nullable_sized_0,
13977                decoder,
13978                offset + 1392,
13979                _depth
13980            )?;
13981            fidl::decode!(
13982                fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
13983                fidl::encoding::DefaultFuchsiaResourceDialect,
13984                &mut self.i64_nullable_sized_0,
13985                decoder,
13986                offset + 1408,
13987                _depth
13988            )?;
13989            fidl::decode!(
13990                fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
13991                fidl::encoding::DefaultFuchsiaResourceDialect,
13992                &mut self.u8_nullable_sized_0,
13993                decoder,
13994                offset + 1424,
13995                _depth
13996            )?;
13997            fidl::decode!(
13998                fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
13999                fidl::encoding::DefaultFuchsiaResourceDialect,
14000                &mut self.u16_nullable_sized_0,
14001                decoder,
14002                offset + 1440,
14003                _depth
14004            )?;
14005            fidl::decode!(
14006                fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
14007                fidl::encoding::DefaultFuchsiaResourceDialect,
14008                &mut self.u32_nullable_sized_0,
14009                decoder,
14010                offset + 1456,
14011                _depth
14012            )?;
14013            fidl::decode!(
14014                fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
14015                fidl::encoding::DefaultFuchsiaResourceDialect,
14016                &mut self.u64_nullable_sized_0,
14017                decoder,
14018                offset + 1472,
14019                _depth
14020            )?;
14021            fidl::decode!(
14022                fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
14023                fidl::encoding::DefaultFuchsiaResourceDialect,
14024                &mut self.f32_nullable_sized_0,
14025                decoder,
14026                offset + 1488,
14027                _depth
14028            )?;
14029            fidl::decode!(
14030                fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
14031                fidl::encoding::DefaultFuchsiaResourceDialect,
14032                &mut self.f64_nullable_sized_0,
14033                decoder,
14034                offset + 1504,
14035                _depth
14036            )?;
14037            fidl::decode!(
14038                fidl::encoding::Optional<
14039                    fidl::encoding::Vector<
14040                        fidl::encoding::HandleType<
14041                            fidl::Handle,
14042                            { fidl::ObjectType::NONE.into_raw() },
14043                            2147483648,
14044                        >,
14045                        1,
14046                    >,
14047                >,
14048                fidl::encoding::DefaultFuchsiaResourceDialect,
14049                &mut self.handle_nullable_sized_0,
14050                decoder,
14051                offset + 1520,
14052                _depth
14053            )?;
14054            fidl::decode!(
14055                fidl::encoding::Optional<fidl::encoding::Vector<bool, 3>>,
14056                fidl::encoding::DefaultFuchsiaResourceDialect,
14057                &mut self.b_nullable_sized_1,
14058                decoder,
14059                offset + 1536,
14060                _depth
14061            )?;
14062            fidl::decode!(
14063                fidl::encoding::Optional<fidl::encoding::Vector<i8, 3>>,
14064                fidl::encoding::DefaultFuchsiaResourceDialect,
14065                &mut self.i8_nullable_sized_1,
14066                decoder,
14067                offset + 1552,
14068                _depth
14069            )?;
14070            fidl::decode!(
14071                fidl::encoding::Optional<fidl::encoding::Vector<i16, 3>>,
14072                fidl::encoding::DefaultFuchsiaResourceDialect,
14073                &mut self.i16_nullable_sized_1,
14074                decoder,
14075                offset + 1568,
14076                _depth
14077            )?;
14078            fidl::decode!(
14079                fidl::encoding::Optional<fidl::encoding::Vector<i32, 3>>,
14080                fidl::encoding::DefaultFuchsiaResourceDialect,
14081                &mut self.i32_nullable_sized_1,
14082                decoder,
14083                offset + 1584,
14084                _depth
14085            )?;
14086            fidl::decode!(
14087                fidl::encoding::Optional<fidl::encoding::Vector<i64, 3>>,
14088                fidl::encoding::DefaultFuchsiaResourceDialect,
14089                &mut self.i64_nullable_sized_1,
14090                decoder,
14091                offset + 1600,
14092                _depth
14093            )?;
14094            fidl::decode!(
14095                fidl::encoding::Optional<fidl::encoding::Vector<u8, 3>>,
14096                fidl::encoding::DefaultFuchsiaResourceDialect,
14097                &mut self.u8_nullable_sized_1,
14098                decoder,
14099                offset + 1616,
14100                _depth
14101            )?;
14102            fidl::decode!(
14103                fidl::encoding::Optional<fidl::encoding::Vector<u16, 3>>,
14104                fidl::encoding::DefaultFuchsiaResourceDialect,
14105                &mut self.u16_nullable_sized_1,
14106                decoder,
14107                offset + 1632,
14108                _depth
14109            )?;
14110            fidl::decode!(
14111                fidl::encoding::Optional<fidl::encoding::Vector<u32, 3>>,
14112                fidl::encoding::DefaultFuchsiaResourceDialect,
14113                &mut self.u32_nullable_sized_1,
14114                decoder,
14115                offset + 1648,
14116                _depth
14117            )?;
14118            fidl::decode!(
14119                fidl::encoding::Optional<fidl::encoding::Vector<u64, 3>>,
14120                fidl::encoding::DefaultFuchsiaResourceDialect,
14121                &mut self.u64_nullable_sized_1,
14122                decoder,
14123                offset + 1664,
14124                _depth
14125            )?;
14126            fidl::decode!(
14127                fidl::encoding::Optional<fidl::encoding::Vector<f32, 3>>,
14128                fidl::encoding::DefaultFuchsiaResourceDialect,
14129                &mut self.f32_nullable_sized_1,
14130                decoder,
14131                offset + 1680,
14132                _depth
14133            )?;
14134            fidl::decode!(
14135                fidl::encoding::Optional<fidl::encoding::Vector<f64, 3>>,
14136                fidl::encoding::DefaultFuchsiaResourceDialect,
14137                &mut self.f64_nullable_sized_1,
14138                decoder,
14139                offset + 1696,
14140                _depth
14141            )?;
14142            fidl::decode!(
14143                fidl::encoding::Optional<
14144                    fidl::encoding::Vector<
14145                        fidl::encoding::HandleType<
14146                            fidl::Handle,
14147                            { fidl::ObjectType::NONE.into_raw() },
14148                            2147483648,
14149                        >,
14150                        3,
14151                    >,
14152                >,
14153                fidl::encoding::DefaultFuchsiaResourceDialect,
14154                &mut self.handle_nullable_sized_1,
14155                decoder,
14156                offset + 1712,
14157                _depth
14158            )?;
14159            fidl::decode!(
14160                fidl::encoding::Optional<
14161                    fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
14162                >,
14163                fidl::encoding::DefaultFuchsiaResourceDialect,
14164                &mut self.b_nullable_sized_2,
14165                decoder,
14166                offset + 1728,
14167                _depth
14168            )?;
14169            fidl::decode!(
14170                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>>,
14171                fidl::encoding::DefaultFuchsiaResourceDialect,
14172                &mut self.i8_nullable_sized_2,
14173                decoder,
14174                offset + 1744,
14175                _depth
14176            )?;
14177            fidl::decode!(
14178                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>>,
14179                fidl::encoding::DefaultFuchsiaResourceDialect,
14180                &mut self.i16_nullable_sized_2,
14181                decoder,
14182                offset + 1760,
14183                _depth
14184            )?;
14185            fidl::decode!(
14186                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>>,
14187                fidl::encoding::DefaultFuchsiaResourceDialect,
14188                &mut self.i32_nullable_sized_2,
14189                decoder,
14190                offset + 1776,
14191                _depth
14192            )?;
14193            fidl::decode!(
14194                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>>,
14195                fidl::encoding::DefaultFuchsiaResourceDialect,
14196                &mut self.i64_nullable_sized_2,
14197                decoder,
14198                offset + 1792,
14199                _depth
14200            )?;
14201            fidl::decode!(
14202                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>>,
14203                fidl::encoding::DefaultFuchsiaResourceDialect,
14204                &mut self.u8_nullable_sized_2,
14205                decoder,
14206                offset + 1808,
14207                _depth
14208            )?;
14209            fidl::decode!(
14210                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>>,
14211                fidl::encoding::DefaultFuchsiaResourceDialect,
14212                &mut self.u16_nullable_sized_2,
14213                decoder,
14214                offset + 1824,
14215                _depth
14216            )?;
14217            fidl::decode!(
14218                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>>,
14219                fidl::encoding::DefaultFuchsiaResourceDialect,
14220                &mut self.u32_nullable_sized_2,
14221                decoder,
14222                offset + 1840,
14223                _depth
14224            )?;
14225            fidl::decode!(
14226                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>>,
14227                fidl::encoding::DefaultFuchsiaResourceDialect,
14228                &mut self.u64_nullable_sized_2,
14229                decoder,
14230                offset + 1856,
14231                _depth
14232            )?;
14233            fidl::decode!(
14234                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>>,
14235                fidl::encoding::DefaultFuchsiaResourceDialect,
14236                &mut self.f32_nullable_sized_2,
14237                decoder,
14238                offset + 1872,
14239                _depth
14240            )?;
14241            fidl::decode!(
14242                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>>,
14243                fidl::encoding::DefaultFuchsiaResourceDialect,
14244                &mut self.f64_nullable_sized_2,
14245                decoder,
14246                offset + 1888,
14247                _depth
14248            )?;
14249            fidl::decode!(
14250                fidl::encoding::Optional<
14251                    fidl::encoding::Vector<
14252                        fidl::encoding::Vector<
14253                            fidl::encoding::HandleType<
14254                                fidl::Handle,
14255                                { fidl::ObjectType::NONE.into_raw() },
14256                                2147483648,
14257                            >,
14258                            2,
14259                        >,
14260                        3,
14261                    >,
14262                >,
14263                fidl::encoding::DefaultFuchsiaResourceDialect,
14264                &mut self.handle_nullable_sized_2,
14265                decoder,
14266                offset + 1904,
14267                _depth
14268            )?;
14269            Ok(())
14270        }
14271    }
14272
14273    impl AllTypesTable {
14274        #[inline(always)]
14275        fn max_ordinal_present(&self) -> u64 {
14276            if let Some(_) = self.xunion_member {
14277                return 21;
14278            }
14279            if let Some(_) = self.table_member {
14280                return 20;
14281            }
14282            if let Some(_) = self.vector_member {
14283                return 19;
14284            }
14285            if let Some(_) = self.array_member {
14286                return 18;
14287            }
14288            if let Some(_) = self.union_member {
14289                return 17;
14290            }
14291            if let Some(_) = self.struct_member {
14292                return 16;
14293            }
14294            if let Some(_) = self.string_member {
14295                return 15;
14296            }
14297            if let Some(_) = self.handle_member {
14298                return 14;
14299            }
14300            if let Some(_) = self.bits_member {
14301                return 13;
14302            }
14303            if let Some(_) = self.enum_member {
14304                return 12;
14305            }
14306            if let Some(_) = self.float64_member {
14307                return 11;
14308            }
14309            if let Some(_) = self.float32_member {
14310                return 10;
14311            }
14312            if let Some(_) = self.uint64_member {
14313                return 9;
14314            }
14315            if let Some(_) = self.uint32_member {
14316                return 8;
14317            }
14318            if let Some(_) = self.uint16_member {
14319                return 7;
14320            }
14321            if let Some(_) = self.uint8_member {
14322                return 6;
14323            }
14324            if let Some(_) = self.int64_member {
14325                return 5;
14326            }
14327            if let Some(_) = self.int32_member {
14328                return 4;
14329            }
14330            if let Some(_) = self.int16_member {
14331                return 3;
14332            }
14333            if let Some(_) = self.int8_member {
14334                return 2;
14335            }
14336            if let Some(_) = self.bool_member {
14337                return 1;
14338            }
14339            0
14340        }
14341    }
14342
14343    impl fidl::encoding::ResourceTypeMarker for AllTypesTable {
14344        type Borrowed<'a> = &'a mut Self;
14345        fn take_or_borrow<'a>(
14346            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
14347        ) -> Self::Borrowed<'a> {
14348            value
14349        }
14350    }
14351
14352    unsafe impl fidl::encoding::TypeMarker for AllTypesTable {
14353        type Owned = Self;
14354
14355        #[inline(always)]
14356        fn inline_align(_context: fidl::encoding::Context) -> usize {
14357            8
14358        }
14359
14360        #[inline(always)]
14361        fn inline_size(_context: fidl::encoding::Context) -> usize {
14362            16
14363        }
14364    }
14365
14366    unsafe impl fidl::encoding::Encode<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>
14367        for &mut AllTypesTable
14368    {
14369        unsafe fn encode(
14370            self,
14371            encoder: &mut fidl::encoding::Encoder<
14372                '_,
14373                fidl::encoding::DefaultFuchsiaResourceDialect,
14374            >,
14375            offset: usize,
14376            mut depth: fidl::encoding::Depth,
14377        ) -> fidl::Result<()> {
14378            encoder.debug_check_bounds::<AllTypesTable>(offset);
14379            // Vector header
14380            let max_ordinal: u64 = self.max_ordinal_present();
14381            encoder.write_num(max_ordinal, offset);
14382            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
14383            // Calling encoder.out_of_line_offset(0) is not allowed.
14384            if max_ordinal == 0 {
14385                return Ok(());
14386            }
14387            depth.increment()?;
14388            let envelope_size = 8;
14389            let bytes_len = max_ordinal as usize * envelope_size;
14390            #[allow(unused_variables)]
14391            let offset = encoder.out_of_line_offset(bytes_len);
14392            let mut _prev_end_offset: usize = 0;
14393            if 1 > max_ordinal {
14394                return Ok(());
14395            }
14396
14397            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14398            // are envelope_size bytes.
14399            let cur_offset: usize = (1 - 1) * envelope_size;
14400
14401            // Zero reserved fields.
14402            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14403
14404            // Safety:
14405            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14406            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14407            //   envelope_size bytes, there is always sufficient room.
14408            fidl::encoding::encode_in_envelope_optional::<
14409                bool,
14410                fidl::encoding::DefaultFuchsiaResourceDialect,
14411            >(
14412                self.bool_member.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
14413                encoder,
14414                offset + cur_offset,
14415                depth,
14416            )?;
14417
14418            _prev_end_offset = cur_offset + envelope_size;
14419            if 2 > max_ordinal {
14420                return Ok(());
14421            }
14422
14423            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14424            // are envelope_size bytes.
14425            let cur_offset: usize = (2 - 1) * envelope_size;
14426
14427            // Zero reserved fields.
14428            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14429
14430            // Safety:
14431            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14432            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14433            //   envelope_size bytes, there is always sufficient room.
14434            fidl::encoding::encode_in_envelope_optional::<
14435                i8,
14436                fidl::encoding::DefaultFuchsiaResourceDialect,
14437            >(
14438                self.int8_member.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
14439                encoder,
14440                offset + cur_offset,
14441                depth,
14442            )?;
14443
14444            _prev_end_offset = cur_offset + envelope_size;
14445            if 3 > max_ordinal {
14446                return Ok(());
14447            }
14448
14449            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14450            // are envelope_size bytes.
14451            let cur_offset: usize = (3 - 1) * envelope_size;
14452
14453            // Zero reserved fields.
14454            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14455
14456            // Safety:
14457            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14458            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14459            //   envelope_size bytes, there is always sufficient room.
14460            fidl::encoding::encode_in_envelope_optional::<
14461                i16,
14462                fidl::encoding::DefaultFuchsiaResourceDialect,
14463            >(
14464                self.int16_member.as_ref().map(<i16 as fidl::encoding::ValueTypeMarker>::borrow),
14465                encoder,
14466                offset + cur_offset,
14467                depth,
14468            )?;
14469
14470            _prev_end_offset = cur_offset + envelope_size;
14471            if 4 > max_ordinal {
14472                return Ok(());
14473            }
14474
14475            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14476            // are envelope_size bytes.
14477            let cur_offset: usize = (4 - 1) * envelope_size;
14478
14479            // Zero reserved fields.
14480            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14481
14482            // Safety:
14483            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14484            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14485            //   envelope_size bytes, there is always sufficient room.
14486            fidl::encoding::encode_in_envelope_optional::<
14487                i32,
14488                fidl::encoding::DefaultFuchsiaResourceDialect,
14489            >(
14490                self.int32_member.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
14491                encoder,
14492                offset + cur_offset,
14493                depth,
14494            )?;
14495
14496            _prev_end_offset = cur_offset + envelope_size;
14497            if 5 > max_ordinal {
14498                return Ok(());
14499            }
14500
14501            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14502            // are envelope_size bytes.
14503            let cur_offset: usize = (5 - 1) * envelope_size;
14504
14505            // Zero reserved fields.
14506            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14507
14508            // Safety:
14509            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14510            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14511            //   envelope_size bytes, there is always sufficient room.
14512            fidl::encoding::encode_in_envelope_optional::<
14513                i64,
14514                fidl::encoding::DefaultFuchsiaResourceDialect,
14515            >(
14516                self.int64_member.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
14517                encoder,
14518                offset + cur_offset,
14519                depth,
14520            )?;
14521
14522            _prev_end_offset = cur_offset + envelope_size;
14523            if 6 > max_ordinal {
14524                return Ok(());
14525            }
14526
14527            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14528            // are envelope_size bytes.
14529            let cur_offset: usize = (6 - 1) * envelope_size;
14530
14531            // Zero reserved fields.
14532            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14533
14534            // Safety:
14535            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14536            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14537            //   envelope_size bytes, there is always sufficient room.
14538            fidl::encoding::encode_in_envelope_optional::<
14539                u8,
14540                fidl::encoding::DefaultFuchsiaResourceDialect,
14541            >(
14542                self.uint8_member.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
14543                encoder,
14544                offset + cur_offset,
14545                depth,
14546            )?;
14547
14548            _prev_end_offset = cur_offset + envelope_size;
14549            if 7 > max_ordinal {
14550                return Ok(());
14551            }
14552
14553            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14554            // are envelope_size bytes.
14555            let cur_offset: usize = (7 - 1) * envelope_size;
14556
14557            // Zero reserved fields.
14558            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14559
14560            // Safety:
14561            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14562            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14563            //   envelope_size bytes, there is always sufficient room.
14564            fidl::encoding::encode_in_envelope_optional::<
14565                u16,
14566                fidl::encoding::DefaultFuchsiaResourceDialect,
14567            >(
14568                self.uint16_member.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
14569                encoder,
14570                offset + cur_offset,
14571                depth,
14572            )?;
14573
14574            _prev_end_offset = cur_offset + envelope_size;
14575            if 8 > max_ordinal {
14576                return Ok(());
14577            }
14578
14579            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14580            // are envelope_size bytes.
14581            let cur_offset: usize = (8 - 1) * envelope_size;
14582
14583            // Zero reserved fields.
14584            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14585
14586            // Safety:
14587            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14588            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14589            //   envelope_size bytes, there is always sufficient room.
14590            fidl::encoding::encode_in_envelope_optional::<
14591                u32,
14592                fidl::encoding::DefaultFuchsiaResourceDialect,
14593            >(
14594                self.uint32_member.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
14595                encoder,
14596                offset + cur_offset,
14597                depth,
14598            )?;
14599
14600            _prev_end_offset = cur_offset + envelope_size;
14601            if 9 > max_ordinal {
14602                return Ok(());
14603            }
14604
14605            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14606            // are envelope_size bytes.
14607            let cur_offset: usize = (9 - 1) * envelope_size;
14608
14609            // Zero reserved fields.
14610            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14611
14612            // Safety:
14613            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14614            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14615            //   envelope_size bytes, there is always sufficient room.
14616            fidl::encoding::encode_in_envelope_optional::<
14617                u64,
14618                fidl::encoding::DefaultFuchsiaResourceDialect,
14619            >(
14620                self.uint64_member.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
14621                encoder,
14622                offset + cur_offset,
14623                depth,
14624            )?;
14625
14626            _prev_end_offset = cur_offset + envelope_size;
14627            if 10 > max_ordinal {
14628                return Ok(());
14629            }
14630
14631            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14632            // are envelope_size bytes.
14633            let cur_offset: usize = (10 - 1) * envelope_size;
14634
14635            // Zero reserved fields.
14636            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14637
14638            // Safety:
14639            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14640            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14641            //   envelope_size bytes, there is always sufficient room.
14642            fidl::encoding::encode_in_envelope_optional::<
14643                f32,
14644                fidl::encoding::DefaultFuchsiaResourceDialect,
14645            >(
14646                self.float32_member.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
14647                encoder,
14648                offset + cur_offset,
14649                depth,
14650            )?;
14651
14652            _prev_end_offset = cur_offset + envelope_size;
14653            if 11 > max_ordinal {
14654                return Ok(());
14655            }
14656
14657            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14658            // are envelope_size bytes.
14659            let cur_offset: usize = (11 - 1) * envelope_size;
14660
14661            // Zero reserved fields.
14662            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14663
14664            // Safety:
14665            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14666            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14667            //   envelope_size bytes, there is always sufficient room.
14668            fidl::encoding::encode_in_envelope_optional::<
14669                f64,
14670                fidl::encoding::DefaultFuchsiaResourceDialect,
14671            >(
14672                self.float64_member.as_ref().map(<f64 as fidl::encoding::ValueTypeMarker>::borrow),
14673                encoder,
14674                offset + cur_offset,
14675                depth,
14676            )?;
14677
14678            _prev_end_offset = cur_offset + envelope_size;
14679            if 12 > max_ordinal {
14680                return Ok(());
14681            }
14682
14683            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14684            // are envelope_size bytes.
14685            let cur_offset: usize = (12 - 1) * envelope_size;
14686
14687            // Zero reserved fields.
14688            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14689
14690            // Safety:
14691            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14692            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14693            //   envelope_size bytes, there is always sufficient room.
14694            fidl::encoding::encode_in_envelope_optional::<
14695                DefaultEnum,
14696                fidl::encoding::DefaultFuchsiaResourceDialect,
14697            >(
14698                self.enum_member
14699                    .as_ref()
14700                    .map(<DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow),
14701                encoder,
14702                offset + cur_offset,
14703                depth,
14704            )?;
14705
14706            _prev_end_offset = cur_offset + envelope_size;
14707            if 13 > max_ordinal {
14708                return Ok(());
14709            }
14710
14711            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14712            // are envelope_size bytes.
14713            let cur_offset: usize = (13 - 1) * envelope_size;
14714
14715            // Zero reserved fields.
14716            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14717
14718            // Safety:
14719            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14720            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14721            //   envelope_size bytes, there is always sufficient room.
14722            fidl::encoding::encode_in_envelope_optional::<
14723                DefaultBits,
14724                fidl::encoding::DefaultFuchsiaResourceDialect,
14725            >(
14726                self.bits_member
14727                    .as_ref()
14728                    .map(<DefaultBits as fidl::encoding::ValueTypeMarker>::borrow),
14729                encoder,
14730                offset + cur_offset,
14731                depth,
14732            )?;
14733
14734            _prev_end_offset = cur_offset + envelope_size;
14735            if 14 > max_ordinal {
14736                return Ok(());
14737            }
14738
14739            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14740            // are envelope_size bytes.
14741            let cur_offset: usize = (14 - 1) * envelope_size;
14742
14743            // Zero reserved fields.
14744            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14745
14746            // Safety:
14747            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14748            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14749            //   envelope_size bytes, there is always sufficient room.
14750            fidl::encoding::encode_in_envelope_optional::<
14751                fidl::encoding::HandleType<
14752                    fidl::Handle,
14753                    { fidl::ObjectType::NONE.into_raw() },
14754                    2147483648,
14755                >,
14756                fidl::encoding::DefaultFuchsiaResourceDialect,
14757            >(
14758                self.handle_member.as_mut().map(
14759                    <fidl::encoding::HandleType<
14760                        fidl::Handle,
14761                        { fidl::ObjectType::NONE.into_raw() },
14762                        2147483648,
14763                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
14764                ),
14765                encoder,
14766                offset + cur_offset,
14767                depth,
14768            )?;
14769
14770            _prev_end_offset = cur_offset + envelope_size;
14771            if 15 > max_ordinal {
14772                return Ok(());
14773            }
14774
14775            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14776            // are envelope_size bytes.
14777            let cur_offset: usize = (15 - 1) * envelope_size;
14778
14779            // Zero reserved fields.
14780            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14781
14782            // Safety:
14783            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14784            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14785            //   envelope_size bytes, there is always sufficient room.
14786            fidl::encoding::encode_in_envelope_optional::<
14787                fidl::encoding::UnboundedString,
14788                fidl::encoding::DefaultFuchsiaResourceDialect,
14789            >(
14790                self.string_member.as_ref().map(
14791                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
14792                ),
14793                encoder,
14794                offset + cur_offset,
14795                depth,
14796            )?;
14797
14798            _prev_end_offset = cur_offset + envelope_size;
14799            if 16 > max_ordinal {
14800                return Ok(());
14801            }
14802
14803            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14804            // are envelope_size bytes.
14805            let cur_offset: usize = (16 - 1) * envelope_size;
14806
14807            // Zero reserved fields.
14808            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14809
14810            // Safety:
14811            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14812            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14813            //   envelope_size bytes, there is always sufficient room.
14814            fidl::encoding::encode_in_envelope_optional::<
14815                ThisIsAStruct,
14816                fidl::encoding::DefaultFuchsiaResourceDialect,
14817            >(
14818                self.struct_member
14819                    .as_ref()
14820                    .map(<ThisIsAStruct as fidl::encoding::ValueTypeMarker>::borrow),
14821                encoder,
14822                offset + cur_offset,
14823                depth,
14824            )?;
14825
14826            _prev_end_offset = cur_offset + envelope_size;
14827            if 17 > max_ordinal {
14828                return Ok(());
14829            }
14830
14831            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14832            // are envelope_size bytes.
14833            let cur_offset: usize = (17 - 1) * envelope_size;
14834
14835            // Zero reserved fields.
14836            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14837
14838            // Safety:
14839            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14840            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14841            //   envelope_size bytes, there is always sufficient room.
14842            fidl::encoding::encode_in_envelope_optional::<
14843                ThisIsAUnion,
14844                fidl::encoding::DefaultFuchsiaResourceDialect,
14845            >(
14846                self.union_member
14847                    .as_ref()
14848                    .map(<ThisIsAUnion as fidl::encoding::ValueTypeMarker>::borrow),
14849                encoder,
14850                offset + cur_offset,
14851                depth,
14852            )?;
14853
14854            _prev_end_offset = cur_offset + envelope_size;
14855            if 18 > max_ordinal {
14856                return Ok(());
14857            }
14858
14859            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14860            // are envelope_size bytes.
14861            let cur_offset: usize = (18 - 1) * envelope_size;
14862
14863            // Zero reserved fields.
14864            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14865
14866            // Safety:
14867            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14868            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14869            //   envelope_size bytes, there is always sufficient room.
14870            fidl::encoding::encode_in_envelope_optional::<
14871                fidl::encoding::Array<u32, 3>,
14872                fidl::encoding::DefaultFuchsiaResourceDialect,
14873            >(
14874                self.array_member.as_ref().map(
14875                    <fidl::encoding::Array<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow,
14876                ),
14877                encoder,
14878                offset + cur_offset,
14879                depth,
14880            )?;
14881
14882            _prev_end_offset = cur_offset + envelope_size;
14883            if 19 > max_ordinal {
14884                return Ok(());
14885            }
14886
14887            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14888            // are envelope_size bytes.
14889            let cur_offset: usize = (19 - 1) * envelope_size;
14890
14891            // Zero reserved fields.
14892            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14893
14894            // Safety:
14895            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14896            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14897            //   envelope_size bytes, there is always sufficient room.
14898            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u32>, fidl::encoding::DefaultFuchsiaResourceDialect>(
14899            self.vector_member.as_ref().map(<fidl::encoding::UnboundedVector<u32> as fidl::encoding::ValueTypeMarker>::borrow),
14900            encoder, offset + cur_offset, depth
14901        )?;
14902
14903            _prev_end_offset = cur_offset + envelope_size;
14904            if 20 > max_ordinal {
14905                return Ok(());
14906            }
14907
14908            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14909            // are envelope_size bytes.
14910            let cur_offset: usize = (20 - 1) * envelope_size;
14911
14912            // Zero reserved fields.
14913            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14914
14915            // Safety:
14916            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14917            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14918            //   envelope_size bytes, there is always sufficient room.
14919            fidl::encoding::encode_in_envelope_optional::<
14920                ThisIsATable,
14921                fidl::encoding::DefaultFuchsiaResourceDialect,
14922            >(
14923                self.table_member
14924                    .as_ref()
14925                    .map(<ThisIsATable as fidl::encoding::ValueTypeMarker>::borrow),
14926                encoder,
14927                offset + cur_offset,
14928                depth,
14929            )?;
14930
14931            _prev_end_offset = cur_offset + envelope_size;
14932            if 21 > max_ordinal {
14933                return Ok(());
14934            }
14935
14936            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14937            // are envelope_size bytes.
14938            let cur_offset: usize = (21 - 1) * envelope_size;
14939
14940            // Zero reserved fields.
14941            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14942
14943            // Safety:
14944            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14945            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14946            //   envelope_size bytes, there is always sufficient room.
14947            fidl::encoding::encode_in_envelope_optional::<
14948                ThisIsAXunion,
14949                fidl::encoding::DefaultFuchsiaResourceDialect,
14950            >(
14951                self.xunion_member
14952                    .as_ref()
14953                    .map(<ThisIsAXunion as fidl::encoding::ValueTypeMarker>::borrow),
14954                encoder,
14955                offset + cur_offset,
14956                depth,
14957            )?;
14958
14959            _prev_end_offset = cur_offset + envelope_size;
14960
14961            Ok(())
14962        }
14963    }
14964
14965    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for AllTypesTable {
14966        #[inline(always)]
14967        fn new_empty() -> Self {
14968            Self::default()
14969        }
14970
14971        unsafe fn decode(
14972            &mut self,
14973            decoder: &mut fidl::encoding::Decoder<
14974                '_,
14975                fidl::encoding::DefaultFuchsiaResourceDialect,
14976            >,
14977            offset: usize,
14978            mut depth: fidl::encoding::Depth,
14979        ) -> fidl::Result<()> {
14980            decoder.debug_check_bounds::<Self>(offset);
14981            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
14982                None => return Err(fidl::Error::NotNullable),
14983                Some(len) => len,
14984            };
14985            // Calling decoder.out_of_line_offset(0) is not allowed.
14986            if len == 0 {
14987                return Ok(());
14988            };
14989            depth.increment()?;
14990            let envelope_size = 8;
14991            let bytes_len = len * envelope_size;
14992            let offset = decoder.out_of_line_offset(bytes_len)?;
14993            // Decode the envelope for each type.
14994            let mut _next_ordinal_to_read = 0;
14995            let mut next_offset = offset;
14996            let end_offset = offset + bytes_len;
14997            _next_ordinal_to_read += 1;
14998            if next_offset >= end_offset {
14999                return Ok(());
15000            }
15001
15002            // Decode unknown envelopes for gaps in ordinals.
15003            while _next_ordinal_to_read < 1 {
15004                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15005                _next_ordinal_to_read += 1;
15006                next_offset += envelope_size;
15007            }
15008
15009            let next_out_of_line = decoder.next_out_of_line();
15010            let handles_before = decoder.remaining_handles();
15011            if let Some((inlined, num_bytes, num_handles)) =
15012                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15013            {
15014                let member_inline_size =
15015                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15016                if inlined != (member_inline_size <= 4) {
15017                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15018                }
15019                let inner_offset;
15020                let mut inner_depth = depth.clone();
15021                if inlined {
15022                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15023                    inner_offset = next_offset;
15024                } else {
15025                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15026                    inner_depth.increment()?;
15027                }
15028                let val_ref = self.bool_member.get_or_insert_with(|| {
15029                    fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect)
15030                });
15031                fidl::decode!(
15032                    bool,
15033                    fidl::encoding::DefaultFuchsiaResourceDialect,
15034                    val_ref,
15035                    decoder,
15036                    inner_offset,
15037                    inner_depth
15038                )?;
15039                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15040                {
15041                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15042                }
15043                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15044                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15045                }
15046            }
15047
15048            next_offset += envelope_size;
15049            _next_ordinal_to_read += 1;
15050            if next_offset >= end_offset {
15051                return Ok(());
15052            }
15053
15054            // Decode unknown envelopes for gaps in ordinals.
15055            while _next_ordinal_to_read < 2 {
15056                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15057                _next_ordinal_to_read += 1;
15058                next_offset += envelope_size;
15059            }
15060
15061            let next_out_of_line = decoder.next_out_of_line();
15062            let handles_before = decoder.remaining_handles();
15063            if let Some((inlined, num_bytes, num_handles)) =
15064                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15065            {
15066                let member_inline_size =
15067                    <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15068                if inlined != (member_inline_size <= 4) {
15069                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15070                }
15071                let inner_offset;
15072                let mut inner_depth = depth.clone();
15073                if inlined {
15074                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15075                    inner_offset = next_offset;
15076                } else {
15077                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15078                    inner_depth.increment()?;
15079                }
15080                let val_ref = self.int8_member.get_or_insert_with(|| {
15081                    fidl::new_empty!(i8, fidl::encoding::DefaultFuchsiaResourceDialect)
15082                });
15083                fidl::decode!(
15084                    i8,
15085                    fidl::encoding::DefaultFuchsiaResourceDialect,
15086                    val_ref,
15087                    decoder,
15088                    inner_offset,
15089                    inner_depth
15090                )?;
15091                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15092                {
15093                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15094                }
15095                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15096                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15097                }
15098            }
15099
15100            next_offset += envelope_size;
15101            _next_ordinal_to_read += 1;
15102            if next_offset >= end_offset {
15103                return Ok(());
15104            }
15105
15106            // Decode unknown envelopes for gaps in ordinals.
15107            while _next_ordinal_to_read < 3 {
15108                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15109                _next_ordinal_to_read += 1;
15110                next_offset += envelope_size;
15111            }
15112
15113            let next_out_of_line = decoder.next_out_of_line();
15114            let handles_before = decoder.remaining_handles();
15115            if let Some((inlined, num_bytes, num_handles)) =
15116                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15117            {
15118                let member_inline_size =
15119                    <i16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15120                if inlined != (member_inline_size <= 4) {
15121                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15122                }
15123                let inner_offset;
15124                let mut inner_depth = depth.clone();
15125                if inlined {
15126                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15127                    inner_offset = next_offset;
15128                } else {
15129                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15130                    inner_depth.increment()?;
15131                }
15132                let val_ref = self.int16_member.get_or_insert_with(|| {
15133                    fidl::new_empty!(i16, fidl::encoding::DefaultFuchsiaResourceDialect)
15134                });
15135                fidl::decode!(
15136                    i16,
15137                    fidl::encoding::DefaultFuchsiaResourceDialect,
15138                    val_ref,
15139                    decoder,
15140                    inner_offset,
15141                    inner_depth
15142                )?;
15143                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15144                {
15145                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15146                }
15147                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15148                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15149                }
15150            }
15151
15152            next_offset += envelope_size;
15153            _next_ordinal_to_read += 1;
15154            if next_offset >= end_offset {
15155                return Ok(());
15156            }
15157
15158            // Decode unknown envelopes for gaps in ordinals.
15159            while _next_ordinal_to_read < 4 {
15160                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15161                _next_ordinal_to_read += 1;
15162                next_offset += envelope_size;
15163            }
15164
15165            let next_out_of_line = decoder.next_out_of_line();
15166            let handles_before = decoder.remaining_handles();
15167            if let Some((inlined, num_bytes, num_handles)) =
15168                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15169            {
15170                let member_inline_size =
15171                    <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15172                if inlined != (member_inline_size <= 4) {
15173                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15174                }
15175                let inner_offset;
15176                let mut inner_depth = depth.clone();
15177                if inlined {
15178                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15179                    inner_offset = next_offset;
15180                } else {
15181                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15182                    inner_depth.increment()?;
15183                }
15184                let val_ref = self.int32_member.get_or_insert_with(|| {
15185                    fidl::new_empty!(i32, fidl::encoding::DefaultFuchsiaResourceDialect)
15186                });
15187                fidl::decode!(
15188                    i32,
15189                    fidl::encoding::DefaultFuchsiaResourceDialect,
15190                    val_ref,
15191                    decoder,
15192                    inner_offset,
15193                    inner_depth
15194                )?;
15195                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15196                {
15197                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15198                }
15199                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15200                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15201                }
15202            }
15203
15204            next_offset += envelope_size;
15205            _next_ordinal_to_read += 1;
15206            if next_offset >= end_offset {
15207                return Ok(());
15208            }
15209
15210            // Decode unknown envelopes for gaps in ordinals.
15211            while _next_ordinal_to_read < 5 {
15212                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15213                _next_ordinal_to_read += 1;
15214                next_offset += envelope_size;
15215            }
15216
15217            let next_out_of_line = decoder.next_out_of_line();
15218            let handles_before = decoder.remaining_handles();
15219            if let Some((inlined, num_bytes, num_handles)) =
15220                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15221            {
15222                let member_inline_size =
15223                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15224                if inlined != (member_inline_size <= 4) {
15225                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15226                }
15227                let inner_offset;
15228                let mut inner_depth = depth.clone();
15229                if inlined {
15230                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15231                    inner_offset = next_offset;
15232                } else {
15233                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15234                    inner_depth.increment()?;
15235                }
15236                let val_ref = self.int64_member.get_or_insert_with(|| {
15237                    fidl::new_empty!(i64, fidl::encoding::DefaultFuchsiaResourceDialect)
15238                });
15239                fidl::decode!(
15240                    i64,
15241                    fidl::encoding::DefaultFuchsiaResourceDialect,
15242                    val_ref,
15243                    decoder,
15244                    inner_offset,
15245                    inner_depth
15246                )?;
15247                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15248                {
15249                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15250                }
15251                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15252                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15253                }
15254            }
15255
15256            next_offset += envelope_size;
15257            _next_ordinal_to_read += 1;
15258            if next_offset >= end_offset {
15259                return Ok(());
15260            }
15261
15262            // Decode unknown envelopes for gaps in ordinals.
15263            while _next_ordinal_to_read < 6 {
15264                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15265                _next_ordinal_to_read += 1;
15266                next_offset += envelope_size;
15267            }
15268
15269            let next_out_of_line = decoder.next_out_of_line();
15270            let handles_before = decoder.remaining_handles();
15271            if let Some((inlined, num_bytes, num_handles)) =
15272                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15273            {
15274                let member_inline_size =
15275                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15276                if inlined != (member_inline_size <= 4) {
15277                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15278                }
15279                let inner_offset;
15280                let mut inner_depth = depth.clone();
15281                if inlined {
15282                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15283                    inner_offset = next_offset;
15284                } else {
15285                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15286                    inner_depth.increment()?;
15287                }
15288                let val_ref = self.uint8_member.get_or_insert_with(|| {
15289                    fidl::new_empty!(u8, fidl::encoding::DefaultFuchsiaResourceDialect)
15290                });
15291                fidl::decode!(
15292                    u8,
15293                    fidl::encoding::DefaultFuchsiaResourceDialect,
15294                    val_ref,
15295                    decoder,
15296                    inner_offset,
15297                    inner_depth
15298                )?;
15299                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15300                {
15301                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15302                }
15303                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15304                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15305                }
15306            }
15307
15308            next_offset += envelope_size;
15309            _next_ordinal_to_read += 1;
15310            if next_offset >= end_offset {
15311                return Ok(());
15312            }
15313
15314            // Decode unknown envelopes for gaps in ordinals.
15315            while _next_ordinal_to_read < 7 {
15316                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15317                _next_ordinal_to_read += 1;
15318                next_offset += envelope_size;
15319            }
15320
15321            let next_out_of_line = decoder.next_out_of_line();
15322            let handles_before = decoder.remaining_handles();
15323            if let Some((inlined, num_bytes, num_handles)) =
15324                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15325            {
15326                let member_inline_size =
15327                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15328                if inlined != (member_inline_size <= 4) {
15329                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15330                }
15331                let inner_offset;
15332                let mut inner_depth = depth.clone();
15333                if inlined {
15334                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15335                    inner_offset = next_offset;
15336                } else {
15337                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15338                    inner_depth.increment()?;
15339                }
15340                let val_ref = self.uint16_member.get_or_insert_with(|| {
15341                    fidl::new_empty!(u16, fidl::encoding::DefaultFuchsiaResourceDialect)
15342                });
15343                fidl::decode!(
15344                    u16,
15345                    fidl::encoding::DefaultFuchsiaResourceDialect,
15346                    val_ref,
15347                    decoder,
15348                    inner_offset,
15349                    inner_depth
15350                )?;
15351                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15352                {
15353                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15354                }
15355                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15356                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15357                }
15358            }
15359
15360            next_offset += envelope_size;
15361            _next_ordinal_to_read += 1;
15362            if next_offset >= end_offset {
15363                return Ok(());
15364            }
15365
15366            // Decode unknown envelopes for gaps in ordinals.
15367            while _next_ordinal_to_read < 8 {
15368                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15369                _next_ordinal_to_read += 1;
15370                next_offset += envelope_size;
15371            }
15372
15373            let next_out_of_line = decoder.next_out_of_line();
15374            let handles_before = decoder.remaining_handles();
15375            if let Some((inlined, num_bytes, num_handles)) =
15376                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15377            {
15378                let member_inline_size =
15379                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15380                if inlined != (member_inline_size <= 4) {
15381                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15382                }
15383                let inner_offset;
15384                let mut inner_depth = depth.clone();
15385                if inlined {
15386                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15387                    inner_offset = next_offset;
15388                } else {
15389                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15390                    inner_depth.increment()?;
15391                }
15392                let val_ref = self.uint32_member.get_or_insert_with(|| {
15393                    fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect)
15394                });
15395                fidl::decode!(
15396                    u32,
15397                    fidl::encoding::DefaultFuchsiaResourceDialect,
15398                    val_ref,
15399                    decoder,
15400                    inner_offset,
15401                    inner_depth
15402                )?;
15403                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15404                {
15405                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15406                }
15407                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15408                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15409                }
15410            }
15411
15412            next_offset += envelope_size;
15413            _next_ordinal_to_read += 1;
15414            if next_offset >= end_offset {
15415                return Ok(());
15416            }
15417
15418            // Decode unknown envelopes for gaps in ordinals.
15419            while _next_ordinal_to_read < 9 {
15420                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15421                _next_ordinal_to_read += 1;
15422                next_offset += envelope_size;
15423            }
15424
15425            let next_out_of_line = decoder.next_out_of_line();
15426            let handles_before = decoder.remaining_handles();
15427            if let Some((inlined, num_bytes, num_handles)) =
15428                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15429            {
15430                let member_inline_size =
15431                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15432                if inlined != (member_inline_size <= 4) {
15433                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15434                }
15435                let inner_offset;
15436                let mut inner_depth = depth.clone();
15437                if inlined {
15438                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15439                    inner_offset = next_offset;
15440                } else {
15441                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15442                    inner_depth.increment()?;
15443                }
15444                let val_ref = self.uint64_member.get_or_insert_with(|| {
15445                    fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect)
15446                });
15447                fidl::decode!(
15448                    u64,
15449                    fidl::encoding::DefaultFuchsiaResourceDialect,
15450                    val_ref,
15451                    decoder,
15452                    inner_offset,
15453                    inner_depth
15454                )?;
15455                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15456                {
15457                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15458                }
15459                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15460                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15461                }
15462            }
15463
15464            next_offset += envelope_size;
15465            _next_ordinal_to_read += 1;
15466            if next_offset >= end_offset {
15467                return Ok(());
15468            }
15469
15470            // Decode unknown envelopes for gaps in ordinals.
15471            while _next_ordinal_to_read < 10 {
15472                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15473                _next_ordinal_to_read += 1;
15474                next_offset += envelope_size;
15475            }
15476
15477            let next_out_of_line = decoder.next_out_of_line();
15478            let handles_before = decoder.remaining_handles();
15479            if let Some((inlined, num_bytes, num_handles)) =
15480                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15481            {
15482                let member_inline_size =
15483                    <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15484                if inlined != (member_inline_size <= 4) {
15485                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15486                }
15487                let inner_offset;
15488                let mut inner_depth = depth.clone();
15489                if inlined {
15490                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15491                    inner_offset = next_offset;
15492                } else {
15493                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15494                    inner_depth.increment()?;
15495                }
15496                let val_ref = self.float32_member.get_or_insert_with(|| {
15497                    fidl::new_empty!(f32, fidl::encoding::DefaultFuchsiaResourceDialect)
15498                });
15499                fidl::decode!(
15500                    f32,
15501                    fidl::encoding::DefaultFuchsiaResourceDialect,
15502                    val_ref,
15503                    decoder,
15504                    inner_offset,
15505                    inner_depth
15506                )?;
15507                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15508                {
15509                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15510                }
15511                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15512                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15513                }
15514            }
15515
15516            next_offset += envelope_size;
15517            _next_ordinal_to_read += 1;
15518            if next_offset >= end_offset {
15519                return Ok(());
15520            }
15521
15522            // Decode unknown envelopes for gaps in ordinals.
15523            while _next_ordinal_to_read < 11 {
15524                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15525                _next_ordinal_to_read += 1;
15526                next_offset += envelope_size;
15527            }
15528
15529            let next_out_of_line = decoder.next_out_of_line();
15530            let handles_before = decoder.remaining_handles();
15531            if let Some((inlined, num_bytes, num_handles)) =
15532                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15533            {
15534                let member_inline_size =
15535                    <f64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15536                if inlined != (member_inline_size <= 4) {
15537                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15538                }
15539                let inner_offset;
15540                let mut inner_depth = depth.clone();
15541                if inlined {
15542                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15543                    inner_offset = next_offset;
15544                } else {
15545                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15546                    inner_depth.increment()?;
15547                }
15548                let val_ref = self.float64_member.get_or_insert_with(|| {
15549                    fidl::new_empty!(f64, fidl::encoding::DefaultFuchsiaResourceDialect)
15550                });
15551                fidl::decode!(
15552                    f64,
15553                    fidl::encoding::DefaultFuchsiaResourceDialect,
15554                    val_ref,
15555                    decoder,
15556                    inner_offset,
15557                    inner_depth
15558                )?;
15559                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15560                {
15561                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15562                }
15563                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15564                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15565                }
15566            }
15567
15568            next_offset += envelope_size;
15569            _next_ordinal_to_read += 1;
15570            if next_offset >= end_offset {
15571                return Ok(());
15572            }
15573
15574            // Decode unknown envelopes for gaps in ordinals.
15575            while _next_ordinal_to_read < 12 {
15576                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15577                _next_ordinal_to_read += 1;
15578                next_offset += envelope_size;
15579            }
15580
15581            let next_out_of_line = decoder.next_out_of_line();
15582            let handles_before = decoder.remaining_handles();
15583            if let Some((inlined, num_bytes, num_handles)) =
15584                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15585            {
15586                let member_inline_size =
15587                    <DefaultEnum as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15588                if inlined != (member_inline_size <= 4) {
15589                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15590                }
15591                let inner_offset;
15592                let mut inner_depth = depth.clone();
15593                if inlined {
15594                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15595                    inner_offset = next_offset;
15596                } else {
15597                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15598                    inner_depth.increment()?;
15599                }
15600                let val_ref = self.enum_member.get_or_insert_with(|| {
15601                    fidl::new_empty!(DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect)
15602                });
15603                fidl::decode!(
15604                    DefaultEnum,
15605                    fidl::encoding::DefaultFuchsiaResourceDialect,
15606                    val_ref,
15607                    decoder,
15608                    inner_offset,
15609                    inner_depth
15610                )?;
15611                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15612                {
15613                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15614                }
15615                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15616                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15617                }
15618            }
15619
15620            next_offset += envelope_size;
15621            _next_ordinal_to_read += 1;
15622            if next_offset >= end_offset {
15623                return Ok(());
15624            }
15625
15626            // Decode unknown envelopes for gaps in ordinals.
15627            while _next_ordinal_to_read < 13 {
15628                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15629                _next_ordinal_to_read += 1;
15630                next_offset += envelope_size;
15631            }
15632
15633            let next_out_of_line = decoder.next_out_of_line();
15634            let handles_before = decoder.remaining_handles();
15635            if let Some((inlined, num_bytes, num_handles)) =
15636                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15637            {
15638                let member_inline_size =
15639                    <DefaultBits as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15640                if inlined != (member_inline_size <= 4) {
15641                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15642                }
15643                let inner_offset;
15644                let mut inner_depth = depth.clone();
15645                if inlined {
15646                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15647                    inner_offset = next_offset;
15648                } else {
15649                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15650                    inner_depth.increment()?;
15651                }
15652                let val_ref = self.bits_member.get_or_insert_with(|| {
15653                    fidl::new_empty!(DefaultBits, fidl::encoding::DefaultFuchsiaResourceDialect)
15654                });
15655                fidl::decode!(
15656                    DefaultBits,
15657                    fidl::encoding::DefaultFuchsiaResourceDialect,
15658                    val_ref,
15659                    decoder,
15660                    inner_offset,
15661                    inner_depth
15662                )?;
15663                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15664                {
15665                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15666                }
15667                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15668                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15669                }
15670            }
15671
15672            next_offset += envelope_size;
15673            _next_ordinal_to_read += 1;
15674            if next_offset >= end_offset {
15675                return Ok(());
15676            }
15677
15678            // Decode unknown envelopes for gaps in ordinals.
15679            while _next_ordinal_to_read < 14 {
15680                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15681                _next_ordinal_to_read += 1;
15682                next_offset += envelope_size;
15683            }
15684
15685            let next_out_of_line = decoder.next_out_of_line();
15686            let handles_before = decoder.remaining_handles();
15687            if let Some((inlined, num_bytes, num_handles)) =
15688                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15689            {
15690                let member_inline_size = <fidl::encoding::HandleType<
15691                    fidl::Handle,
15692                    { fidl::ObjectType::NONE.into_raw() },
15693                    2147483648,
15694                > as fidl::encoding::TypeMarker>::inline_size(
15695                    decoder.context
15696                );
15697                if inlined != (member_inline_size <= 4) {
15698                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15699                }
15700                let inner_offset;
15701                let mut inner_depth = depth.clone();
15702                if inlined {
15703                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15704                    inner_offset = next_offset;
15705                } else {
15706                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15707                    inner_depth.increment()?;
15708                }
15709                let val_ref =
15710                self.handle_member.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
15711                fidl::decode!(fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
15712                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15713                {
15714                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15715                }
15716                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15717                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15718                }
15719            }
15720
15721            next_offset += envelope_size;
15722            _next_ordinal_to_read += 1;
15723            if next_offset >= end_offset {
15724                return Ok(());
15725            }
15726
15727            // Decode unknown envelopes for gaps in ordinals.
15728            while _next_ordinal_to_read < 15 {
15729                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15730                _next_ordinal_to_read += 1;
15731                next_offset += envelope_size;
15732            }
15733
15734            let next_out_of_line = decoder.next_out_of_line();
15735            let handles_before = decoder.remaining_handles();
15736            if let Some((inlined, num_bytes, num_handles)) =
15737                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15738            {
15739                let member_inline_size =
15740                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
15741                        decoder.context,
15742                    );
15743                if inlined != (member_inline_size <= 4) {
15744                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15745                }
15746                let inner_offset;
15747                let mut inner_depth = depth.clone();
15748                if inlined {
15749                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15750                    inner_offset = next_offset;
15751                } else {
15752                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15753                    inner_depth.increment()?;
15754                }
15755                let val_ref = self.string_member.get_or_insert_with(|| {
15756                    fidl::new_empty!(
15757                        fidl::encoding::UnboundedString,
15758                        fidl::encoding::DefaultFuchsiaResourceDialect
15759                    )
15760                });
15761                fidl::decode!(
15762                    fidl::encoding::UnboundedString,
15763                    fidl::encoding::DefaultFuchsiaResourceDialect,
15764                    val_ref,
15765                    decoder,
15766                    inner_offset,
15767                    inner_depth
15768                )?;
15769                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15770                {
15771                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15772                }
15773                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15774                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15775                }
15776            }
15777
15778            next_offset += envelope_size;
15779            _next_ordinal_to_read += 1;
15780            if next_offset >= end_offset {
15781                return Ok(());
15782            }
15783
15784            // Decode unknown envelopes for gaps in ordinals.
15785            while _next_ordinal_to_read < 16 {
15786                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15787                _next_ordinal_to_read += 1;
15788                next_offset += envelope_size;
15789            }
15790
15791            let next_out_of_line = decoder.next_out_of_line();
15792            let handles_before = decoder.remaining_handles();
15793            if let Some((inlined, num_bytes, num_handles)) =
15794                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15795            {
15796                let member_inline_size =
15797                    <ThisIsAStruct as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15798                if inlined != (member_inline_size <= 4) {
15799                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15800                }
15801                let inner_offset;
15802                let mut inner_depth = depth.clone();
15803                if inlined {
15804                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15805                    inner_offset = next_offset;
15806                } else {
15807                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15808                    inner_depth.increment()?;
15809                }
15810                let val_ref = self.struct_member.get_or_insert_with(|| {
15811                    fidl::new_empty!(ThisIsAStruct, fidl::encoding::DefaultFuchsiaResourceDialect)
15812                });
15813                fidl::decode!(
15814                    ThisIsAStruct,
15815                    fidl::encoding::DefaultFuchsiaResourceDialect,
15816                    val_ref,
15817                    decoder,
15818                    inner_offset,
15819                    inner_depth
15820                )?;
15821                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15822                {
15823                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15824                }
15825                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15826                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15827                }
15828            }
15829
15830            next_offset += envelope_size;
15831            _next_ordinal_to_read += 1;
15832            if next_offset >= end_offset {
15833                return Ok(());
15834            }
15835
15836            // Decode unknown envelopes for gaps in ordinals.
15837            while _next_ordinal_to_read < 17 {
15838                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15839                _next_ordinal_to_read += 1;
15840                next_offset += envelope_size;
15841            }
15842
15843            let next_out_of_line = decoder.next_out_of_line();
15844            let handles_before = decoder.remaining_handles();
15845            if let Some((inlined, num_bytes, num_handles)) =
15846                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15847            {
15848                let member_inline_size =
15849                    <ThisIsAUnion as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15850                if inlined != (member_inline_size <= 4) {
15851                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15852                }
15853                let inner_offset;
15854                let mut inner_depth = depth.clone();
15855                if inlined {
15856                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15857                    inner_offset = next_offset;
15858                } else {
15859                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15860                    inner_depth.increment()?;
15861                }
15862                let val_ref = self.union_member.get_or_insert_with(|| {
15863                    fidl::new_empty!(ThisIsAUnion, fidl::encoding::DefaultFuchsiaResourceDialect)
15864                });
15865                fidl::decode!(
15866                    ThisIsAUnion,
15867                    fidl::encoding::DefaultFuchsiaResourceDialect,
15868                    val_ref,
15869                    decoder,
15870                    inner_offset,
15871                    inner_depth
15872                )?;
15873                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15874                {
15875                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15876                }
15877                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15878                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15879                }
15880            }
15881
15882            next_offset += envelope_size;
15883            _next_ordinal_to_read += 1;
15884            if next_offset >= end_offset {
15885                return Ok(());
15886            }
15887
15888            // Decode unknown envelopes for gaps in ordinals.
15889            while _next_ordinal_to_read < 18 {
15890                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15891                _next_ordinal_to_read += 1;
15892                next_offset += envelope_size;
15893            }
15894
15895            let next_out_of_line = decoder.next_out_of_line();
15896            let handles_before = decoder.remaining_handles();
15897            if let Some((inlined, num_bytes, num_handles)) =
15898                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15899            {
15900                let member_inline_size =
15901                    <fidl::encoding::Array<u32, 3> as fidl::encoding::TypeMarker>::inline_size(
15902                        decoder.context,
15903                    );
15904                if inlined != (member_inline_size <= 4) {
15905                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15906                }
15907                let inner_offset;
15908                let mut inner_depth = depth.clone();
15909                if inlined {
15910                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15911                    inner_offset = next_offset;
15912                } else {
15913                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15914                    inner_depth.increment()?;
15915                }
15916                let val_ref =
15917                self.array_member.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect));
15918                fidl::decode!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
15919                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15920                {
15921                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15922                }
15923                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15924                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15925                }
15926            }
15927
15928            next_offset += envelope_size;
15929            _next_ordinal_to_read += 1;
15930            if next_offset >= end_offset {
15931                return Ok(());
15932            }
15933
15934            // Decode unknown envelopes for gaps in ordinals.
15935            while _next_ordinal_to_read < 19 {
15936                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15937                _next_ordinal_to_read += 1;
15938                next_offset += envelope_size;
15939            }
15940
15941            let next_out_of_line = decoder.next_out_of_line();
15942            let handles_before = decoder.remaining_handles();
15943            if let Some((inlined, num_bytes, num_handles)) =
15944                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15945            {
15946                let member_inline_size = <fidl::encoding::UnboundedVector<u32> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15947                if inlined != (member_inline_size <= 4) {
15948                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15949                }
15950                let inner_offset;
15951                let mut inner_depth = depth.clone();
15952                if inlined {
15953                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15954                    inner_offset = next_offset;
15955                } else {
15956                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15957                    inner_depth.increment()?;
15958                }
15959                let val_ref = self.vector_member.get_or_insert_with(|| {
15960                    fidl::new_empty!(
15961                        fidl::encoding::UnboundedVector<u32>,
15962                        fidl::encoding::DefaultFuchsiaResourceDialect
15963                    )
15964                });
15965                fidl::decode!(
15966                    fidl::encoding::UnboundedVector<u32>,
15967                    fidl::encoding::DefaultFuchsiaResourceDialect,
15968                    val_ref,
15969                    decoder,
15970                    inner_offset,
15971                    inner_depth
15972                )?;
15973                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15974                {
15975                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15976                }
15977                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15978                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15979                }
15980            }
15981
15982            next_offset += envelope_size;
15983            _next_ordinal_to_read += 1;
15984            if next_offset >= end_offset {
15985                return Ok(());
15986            }
15987
15988            // Decode unknown envelopes for gaps in ordinals.
15989            while _next_ordinal_to_read < 20 {
15990                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15991                _next_ordinal_to_read += 1;
15992                next_offset += envelope_size;
15993            }
15994
15995            let next_out_of_line = decoder.next_out_of_line();
15996            let handles_before = decoder.remaining_handles();
15997            if let Some((inlined, num_bytes, num_handles)) =
15998                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15999            {
16000                let member_inline_size =
16001                    <ThisIsATable as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16002                if inlined != (member_inline_size <= 4) {
16003                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16004                }
16005                let inner_offset;
16006                let mut inner_depth = depth.clone();
16007                if inlined {
16008                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16009                    inner_offset = next_offset;
16010                } else {
16011                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16012                    inner_depth.increment()?;
16013                }
16014                let val_ref = self.table_member.get_or_insert_with(|| {
16015                    fidl::new_empty!(ThisIsATable, fidl::encoding::DefaultFuchsiaResourceDialect)
16016                });
16017                fidl::decode!(
16018                    ThisIsATable,
16019                    fidl::encoding::DefaultFuchsiaResourceDialect,
16020                    val_ref,
16021                    decoder,
16022                    inner_offset,
16023                    inner_depth
16024                )?;
16025                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16026                {
16027                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16028                }
16029                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16030                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16031                }
16032            }
16033
16034            next_offset += envelope_size;
16035            _next_ordinal_to_read += 1;
16036            if next_offset >= end_offset {
16037                return Ok(());
16038            }
16039
16040            // Decode unknown envelopes for gaps in ordinals.
16041            while _next_ordinal_to_read < 21 {
16042                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16043                _next_ordinal_to_read += 1;
16044                next_offset += envelope_size;
16045            }
16046
16047            let next_out_of_line = decoder.next_out_of_line();
16048            let handles_before = decoder.remaining_handles();
16049            if let Some((inlined, num_bytes, num_handles)) =
16050                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16051            {
16052                let member_inline_size =
16053                    <ThisIsAXunion as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16054                if inlined != (member_inline_size <= 4) {
16055                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16056                }
16057                let inner_offset;
16058                let mut inner_depth = depth.clone();
16059                if inlined {
16060                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16061                    inner_offset = next_offset;
16062                } else {
16063                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16064                    inner_depth.increment()?;
16065                }
16066                let val_ref = self.xunion_member.get_or_insert_with(|| {
16067                    fidl::new_empty!(ThisIsAXunion, fidl::encoding::DefaultFuchsiaResourceDialect)
16068                });
16069                fidl::decode!(
16070                    ThisIsAXunion,
16071                    fidl::encoding::DefaultFuchsiaResourceDialect,
16072                    val_ref,
16073                    decoder,
16074                    inner_offset,
16075                    inner_depth
16076                )?;
16077                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16078                {
16079                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16080                }
16081                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16082                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16083                }
16084            }
16085
16086            next_offset += envelope_size;
16087
16088            // Decode the remaining unknown envelopes.
16089            while next_offset < end_offset {
16090                _next_ordinal_to_read += 1;
16091                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16092                next_offset += envelope_size;
16093            }
16094
16095            Ok(())
16096        }
16097    }
16098
16099    impl fidl::encoding::ResourceTypeMarker for AllTypesXunion {
16100        type Borrowed<'a> = &'a mut Self;
16101        fn take_or_borrow<'a>(
16102            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
16103        ) -> Self::Borrowed<'a> {
16104            value
16105        }
16106    }
16107
16108    unsafe impl fidl::encoding::TypeMarker for AllTypesXunion {
16109        type Owned = Self;
16110
16111        #[inline(always)]
16112        fn inline_align(_context: fidl::encoding::Context) -> usize {
16113            8
16114        }
16115
16116        #[inline(always)]
16117        fn inline_size(_context: fidl::encoding::Context) -> usize {
16118            16
16119        }
16120    }
16121
16122    unsafe impl
16123        fidl::encoding::Encode<AllTypesXunion, fidl::encoding::DefaultFuchsiaResourceDialect>
16124        for &mut AllTypesXunion
16125    {
16126        #[inline]
16127        unsafe fn encode(
16128            self,
16129            encoder: &mut fidl::encoding::Encoder<
16130                '_,
16131                fidl::encoding::DefaultFuchsiaResourceDialect,
16132            >,
16133            offset: usize,
16134            _depth: fidl::encoding::Depth,
16135        ) -> fidl::Result<()> {
16136            encoder.debug_check_bounds::<AllTypesXunion>(offset);
16137            encoder.write_num::<u64>(self.ordinal(), offset);
16138            match self {
16139            AllTypesXunion::BoolMember(ref val) => {
16140                fidl::encoding::encode_in_envelope::<bool, fidl::encoding::DefaultFuchsiaResourceDialect>(
16141                    <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
16142                    encoder, offset + 8, _depth
16143                )
16144            }
16145            AllTypesXunion::Int8Member(ref val) => {
16146                fidl::encoding::encode_in_envelope::<i8, fidl::encoding::DefaultFuchsiaResourceDialect>(
16147                    <i8 as fidl::encoding::ValueTypeMarker>::borrow(val),
16148                    encoder, offset + 8, _depth
16149                )
16150            }
16151            AllTypesXunion::Int16Member(ref val) => {
16152                fidl::encoding::encode_in_envelope::<i16, fidl::encoding::DefaultFuchsiaResourceDialect>(
16153                    <i16 as fidl::encoding::ValueTypeMarker>::borrow(val),
16154                    encoder, offset + 8, _depth
16155                )
16156            }
16157            AllTypesXunion::Int32Member(ref val) => {
16158                fidl::encoding::encode_in_envelope::<i32, fidl::encoding::DefaultFuchsiaResourceDialect>(
16159                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(val),
16160                    encoder, offset + 8, _depth
16161                )
16162            }
16163            AllTypesXunion::Int64Member(ref val) => {
16164                fidl::encoding::encode_in_envelope::<i64, fidl::encoding::DefaultFuchsiaResourceDialect>(
16165                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(val),
16166                    encoder, offset + 8, _depth
16167                )
16168            }
16169            AllTypesXunion::Uint8Member(ref val) => {
16170                fidl::encoding::encode_in_envelope::<u8, fidl::encoding::DefaultFuchsiaResourceDialect>(
16171                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(val),
16172                    encoder, offset + 8, _depth
16173                )
16174            }
16175            AllTypesXunion::Uint16Member(ref val) => {
16176                fidl::encoding::encode_in_envelope::<u16, fidl::encoding::DefaultFuchsiaResourceDialect>(
16177                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(val),
16178                    encoder, offset + 8, _depth
16179                )
16180            }
16181            AllTypesXunion::Uint32Member(ref val) => {
16182                fidl::encoding::encode_in_envelope::<u32, fidl::encoding::DefaultFuchsiaResourceDialect>(
16183                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
16184                    encoder, offset + 8, _depth
16185                )
16186            }
16187            AllTypesXunion::Uint64Member(ref val) => {
16188                fidl::encoding::encode_in_envelope::<u64, fidl::encoding::DefaultFuchsiaResourceDialect>(
16189                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(val),
16190                    encoder, offset + 8, _depth
16191                )
16192            }
16193            AllTypesXunion::Float32Member(ref val) => {
16194                fidl::encoding::encode_in_envelope::<f32, fidl::encoding::DefaultFuchsiaResourceDialect>(
16195                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(val),
16196                    encoder, offset + 8, _depth
16197                )
16198            }
16199            AllTypesXunion::Float64Member(ref val) => {
16200                fidl::encoding::encode_in_envelope::<f64, fidl::encoding::DefaultFuchsiaResourceDialect>(
16201                    <f64 as fidl::encoding::ValueTypeMarker>::borrow(val),
16202                    encoder, offset + 8, _depth
16203                )
16204            }
16205            AllTypesXunion::EnumMember(ref val) => {
16206                fidl::encoding::encode_in_envelope::<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>(
16207                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(val),
16208                    encoder, offset + 8, _depth
16209                )
16210            }
16211            AllTypesXunion::BitsMember(ref val) => {
16212                fidl::encoding::encode_in_envelope::<DefaultBits, fidl::encoding::DefaultFuchsiaResourceDialect>(
16213                    <DefaultBits as fidl::encoding::ValueTypeMarker>::borrow(val),
16214                    encoder, offset + 8, _depth
16215                )
16216            }
16217            AllTypesXunion::HandleMember(ref mut val) => {
16218                fidl::encoding::encode_in_envelope::<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect>(
16219                    <fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
16220                    encoder, offset + 8, _depth
16221                )
16222            }
16223            AllTypesXunion::StringMember(ref val) => {
16224                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedString, fidl::encoding::DefaultFuchsiaResourceDialect>(
16225                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(val),
16226                    encoder, offset + 8, _depth
16227                )
16228            }
16229            AllTypesXunion::StructMember(ref val) => {
16230                fidl::encoding::encode_in_envelope::<ThisIsAStruct, fidl::encoding::DefaultFuchsiaResourceDialect>(
16231                    <ThisIsAStruct as fidl::encoding::ValueTypeMarker>::borrow(val),
16232                    encoder, offset + 8, _depth
16233                )
16234            }
16235            AllTypesXunion::UnionMember(ref val) => {
16236                fidl::encoding::encode_in_envelope::<ThisIsAUnion, fidl::encoding::DefaultFuchsiaResourceDialect>(
16237                    <ThisIsAUnion as fidl::encoding::ValueTypeMarker>::borrow(val),
16238                    encoder, offset + 8, _depth
16239                )
16240            }
16241            AllTypesXunion::ArrayMember(ref val) => {
16242                fidl::encoding::encode_in_envelope::<fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect>(
16243                    <fidl::encoding::Array<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow(val),
16244                    encoder, offset + 8, _depth
16245                )
16246            }
16247            AllTypesXunion::VectorMember(ref val) => {
16248                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<u32>, fidl::encoding::DefaultFuchsiaResourceDialect>(
16249                    <fidl::encoding::UnboundedVector<u32> as fidl::encoding::ValueTypeMarker>::borrow(val),
16250                    encoder, offset + 8, _depth
16251                )
16252            }
16253            AllTypesXunion::TableMember(ref val) => {
16254                fidl::encoding::encode_in_envelope::<ThisIsATable, fidl::encoding::DefaultFuchsiaResourceDialect>(
16255                    <ThisIsATable as fidl::encoding::ValueTypeMarker>::borrow(val),
16256                    encoder, offset + 8, _depth
16257                )
16258            }
16259            AllTypesXunion::XunionMember(ref val) => {
16260                fidl::encoding::encode_in_envelope::<ThisIsAXunion, fidl::encoding::DefaultFuchsiaResourceDialect>(
16261                    <ThisIsAXunion as fidl::encoding::ValueTypeMarker>::borrow(val),
16262                    encoder, offset + 8, _depth
16263                )
16264            }
16265            AllTypesXunion::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
16266        }
16267        }
16268    }
16269
16270    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
16271        for AllTypesXunion
16272    {
16273        #[inline(always)]
16274        fn new_empty() -> Self {
16275            Self::__SourceBreaking { unknown_ordinal: 0 }
16276        }
16277
16278        #[inline]
16279        unsafe fn decode(
16280            &mut self,
16281            decoder: &mut fidl::encoding::Decoder<
16282                '_,
16283                fidl::encoding::DefaultFuchsiaResourceDialect,
16284            >,
16285            offset: usize,
16286            mut depth: fidl::encoding::Depth,
16287        ) -> fidl::Result<()> {
16288            decoder.debug_check_bounds::<Self>(offset);
16289            #[allow(unused_variables)]
16290            let next_out_of_line = decoder.next_out_of_line();
16291            let handles_before = decoder.remaining_handles();
16292            let (ordinal, inlined, num_bytes, num_handles) =
16293                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
16294
16295            let member_inline_size = match ordinal {
16296            1 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16297            2 => <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16298            3 => <i16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16299            4 => <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16300            5 => <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16301            6 => <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16302            7 => <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16303            8 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16304            9 => <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16305            10 => <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16306            11 => <f64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16307            12 => <DefaultEnum as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16308            13 => <DefaultBits as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16309            14 => <fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16310            15 => <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16311            16 => <ThisIsAStruct as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16312            17 => <ThisIsAUnion as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16313            18 => <fidl::encoding::Array<u32, 3> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16314            19 => <fidl::encoding::UnboundedVector<u32> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16315            20 => <ThisIsATable as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16316            21 => <ThisIsAXunion as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16317            0 => return Err(fidl::Error::UnknownUnionTag),
16318            _ => num_bytes as usize,
16319        };
16320
16321            if inlined != (member_inline_size <= 4) {
16322                return Err(fidl::Error::InvalidInlineBitInEnvelope);
16323            }
16324            let _inner_offset;
16325            if inlined {
16326                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
16327                _inner_offset = offset + 8;
16328            } else {
16329                depth.increment()?;
16330                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16331            }
16332            match ordinal {
16333                1 => {
16334                    #[allow(irrefutable_let_patterns)]
16335                    if let AllTypesXunion::BoolMember(_) = self {
16336                        // Do nothing, read the value into the object
16337                    } else {
16338                        // Initialize `self` to the right variant
16339                        *self = AllTypesXunion::BoolMember(fidl::new_empty!(
16340                            bool,
16341                            fidl::encoding::DefaultFuchsiaResourceDialect
16342                        ));
16343                    }
16344                    #[allow(irrefutable_let_patterns)]
16345                    if let AllTypesXunion::BoolMember(ref mut val) = self {
16346                        fidl::decode!(
16347                            bool,
16348                            fidl::encoding::DefaultFuchsiaResourceDialect,
16349                            val,
16350                            decoder,
16351                            _inner_offset,
16352                            depth
16353                        )?;
16354                    } else {
16355                        unreachable!()
16356                    }
16357                }
16358                2 => {
16359                    #[allow(irrefutable_let_patterns)]
16360                    if let AllTypesXunion::Int8Member(_) = self {
16361                        // Do nothing, read the value into the object
16362                    } else {
16363                        // Initialize `self` to the right variant
16364                        *self = AllTypesXunion::Int8Member(fidl::new_empty!(
16365                            i8,
16366                            fidl::encoding::DefaultFuchsiaResourceDialect
16367                        ));
16368                    }
16369                    #[allow(irrefutable_let_patterns)]
16370                    if let AllTypesXunion::Int8Member(ref mut val) = self {
16371                        fidl::decode!(
16372                            i8,
16373                            fidl::encoding::DefaultFuchsiaResourceDialect,
16374                            val,
16375                            decoder,
16376                            _inner_offset,
16377                            depth
16378                        )?;
16379                    } else {
16380                        unreachable!()
16381                    }
16382                }
16383                3 => {
16384                    #[allow(irrefutable_let_patterns)]
16385                    if let AllTypesXunion::Int16Member(_) = self {
16386                        // Do nothing, read the value into the object
16387                    } else {
16388                        // Initialize `self` to the right variant
16389                        *self = AllTypesXunion::Int16Member(fidl::new_empty!(
16390                            i16,
16391                            fidl::encoding::DefaultFuchsiaResourceDialect
16392                        ));
16393                    }
16394                    #[allow(irrefutable_let_patterns)]
16395                    if let AllTypesXunion::Int16Member(ref mut val) = self {
16396                        fidl::decode!(
16397                            i16,
16398                            fidl::encoding::DefaultFuchsiaResourceDialect,
16399                            val,
16400                            decoder,
16401                            _inner_offset,
16402                            depth
16403                        )?;
16404                    } else {
16405                        unreachable!()
16406                    }
16407                }
16408                4 => {
16409                    #[allow(irrefutable_let_patterns)]
16410                    if let AllTypesXunion::Int32Member(_) = self {
16411                        // Do nothing, read the value into the object
16412                    } else {
16413                        // Initialize `self` to the right variant
16414                        *self = AllTypesXunion::Int32Member(fidl::new_empty!(
16415                            i32,
16416                            fidl::encoding::DefaultFuchsiaResourceDialect
16417                        ));
16418                    }
16419                    #[allow(irrefutable_let_patterns)]
16420                    if let AllTypesXunion::Int32Member(ref mut val) = self {
16421                        fidl::decode!(
16422                            i32,
16423                            fidl::encoding::DefaultFuchsiaResourceDialect,
16424                            val,
16425                            decoder,
16426                            _inner_offset,
16427                            depth
16428                        )?;
16429                    } else {
16430                        unreachable!()
16431                    }
16432                }
16433                5 => {
16434                    #[allow(irrefutable_let_patterns)]
16435                    if let AllTypesXunion::Int64Member(_) = self {
16436                        // Do nothing, read the value into the object
16437                    } else {
16438                        // Initialize `self` to the right variant
16439                        *self = AllTypesXunion::Int64Member(fidl::new_empty!(
16440                            i64,
16441                            fidl::encoding::DefaultFuchsiaResourceDialect
16442                        ));
16443                    }
16444                    #[allow(irrefutable_let_patterns)]
16445                    if let AllTypesXunion::Int64Member(ref mut val) = self {
16446                        fidl::decode!(
16447                            i64,
16448                            fidl::encoding::DefaultFuchsiaResourceDialect,
16449                            val,
16450                            decoder,
16451                            _inner_offset,
16452                            depth
16453                        )?;
16454                    } else {
16455                        unreachable!()
16456                    }
16457                }
16458                6 => {
16459                    #[allow(irrefutable_let_patterns)]
16460                    if let AllTypesXunion::Uint8Member(_) = self {
16461                        // Do nothing, read the value into the object
16462                    } else {
16463                        // Initialize `self` to the right variant
16464                        *self = AllTypesXunion::Uint8Member(fidl::new_empty!(
16465                            u8,
16466                            fidl::encoding::DefaultFuchsiaResourceDialect
16467                        ));
16468                    }
16469                    #[allow(irrefutable_let_patterns)]
16470                    if let AllTypesXunion::Uint8Member(ref mut val) = self {
16471                        fidl::decode!(
16472                            u8,
16473                            fidl::encoding::DefaultFuchsiaResourceDialect,
16474                            val,
16475                            decoder,
16476                            _inner_offset,
16477                            depth
16478                        )?;
16479                    } else {
16480                        unreachable!()
16481                    }
16482                }
16483                7 => {
16484                    #[allow(irrefutable_let_patterns)]
16485                    if let AllTypesXunion::Uint16Member(_) = self {
16486                        // Do nothing, read the value into the object
16487                    } else {
16488                        // Initialize `self` to the right variant
16489                        *self = AllTypesXunion::Uint16Member(fidl::new_empty!(
16490                            u16,
16491                            fidl::encoding::DefaultFuchsiaResourceDialect
16492                        ));
16493                    }
16494                    #[allow(irrefutable_let_patterns)]
16495                    if let AllTypesXunion::Uint16Member(ref mut val) = self {
16496                        fidl::decode!(
16497                            u16,
16498                            fidl::encoding::DefaultFuchsiaResourceDialect,
16499                            val,
16500                            decoder,
16501                            _inner_offset,
16502                            depth
16503                        )?;
16504                    } else {
16505                        unreachable!()
16506                    }
16507                }
16508                8 => {
16509                    #[allow(irrefutable_let_patterns)]
16510                    if let AllTypesXunion::Uint32Member(_) = self {
16511                        // Do nothing, read the value into the object
16512                    } else {
16513                        // Initialize `self` to the right variant
16514                        *self = AllTypesXunion::Uint32Member(fidl::new_empty!(
16515                            u32,
16516                            fidl::encoding::DefaultFuchsiaResourceDialect
16517                        ));
16518                    }
16519                    #[allow(irrefutable_let_patterns)]
16520                    if let AllTypesXunion::Uint32Member(ref mut val) = self {
16521                        fidl::decode!(
16522                            u32,
16523                            fidl::encoding::DefaultFuchsiaResourceDialect,
16524                            val,
16525                            decoder,
16526                            _inner_offset,
16527                            depth
16528                        )?;
16529                    } else {
16530                        unreachable!()
16531                    }
16532                }
16533                9 => {
16534                    #[allow(irrefutable_let_patterns)]
16535                    if let AllTypesXunion::Uint64Member(_) = self {
16536                        // Do nothing, read the value into the object
16537                    } else {
16538                        // Initialize `self` to the right variant
16539                        *self = AllTypesXunion::Uint64Member(fidl::new_empty!(
16540                            u64,
16541                            fidl::encoding::DefaultFuchsiaResourceDialect
16542                        ));
16543                    }
16544                    #[allow(irrefutable_let_patterns)]
16545                    if let AllTypesXunion::Uint64Member(ref mut val) = self {
16546                        fidl::decode!(
16547                            u64,
16548                            fidl::encoding::DefaultFuchsiaResourceDialect,
16549                            val,
16550                            decoder,
16551                            _inner_offset,
16552                            depth
16553                        )?;
16554                    } else {
16555                        unreachable!()
16556                    }
16557                }
16558                10 => {
16559                    #[allow(irrefutable_let_patterns)]
16560                    if let AllTypesXunion::Float32Member(_) = self {
16561                        // Do nothing, read the value into the object
16562                    } else {
16563                        // Initialize `self` to the right variant
16564                        *self = AllTypesXunion::Float32Member(fidl::new_empty!(
16565                            f32,
16566                            fidl::encoding::DefaultFuchsiaResourceDialect
16567                        ));
16568                    }
16569                    #[allow(irrefutable_let_patterns)]
16570                    if let AllTypesXunion::Float32Member(ref mut val) = self {
16571                        fidl::decode!(
16572                            f32,
16573                            fidl::encoding::DefaultFuchsiaResourceDialect,
16574                            val,
16575                            decoder,
16576                            _inner_offset,
16577                            depth
16578                        )?;
16579                    } else {
16580                        unreachable!()
16581                    }
16582                }
16583                11 => {
16584                    #[allow(irrefutable_let_patterns)]
16585                    if let AllTypesXunion::Float64Member(_) = self {
16586                        // Do nothing, read the value into the object
16587                    } else {
16588                        // Initialize `self` to the right variant
16589                        *self = AllTypesXunion::Float64Member(fidl::new_empty!(
16590                            f64,
16591                            fidl::encoding::DefaultFuchsiaResourceDialect
16592                        ));
16593                    }
16594                    #[allow(irrefutable_let_patterns)]
16595                    if let AllTypesXunion::Float64Member(ref mut val) = self {
16596                        fidl::decode!(
16597                            f64,
16598                            fidl::encoding::DefaultFuchsiaResourceDialect,
16599                            val,
16600                            decoder,
16601                            _inner_offset,
16602                            depth
16603                        )?;
16604                    } else {
16605                        unreachable!()
16606                    }
16607                }
16608                12 => {
16609                    #[allow(irrefutable_let_patterns)]
16610                    if let AllTypesXunion::EnumMember(_) = self {
16611                        // Do nothing, read the value into the object
16612                    } else {
16613                        // Initialize `self` to the right variant
16614                        *self = AllTypesXunion::EnumMember(fidl::new_empty!(
16615                            DefaultEnum,
16616                            fidl::encoding::DefaultFuchsiaResourceDialect
16617                        ));
16618                    }
16619                    #[allow(irrefutable_let_patterns)]
16620                    if let AllTypesXunion::EnumMember(ref mut val) = self {
16621                        fidl::decode!(
16622                            DefaultEnum,
16623                            fidl::encoding::DefaultFuchsiaResourceDialect,
16624                            val,
16625                            decoder,
16626                            _inner_offset,
16627                            depth
16628                        )?;
16629                    } else {
16630                        unreachable!()
16631                    }
16632                }
16633                13 => {
16634                    #[allow(irrefutable_let_patterns)]
16635                    if let AllTypesXunion::BitsMember(_) = self {
16636                        // Do nothing, read the value into the object
16637                    } else {
16638                        // Initialize `self` to the right variant
16639                        *self = AllTypesXunion::BitsMember(fidl::new_empty!(
16640                            DefaultBits,
16641                            fidl::encoding::DefaultFuchsiaResourceDialect
16642                        ));
16643                    }
16644                    #[allow(irrefutable_let_patterns)]
16645                    if let AllTypesXunion::BitsMember(ref mut val) = self {
16646                        fidl::decode!(
16647                            DefaultBits,
16648                            fidl::encoding::DefaultFuchsiaResourceDialect,
16649                            val,
16650                            decoder,
16651                            _inner_offset,
16652                            depth
16653                        )?;
16654                    } else {
16655                        unreachable!()
16656                    }
16657                }
16658                14 => {
16659                    #[allow(irrefutable_let_patterns)]
16660                    if let AllTypesXunion::HandleMember(_) = self {
16661                        // Do nothing, read the value into the object
16662                    } else {
16663                        // Initialize `self` to the right variant
16664                        *self = AllTypesXunion::HandleMember(
16665                            fidl::new_empty!(fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
16666                        );
16667                    }
16668                    #[allow(irrefutable_let_patterns)]
16669                    if let AllTypesXunion::HandleMember(ref mut val) = self {
16670                        fidl::decode!(fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val, decoder, _inner_offset, depth)?;
16671                    } else {
16672                        unreachable!()
16673                    }
16674                }
16675                15 => {
16676                    #[allow(irrefutable_let_patterns)]
16677                    if let AllTypesXunion::StringMember(_) = self {
16678                        // Do nothing, read the value into the object
16679                    } else {
16680                        // Initialize `self` to the right variant
16681                        *self = AllTypesXunion::StringMember(fidl::new_empty!(
16682                            fidl::encoding::UnboundedString,
16683                            fidl::encoding::DefaultFuchsiaResourceDialect
16684                        ));
16685                    }
16686                    #[allow(irrefutable_let_patterns)]
16687                    if let AllTypesXunion::StringMember(ref mut val) = self {
16688                        fidl::decode!(
16689                            fidl::encoding::UnboundedString,
16690                            fidl::encoding::DefaultFuchsiaResourceDialect,
16691                            val,
16692                            decoder,
16693                            _inner_offset,
16694                            depth
16695                        )?;
16696                    } else {
16697                        unreachable!()
16698                    }
16699                }
16700                16 => {
16701                    #[allow(irrefutable_let_patterns)]
16702                    if let AllTypesXunion::StructMember(_) = self {
16703                        // Do nothing, read the value into the object
16704                    } else {
16705                        // Initialize `self` to the right variant
16706                        *self = AllTypesXunion::StructMember(fidl::new_empty!(
16707                            ThisIsAStruct,
16708                            fidl::encoding::DefaultFuchsiaResourceDialect
16709                        ));
16710                    }
16711                    #[allow(irrefutable_let_patterns)]
16712                    if let AllTypesXunion::StructMember(ref mut val) = self {
16713                        fidl::decode!(
16714                            ThisIsAStruct,
16715                            fidl::encoding::DefaultFuchsiaResourceDialect,
16716                            val,
16717                            decoder,
16718                            _inner_offset,
16719                            depth
16720                        )?;
16721                    } else {
16722                        unreachable!()
16723                    }
16724                }
16725                17 => {
16726                    #[allow(irrefutable_let_patterns)]
16727                    if let AllTypesXunion::UnionMember(_) = self {
16728                        // Do nothing, read the value into the object
16729                    } else {
16730                        // Initialize `self` to the right variant
16731                        *self = AllTypesXunion::UnionMember(fidl::new_empty!(
16732                            ThisIsAUnion,
16733                            fidl::encoding::DefaultFuchsiaResourceDialect
16734                        ));
16735                    }
16736                    #[allow(irrefutable_let_patterns)]
16737                    if let AllTypesXunion::UnionMember(ref mut val) = self {
16738                        fidl::decode!(
16739                            ThisIsAUnion,
16740                            fidl::encoding::DefaultFuchsiaResourceDialect,
16741                            val,
16742                            decoder,
16743                            _inner_offset,
16744                            depth
16745                        )?;
16746                    } else {
16747                        unreachable!()
16748                    }
16749                }
16750                18 => {
16751                    #[allow(irrefutable_let_patterns)]
16752                    if let AllTypesXunion::ArrayMember(_) = self {
16753                        // Do nothing, read the value into the object
16754                    } else {
16755                        // Initialize `self` to the right variant
16756                        *self = AllTypesXunion::ArrayMember(
16757                            fidl::new_empty!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
16758                        );
16759                    }
16760                    #[allow(irrefutable_let_patterns)]
16761                    if let AllTypesXunion::ArrayMember(ref mut val) = self {
16762                        fidl::decode!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, val, decoder, _inner_offset, depth)?;
16763                    } else {
16764                        unreachable!()
16765                    }
16766                }
16767                19 => {
16768                    #[allow(irrefutable_let_patterns)]
16769                    if let AllTypesXunion::VectorMember(_) = self {
16770                        // Do nothing, read the value into the object
16771                    } else {
16772                        // Initialize `self` to the right variant
16773                        *self = AllTypesXunion::VectorMember(fidl::new_empty!(
16774                            fidl::encoding::UnboundedVector<u32>,
16775                            fidl::encoding::DefaultFuchsiaResourceDialect
16776                        ));
16777                    }
16778                    #[allow(irrefutable_let_patterns)]
16779                    if let AllTypesXunion::VectorMember(ref mut val) = self {
16780                        fidl::decode!(
16781                            fidl::encoding::UnboundedVector<u32>,
16782                            fidl::encoding::DefaultFuchsiaResourceDialect,
16783                            val,
16784                            decoder,
16785                            _inner_offset,
16786                            depth
16787                        )?;
16788                    } else {
16789                        unreachable!()
16790                    }
16791                }
16792                20 => {
16793                    #[allow(irrefutable_let_patterns)]
16794                    if let AllTypesXunion::TableMember(_) = self {
16795                        // Do nothing, read the value into the object
16796                    } else {
16797                        // Initialize `self` to the right variant
16798                        *self = AllTypesXunion::TableMember(fidl::new_empty!(
16799                            ThisIsATable,
16800                            fidl::encoding::DefaultFuchsiaResourceDialect
16801                        ));
16802                    }
16803                    #[allow(irrefutable_let_patterns)]
16804                    if let AllTypesXunion::TableMember(ref mut val) = self {
16805                        fidl::decode!(
16806                            ThisIsATable,
16807                            fidl::encoding::DefaultFuchsiaResourceDialect,
16808                            val,
16809                            decoder,
16810                            _inner_offset,
16811                            depth
16812                        )?;
16813                    } else {
16814                        unreachable!()
16815                    }
16816                }
16817                21 => {
16818                    #[allow(irrefutable_let_patterns)]
16819                    if let AllTypesXunion::XunionMember(_) = self {
16820                        // Do nothing, read the value into the object
16821                    } else {
16822                        // Initialize `self` to the right variant
16823                        *self = AllTypesXunion::XunionMember(fidl::new_empty!(
16824                            ThisIsAXunion,
16825                            fidl::encoding::DefaultFuchsiaResourceDialect
16826                        ));
16827                    }
16828                    #[allow(irrefutable_let_patterns)]
16829                    if let AllTypesXunion::XunionMember(ref mut val) = self {
16830                        fidl::decode!(
16831                            ThisIsAXunion,
16832                            fidl::encoding::DefaultFuchsiaResourceDialect,
16833                            val,
16834                            decoder,
16835                            _inner_offset,
16836                            depth
16837                        )?;
16838                    } else {
16839                        unreachable!()
16840                    }
16841                }
16842                #[allow(deprecated)]
16843                ordinal => {
16844                    for _ in 0..num_handles {
16845                        decoder.drop_next_handle()?;
16846                    }
16847                    *self = AllTypesXunion::__SourceBreaking { unknown_ordinal: ordinal };
16848                }
16849            }
16850            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
16851                return Err(fidl::Error::InvalidNumBytesInEnvelope);
16852            }
16853            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16854                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16855            }
16856            Ok(())
16857        }
16858    }
16859}
fidl_fidl_test_compatibility/fidl_fidl_test_compatibility.rs

fidl_fidl_test_compatibility/
fidl_fidl_test_compatibility.rs
