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::NullableHandle; 3],
30    pub nullable_handles: [Option<fidl::NullableHandle>; 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::NullableHandle>,
302    pub nullable_handles: Vec<Option<fidl::NullableHandle>>,
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::NullableHandle; 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::NullableHandle; 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::NullableHandle; 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::NullableHandle,
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::NullableHandle>,
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::NullableHandle>,
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::NullableHandle>>,
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::NullableHandle>,
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::NullableHandle>,
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::NullableHandle>>,
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::NullableHandle>>,
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::NullableHandle>>>,
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::NullableHandle>>,
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::NullableHandle>>,
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::NullableHandle>>>,
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::NullableHandle>,
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::NullableHandle),
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        Self { client: fidl::client::sync::Client::new(channel) }
711    }
712
713    pub fn into_channel(self) -> fidl::Channel {
714        self.client.into_channel()
715    }
716
717    /// Waits until an event arrives and returns it. It is safe for other
718    /// threads to make concurrent requests while waiting for an event.
719    pub fn wait_for_event(
720        &self,
721        deadline: zx::MonotonicInstant,
722    ) -> Result<ConfigEvent, fidl::Error> {
723        ConfigEvent::decode(self.client.wait_for_event::<ConfigMarker>(deadline)?)
724    }
725
726    pub fn r#get_impls(
727        &self,
728        ___deadline: zx::MonotonicInstant,
729    ) -> Result<Vec<String>, fidl::Error> {
730        let _response = self
731            .client
732            .send_query::<fidl::encoding::EmptyPayload, ConfigGetImplsResponse, ConfigMarker>(
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::NullableHandle {
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
1013    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1014        self.inner.shutdown_with_epitaph(status)
1015    }
1016
1017    fn is_closed(&self) -> bool {
1018        self.inner.channel().is_closed()
1019    }
1020    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1021        self.inner.channel().on_closed()
1022    }
1023
1024    #[cfg(target_os = "fuchsia")]
1025    fn signal_peer(
1026        &self,
1027        clear_mask: zx::Signals,
1028        set_mask: zx::Signals,
1029    ) -> Result<(), zx_status::Status> {
1030        use fidl::Peered;
1031        self.inner.channel().signal_peer(clear_mask, set_mask)
1032    }
1033}
1034
1035impl ConfigControlHandle {}
1036
1037#[must_use = "FIDL methods require a response to be sent"]
1038#[derive(Debug)]
1039pub struct ConfigGetImplsResponder {
1040    control_handle: std::mem::ManuallyDrop<ConfigControlHandle>,
1041    tx_id: u32,
1042}
1043
1044/// Set the the channel to be shutdown (see [`ConfigControlHandle::shutdown`])
1045/// if the responder is dropped without sending a response, so that the client
1046/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1047impl std::ops::Drop for ConfigGetImplsResponder {
1048    fn drop(&mut self) {
1049        self.control_handle.shutdown();
1050        // Safety: drops once, never accessed again
1051        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1052    }
1053}
1054
1055impl fidl::endpoints::Responder for ConfigGetImplsResponder {
1056    type ControlHandle = ConfigControlHandle;
1057
1058    fn control_handle(&self) -> &ConfigControlHandle {
1059        &self.control_handle
1060    }
1061
1062    fn drop_without_shutdown(mut self) {
1063        // Safety: drops once, never accessed again due to mem::forget
1064        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1065        // Prevent Drop from running (which would shut down the channel)
1066        std::mem::forget(self);
1067    }
1068}
1069
1070impl ConfigGetImplsResponder {
1071    /// Sends a response to the FIDL transaction.
1072    ///
1073    /// Sets the channel to shutdown if an error occurs.
1074    pub fn send(self, mut impls: &[String]) -> Result<(), fidl::Error> {
1075        let _result = self.send_raw(impls);
1076        if _result.is_err() {
1077            self.control_handle.shutdown();
1078        }
1079        self.drop_without_shutdown();
1080        _result
1081    }
1082
1083    /// Similar to "send" but does not shutdown the channel if an error occurs.
1084    pub fn send_no_shutdown_on_err(self, mut impls: &[String]) -> Result<(), fidl::Error> {
1085        let _result = self.send_raw(impls);
1086        self.drop_without_shutdown();
1087        _result
1088    }
1089
1090    fn send_raw(&self, mut impls: &[String]) -> Result<(), fidl::Error> {
1091        self.control_handle.inner.send::<ConfigGetImplsResponse>(
1092            (impls,),
1093            self.tx_id,
1094            0x3b360c86a6dbdfe0,
1095            fidl::encoding::DynamicFlags::empty(),
1096        )
1097    }
1098}
1099
1100#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
1101pub struct EchoMarker;
1102
1103impl fidl::endpoints::ProtocolMarker for EchoMarker {
1104    type Proxy = EchoProxy;
1105    type RequestStream = EchoRequestStream;
1106    #[cfg(target_os = "fuchsia")]
1107    type SynchronousProxy = EchoSynchronousProxy;
1108
1109    const DEBUG_NAME: &'static str = "fidl.test.compatibility.Echo";
1110}
1111impl fidl::endpoints::DiscoverableProtocolMarker for EchoMarker {}
1112pub type EchoEchoMinimalWithErrorResult = Result<(), u32>;
1113pub type EchoEchoStructWithErrorResult = Result<Struct, DefaultEnum>;
1114pub type EchoEchoArraysWithErrorResult = Result<ArraysStruct, DefaultEnum>;
1115pub type EchoEchoVectorsWithErrorResult = Result<VectorsStruct, DefaultEnum>;
1116pub type EchoEchoTableWithErrorResult = Result<AllTypesTable, DefaultEnum>;
1117pub type EchoEchoXunionsWithErrorResult = Result<Vec<AllTypesXunion>, DefaultEnum>;
1118pub type EchoEchoNamedStructWithErrorResult = Result<fidl_fidl_test_imported::SimpleStruct, u32>;
1119pub type EchoEchoTablePayloadWithErrorResult = Result<ResponseTable, DefaultEnum>;
1120pub type EchoEchoUnionPayloadWithErrorResult = Result<ResponseUnion, DefaultEnum>;
1121
1122pub trait EchoProxyInterface: Send + Sync {
1123    type EchoTableRequestComposedResponseFut: std::future::Future<Output = Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error>>
1124        + Send;
1125    fn r#echo_table_request_composed(
1126        &self,
1127        payload: &fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
1128    ) -> Self::EchoTableRequestComposedResponseFut;
1129    type EchoUnionResponseWithErrorComposedResponseFut: std::future::Future<
1130            Output = Result<
1131                fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
1132                fidl::Error,
1133            >,
1134        > + Send;
1135    fn r#echo_union_response_with_error_composed(
1136        &self,
1137        value: i64,
1138        want_absolute_value: bool,
1139        forward_to_server: &str,
1140        result_err: u32,
1141        result_variant: fidl_fidl_test_imported::WantResponse,
1142    ) -> Self::EchoUnionResponseWithErrorComposedResponseFut;
1143    type EchoMinimalResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
1144    fn r#echo_minimal(&self, forward_to_server: &str) -> Self::EchoMinimalResponseFut;
1145    type EchoMinimalWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoMinimalWithErrorResult, fidl::Error>>
1146        + Send;
1147    fn r#echo_minimal_with_error(
1148        &self,
1149        forward_to_server: &str,
1150        result_variant: RespondWith,
1151    ) -> Self::EchoMinimalWithErrorResponseFut;
1152    fn r#echo_minimal_no_ret_val(&self, forward_to_server: &str) -> Result<(), fidl::Error>;
1153    type EchoStructResponseFut: std::future::Future<Output = Result<Struct, fidl::Error>> + Send;
1154    fn r#echo_struct(&self, value: Struct, forward_to_server: &str) -> Self::EchoStructResponseFut;
1155    type EchoStructWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoStructWithErrorResult, fidl::Error>>
1156        + Send;
1157    fn r#echo_struct_with_error(
1158        &self,
1159        value: Struct,
1160        result_err: DefaultEnum,
1161        forward_to_server: &str,
1162        result_variant: RespondWith,
1163    ) -> Self::EchoStructWithErrorResponseFut;
1164    fn r#echo_struct_no_ret_val(
1165        &self,
1166        value: Struct,
1167        forward_to_server: &str,
1168    ) -> Result<(), fidl::Error>;
1169    type EchoArraysResponseFut: std::future::Future<Output = Result<ArraysStruct, fidl::Error>>
1170        + Send;
1171    fn r#echo_arrays(
1172        &self,
1173        value: ArraysStruct,
1174        forward_to_server: &str,
1175    ) -> Self::EchoArraysResponseFut;
1176    type EchoArraysWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoArraysWithErrorResult, fidl::Error>>
1177        + Send;
1178    fn r#echo_arrays_with_error(
1179        &self,
1180        value: ArraysStruct,
1181        result_err: DefaultEnum,
1182        forward_to_server: &str,
1183        result_variant: RespondWith,
1184    ) -> Self::EchoArraysWithErrorResponseFut;
1185    type EchoVectorsResponseFut: std::future::Future<Output = Result<VectorsStruct, fidl::Error>>
1186        + Send;
1187    fn r#echo_vectors(
1188        &self,
1189        value: VectorsStruct,
1190        forward_to_server: &str,
1191    ) -> Self::EchoVectorsResponseFut;
1192    type EchoVectorsWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoVectorsWithErrorResult, fidl::Error>>
1193        + Send;
1194    fn r#echo_vectors_with_error(
1195        &self,
1196        value: VectorsStruct,
1197        result_err: DefaultEnum,
1198        forward_to_server: &str,
1199        result_variant: RespondWith,
1200    ) -> Self::EchoVectorsWithErrorResponseFut;
1201    type EchoTableResponseFut: std::future::Future<Output = Result<AllTypesTable, fidl::Error>>
1202        + Send;
1203    fn r#echo_table(
1204        &self,
1205        value: AllTypesTable,
1206        forward_to_server: &str,
1207    ) -> Self::EchoTableResponseFut;
1208    type EchoTableWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoTableWithErrorResult, fidl::Error>>
1209        + Send;
1210    fn r#echo_table_with_error(
1211        &self,
1212        value: AllTypesTable,
1213        result_err: DefaultEnum,
1214        forward_to_server: &str,
1215        result_variant: RespondWith,
1216    ) -> Self::EchoTableWithErrorResponseFut;
1217    type EchoXunionsResponseFut: std::future::Future<Output = Result<Vec<AllTypesXunion>, fidl::Error>>
1218        + Send;
1219    fn r#echo_xunions(
1220        &self,
1221        value: Vec<AllTypesXunion>,
1222        forward_to_server: &str,
1223    ) -> Self::EchoXunionsResponseFut;
1224    type EchoXunionsWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoXunionsWithErrorResult, fidl::Error>>
1225        + Send;
1226    fn r#echo_xunions_with_error(
1227        &self,
1228        value: Vec<AllTypesXunion>,
1229        result_err: DefaultEnum,
1230        forward_to_server: &str,
1231        result_variant: RespondWith,
1232    ) -> Self::EchoXunionsWithErrorResponseFut;
1233    type EchoNamedStructResponseFut: std::future::Future<Output = Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error>>
1234        + Send;
1235    fn r#echo_named_struct(
1236        &self,
1237        value: &fidl_fidl_test_imported::SimpleStruct,
1238        forward_to_server: &str,
1239    ) -> Self::EchoNamedStructResponseFut;
1240    type EchoNamedStructWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoNamedStructWithErrorResult, fidl::Error>>
1241        + Send;
1242    fn r#echo_named_struct_with_error(
1243        &self,
1244        value: &fidl_fidl_test_imported::SimpleStruct,
1245        result_err: u32,
1246        forward_to_server: &str,
1247        result_variant: fidl_fidl_test_imported::WantResponse,
1248    ) -> Self::EchoNamedStructWithErrorResponseFut;
1249    fn r#echo_named_struct_no_ret_val(
1250        &self,
1251        value: &fidl_fidl_test_imported::SimpleStruct,
1252        forward_to_server: &str,
1253    ) -> Result<(), fidl::Error>;
1254    type EchoTablePayloadResponseFut: std::future::Future<Output = Result<ResponseTable, fidl::Error>>
1255        + Send;
1256    fn r#echo_table_payload(&self, payload: &RequestTable) -> Self::EchoTablePayloadResponseFut;
1257    type EchoTablePayloadWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoTablePayloadWithErrorResult, fidl::Error>>
1258        + Send;
1259    fn r#echo_table_payload_with_error(
1260        &self,
1261        payload: &EchoEchoTablePayloadWithErrorRequest,
1262    ) -> Self::EchoTablePayloadWithErrorResponseFut;
1263    fn r#echo_table_payload_no_ret_val(&self, payload: &RequestTable) -> Result<(), fidl::Error>;
1264    type EchoUnionPayloadResponseFut: std::future::Future<Output = Result<ResponseUnion, fidl::Error>>
1265        + Send;
1266    fn r#echo_union_payload(&self, payload: &RequestUnion) -> Self::EchoUnionPayloadResponseFut;
1267    type EchoUnionPayloadWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoUnionPayloadWithErrorResult, fidl::Error>>
1268        + Send;
1269    fn r#echo_union_payload_with_error(
1270        &self,
1271        payload: &EchoEchoUnionPayloadWithErrorRequest,
1272    ) -> Self::EchoUnionPayloadWithErrorResponseFut;
1273    fn r#echo_union_payload_no_ret_val(&self, payload: &RequestUnion) -> Result<(), fidl::Error>;
1274}
1275#[derive(Debug)]
1276#[cfg(target_os = "fuchsia")]
1277pub struct EchoSynchronousProxy {
1278    client: fidl::client::sync::Client,
1279}
1280
1281#[cfg(target_os = "fuchsia")]
1282impl fidl::endpoints::SynchronousProxy for EchoSynchronousProxy {
1283    type Proxy = EchoProxy;
1284    type Protocol = EchoMarker;
1285
1286    fn from_channel(inner: fidl::Channel) -> Self {
1287        Self::new(inner)
1288    }
1289
1290    fn into_channel(self) -> fidl::Channel {
1291        self.client.into_channel()
1292    }
1293
1294    fn as_channel(&self) -> &fidl::Channel {
1295        self.client.as_channel()
1296    }
1297}
1298
1299#[cfg(target_os = "fuchsia")]
1300impl EchoSynchronousProxy {
1301    pub fn new(channel: fidl::Channel) -> Self {
1302        Self { client: fidl::client::sync::Client::new(channel) }
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::<EchoMarker>(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            EchoMarker,
1324        >(
1325            payload,
1326            0x1d545c738c7a8ee,
1327            fidl::encoding::DynamicFlags::empty(),
1328            ___deadline,
1329        )?;
1330        Ok(_response.value)
1331    }
1332
1333    pub fn r#echo_union_response_with_error_composed(
1334        &self,
1335        mut value: i64,
1336        mut want_absolute_value: bool,
1337        mut forward_to_server: &str,
1338        mut result_err: u32,
1339        mut result_variant: fidl_fidl_test_imported::WantResponse,
1340        ___deadline: zx::MonotonicInstant,
1341    ) -> Result<
1342        fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
1343        fidl::Error,
1344    > {
1345        let _response = self.client.send_query::<
1346            fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedRequest,
1347            fidl::encoding::ResultType<fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse, u32>,
1348            EchoMarker,
1349        >(
1350            (value, want_absolute_value, forward_to_server, result_err, result_variant,),
1351            0x38a67e88d6106443,
1352            fidl::encoding::DynamicFlags::empty(),
1353            ___deadline,
1354        )?;
1355        Ok(_response.map(|x| x))
1356    }
1357
1358    pub fn r#echo_minimal(
1359        &self,
1360        mut forward_to_server: &str,
1361        ___deadline: zx::MonotonicInstant,
1362    ) -> Result<(), fidl::Error> {
1363        let _response = self
1364            .client
1365            .send_query::<EchoEchoMinimalRequest, fidl::encoding::EmptyPayload, EchoMarker>(
1366                (forward_to_server,),
1367                0x39edd68c837482ec,
1368                fidl::encoding::DynamicFlags::empty(),
1369                ___deadline,
1370            )?;
1371        Ok(_response)
1372    }
1373
1374    pub fn r#echo_minimal_with_error(
1375        &self,
1376        mut forward_to_server: &str,
1377        mut result_variant: RespondWith,
1378        ___deadline: zx::MonotonicInstant,
1379    ) -> Result<EchoEchoMinimalWithErrorResult, fidl::Error> {
1380        let _response = self.client.send_query::<
1381            EchoEchoMinimalWithErrorRequest,
1382            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, u32>,
1383            EchoMarker,
1384        >(
1385            (forward_to_server, result_variant,),
1386            0x36f4695996e35acc,
1387            fidl::encoding::DynamicFlags::empty(),
1388            ___deadline,
1389        )?;
1390        Ok(_response.map(|x| x))
1391    }
1392
1393    pub fn r#echo_minimal_no_ret_val(
1394        &self,
1395        mut forward_to_server: &str,
1396    ) -> Result<(), fidl::Error> {
1397        self.client.send::<EchoEchoMinimalNoRetValRequest>(
1398            (forward_to_server,),
1399            0x42693c143e2c3694,
1400            fidl::encoding::DynamicFlags::empty(),
1401        )
1402    }
1403
1404    pub fn r#echo_struct(
1405        &self,
1406        mut value: Struct,
1407        mut forward_to_server: &str,
1408        ___deadline: zx::MonotonicInstant,
1409    ) -> Result<Struct, fidl::Error> {
1410        let _response =
1411            self.client.send_query::<EchoEchoStructRequest, EchoEchoStructResponse, EchoMarker>(
1412                (&mut value, forward_to_server),
1413                0x4c2f85818cc53f37,
1414                fidl::encoding::DynamicFlags::empty(),
1415                ___deadline,
1416            )?;
1417        Ok(_response.value)
1418    }
1419
1420    pub fn r#echo_struct_with_error(
1421        &self,
1422        mut value: Struct,
1423        mut result_err: DefaultEnum,
1424        mut forward_to_server: &str,
1425        mut result_variant: RespondWith,
1426        ___deadline: zx::MonotonicInstant,
1427    ) -> Result<EchoEchoStructWithErrorResult, fidl::Error> {
1428        let _response = self.client.send_query::<
1429            EchoEchoStructWithErrorRequest,
1430            fidl::encoding::ResultType<EchoEchoStructWithErrorResponse, DefaultEnum>,
1431            EchoMarker,
1432        >(
1433            (&mut value, result_err, forward_to_server, result_variant,),
1434            0x46cb32652c4c0899,
1435            fidl::encoding::DynamicFlags::empty(),
1436            ___deadline,
1437        )?;
1438        Ok(_response.map(|x| x.value))
1439    }
1440
1441    pub fn r#echo_struct_no_ret_val(
1442        &self,
1443        mut value: Struct,
1444        mut forward_to_server: &str,
1445    ) -> Result<(), fidl::Error> {
1446        self.client.send::<EchoEchoStructNoRetValRequest>(
1447            (&mut value, forward_to_server),
1448            0x1f763e602cf5892a,
1449            fidl::encoding::DynamicFlags::empty(),
1450        )
1451    }
1452
1453    pub fn r#echo_arrays(
1454        &self,
1455        mut value: ArraysStruct,
1456        mut forward_to_server: &str,
1457        ___deadline: zx::MonotonicInstant,
1458    ) -> Result<ArraysStruct, fidl::Error> {
1459        let _response =
1460            self.client.send_query::<EchoEchoArraysRequest, EchoEchoArraysResponse, EchoMarker>(
1461                (&mut value, forward_to_server),
1462                0x1b6019d5611f2470,
1463                fidl::encoding::DynamicFlags::empty(),
1464                ___deadline,
1465            )?;
1466        Ok(_response.value)
1467    }
1468
1469    pub fn r#echo_arrays_with_error(
1470        &self,
1471        mut value: ArraysStruct,
1472        mut result_err: DefaultEnum,
1473        mut forward_to_server: &str,
1474        mut result_variant: RespondWith,
1475        ___deadline: zx::MonotonicInstant,
1476    ) -> Result<EchoEchoArraysWithErrorResult, fidl::Error> {
1477        let _response = self.client.send_query::<
1478            EchoEchoArraysWithErrorRequest,
1479            fidl::encoding::ResultType<EchoEchoArraysWithErrorResponse, DefaultEnum>,
1480            EchoMarker,
1481        >(
1482            (&mut value, result_err, forward_to_server, result_variant,),
1483            0x6dbf26e67e253afa,
1484            fidl::encoding::DynamicFlags::empty(),
1485            ___deadline,
1486        )?;
1487        Ok(_response.map(|x| x.value))
1488    }
1489
1490    pub fn r#echo_vectors(
1491        &self,
1492        mut value: VectorsStruct,
1493        mut forward_to_server: &str,
1494        ___deadline: zx::MonotonicInstant,
1495    ) -> Result<VectorsStruct, fidl::Error> {
1496        let _response =
1497            self.client.send_query::<EchoEchoVectorsRequest, EchoEchoVectorsResponse, EchoMarker>(
1498                (&mut value, forward_to_server),
1499                0x1582623f0d9f6e5e,
1500                fidl::encoding::DynamicFlags::empty(),
1501                ___deadline,
1502            )?;
1503        Ok(_response.value)
1504    }
1505
1506    pub fn r#echo_vectors_with_error(
1507        &self,
1508        mut value: VectorsStruct,
1509        mut result_err: DefaultEnum,
1510        mut forward_to_server: &str,
1511        mut result_variant: RespondWith,
1512        ___deadline: zx::MonotonicInstant,
1513    ) -> Result<EchoEchoVectorsWithErrorResult, fidl::Error> {
1514        let _response = self.client.send_query::<
1515            EchoEchoVectorsWithErrorRequest,
1516            fidl::encoding::ResultType<EchoEchoVectorsWithErrorResponse, DefaultEnum>,
1517            EchoMarker,
1518        >(
1519            (&mut value, result_err, forward_to_server, result_variant,),
1520            0x730f163401e2b3e5,
1521            fidl::encoding::DynamicFlags::empty(),
1522            ___deadline,
1523        )?;
1524        Ok(_response.map(|x| x.value))
1525    }
1526
1527    pub fn r#echo_table(
1528        &self,
1529        mut value: AllTypesTable,
1530        mut forward_to_server: &str,
1531        ___deadline: zx::MonotonicInstant,
1532    ) -> Result<AllTypesTable, fidl::Error> {
1533        let _response =
1534            self.client.send_query::<EchoEchoTableRequest, EchoEchoTableResponse, EchoMarker>(
1535                (&mut value, forward_to_server),
1536                0x4f1fb0a512f47c4b,
1537                fidl::encoding::DynamicFlags::empty(),
1538                ___deadline,
1539            )?;
1540        Ok(_response.value)
1541    }
1542
1543    pub fn r#echo_table_with_error(
1544        &self,
1545        mut value: AllTypesTable,
1546        mut result_err: DefaultEnum,
1547        mut forward_to_server: &str,
1548        mut result_variant: RespondWith,
1549        ___deadline: zx::MonotonicInstant,
1550    ) -> Result<EchoEchoTableWithErrorResult, fidl::Error> {
1551        let _response = self.client.send_query::<
1552            EchoEchoTableWithErrorRequest,
1553            fidl::encoding::ResultType<EchoEchoTableWithErrorResponse, DefaultEnum>,
1554            EchoMarker,
1555        >(
1556            (&mut value, result_err, forward_to_server, result_variant,),
1557            0x44e835cb1eb9a931,
1558            fidl::encoding::DynamicFlags::empty(),
1559            ___deadline,
1560        )?;
1561        Ok(_response.map(|x| x.value))
1562    }
1563
1564    pub fn r#echo_xunions(
1565        &self,
1566        mut value: Vec<AllTypesXunion>,
1567        mut forward_to_server: &str,
1568        ___deadline: zx::MonotonicInstant,
1569    ) -> Result<Vec<AllTypesXunion>, fidl::Error> {
1570        let _response =
1571            self.client.send_query::<EchoEchoXunionsRequest, EchoEchoXunionsResponse, EchoMarker>(
1572                (value.as_mut(), forward_to_server),
1573                0x3dc181909041a583,
1574                fidl::encoding::DynamicFlags::empty(),
1575                ___deadline,
1576            )?;
1577        Ok(_response.value)
1578    }
1579
1580    pub fn r#echo_xunions_with_error(
1581        &self,
1582        mut value: Vec<AllTypesXunion>,
1583        mut result_err: DefaultEnum,
1584        mut forward_to_server: &str,
1585        mut result_variant: RespondWith,
1586        ___deadline: zx::MonotonicInstant,
1587    ) -> Result<EchoEchoXunionsWithErrorResult, fidl::Error> {
1588        let _response = self.client.send_query::<
1589            EchoEchoXunionsWithErrorRequest,
1590            fidl::encoding::ResultType<EchoEchoXunionsWithErrorResponse, DefaultEnum>,
1591            EchoMarker,
1592        >(
1593            (value.as_mut(), result_err, forward_to_server, result_variant,),
1594            0x75184102667fa766,
1595            fidl::encoding::DynamicFlags::empty(),
1596            ___deadline,
1597        )?;
1598        Ok(_response.map(|x| x.value))
1599    }
1600
1601    pub fn r#echo_named_struct(
1602        &self,
1603        mut value: &fidl_fidl_test_imported::SimpleStruct,
1604        mut forward_to_server: &str,
1605        ___deadline: zx::MonotonicInstant,
1606    ) -> Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error> {
1607        let _response = self.client.send_query::<
1608            fidl_fidl_test_imported::RequestStruct,
1609            fidl_fidl_test_imported::ResponseStruct,
1610            EchoMarker,
1611        >(
1612            (value, forward_to_server,),
1613            0xf2d4aa9e65f7111,
1614            fidl::encoding::DynamicFlags::empty(),
1615            ___deadline,
1616        )?;
1617        Ok(_response.value)
1618    }
1619
1620    pub fn r#echo_named_struct_with_error(
1621        &self,
1622        mut value: &fidl_fidl_test_imported::SimpleStruct,
1623        mut result_err: u32,
1624        mut forward_to_server: &str,
1625        mut result_variant: fidl_fidl_test_imported::WantResponse,
1626        ___deadline: zx::MonotonicInstant,
1627    ) -> Result<EchoEchoNamedStructWithErrorResult, fidl::Error> {
1628        let _response = self.client.send_query::<
1629            fidl_fidl_test_imported::ErrorableRequestStruct,
1630            fidl::encoding::ResultType<fidl_fidl_test_imported::ResponseStruct, u32>,
1631            EchoMarker,
1632        >(
1633            (value, result_err, forward_to_server, result_variant,),
1634            0x5766fee9e74442e8,
1635            fidl::encoding::DynamicFlags::empty(),
1636            ___deadline,
1637        )?;
1638        Ok(_response.map(|x| x.value))
1639    }
1640
1641    pub fn r#echo_named_struct_no_ret_val(
1642        &self,
1643        mut value: &fidl_fidl_test_imported::SimpleStruct,
1644        mut forward_to_server: &str,
1645    ) -> Result<(), fidl::Error> {
1646        self.client.send::<fidl_fidl_test_imported::EventTriggeringRequestStruct>(
1647            (value, forward_to_server),
1648            0x3a50bbf7d2113ad7,
1649            fidl::encoding::DynamicFlags::empty(),
1650        )
1651    }
1652
1653    pub fn r#echo_table_payload(
1654        &self,
1655        mut payload: &RequestTable,
1656        ___deadline: zx::MonotonicInstant,
1657    ) -> Result<ResponseTable, fidl::Error> {
1658        let _response = self.client.send_query::<RequestTable, ResponseTable, EchoMarker>(
1659            payload,
1660            0x641d98087378c003,
1661            fidl::encoding::DynamicFlags::empty(),
1662            ___deadline,
1663        )?;
1664        Ok(_response)
1665    }
1666
1667    pub fn r#echo_table_payload_with_error(
1668        &self,
1669        mut payload: &EchoEchoTablePayloadWithErrorRequest,
1670        ___deadline: zx::MonotonicInstant,
1671    ) -> Result<EchoEchoTablePayloadWithErrorResult, fidl::Error> {
1672        let _response = self.client.send_query::<
1673            EchoEchoTablePayloadWithErrorRequest,
1674            fidl::encoding::ResultType<ResponseTable, DefaultEnum>,
1675            EchoMarker,
1676        >(
1677            payload,
1678            0x636ed243761ab66d,
1679            fidl::encoding::DynamicFlags::empty(),
1680            ___deadline,
1681        )?;
1682        Ok(_response.map(|x| x))
1683    }
1684
1685    pub fn r#echo_table_payload_no_ret_val(
1686        &self,
1687        mut payload: &RequestTable,
1688    ) -> Result<(), fidl::Error> {
1689        self.client.send::<RequestTable>(
1690            payload,
1691            0x32961f7d718569f8,
1692            fidl::encoding::DynamicFlags::empty(),
1693        )
1694    }
1695
1696    pub fn r#echo_union_payload(
1697        &self,
1698        mut payload: &RequestUnion,
1699        ___deadline: zx::MonotonicInstant,
1700    ) -> Result<ResponseUnion, fidl::Error> {
1701        let _response = self.client.send_query::<RequestUnion, ResponseUnion, EchoMarker>(
1702            payload,
1703            0x66def9e793f10c55,
1704            fidl::encoding::DynamicFlags::empty(),
1705            ___deadline,
1706        )?;
1707        Ok(_response)
1708    }
1709
1710    pub fn r#echo_union_payload_with_error(
1711        &self,
1712        mut payload: &EchoEchoUnionPayloadWithErrorRequest,
1713        ___deadline: zx::MonotonicInstant,
1714    ) -> Result<EchoEchoUnionPayloadWithErrorResult, fidl::Error> {
1715        let _response = self.client.send_query::<
1716            EchoEchoUnionPayloadWithErrorRequest,
1717            fidl::encoding::ResultType<ResponseUnion, DefaultEnum>,
1718            EchoMarker,
1719        >(
1720            payload,
1721            0x1be890d6e68ef063,
1722            fidl::encoding::DynamicFlags::empty(),
1723            ___deadline,
1724        )?;
1725        Ok(_response.map(|x| x))
1726    }
1727
1728    pub fn r#echo_union_payload_no_ret_val(
1729        &self,
1730        mut payload: &RequestUnion,
1731    ) -> Result<(), fidl::Error> {
1732        self.client.send::<RequestUnion>(
1733            payload,
1734            0x11518bf346430040,
1735            fidl::encoding::DynamicFlags::empty(),
1736        )
1737    }
1738}
1739
1740#[cfg(target_os = "fuchsia")]
1741impl From<EchoSynchronousProxy> for zx::NullableHandle {
1742    fn from(value: EchoSynchronousProxy) -> Self {
1743        value.into_channel().into()
1744    }
1745}
1746
1747#[cfg(target_os = "fuchsia")]
1748impl From<fidl::Channel> for EchoSynchronousProxy {
1749    fn from(value: fidl::Channel) -> Self {
1750        Self::new(value)
1751    }
1752}
1753
1754#[cfg(target_os = "fuchsia")]
1755impl fidl::endpoints::FromClient for EchoSynchronousProxy {
1756    type Protocol = EchoMarker;
1757
1758    fn from_client(value: fidl::endpoints::ClientEnd<EchoMarker>) -> Self {
1759        Self::new(value.into_channel())
1760    }
1761}
1762
1763#[derive(Debug, Clone)]
1764pub struct EchoProxy {
1765    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
1766}
1767
1768impl fidl::endpoints::Proxy for EchoProxy {
1769    type Protocol = EchoMarker;
1770
1771    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
1772        Self::new(inner)
1773    }
1774
1775    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
1776        self.client.into_channel().map_err(|client| Self { client })
1777    }
1778
1779    fn as_channel(&self) -> &::fidl::AsyncChannel {
1780        self.client.as_channel()
1781    }
1782}
1783
1784impl EchoProxy {
1785    /// Create a new Proxy for fidl.test.compatibility/Echo.
1786    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
1787        let protocol_name = <EchoMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1788        Self { client: fidl::client::Client::new(channel, protocol_name) }
1789    }
1790
1791    /// Get a Stream of events from the remote end of the protocol.
1792    ///
1793    /// # Panics
1794    ///
1795    /// Panics if the event stream was already taken.
1796    pub fn take_event_stream(&self) -> EchoEventStream {
1797        EchoEventStream { event_receiver: self.client.take_event_receiver() }
1798    }
1799
1800    pub fn r#echo_table_request_composed(
1801        &self,
1802        mut payload: &fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
1803    ) -> fidl::client::QueryResponseFut<
1804        fidl_fidl_test_imported::SimpleStruct,
1805        fidl::encoding::DefaultFuchsiaResourceDialect,
1806    > {
1807        EchoProxyInterface::r#echo_table_request_composed(self, payload)
1808    }
1809
1810    pub fn r#echo_union_response_with_error_composed(
1811        &self,
1812        mut value: i64,
1813        mut want_absolute_value: bool,
1814        mut forward_to_server: &str,
1815        mut result_err: u32,
1816        mut result_variant: fidl_fidl_test_imported::WantResponse,
1817    ) -> fidl::client::QueryResponseFut<
1818        fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
1819        fidl::encoding::DefaultFuchsiaResourceDialect,
1820    > {
1821        EchoProxyInterface::r#echo_union_response_with_error_composed(
1822            self,
1823            value,
1824            want_absolute_value,
1825            forward_to_server,
1826            result_err,
1827            result_variant,
1828        )
1829    }
1830
1831    pub fn r#echo_minimal(
1832        &self,
1833        mut forward_to_server: &str,
1834    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
1835        EchoProxyInterface::r#echo_minimal(self, forward_to_server)
1836    }
1837
1838    pub fn r#echo_minimal_with_error(
1839        &self,
1840        mut forward_to_server: &str,
1841        mut result_variant: RespondWith,
1842    ) -> fidl::client::QueryResponseFut<
1843        EchoEchoMinimalWithErrorResult,
1844        fidl::encoding::DefaultFuchsiaResourceDialect,
1845    > {
1846        EchoProxyInterface::r#echo_minimal_with_error(self, forward_to_server, result_variant)
1847    }
1848
1849    pub fn r#echo_minimal_no_ret_val(
1850        &self,
1851        mut forward_to_server: &str,
1852    ) -> Result<(), fidl::Error> {
1853        EchoProxyInterface::r#echo_minimal_no_ret_val(self, forward_to_server)
1854    }
1855
1856    pub fn r#echo_struct(
1857        &self,
1858        mut value: Struct,
1859        mut forward_to_server: &str,
1860    ) -> fidl::client::QueryResponseFut<Struct, fidl::encoding::DefaultFuchsiaResourceDialect> {
1861        EchoProxyInterface::r#echo_struct(self, value, forward_to_server)
1862    }
1863
1864    pub fn r#echo_struct_with_error(
1865        &self,
1866        mut value: Struct,
1867        mut result_err: DefaultEnum,
1868        mut forward_to_server: &str,
1869        mut result_variant: RespondWith,
1870    ) -> fidl::client::QueryResponseFut<
1871        EchoEchoStructWithErrorResult,
1872        fidl::encoding::DefaultFuchsiaResourceDialect,
1873    > {
1874        EchoProxyInterface::r#echo_struct_with_error(
1875            self,
1876            value,
1877            result_err,
1878            forward_to_server,
1879            result_variant,
1880        )
1881    }
1882
1883    pub fn r#echo_struct_no_ret_val(
1884        &self,
1885        mut value: Struct,
1886        mut forward_to_server: &str,
1887    ) -> Result<(), fidl::Error> {
1888        EchoProxyInterface::r#echo_struct_no_ret_val(self, value, forward_to_server)
1889    }
1890
1891    pub fn r#echo_arrays(
1892        &self,
1893        mut value: ArraysStruct,
1894        mut forward_to_server: &str,
1895    ) -> fidl::client::QueryResponseFut<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
1896    {
1897        EchoProxyInterface::r#echo_arrays(self, value, forward_to_server)
1898    }
1899
1900    pub fn r#echo_arrays_with_error(
1901        &self,
1902        mut value: ArraysStruct,
1903        mut result_err: DefaultEnum,
1904        mut forward_to_server: &str,
1905        mut result_variant: RespondWith,
1906    ) -> fidl::client::QueryResponseFut<
1907        EchoEchoArraysWithErrorResult,
1908        fidl::encoding::DefaultFuchsiaResourceDialect,
1909    > {
1910        EchoProxyInterface::r#echo_arrays_with_error(
1911            self,
1912            value,
1913            result_err,
1914            forward_to_server,
1915            result_variant,
1916        )
1917    }
1918
1919    pub fn r#echo_vectors(
1920        &self,
1921        mut value: VectorsStruct,
1922        mut forward_to_server: &str,
1923    ) -> fidl::client::QueryResponseFut<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
1924    {
1925        EchoProxyInterface::r#echo_vectors(self, value, forward_to_server)
1926    }
1927
1928    pub fn r#echo_vectors_with_error(
1929        &self,
1930        mut value: VectorsStruct,
1931        mut result_err: DefaultEnum,
1932        mut forward_to_server: &str,
1933        mut result_variant: RespondWith,
1934    ) -> fidl::client::QueryResponseFut<
1935        EchoEchoVectorsWithErrorResult,
1936        fidl::encoding::DefaultFuchsiaResourceDialect,
1937    > {
1938        EchoProxyInterface::r#echo_vectors_with_error(
1939            self,
1940            value,
1941            result_err,
1942            forward_to_server,
1943            result_variant,
1944        )
1945    }
1946
1947    pub fn r#echo_table(
1948        &self,
1949        mut value: AllTypesTable,
1950        mut forward_to_server: &str,
1951    ) -> fidl::client::QueryResponseFut<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>
1952    {
1953        EchoProxyInterface::r#echo_table(self, value, forward_to_server)
1954    }
1955
1956    pub fn r#echo_table_with_error(
1957        &self,
1958        mut value: AllTypesTable,
1959        mut result_err: DefaultEnum,
1960        mut forward_to_server: &str,
1961        mut result_variant: RespondWith,
1962    ) -> fidl::client::QueryResponseFut<
1963        EchoEchoTableWithErrorResult,
1964        fidl::encoding::DefaultFuchsiaResourceDialect,
1965    > {
1966        EchoProxyInterface::r#echo_table_with_error(
1967            self,
1968            value,
1969            result_err,
1970            forward_to_server,
1971            result_variant,
1972        )
1973    }
1974
1975    pub fn r#echo_xunions(
1976        &self,
1977        mut value: Vec<AllTypesXunion>,
1978        mut forward_to_server: &str,
1979    ) -> fidl::client::QueryResponseFut<
1980        Vec<AllTypesXunion>,
1981        fidl::encoding::DefaultFuchsiaResourceDialect,
1982    > {
1983        EchoProxyInterface::r#echo_xunions(self, value, forward_to_server)
1984    }
1985
1986    pub fn r#echo_xunions_with_error(
1987        &self,
1988        mut value: Vec<AllTypesXunion>,
1989        mut result_err: DefaultEnum,
1990        mut forward_to_server: &str,
1991        mut result_variant: RespondWith,
1992    ) -> fidl::client::QueryResponseFut<
1993        EchoEchoXunionsWithErrorResult,
1994        fidl::encoding::DefaultFuchsiaResourceDialect,
1995    > {
1996        EchoProxyInterface::r#echo_xunions_with_error(
1997            self,
1998            value,
1999            result_err,
2000            forward_to_server,
2001            result_variant,
2002        )
2003    }
2004
2005    pub fn r#echo_named_struct(
2006        &self,
2007        mut value: &fidl_fidl_test_imported::SimpleStruct,
2008        mut forward_to_server: &str,
2009    ) -> fidl::client::QueryResponseFut<
2010        fidl_fidl_test_imported::SimpleStruct,
2011        fidl::encoding::DefaultFuchsiaResourceDialect,
2012    > {
2013        EchoProxyInterface::r#echo_named_struct(self, value, forward_to_server)
2014    }
2015
2016    pub fn r#echo_named_struct_with_error(
2017        &self,
2018        mut value: &fidl_fidl_test_imported::SimpleStruct,
2019        mut result_err: u32,
2020        mut forward_to_server: &str,
2021        mut result_variant: fidl_fidl_test_imported::WantResponse,
2022    ) -> fidl::client::QueryResponseFut<
2023        EchoEchoNamedStructWithErrorResult,
2024        fidl::encoding::DefaultFuchsiaResourceDialect,
2025    > {
2026        EchoProxyInterface::r#echo_named_struct_with_error(
2027            self,
2028            value,
2029            result_err,
2030            forward_to_server,
2031            result_variant,
2032        )
2033    }
2034
2035    pub fn r#echo_named_struct_no_ret_val(
2036        &self,
2037        mut value: &fidl_fidl_test_imported::SimpleStruct,
2038        mut forward_to_server: &str,
2039    ) -> Result<(), fidl::Error> {
2040        EchoProxyInterface::r#echo_named_struct_no_ret_val(self, value, forward_to_server)
2041    }
2042
2043    pub fn r#echo_table_payload(
2044        &self,
2045        mut payload: &RequestTable,
2046    ) -> fidl::client::QueryResponseFut<ResponseTable, fidl::encoding::DefaultFuchsiaResourceDialect>
2047    {
2048        EchoProxyInterface::r#echo_table_payload(self, payload)
2049    }
2050
2051    pub fn r#echo_table_payload_with_error(
2052        &self,
2053        mut payload: &EchoEchoTablePayloadWithErrorRequest,
2054    ) -> fidl::client::QueryResponseFut<
2055        EchoEchoTablePayloadWithErrorResult,
2056        fidl::encoding::DefaultFuchsiaResourceDialect,
2057    > {
2058        EchoProxyInterface::r#echo_table_payload_with_error(self, payload)
2059    }
2060
2061    pub fn r#echo_table_payload_no_ret_val(
2062        &self,
2063        mut payload: &RequestTable,
2064    ) -> Result<(), fidl::Error> {
2065        EchoProxyInterface::r#echo_table_payload_no_ret_val(self, payload)
2066    }
2067
2068    pub fn r#echo_union_payload(
2069        &self,
2070        mut payload: &RequestUnion,
2071    ) -> fidl::client::QueryResponseFut<ResponseUnion, fidl::encoding::DefaultFuchsiaResourceDialect>
2072    {
2073        EchoProxyInterface::r#echo_union_payload(self, payload)
2074    }
2075
2076    pub fn r#echo_union_payload_with_error(
2077        &self,
2078        mut payload: &EchoEchoUnionPayloadWithErrorRequest,
2079    ) -> fidl::client::QueryResponseFut<
2080        EchoEchoUnionPayloadWithErrorResult,
2081        fidl::encoding::DefaultFuchsiaResourceDialect,
2082    > {
2083        EchoProxyInterface::r#echo_union_payload_with_error(self, payload)
2084    }
2085
2086    pub fn r#echo_union_payload_no_ret_val(
2087        &self,
2088        mut payload: &RequestUnion,
2089    ) -> Result<(), fidl::Error> {
2090        EchoProxyInterface::r#echo_union_payload_no_ret_val(self, payload)
2091    }
2092}
2093
2094impl EchoProxyInterface for EchoProxy {
2095    type EchoTableRequestComposedResponseFut = fidl::client::QueryResponseFut<
2096        fidl_fidl_test_imported::SimpleStruct,
2097        fidl::encoding::DefaultFuchsiaResourceDialect,
2098    >;
2099    fn r#echo_table_request_composed(
2100        &self,
2101        mut payload: &fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
2102    ) -> Self::EchoTableRequestComposedResponseFut {
2103        fn _decode(
2104            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2105        ) -> Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error> {
2106            let _response = fidl::client::decode_transaction_body::<
2107                fidl_fidl_test_imported::ResponseStruct,
2108                fidl::encoding::DefaultFuchsiaResourceDialect,
2109                0x1d545c738c7a8ee,
2110            >(_buf?)?;
2111            Ok(_response.value)
2112        }
2113        self.client.send_query_and_decode::<
2114            fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
2115            fidl_fidl_test_imported::SimpleStruct,
2116        >(
2117            payload,
2118            0x1d545c738c7a8ee,
2119            fidl::encoding::DynamicFlags::empty(),
2120            _decode,
2121        )
2122    }
2123
2124    type EchoUnionResponseWithErrorComposedResponseFut = fidl::client::QueryResponseFut<
2125        fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
2126        fidl::encoding::DefaultFuchsiaResourceDialect,
2127    >;
2128    fn r#echo_union_response_with_error_composed(
2129        &self,
2130        mut value: i64,
2131        mut want_absolute_value: bool,
2132        mut forward_to_server: &str,
2133        mut result_err: u32,
2134        mut result_variant: fidl_fidl_test_imported::WantResponse,
2135    ) -> Self::EchoUnionResponseWithErrorComposedResponseFut {
2136        fn _decode(
2137            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2138        ) -> Result<
2139            fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
2140            fidl::Error,
2141        > {
2142            let _response = fidl::client::decode_transaction_body::<
2143                fidl::encoding::ResultType<
2144                    fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse,
2145                    u32,
2146                >,
2147                fidl::encoding::DefaultFuchsiaResourceDialect,
2148                0x38a67e88d6106443,
2149            >(_buf?)?;
2150            Ok(_response.map(|x| x))
2151        }
2152        self.client.send_query_and_decode::<
2153            fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedRequest,
2154            fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
2155        >(
2156            (value, want_absolute_value, forward_to_server, result_err, result_variant,),
2157            0x38a67e88d6106443,
2158            fidl::encoding::DynamicFlags::empty(),
2159            _decode,
2160        )
2161    }
2162
2163    type EchoMinimalResponseFut =
2164        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
2165    fn r#echo_minimal(&self, mut forward_to_server: &str) -> Self::EchoMinimalResponseFut {
2166        fn _decode(
2167            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2168        ) -> Result<(), fidl::Error> {
2169            let _response = fidl::client::decode_transaction_body::<
2170                fidl::encoding::EmptyPayload,
2171                fidl::encoding::DefaultFuchsiaResourceDialect,
2172                0x39edd68c837482ec,
2173            >(_buf?)?;
2174            Ok(_response)
2175        }
2176        self.client.send_query_and_decode::<EchoEchoMinimalRequest, ()>(
2177            (forward_to_server,),
2178            0x39edd68c837482ec,
2179            fidl::encoding::DynamicFlags::empty(),
2180            _decode,
2181        )
2182    }
2183
2184    type EchoMinimalWithErrorResponseFut = fidl::client::QueryResponseFut<
2185        EchoEchoMinimalWithErrorResult,
2186        fidl::encoding::DefaultFuchsiaResourceDialect,
2187    >;
2188    fn r#echo_minimal_with_error(
2189        &self,
2190        mut forward_to_server: &str,
2191        mut result_variant: RespondWith,
2192    ) -> Self::EchoMinimalWithErrorResponseFut {
2193        fn _decode(
2194            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2195        ) -> Result<EchoEchoMinimalWithErrorResult, fidl::Error> {
2196            let _response = fidl::client::decode_transaction_body::<
2197                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, u32>,
2198                fidl::encoding::DefaultFuchsiaResourceDialect,
2199                0x36f4695996e35acc,
2200            >(_buf?)?;
2201            Ok(_response.map(|x| x))
2202        }
2203        self.client.send_query_and_decode::<
2204            EchoEchoMinimalWithErrorRequest,
2205            EchoEchoMinimalWithErrorResult,
2206        >(
2207            (forward_to_server, result_variant,),
2208            0x36f4695996e35acc,
2209            fidl::encoding::DynamicFlags::empty(),
2210            _decode,
2211        )
2212    }
2213
2214    fn r#echo_minimal_no_ret_val(&self, mut forward_to_server: &str) -> Result<(), fidl::Error> {
2215        self.client.send::<EchoEchoMinimalNoRetValRequest>(
2216            (forward_to_server,),
2217            0x42693c143e2c3694,
2218            fidl::encoding::DynamicFlags::empty(),
2219        )
2220    }
2221
2222    type EchoStructResponseFut =
2223        fidl::client::QueryResponseFut<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>;
2224    fn r#echo_struct(
2225        &self,
2226        mut value: Struct,
2227        mut forward_to_server: &str,
2228    ) -> Self::EchoStructResponseFut {
2229        fn _decode(
2230            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2231        ) -> Result<Struct, fidl::Error> {
2232            let _response = fidl::client::decode_transaction_body::<
2233                EchoEchoStructResponse,
2234                fidl::encoding::DefaultFuchsiaResourceDialect,
2235                0x4c2f85818cc53f37,
2236            >(_buf?)?;
2237            Ok(_response.value)
2238        }
2239        self.client.send_query_and_decode::<EchoEchoStructRequest, Struct>(
2240            (&mut value, forward_to_server),
2241            0x4c2f85818cc53f37,
2242            fidl::encoding::DynamicFlags::empty(),
2243            _decode,
2244        )
2245    }
2246
2247    type EchoStructWithErrorResponseFut = fidl::client::QueryResponseFut<
2248        EchoEchoStructWithErrorResult,
2249        fidl::encoding::DefaultFuchsiaResourceDialect,
2250    >;
2251    fn r#echo_struct_with_error(
2252        &self,
2253        mut value: Struct,
2254        mut result_err: DefaultEnum,
2255        mut forward_to_server: &str,
2256        mut result_variant: RespondWith,
2257    ) -> Self::EchoStructWithErrorResponseFut {
2258        fn _decode(
2259            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2260        ) -> Result<EchoEchoStructWithErrorResult, fidl::Error> {
2261            let _response = fidl::client::decode_transaction_body::<
2262                fidl::encoding::ResultType<EchoEchoStructWithErrorResponse, DefaultEnum>,
2263                fidl::encoding::DefaultFuchsiaResourceDialect,
2264                0x46cb32652c4c0899,
2265            >(_buf?)?;
2266            Ok(_response.map(|x| x.value))
2267        }
2268        self.client
2269            .send_query_and_decode::<EchoEchoStructWithErrorRequest, EchoEchoStructWithErrorResult>(
2270                (&mut value, result_err, forward_to_server, result_variant),
2271                0x46cb32652c4c0899,
2272                fidl::encoding::DynamicFlags::empty(),
2273                _decode,
2274            )
2275    }
2276
2277    fn r#echo_struct_no_ret_val(
2278        &self,
2279        mut value: Struct,
2280        mut forward_to_server: &str,
2281    ) -> Result<(), fidl::Error> {
2282        self.client.send::<EchoEchoStructNoRetValRequest>(
2283            (&mut value, forward_to_server),
2284            0x1f763e602cf5892a,
2285            fidl::encoding::DynamicFlags::empty(),
2286        )
2287    }
2288
2289    type EchoArraysResponseFut =
2290        fidl::client::QueryResponseFut<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>;
2291    fn r#echo_arrays(
2292        &self,
2293        mut value: ArraysStruct,
2294        mut forward_to_server: &str,
2295    ) -> Self::EchoArraysResponseFut {
2296        fn _decode(
2297            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2298        ) -> Result<ArraysStruct, fidl::Error> {
2299            let _response = fidl::client::decode_transaction_body::<
2300                EchoEchoArraysResponse,
2301                fidl::encoding::DefaultFuchsiaResourceDialect,
2302                0x1b6019d5611f2470,
2303            >(_buf?)?;
2304            Ok(_response.value)
2305        }
2306        self.client.send_query_and_decode::<EchoEchoArraysRequest, ArraysStruct>(
2307            (&mut value, forward_to_server),
2308            0x1b6019d5611f2470,
2309            fidl::encoding::DynamicFlags::empty(),
2310            _decode,
2311        )
2312    }
2313
2314    type EchoArraysWithErrorResponseFut = fidl::client::QueryResponseFut<
2315        EchoEchoArraysWithErrorResult,
2316        fidl::encoding::DefaultFuchsiaResourceDialect,
2317    >;
2318    fn r#echo_arrays_with_error(
2319        &self,
2320        mut value: ArraysStruct,
2321        mut result_err: DefaultEnum,
2322        mut forward_to_server: &str,
2323        mut result_variant: RespondWith,
2324    ) -> Self::EchoArraysWithErrorResponseFut {
2325        fn _decode(
2326            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2327        ) -> Result<EchoEchoArraysWithErrorResult, fidl::Error> {
2328            let _response = fidl::client::decode_transaction_body::<
2329                fidl::encoding::ResultType<EchoEchoArraysWithErrorResponse, DefaultEnum>,
2330                fidl::encoding::DefaultFuchsiaResourceDialect,
2331                0x6dbf26e67e253afa,
2332            >(_buf?)?;
2333            Ok(_response.map(|x| x.value))
2334        }
2335        self.client
2336            .send_query_and_decode::<EchoEchoArraysWithErrorRequest, EchoEchoArraysWithErrorResult>(
2337                (&mut value, result_err, forward_to_server, result_variant),
2338                0x6dbf26e67e253afa,
2339                fidl::encoding::DynamicFlags::empty(),
2340                _decode,
2341            )
2342    }
2343
2344    type EchoVectorsResponseFut = fidl::client::QueryResponseFut<
2345        VectorsStruct,
2346        fidl::encoding::DefaultFuchsiaResourceDialect,
2347    >;
2348    fn r#echo_vectors(
2349        &self,
2350        mut value: VectorsStruct,
2351        mut forward_to_server: &str,
2352    ) -> Self::EchoVectorsResponseFut {
2353        fn _decode(
2354            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2355        ) -> Result<VectorsStruct, fidl::Error> {
2356            let _response = fidl::client::decode_transaction_body::<
2357                EchoEchoVectorsResponse,
2358                fidl::encoding::DefaultFuchsiaResourceDialect,
2359                0x1582623f0d9f6e5e,
2360            >(_buf?)?;
2361            Ok(_response.value)
2362        }
2363        self.client.send_query_and_decode::<EchoEchoVectorsRequest, VectorsStruct>(
2364            (&mut value, forward_to_server),
2365            0x1582623f0d9f6e5e,
2366            fidl::encoding::DynamicFlags::empty(),
2367            _decode,
2368        )
2369    }
2370
2371    type EchoVectorsWithErrorResponseFut = fidl::client::QueryResponseFut<
2372        EchoEchoVectorsWithErrorResult,
2373        fidl::encoding::DefaultFuchsiaResourceDialect,
2374    >;
2375    fn r#echo_vectors_with_error(
2376        &self,
2377        mut value: VectorsStruct,
2378        mut result_err: DefaultEnum,
2379        mut forward_to_server: &str,
2380        mut result_variant: RespondWith,
2381    ) -> Self::EchoVectorsWithErrorResponseFut {
2382        fn _decode(
2383            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2384        ) -> Result<EchoEchoVectorsWithErrorResult, fidl::Error> {
2385            let _response = fidl::client::decode_transaction_body::<
2386                fidl::encoding::ResultType<EchoEchoVectorsWithErrorResponse, DefaultEnum>,
2387                fidl::encoding::DefaultFuchsiaResourceDialect,
2388                0x730f163401e2b3e5,
2389            >(_buf?)?;
2390            Ok(_response.map(|x| x.value))
2391        }
2392        self.client.send_query_and_decode::<
2393            EchoEchoVectorsWithErrorRequest,
2394            EchoEchoVectorsWithErrorResult,
2395        >(
2396            (&mut value, result_err, forward_to_server, result_variant,),
2397            0x730f163401e2b3e5,
2398            fidl::encoding::DynamicFlags::empty(),
2399            _decode,
2400        )
2401    }
2402
2403    type EchoTableResponseFut = fidl::client::QueryResponseFut<
2404        AllTypesTable,
2405        fidl::encoding::DefaultFuchsiaResourceDialect,
2406    >;
2407    fn r#echo_table(
2408        &self,
2409        mut value: AllTypesTable,
2410        mut forward_to_server: &str,
2411    ) -> Self::EchoTableResponseFut {
2412        fn _decode(
2413            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2414        ) -> Result<AllTypesTable, fidl::Error> {
2415            let _response = fidl::client::decode_transaction_body::<
2416                EchoEchoTableResponse,
2417                fidl::encoding::DefaultFuchsiaResourceDialect,
2418                0x4f1fb0a512f47c4b,
2419            >(_buf?)?;
2420            Ok(_response.value)
2421        }
2422        self.client.send_query_and_decode::<EchoEchoTableRequest, AllTypesTable>(
2423            (&mut value, forward_to_server),
2424            0x4f1fb0a512f47c4b,
2425            fidl::encoding::DynamicFlags::empty(),
2426            _decode,
2427        )
2428    }
2429
2430    type EchoTableWithErrorResponseFut = fidl::client::QueryResponseFut<
2431        EchoEchoTableWithErrorResult,
2432        fidl::encoding::DefaultFuchsiaResourceDialect,
2433    >;
2434    fn r#echo_table_with_error(
2435        &self,
2436        mut value: AllTypesTable,
2437        mut result_err: DefaultEnum,
2438        mut forward_to_server: &str,
2439        mut result_variant: RespondWith,
2440    ) -> Self::EchoTableWithErrorResponseFut {
2441        fn _decode(
2442            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2443        ) -> Result<EchoEchoTableWithErrorResult, fidl::Error> {
2444            let _response = fidl::client::decode_transaction_body::<
2445                fidl::encoding::ResultType<EchoEchoTableWithErrorResponse, DefaultEnum>,
2446                fidl::encoding::DefaultFuchsiaResourceDialect,
2447                0x44e835cb1eb9a931,
2448            >(_buf?)?;
2449            Ok(_response.map(|x| x.value))
2450        }
2451        self.client
2452            .send_query_and_decode::<EchoEchoTableWithErrorRequest, EchoEchoTableWithErrorResult>(
2453                (&mut value, result_err, forward_to_server, result_variant),
2454                0x44e835cb1eb9a931,
2455                fidl::encoding::DynamicFlags::empty(),
2456                _decode,
2457            )
2458    }
2459
2460    type EchoXunionsResponseFut = fidl::client::QueryResponseFut<
2461        Vec<AllTypesXunion>,
2462        fidl::encoding::DefaultFuchsiaResourceDialect,
2463    >;
2464    fn r#echo_xunions(
2465        &self,
2466        mut value: Vec<AllTypesXunion>,
2467        mut forward_to_server: &str,
2468    ) -> Self::EchoXunionsResponseFut {
2469        fn _decode(
2470            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2471        ) -> Result<Vec<AllTypesXunion>, fidl::Error> {
2472            let _response = fidl::client::decode_transaction_body::<
2473                EchoEchoXunionsResponse,
2474                fidl::encoding::DefaultFuchsiaResourceDialect,
2475                0x3dc181909041a583,
2476            >(_buf?)?;
2477            Ok(_response.value)
2478        }
2479        self.client.send_query_and_decode::<EchoEchoXunionsRequest, Vec<AllTypesXunion>>(
2480            (value.as_mut(), forward_to_server),
2481            0x3dc181909041a583,
2482            fidl::encoding::DynamicFlags::empty(),
2483            _decode,
2484        )
2485    }
2486
2487    type EchoXunionsWithErrorResponseFut = fidl::client::QueryResponseFut<
2488        EchoEchoXunionsWithErrorResult,
2489        fidl::encoding::DefaultFuchsiaResourceDialect,
2490    >;
2491    fn r#echo_xunions_with_error(
2492        &self,
2493        mut value: Vec<AllTypesXunion>,
2494        mut result_err: DefaultEnum,
2495        mut forward_to_server: &str,
2496        mut result_variant: RespondWith,
2497    ) -> Self::EchoXunionsWithErrorResponseFut {
2498        fn _decode(
2499            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2500        ) -> Result<EchoEchoXunionsWithErrorResult, fidl::Error> {
2501            let _response = fidl::client::decode_transaction_body::<
2502                fidl::encoding::ResultType<EchoEchoXunionsWithErrorResponse, DefaultEnum>,
2503                fidl::encoding::DefaultFuchsiaResourceDialect,
2504                0x75184102667fa766,
2505            >(_buf?)?;
2506            Ok(_response.map(|x| x.value))
2507        }
2508        self.client.send_query_and_decode::<
2509            EchoEchoXunionsWithErrorRequest,
2510            EchoEchoXunionsWithErrorResult,
2511        >(
2512            (value.as_mut(), result_err, forward_to_server, result_variant,),
2513            0x75184102667fa766,
2514            fidl::encoding::DynamicFlags::empty(),
2515            _decode,
2516        )
2517    }
2518
2519    type EchoNamedStructResponseFut = fidl::client::QueryResponseFut<
2520        fidl_fidl_test_imported::SimpleStruct,
2521        fidl::encoding::DefaultFuchsiaResourceDialect,
2522    >;
2523    fn r#echo_named_struct(
2524        &self,
2525        mut value: &fidl_fidl_test_imported::SimpleStruct,
2526        mut forward_to_server: &str,
2527    ) -> Self::EchoNamedStructResponseFut {
2528        fn _decode(
2529            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2530        ) -> Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error> {
2531            let _response = fidl::client::decode_transaction_body::<
2532                fidl_fidl_test_imported::ResponseStruct,
2533                fidl::encoding::DefaultFuchsiaResourceDialect,
2534                0xf2d4aa9e65f7111,
2535            >(_buf?)?;
2536            Ok(_response.value)
2537        }
2538        self.client.send_query_and_decode::<
2539            fidl_fidl_test_imported::RequestStruct,
2540            fidl_fidl_test_imported::SimpleStruct,
2541        >(
2542            (value, forward_to_server,),
2543            0xf2d4aa9e65f7111,
2544            fidl::encoding::DynamicFlags::empty(),
2545            _decode,
2546        )
2547    }
2548
2549    type EchoNamedStructWithErrorResponseFut = fidl::client::QueryResponseFut<
2550        EchoEchoNamedStructWithErrorResult,
2551        fidl::encoding::DefaultFuchsiaResourceDialect,
2552    >;
2553    fn r#echo_named_struct_with_error(
2554        &self,
2555        mut value: &fidl_fidl_test_imported::SimpleStruct,
2556        mut result_err: u32,
2557        mut forward_to_server: &str,
2558        mut result_variant: fidl_fidl_test_imported::WantResponse,
2559    ) -> Self::EchoNamedStructWithErrorResponseFut {
2560        fn _decode(
2561            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2562        ) -> Result<EchoEchoNamedStructWithErrorResult, fidl::Error> {
2563            let _response = fidl::client::decode_transaction_body::<
2564                fidl::encoding::ResultType<fidl_fidl_test_imported::ResponseStruct, u32>,
2565                fidl::encoding::DefaultFuchsiaResourceDialect,
2566                0x5766fee9e74442e8,
2567            >(_buf?)?;
2568            Ok(_response.map(|x| x.value))
2569        }
2570        self.client.send_query_and_decode::<
2571            fidl_fidl_test_imported::ErrorableRequestStruct,
2572            EchoEchoNamedStructWithErrorResult,
2573        >(
2574            (value, result_err, forward_to_server, result_variant,),
2575            0x5766fee9e74442e8,
2576            fidl::encoding::DynamicFlags::empty(),
2577            _decode,
2578        )
2579    }
2580
2581    fn r#echo_named_struct_no_ret_val(
2582        &self,
2583        mut value: &fidl_fidl_test_imported::SimpleStruct,
2584        mut forward_to_server: &str,
2585    ) -> Result<(), fidl::Error> {
2586        self.client.send::<fidl_fidl_test_imported::EventTriggeringRequestStruct>(
2587            (value, forward_to_server),
2588            0x3a50bbf7d2113ad7,
2589            fidl::encoding::DynamicFlags::empty(),
2590        )
2591    }
2592
2593    type EchoTablePayloadResponseFut = fidl::client::QueryResponseFut<
2594        ResponseTable,
2595        fidl::encoding::DefaultFuchsiaResourceDialect,
2596    >;
2597    fn r#echo_table_payload(
2598        &self,
2599        mut payload: &RequestTable,
2600    ) -> Self::EchoTablePayloadResponseFut {
2601        fn _decode(
2602            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2603        ) -> Result<ResponseTable, fidl::Error> {
2604            let _response = fidl::client::decode_transaction_body::<
2605                ResponseTable,
2606                fidl::encoding::DefaultFuchsiaResourceDialect,
2607                0x641d98087378c003,
2608            >(_buf?)?;
2609            Ok(_response)
2610        }
2611        self.client.send_query_and_decode::<RequestTable, ResponseTable>(
2612            payload,
2613            0x641d98087378c003,
2614            fidl::encoding::DynamicFlags::empty(),
2615            _decode,
2616        )
2617    }
2618
2619    type EchoTablePayloadWithErrorResponseFut = fidl::client::QueryResponseFut<
2620        EchoEchoTablePayloadWithErrorResult,
2621        fidl::encoding::DefaultFuchsiaResourceDialect,
2622    >;
2623    fn r#echo_table_payload_with_error(
2624        &self,
2625        mut payload: &EchoEchoTablePayloadWithErrorRequest,
2626    ) -> Self::EchoTablePayloadWithErrorResponseFut {
2627        fn _decode(
2628            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2629        ) -> Result<EchoEchoTablePayloadWithErrorResult, fidl::Error> {
2630            let _response = fidl::client::decode_transaction_body::<
2631                fidl::encoding::ResultType<ResponseTable, DefaultEnum>,
2632                fidl::encoding::DefaultFuchsiaResourceDialect,
2633                0x636ed243761ab66d,
2634            >(_buf?)?;
2635            Ok(_response.map(|x| x))
2636        }
2637        self.client.send_query_and_decode::<
2638            EchoEchoTablePayloadWithErrorRequest,
2639            EchoEchoTablePayloadWithErrorResult,
2640        >(
2641            payload,
2642            0x636ed243761ab66d,
2643            fidl::encoding::DynamicFlags::empty(),
2644            _decode,
2645        )
2646    }
2647
2648    fn r#echo_table_payload_no_ret_val(
2649        &self,
2650        mut payload: &RequestTable,
2651    ) -> Result<(), fidl::Error> {
2652        self.client.send::<RequestTable>(
2653            payload,
2654            0x32961f7d718569f8,
2655            fidl::encoding::DynamicFlags::empty(),
2656        )
2657    }
2658
2659    type EchoUnionPayloadResponseFut = fidl::client::QueryResponseFut<
2660        ResponseUnion,
2661        fidl::encoding::DefaultFuchsiaResourceDialect,
2662    >;
2663    fn r#echo_union_payload(
2664        &self,
2665        mut payload: &RequestUnion,
2666    ) -> Self::EchoUnionPayloadResponseFut {
2667        fn _decode(
2668            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2669        ) -> Result<ResponseUnion, fidl::Error> {
2670            let _response = fidl::client::decode_transaction_body::<
2671                ResponseUnion,
2672                fidl::encoding::DefaultFuchsiaResourceDialect,
2673                0x66def9e793f10c55,
2674            >(_buf?)?;
2675            Ok(_response)
2676        }
2677        self.client.send_query_and_decode::<RequestUnion, ResponseUnion>(
2678            payload,
2679            0x66def9e793f10c55,
2680            fidl::encoding::DynamicFlags::empty(),
2681            _decode,
2682        )
2683    }
2684
2685    type EchoUnionPayloadWithErrorResponseFut = fidl::client::QueryResponseFut<
2686        EchoEchoUnionPayloadWithErrorResult,
2687        fidl::encoding::DefaultFuchsiaResourceDialect,
2688    >;
2689    fn r#echo_union_payload_with_error(
2690        &self,
2691        mut payload: &EchoEchoUnionPayloadWithErrorRequest,
2692    ) -> Self::EchoUnionPayloadWithErrorResponseFut {
2693        fn _decode(
2694            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2695        ) -> Result<EchoEchoUnionPayloadWithErrorResult, fidl::Error> {
2696            let _response = fidl::client::decode_transaction_body::<
2697                fidl::encoding::ResultType<ResponseUnion, DefaultEnum>,
2698                fidl::encoding::DefaultFuchsiaResourceDialect,
2699                0x1be890d6e68ef063,
2700            >(_buf?)?;
2701            Ok(_response.map(|x| x))
2702        }
2703        self.client.send_query_and_decode::<
2704            EchoEchoUnionPayloadWithErrorRequest,
2705            EchoEchoUnionPayloadWithErrorResult,
2706        >(
2707            payload,
2708            0x1be890d6e68ef063,
2709            fidl::encoding::DynamicFlags::empty(),
2710            _decode,
2711        )
2712    }
2713
2714    fn r#echo_union_payload_no_ret_val(
2715        &self,
2716        mut payload: &RequestUnion,
2717    ) -> Result<(), fidl::Error> {
2718        self.client.send::<RequestUnion>(
2719            payload,
2720            0x11518bf346430040,
2721            fidl::encoding::DynamicFlags::empty(),
2722        )
2723    }
2724}
2725
2726pub struct EchoEventStream {
2727    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
2728}
2729
2730impl std::marker::Unpin for EchoEventStream {}
2731
2732impl futures::stream::FusedStream for EchoEventStream {
2733    fn is_terminated(&self) -> bool {
2734        self.event_receiver.is_terminated()
2735    }
2736}
2737
2738impl futures::Stream for EchoEventStream {
2739    type Item = Result<EchoEvent, fidl::Error>;
2740
2741    fn poll_next(
2742        mut self: std::pin::Pin<&mut Self>,
2743        cx: &mut std::task::Context<'_>,
2744    ) -> std::task::Poll<Option<Self::Item>> {
2745        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
2746            &mut self.event_receiver,
2747            cx
2748        )?) {
2749            Some(buf) => std::task::Poll::Ready(Some(EchoEvent::decode(buf))),
2750            None => std::task::Poll::Ready(None),
2751        }
2752    }
2753}
2754
2755#[derive(Debug)]
2756pub enum EchoEvent {
2757    EchoMinimalEvent {},
2758    EchoEvent { value: Struct },
2759    OnEchoNamedEvent { value: fidl_fidl_test_imported::SimpleStruct },
2760    OnEchoTablePayloadEvent { payload: ResponseTable },
2761    OnEchoUnionPayloadEvent { payload: ResponseUnion },
2762}
2763
2764impl EchoEvent {
2765    #[allow(irrefutable_let_patterns)]
2766    pub fn into_echo_minimal_event(self) -> Option<()> {
2767        if let EchoEvent::EchoMinimalEvent {} = self { Some(()) } else { None }
2768    }
2769    #[allow(irrefutable_let_patterns)]
2770    pub fn into_echo_event(self) -> Option<Struct> {
2771        if let EchoEvent::EchoEvent { value } = self { Some((value)) } else { None }
2772    }
2773    #[allow(irrefutable_let_patterns)]
2774    pub fn into_on_echo_named_event(self) -> Option<fidl_fidl_test_imported::SimpleStruct> {
2775        if let EchoEvent::OnEchoNamedEvent { value } = self { Some((value)) } else { None }
2776    }
2777    #[allow(irrefutable_let_patterns)]
2778    pub fn into_on_echo_table_payload_event(self) -> Option<ResponseTable> {
2779        if let EchoEvent::OnEchoTablePayloadEvent { payload } = self {
2780            Some((payload))
2781        } else {
2782            None
2783        }
2784    }
2785    #[allow(irrefutable_let_patterns)]
2786    pub fn into_on_echo_union_payload_event(self) -> Option<ResponseUnion> {
2787        if let EchoEvent::OnEchoUnionPayloadEvent { payload } = self {
2788            Some((payload))
2789        } else {
2790            None
2791        }
2792    }
2793
2794    /// Decodes a message buffer as a [`EchoEvent`].
2795    fn decode(
2796        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
2797    ) -> Result<EchoEvent, fidl::Error> {
2798        let (bytes, _handles) = buf.split_mut();
2799        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
2800        debug_assert_eq!(tx_header.tx_id, 0);
2801        match tx_header.ordinal {
2802            0x273b2029f1a0aee2 => {
2803                let mut out = fidl::new_empty!(
2804                    fidl::encoding::EmptyPayload,
2805                    fidl::encoding::DefaultFuchsiaResourceDialect
2806                );
2807                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&tx_header, _body_bytes, _handles, &mut out)?;
2808                Ok((EchoEvent::EchoMinimalEvent {}))
2809            }
2810            0x1219e12e0450024 => {
2811                let mut out = fidl::new_empty!(
2812                    EchoEchoEventRequest,
2813                    fidl::encoding::DefaultFuchsiaResourceDialect
2814                );
2815                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoEventRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
2816                Ok((EchoEvent::EchoEvent { value: out.value }))
2817            }
2818            0x749ebde83348a374 => {
2819                let mut out = fidl::new_empty!(
2820                    fidl_fidl_test_imported::ResponseStruct,
2821                    fidl::encoding::DefaultFuchsiaResourceDialect
2822                );
2823                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::ResponseStruct>(&tx_header, _body_bytes, _handles, &mut out)?;
2824                Ok((EchoEvent::OnEchoNamedEvent { value: out.value }))
2825            }
2826            0x708dddea1cb98430 => {
2827                let mut out =
2828                    fidl::new_empty!(ResponseTable, fidl::encoding::DefaultFuchsiaResourceDialect);
2829                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ResponseTable>(&tx_header, _body_bytes, _handles, &mut out)?;
2830                Ok((EchoEvent::OnEchoTablePayloadEvent { payload: out }))
2831            }
2832            0x642f4c265a05f4c0 => {
2833                let mut out =
2834                    fidl::new_empty!(ResponseUnion, fidl::encoding::DefaultFuchsiaResourceDialect);
2835                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ResponseUnion>(&tx_header, _body_bytes, _handles, &mut out)?;
2836                Ok((EchoEvent::OnEchoUnionPayloadEvent { payload: out }))
2837            }
2838            _ => Err(fidl::Error::UnknownOrdinal {
2839                ordinal: tx_header.ordinal,
2840                protocol_name: <EchoMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
2841            }),
2842        }
2843    }
2844}
2845
2846/// A Stream of incoming requests for fidl.test.compatibility/Echo.
2847pub struct EchoRequestStream {
2848    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
2849    is_terminated: bool,
2850}
2851
2852impl std::marker::Unpin for EchoRequestStream {}
2853
2854impl futures::stream::FusedStream for EchoRequestStream {
2855    fn is_terminated(&self) -> bool {
2856        self.is_terminated
2857    }
2858}
2859
2860impl fidl::endpoints::RequestStream for EchoRequestStream {
2861    type Protocol = EchoMarker;
2862    type ControlHandle = EchoControlHandle;
2863
2864    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
2865        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
2866    }
2867
2868    fn control_handle(&self) -> Self::ControlHandle {
2869        EchoControlHandle { inner: self.inner.clone() }
2870    }
2871
2872    fn into_inner(
2873        self,
2874    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
2875    {
2876        (self.inner, self.is_terminated)
2877    }
2878
2879    fn from_inner(
2880        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
2881        is_terminated: bool,
2882    ) -> Self {
2883        Self { inner, is_terminated }
2884    }
2885}
2886
2887impl futures::Stream for EchoRequestStream {
2888    type Item = Result<EchoRequest, fidl::Error>;
2889
2890    fn poll_next(
2891        mut self: std::pin::Pin<&mut Self>,
2892        cx: &mut std::task::Context<'_>,
2893    ) -> std::task::Poll<Option<Self::Item>> {
2894        let this = &mut *self;
2895        if this.inner.check_shutdown(cx) {
2896            this.is_terminated = true;
2897            return std::task::Poll::Ready(None);
2898        }
2899        if this.is_terminated {
2900            panic!("polled EchoRequestStream after completion");
2901        }
2902        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
2903            |bytes, handles| {
2904                match this.inner.channel().read_etc(cx, bytes, handles) {
2905                    std::task::Poll::Ready(Ok(())) => {}
2906                    std::task::Poll::Pending => return std::task::Poll::Pending,
2907                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
2908                        this.is_terminated = true;
2909                        return std::task::Poll::Ready(None);
2910                    }
2911                    std::task::Poll::Ready(Err(e)) => {
2912                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
2913                            e.into(),
2914                        ))));
2915                    }
2916                }
2917
2918                // A message has been received from the channel
2919                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
2920
2921                std::task::Poll::Ready(Some(match header.ordinal {
2922                    0x1d545c738c7a8ee => {
2923                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2924                        let mut req = fidl::new_empty!(
2925                            fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
2926                            fidl::encoding::DefaultFuchsiaResourceDialect
2927                        );
2928                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest>(&header, _body_bytes, handles, &mut req)?;
2929                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
2930                        Ok(EchoRequest::EchoTableRequestComposed {
2931                            payload: req,
2932                            responder: EchoEchoTableRequestComposedResponder {
2933                                control_handle: std::mem::ManuallyDrop::new(control_handle),
2934                                tx_id: header.tx_id,
2935                            },
2936                        })
2937                    }
2938                    0x38a67e88d6106443 => {
2939                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2940                        let mut req = fidl::new_empty!(fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
2941                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedRequest>(&header, _body_bytes, handles, &mut req)?;
2942                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
2943                        Ok(EchoRequest::EchoUnionResponseWithErrorComposed {
2944                            value: req.value,
2945                            want_absolute_value: req.want_absolute_value,
2946                            forward_to_server: req.forward_to_server,
2947                            result_err: req.result_err,
2948                            result_variant: req.result_variant,
2949
2950                            responder: EchoEchoUnionResponseWithErrorComposedResponder {
2951                                control_handle: std::mem::ManuallyDrop::new(control_handle),
2952                                tx_id: header.tx_id,
2953                            },
2954                        })
2955                    }
2956                    0x39edd68c837482ec => {
2957                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2958                        let mut req = fidl::new_empty!(
2959                            EchoEchoMinimalRequest,
2960                            fidl::encoding::DefaultFuchsiaResourceDialect
2961                        );
2962                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoMinimalRequest>(&header, _body_bytes, handles, &mut req)?;
2963                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
2964                        Ok(EchoRequest::EchoMinimal {
2965                            forward_to_server: req.forward_to_server,
2966
2967                            responder: EchoEchoMinimalResponder {
2968                                control_handle: std::mem::ManuallyDrop::new(control_handle),
2969                                tx_id: header.tx_id,
2970                            },
2971                        })
2972                    }
2973                    0x36f4695996e35acc => {
2974                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2975                        let mut req = fidl::new_empty!(
2976                            EchoEchoMinimalWithErrorRequest,
2977                            fidl::encoding::DefaultFuchsiaResourceDialect
2978                        );
2979                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoMinimalWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
2980                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
2981                        Ok(EchoRequest::EchoMinimalWithError {
2982                            forward_to_server: req.forward_to_server,
2983                            result_variant: req.result_variant,
2984
2985                            responder: EchoEchoMinimalWithErrorResponder {
2986                                control_handle: std::mem::ManuallyDrop::new(control_handle),
2987                                tx_id: header.tx_id,
2988                            },
2989                        })
2990                    }
2991                    0x42693c143e2c3694 => {
2992                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
2993                        let mut req = fidl::new_empty!(
2994                            EchoEchoMinimalNoRetValRequest,
2995                            fidl::encoding::DefaultFuchsiaResourceDialect
2996                        );
2997                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoMinimalNoRetValRequest>(&header, _body_bytes, handles, &mut req)?;
2998                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
2999                        Ok(EchoRequest::EchoMinimalNoRetVal {
3000                            forward_to_server: req.forward_to_server,
3001
3002                            control_handle,
3003                        })
3004                    }
3005                    0x4c2f85818cc53f37 => {
3006                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3007                        let mut req = fidl::new_empty!(
3008                            EchoEchoStructRequest,
3009                            fidl::encoding::DefaultFuchsiaResourceDialect
3010                        );
3011                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoStructRequest>(&header, _body_bytes, handles, &mut req)?;
3012                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3013                        Ok(EchoRequest::EchoStruct {
3014                            value: req.value,
3015                            forward_to_server: req.forward_to_server,
3016
3017                            responder: EchoEchoStructResponder {
3018                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3019                                tx_id: header.tx_id,
3020                            },
3021                        })
3022                    }
3023                    0x46cb32652c4c0899 => {
3024                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3025                        let mut req = fidl::new_empty!(
3026                            EchoEchoStructWithErrorRequest,
3027                            fidl::encoding::DefaultFuchsiaResourceDialect
3028                        );
3029                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoStructWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3030                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3031                        Ok(EchoRequest::EchoStructWithError {
3032                            value: req.value,
3033                            result_err: req.result_err,
3034                            forward_to_server: req.forward_to_server,
3035                            result_variant: req.result_variant,
3036
3037                            responder: EchoEchoStructWithErrorResponder {
3038                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3039                                tx_id: header.tx_id,
3040                            },
3041                        })
3042                    }
3043                    0x1f763e602cf5892a => {
3044                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
3045                        let mut req = fidl::new_empty!(
3046                            EchoEchoStructNoRetValRequest,
3047                            fidl::encoding::DefaultFuchsiaResourceDialect
3048                        );
3049                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoStructNoRetValRequest>(&header, _body_bytes, handles, &mut req)?;
3050                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3051                        Ok(EchoRequest::EchoStructNoRetVal {
3052                            value: req.value,
3053                            forward_to_server: req.forward_to_server,
3054
3055                            control_handle,
3056                        })
3057                    }
3058                    0x1b6019d5611f2470 => {
3059                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3060                        let mut req = fidl::new_empty!(
3061                            EchoEchoArraysRequest,
3062                            fidl::encoding::DefaultFuchsiaResourceDialect
3063                        );
3064                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoArraysRequest>(&header, _body_bytes, handles, &mut req)?;
3065                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3066                        Ok(EchoRequest::EchoArrays {
3067                            value: req.value,
3068                            forward_to_server: req.forward_to_server,
3069
3070                            responder: EchoEchoArraysResponder {
3071                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3072                                tx_id: header.tx_id,
3073                            },
3074                        })
3075                    }
3076                    0x6dbf26e67e253afa => {
3077                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3078                        let mut req = fidl::new_empty!(
3079                            EchoEchoArraysWithErrorRequest,
3080                            fidl::encoding::DefaultFuchsiaResourceDialect
3081                        );
3082                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoArraysWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3083                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3084                        Ok(EchoRequest::EchoArraysWithError {
3085                            value: req.value,
3086                            result_err: req.result_err,
3087                            forward_to_server: req.forward_to_server,
3088                            result_variant: req.result_variant,
3089
3090                            responder: EchoEchoArraysWithErrorResponder {
3091                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3092                                tx_id: header.tx_id,
3093                            },
3094                        })
3095                    }
3096                    0x1582623f0d9f6e5e => {
3097                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3098                        let mut req = fidl::new_empty!(
3099                            EchoEchoVectorsRequest,
3100                            fidl::encoding::DefaultFuchsiaResourceDialect
3101                        );
3102                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoVectorsRequest>(&header, _body_bytes, handles, &mut req)?;
3103                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3104                        Ok(EchoRequest::EchoVectors {
3105                            value: req.value,
3106                            forward_to_server: req.forward_to_server,
3107
3108                            responder: EchoEchoVectorsResponder {
3109                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3110                                tx_id: header.tx_id,
3111                            },
3112                        })
3113                    }
3114                    0x730f163401e2b3e5 => {
3115                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3116                        let mut req = fidl::new_empty!(
3117                            EchoEchoVectorsWithErrorRequest,
3118                            fidl::encoding::DefaultFuchsiaResourceDialect
3119                        );
3120                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoVectorsWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3121                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3122                        Ok(EchoRequest::EchoVectorsWithError {
3123                            value: req.value,
3124                            result_err: req.result_err,
3125                            forward_to_server: req.forward_to_server,
3126                            result_variant: req.result_variant,
3127
3128                            responder: EchoEchoVectorsWithErrorResponder {
3129                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3130                                tx_id: header.tx_id,
3131                            },
3132                        })
3133                    }
3134                    0x4f1fb0a512f47c4b => {
3135                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3136                        let mut req = fidl::new_empty!(
3137                            EchoEchoTableRequest,
3138                            fidl::encoding::DefaultFuchsiaResourceDialect
3139                        );
3140                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoTableRequest>(&header, _body_bytes, handles, &mut req)?;
3141                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3142                        Ok(EchoRequest::EchoTable {
3143                            value: req.value,
3144                            forward_to_server: req.forward_to_server,
3145
3146                            responder: EchoEchoTableResponder {
3147                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3148                                tx_id: header.tx_id,
3149                            },
3150                        })
3151                    }
3152                    0x44e835cb1eb9a931 => {
3153                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3154                        let mut req = fidl::new_empty!(
3155                            EchoEchoTableWithErrorRequest,
3156                            fidl::encoding::DefaultFuchsiaResourceDialect
3157                        );
3158                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoTableWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3159                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3160                        Ok(EchoRequest::EchoTableWithError {
3161                            value: req.value,
3162                            result_err: req.result_err,
3163                            forward_to_server: req.forward_to_server,
3164                            result_variant: req.result_variant,
3165
3166                            responder: EchoEchoTableWithErrorResponder {
3167                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3168                                tx_id: header.tx_id,
3169                            },
3170                        })
3171                    }
3172                    0x3dc181909041a583 => {
3173                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3174                        let mut req = fidl::new_empty!(
3175                            EchoEchoXunionsRequest,
3176                            fidl::encoding::DefaultFuchsiaResourceDialect
3177                        );
3178                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoXunionsRequest>(&header, _body_bytes, handles, &mut req)?;
3179                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3180                        Ok(EchoRequest::EchoXunions {
3181                            value: req.value,
3182                            forward_to_server: req.forward_to_server,
3183
3184                            responder: EchoEchoXunionsResponder {
3185                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3186                                tx_id: header.tx_id,
3187                            },
3188                        })
3189                    }
3190                    0x75184102667fa766 => {
3191                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3192                        let mut req = fidl::new_empty!(
3193                            EchoEchoXunionsWithErrorRequest,
3194                            fidl::encoding::DefaultFuchsiaResourceDialect
3195                        );
3196                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoXunionsWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3197                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3198                        Ok(EchoRequest::EchoXunionsWithError {
3199                            value: req.value,
3200                            result_err: req.result_err,
3201                            forward_to_server: req.forward_to_server,
3202                            result_variant: req.result_variant,
3203
3204                            responder: EchoEchoXunionsWithErrorResponder {
3205                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3206                                tx_id: header.tx_id,
3207                            },
3208                        })
3209                    }
3210                    0xf2d4aa9e65f7111 => {
3211                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3212                        let mut req = fidl::new_empty!(
3213                            fidl_fidl_test_imported::RequestStruct,
3214                            fidl::encoding::DefaultFuchsiaResourceDialect
3215                        );
3216                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::RequestStruct>(&header, _body_bytes, handles, &mut req)?;
3217                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3218                        Ok(EchoRequest::EchoNamedStruct {
3219                            value: req.value,
3220                            forward_to_server: req.forward_to_server,
3221
3222                            responder: EchoEchoNamedStructResponder {
3223                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3224                                tx_id: header.tx_id,
3225                            },
3226                        })
3227                    }
3228                    0x5766fee9e74442e8 => {
3229                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3230                        let mut req = fidl::new_empty!(
3231                            fidl_fidl_test_imported::ErrorableRequestStruct,
3232                            fidl::encoding::DefaultFuchsiaResourceDialect
3233                        );
3234                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::ErrorableRequestStruct>(&header, _body_bytes, handles, &mut req)?;
3235                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3236                        Ok(EchoRequest::EchoNamedStructWithError {
3237                            value: req.value,
3238                            result_err: req.result_err,
3239                            forward_to_server: req.forward_to_server,
3240                            result_variant: req.result_variant,
3241
3242                            responder: EchoEchoNamedStructWithErrorResponder {
3243                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3244                                tx_id: header.tx_id,
3245                            },
3246                        })
3247                    }
3248                    0x3a50bbf7d2113ad7 => {
3249                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
3250                        let mut req = fidl::new_empty!(
3251                            fidl_fidl_test_imported::EventTriggeringRequestStruct,
3252                            fidl::encoding::DefaultFuchsiaResourceDialect
3253                        );
3254                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::EventTriggeringRequestStruct>(&header, _body_bytes, handles, &mut req)?;
3255                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3256                        Ok(EchoRequest::EchoNamedStructNoRetVal {
3257                            value: req.value,
3258                            forward_to_server: req.forward_to_server,
3259
3260                            control_handle,
3261                        })
3262                    }
3263                    0x641d98087378c003 => {
3264                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3265                        let mut req = fidl::new_empty!(
3266                            RequestTable,
3267                            fidl::encoding::DefaultFuchsiaResourceDialect
3268                        );
3269                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RequestTable>(&header, _body_bytes, handles, &mut req)?;
3270                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3271                        Ok(EchoRequest::EchoTablePayload {
3272                            payload: req,
3273                            responder: EchoEchoTablePayloadResponder {
3274                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3275                                tx_id: header.tx_id,
3276                            },
3277                        })
3278                    }
3279                    0x636ed243761ab66d => {
3280                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3281                        let mut req = fidl::new_empty!(
3282                            EchoEchoTablePayloadWithErrorRequest,
3283                            fidl::encoding::DefaultFuchsiaResourceDialect
3284                        );
3285                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoTablePayloadWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3286                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3287                        Ok(EchoRequest::EchoTablePayloadWithError {
3288                            payload: req,
3289                            responder: EchoEchoTablePayloadWithErrorResponder {
3290                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3291                                tx_id: header.tx_id,
3292                            },
3293                        })
3294                    }
3295                    0x32961f7d718569f8 => {
3296                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
3297                        let mut req = fidl::new_empty!(
3298                            RequestTable,
3299                            fidl::encoding::DefaultFuchsiaResourceDialect
3300                        );
3301                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RequestTable>(&header, _body_bytes, handles, &mut req)?;
3302                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3303                        Ok(EchoRequest::EchoTablePayloadNoRetVal { payload: req, control_handle })
3304                    }
3305                    0x66def9e793f10c55 => {
3306                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3307                        let mut req = fidl::new_empty!(
3308                            RequestUnion,
3309                            fidl::encoding::DefaultFuchsiaResourceDialect
3310                        );
3311                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RequestUnion>(&header, _body_bytes, handles, &mut req)?;
3312                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3313                        Ok(EchoRequest::EchoUnionPayload {
3314                            payload: req,
3315                            responder: EchoEchoUnionPayloadResponder {
3316                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3317                                tx_id: header.tx_id,
3318                            },
3319                        })
3320                    }
3321                    0x1be890d6e68ef063 => {
3322                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3323                        let mut req = fidl::new_empty!(
3324                            EchoEchoUnionPayloadWithErrorRequest,
3325                            fidl::encoding::DefaultFuchsiaResourceDialect
3326                        );
3327                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoUnionPayloadWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3328                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3329                        Ok(EchoRequest::EchoUnionPayloadWithError {
3330                            payload: req,
3331                            responder: EchoEchoUnionPayloadWithErrorResponder {
3332                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3333                                tx_id: header.tx_id,
3334                            },
3335                        })
3336                    }
3337                    0x11518bf346430040 => {
3338                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
3339                        let mut req = fidl::new_empty!(
3340                            RequestUnion,
3341                            fidl::encoding::DefaultFuchsiaResourceDialect
3342                        );
3343                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RequestUnion>(&header, _body_bytes, handles, &mut req)?;
3344                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3345                        Ok(EchoRequest::EchoUnionPayloadNoRetVal { payload: req, control_handle })
3346                    }
3347                    _ => Err(fidl::Error::UnknownOrdinal {
3348                        ordinal: header.ordinal,
3349                        protocol_name: <EchoMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
3350                    }),
3351                }))
3352            },
3353        )
3354    }
3355}
3356
3357#[derive(Debug)]
3358pub enum EchoRequest {
3359    EchoTableRequestComposed {
3360        payload: fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
3361        responder: EchoEchoTableRequestComposedResponder,
3362    },
3363    EchoUnionResponseWithErrorComposed {
3364        value: i64,
3365        want_absolute_value: bool,
3366        forward_to_server: String,
3367        result_err: u32,
3368        result_variant: fidl_fidl_test_imported::WantResponse,
3369        responder: EchoEchoUnionResponseWithErrorComposedResponder,
3370    },
3371    EchoMinimal {
3372        forward_to_server: String,
3373        responder: EchoEchoMinimalResponder,
3374    },
3375    EchoMinimalWithError {
3376        forward_to_server: String,
3377        result_variant: RespondWith,
3378        responder: EchoEchoMinimalWithErrorResponder,
3379    },
3380    EchoMinimalNoRetVal {
3381        forward_to_server: String,
3382        control_handle: EchoControlHandle,
3383    },
3384    EchoStruct {
3385        value: Struct,
3386        forward_to_server: String,
3387        responder: EchoEchoStructResponder,
3388    },
3389    EchoStructWithError {
3390        value: Struct,
3391        result_err: DefaultEnum,
3392        forward_to_server: String,
3393        result_variant: RespondWith,
3394        responder: EchoEchoStructWithErrorResponder,
3395    },
3396    EchoStructNoRetVal {
3397        value: Struct,
3398        forward_to_server: String,
3399        control_handle: EchoControlHandle,
3400    },
3401    EchoArrays {
3402        value: ArraysStruct,
3403        forward_to_server: String,
3404        responder: EchoEchoArraysResponder,
3405    },
3406    EchoArraysWithError {
3407        value: ArraysStruct,
3408        result_err: DefaultEnum,
3409        forward_to_server: String,
3410        result_variant: RespondWith,
3411        responder: EchoEchoArraysWithErrorResponder,
3412    },
3413    EchoVectors {
3414        value: VectorsStruct,
3415        forward_to_server: String,
3416        responder: EchoEchoVectorsResponder,
3417    },
3418    EchoVectorsWithError {
3419        value: VectorsStruct,
3420        result_err: DefaultEnum,
3421        forward_to_server: String,
3422        result_variant: RespondWith,
3423        responder: EchoEchoVectorsWithErrorResponder,
3424    },
3425    EchoTable {
3426        value: AllTypesTable,
3427        forward_to_server: String,
3428        responder: EchoEchoTableResponder,
3429    },
3430    EchoTableWithError {
3431        value: AllTypesTable,
3432        result_err: DefaultEnum,
3433        forward_to_server: String,
3434        result_variant: RespondWith,
3435        responder: EchoEchoTableWithErrorResponder,
3436    },
3437    EchoXunions {
3438        value: Vec<AllTypesXunion>,
3439        forward_to_server: String,
3440        responder: EchoEchoXunionsResponder,
3441    },
3442    EchoXunionsWithError {
3443        value: Vec<AllTypesXunion>,
3444        result_err: DefaultEnum,
3445        forward_to_server: String,
3446        result_variant: RespondWith,
3447        responder: EchoEchoXunionsWithErrorResponder,
3448    },
3449    EchoNamedStruct {
3450        value: fidl_fidl_test_imported::SimpleStruct,
3451        forward_to_server: String,
3452        responder: EchoEchoNamedStructResponder,
3453    },
3454    EchoNamedStructWithError {
3455        value: fidl_fidl_test_imported::SimpleStruct,
3456        result_err: u32,
3457        forward_to_server: String,
3458        result_variant: fidl_fidl_test_imported::WantResponse,
3459        responder: EchoEchoNamedStructWithErrorResponder,
3460    },
3461    EchoNamedStructNoRetVal {
3462        value: fidl_fidl_test_imported::SimpleStruct,
3463        forward_to_server: String,
3464        control_handle: EchoControlHandle,
3465    },
3466    EchoTablePayload {
3467        payload: RequestTable,
3468        responder: EchoEchoTablePayloadResponder,
3469    },
3470    EchoTablePayloadWithError {
3471        payload: EchoEchoTablePayloadWithErrorRequest,
3472        responder: EchoEchoTablePayloadWithErrorResponder,
3473    },
3474    EchoTablePayloadNoRetVal {
3475        payload: RequestTable,
3476        control_handle: EchoControlHandle,
3477    },
3478    EchoUnionPayload {
3479        payload: RequestUnion,
3480        responder: EchoEchoUnionPayloadResponder,
3481    },
3482    EchoUnionPayloadWithError {
3483        payload: EchoEchoUnionPayloadWithErrorRequest,
3484        responder: EchoEchoUnionPayloadWithErrorResponder,
3485    },
3486    EchoUnionPayloadNoRetVal {
3487        payload: RequestUnion,
3488        control_handle: EchoControlHandle,
3489    },
3490}
3491
3492impl EchoRequest {
3493    #[allow(irrefutable_let_patterns)]
3494    pub fn into_echo_table_request_composed(
3495        self,
3496    ) -> Option<(
3497        fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
3498        EchoEchoTableRequestComposedResponder,
3499    )> {
3500        if let EchoRequest::EchoTableRequestComposed { payload, responder } = self {
3501            Some((payload, responder))
3502        } else {
3503            None
3504        }
3505    }
3506
3507    #[allow(irrefutable_let_patterns)]
3508    pub fn into_echo_union_response_with_error_composed(
3509        self,
3510    ) -> Option<(
3511        i64,
3512        bool,
3513        String,
3514        u32,
3515        fidl_fidl_test_imported::WantResponse,
3516        EchoEchoUnionResponseWithErrorComposedResponder,
3517    )> {
3518        if let EchoRequest::EchoUnionResponseWithErrorComposed {
3519            value,
3520            want_absolute_value,
3521            forward_to_server,
3522            result_err,
3523            result_variant,
3524            responder,
3525        } = self
3526        {
3527            Some((
3528                value,
3529                want_absolute_value,
3530                forward_to_server,
3531                result_err,
3532                result_variant,
3533                responder,
3534            ))
3535        } else {
3536            None
3537        }
3538    }
3539
3540    #[allow(irrefutable_let_patterns)]
3541    pub fn into_echo_minimal(self) -> Option<(String, EchoEchoMinimalResponder)> {
3542        if let EchoRequest::EchoMinimal { forward_to_server, responder } = self {
3543            Some((forward_to_server, responder))
3544        } else {
3545            None
3546        }
3547    }
3548
3549    #[allow(irrefutable_let_patterns)]
3550    pub fn into_echo_minimal_with_error(
3551        self,
3552    ) -> Option<(String, RespondWith, EchoEchoMinimalWithErrorResponder)> {
3553        if let EchoRequest::EchoMinimalWithError { forward_to_server, result_variant, responder } =
3554            self
3555        {
3556            Some((forward_to_server, result_variant, responder))
3557        } else {
3558            None
3559        }
3560    }
3561
3562    #[allow(irrefutable_let_patterns)]
3563    pub fn into_echo_minimal_no_ret_val(self) -> Option<(String, EchoControlHandle)> {
3564        if let EchoRequest::EchoMinimalNoRetVal { forward_to_server, control_handle } = self {
3565            Some((forward_to_server, control_handle))
3566        } else {
3567            None
3568        }
3569    }
3570
3571    #[allow(irrefutable_let_patterns)]
3572    pub fn into_echo_struct(self) -> Option<(Struct, String, EchoEchoStructResponder)> {
3573        if let EchoRequest::EchoStruct { value, forward_to_server, responder } = self {
3574            Some((value, forward_to_server, responder))
3575        } else {
3576            None
3577        }
3578    }
3579
3580    #[allow(irrefutable_let_patterns)]
3581    pub fn into_echo_struct_with_error(
3582        self,
3583    ) -> Option<(Struct, DefaultEnum, String, RespondWith, EchoEchoStructWithErrorResponder)> {
3584        if let EchoRequest::EchoStructWithError {
3585            value,
3586            result_err,
3587            forward_to_server,
3588            result_variant,
3589            responder,
3590        } = self
3591        {
3592            Some((value, result_err, forward_to_server, result_variant, responder))
3593        } else {
3594            None
3595        }
3596    }
3597
3598    #[allow(irrefutable_let_patterns)]
3599    pub fn into_echo_struct_no_ret_val(self) -> Option<(Struct, String, EchoControlHandle)> {
3600        if let EchoRequest::EchoStructNoRetVal { value, forward_to_server, control_handle } = self {
3601            Some((value, forward_to_server, control_handle))
3602        } else {
3603            None
3604        }
3605    }
3606
3607    #[allow(irrefutable_let_patterns)]
3608    pub fn into_echo_arrays(self) -> Option<(ArraysStruct, String, EchoEchoArraysResponder)> {
3609        if let EchoRequest::EchoArrays { value, forward_to_server, responder } = self {
3610            Some((value, forward_to_server, responder))
3611        } else {
3612            None
3613        }
3614    }
3615
3616    #[allow(irrefutable_let_patterns)]
3617    pub fn into_echo_arrays_with_error(
3618        self,
3619    ) -> Option<(ArraysStruct, DefaultEnum, String, RespondWith, EchoEchoArraysWithErrorResponder)>
3620    {
3621        if let EchoRequest::EchoArraysWithError {
3622            value,
3623            result_err,
3624            forward_to_server,
3625            result_variant,
3626            responder,
3627        } = self
3628        {
3629            Some((value, result_err, forward_to_server, result_variant, responder))
3630        } else {
3631            None
3632        }
3633    }
3634
3635    #[allow(irrefutable_let_patterns)]
3636    pub fn into_echo_vectors(self) -> Option<(VectorsStruct, String, EchoEchoVectorsResponder)> {
3637        if let EchoRequest::EchoVectors { value, forward_to_server, responder } = self {
3638            Some((value, forward_to_server, responder))
3639        } else {
3640            None
3641        }
3642    }
3643
3644    #[allow(irrefutable_let_patterns)]
3645    pub fn into_echo_vectors_with_error(
3646        self,
3647    ) -> Option<(VectorsStruct, DefaultEnum, String, RespondWith, EchoEchoVectorsWithErrorResponder)>
3648    {
3649        if let EchoRequest::EchoVectorsWithError {
3650            value,
3651            result_err,
3652            forward_to_server,
3653            result_variant,
3654            responder,
3655        } = self
3656        {
3657            Some((value, result_err, forward_to_server, result_variant, responder))
3658        } else {
3659            None
3660        }
3661    }
3662
3663    #[allow(irrefutable_let_patterns)]
3664    pub fn into_echo_table(self) -> Option<(AllTypesTable, String, EchoEchoTableResponder)> {
3665        if let EchoRequest::EchoTable { value, forward_to_server, responder } = self {
3666            Some((value, forward_to_server, responder))
3667        } else {
3668            None
3669        }
3670    }
3671
3672    #[allow(irrefutable_let_patterns)]
3673    pub fn into_echo_table_with_error(
3674        self,
3675    ) -> Option<(AllTypesTable, DefaultEnum, String, RespondWith, EchoEchoTableWithErrorResponder)>
3676    {
3677        if let EchoRequest::EchoTableWithError {
3678            value,
3679            result_err,
3680            forward_to_server,
3681            result_variant,
3682            responder,
3683        } = self
3684        {
3685            Some((value, result_err, forward_to_server, result_variant, responder))
3686        } else {
3687            None
3688        }
3689    }
3690
3691    #[allow(irrefutable_let_patterns)]
3692    pub fn into_echo_xunions(
3693        self,
3694    ) -> Option<(Vec<AllTypesXunion>, String, EchoEchoXunionsResponder)> {
3695        if let EchoRequest::EchoXunions { value, forward_to_server, responder } = self {
3696            Some((value, forward_to_server, responder))
3697        } else {
3698            None
3699        }
3700    }
3701
3702    #[allow(irrefutable_let_patterns)]
3703    pub fn into_echo_xunions_with_error(
3704        self,
3705    ) -> Option<(
3706        Vec<AllTypesXunion>,
3707        DefaultEnum,
3708        String,
3709        RespondWith,
3710        EchoEchoXunionsWithErrorResponder,
3711    )> {
3712        if let EchoRequest::EchoXunionsWithError {
3713            value,
3714            result_err,
3715            forward_to_server,
3716            result_variant,
3717            responder,
3718        } = self
3719        {
3720            Some((value, result_err, forward_to_server, result_variant, responder))
3721        } else {
3722            None
3723        }
3724    }
3725
3726    #[allow(irrefutable_let_patterns)]
3727    pub fn into_echo_named_struct(
3728        self,
3729    ) -> Option<(fidl_fidl_test_imported::SimpleStruct, String, EchoEchoNamedStructResponder)> {
3730        if let EchoRequest::EchoNamedStruct { value, forward_to_server, responder } = self {
3731            Some((value, forward_to_server, responder))
3732        } else {
3733            None
3734        }
3735    }
3736
3737    #[allow(irrefutable_let_patterns)]
3738    pub fn into_echo_named_struct_with_error(
3739        self,
3740    ) -> Option<(
3741        fidl_fidl_test_imported::SimpleStruct,
3742        u32,
3743        String,
3744        fidl_fidl_test_imported::WantResponse,
3745        EchoEchoNamedStructWithErrorResponder,
3746    )> {
3747        if let EchoRequest::EchoNamedStructWithError {
3748            value,
3749            result_err,
3750            forward_to_server,
3751            result_variant,
3752            responder,
3753        } = self
3754        {
3755            Some((value, result_err, forward_to_server, result_variant, responder))
3756        } else {
3757            None
3758        }
3759    }
3760
3761    #[allow(irrefutable_let_patterns)]
3762    pub fn into_echo_named_struct_no_ret_val(
3763        self,
3764    ) -> Option<(fidl_fidl_test_imported::SimpleStruct, String, EchoControlHandle)> {
3765        if let EchoRequest::EchoNamedStructNoRetVal { value, forward_to_server, control_handle } =
3766            self
3767        {
3768            Some((value, forward_to_server, control_handle))
3769        } else {
3770            None
3771        }
3772    }
3773
3774    #[allow(irrefutable_let_patterns)]
3775    pub fn into_echo_table_payload(self) -> Option<(RequestTable, EchoEchoTablePayloadResponder)> {
3776        if let EchoRequest::EchoTablePayload { payload, responder } = self {
3777            Some((payload, responder))
3778        } else {
3779            None
3780        }
3781    }
3782
3783    #[allow(irrefutable_let_patterns)]
3784    pub fn into_echo_table_payload_with_error(
3785        self,
3786    ) -> Option<(EchoEchoTablePayloadWithErrorRequest, EchoEchoTablePayloadWithErrorResponder)>
3787    {
3788        if let EchoRequest::EchoTablePayloadWithError { payload, responder } = self {
3789            Some((payload, responder))
3790        } else {
3791            None
3792        }
3793    }
3794
3795    #[allow(irrefutable_let_patterns)]
3796    pub fn into_echo_table_payload_no_ret_val(self) -> Option<(RequestTable, EchoControlHandle)> {
3797        if let EchoRequest::EchoTablePayloadNoRetVal { payload, control_handle } = self {
3798            Some((payload, control_handle))
3799        } else {
3800            None
3801        }
3802    }
3803
3804    #[allow(irrefutable_let_patterns)]
3805    pub fn into_echo_union_payload(self) -> Option<(RequestUnion, EchoEchoUnionPayloadResponder)> {
3806        if let EchoRequest::EchoUnionPayload { payload, responder } = self {
3807            Some((payload, responder))
3808        } else {
3809            None
3810        }
3811    }
3812
3813    #[allow(irrefutable_let_patterns)]
3814    pub fn into_echo_union_payload_with_error(
3815        self,
3816    ) -> Option<(EchoEchoUnionPayloadWithErrorRequest, EchoEchoUnionPayloadWithErrorResponder)>
3817    {
3818        if let EchoRequest::EchoUnionPayloadWithError { payload, responder } = self {
3819            Some((payload, responder))
3820        } else {
3821            None
3822        }
3823    }
3824
3825    #[allow(irrefutable_let_patterns)]
3826    pub fn into_echo_union_payload_no_ret_val(self) -> Option<(RequestUnion, EchoControlHandle)> {
3827        if let EchoRequest::EchoUnionPayloadNoRetVal { payload, control_handle } = self {
3828            Some((payload, control_handle))
3829        } else {
3830            None
3831        }
3832    }
3833
3834    /// Name of the method defined in FIDL
3835    pub fn method_name(&self) -> &'static str {
3836        match *self {
3837            EchoRequest::EchoTableRequestComposed { .. } => "echo_table_request_composed",
3838            EchoRequest::EchoUnionResponseWithErrorComposed { .. } => {
3839                "echo_union_response_with_error_composed"
3840            }
3841            EchoRequest::EchoMinimal { .. } => "echo_minimal",
3842            EchoRequest::EchoMinimalWithError { .. } => "echo_minimal_with_error",
3843            EchoRequest::EchoMinimalNoRetVal { .. } => "echo_minimal_no_ret_val",
3844            EchoRequest::EchoStruct { .. } => "echo_struct",
3845            EchoRequest::EchoStructWithError { .. } => "echo_struct_with_error",
3846            EchoRequest::EchoStructNoRetVal { .. } => "echo_struct_no_ret_val",
3847            EchoRequest::EchoArrays { .. } => "echo_arrays",
3848            EchoRequest::EchoArraysWithError { .. } => "echo_arrays_with_error",
3849            EchoRequest::EchoVectors { .. } => "echo_vectors",
3850            EchoRequest::EchoVectorsWithError { .. } => "echo_vectors_with_error",
3851            EchoRequest::EchoTable { .. } => "echo_table",
3852            EchoRequest::EchoTableWithError { .. } => "echo_table_with_error",
3853            EchoRequest::EchoXunions { .. } => "echo_xunions",
3854            EchoRequest::EchoXunionsWithError { .. } => "echo_xunions_with_error",
3855            EchoRequest::EchoNamedStruct { .. } => "echo_named_struct",
3856            EchoRequest::EchoNamedStructWithError { .. } => "echo_named_struct_with_error",
3857            EchoRequest::EchoNamedStructNoRetVal { .. } => "echo_named_struct_no_ret_val",
3858            EchoRequest::EchoTablePayload { .. } => "echo_table_payload",
3859            EchoRequest::EchoTablePayloadWithError { .. } => "echo_table_payload_with_error",
3860            EchoRequest::EchoTablePayloadNoRetVal { .. } => "echo_table_payload_no_ret_val",
3861            EchoRequest::EchoUnionPayload { .. } => "echo_union_payload",
3862            EchoRequest::EchoUnionPayloadWithError { .. } => "echo_union_payload_with_error",
3863            EchoRequest::EchoUnionPayloadNoRetVal { .. } => "echo_union_payload_no_ret_val",
3864        }
3865    }
3866}
3867
3868#[derive(Debug, Clone)]
3869pub struct EchoControlHandle {
3870    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
3871}
3872
3873impl fidl::endpoints::ControlHandle for EchoControlHandle {
3874    fn shutdown(&self) {
3875        self.inner.shutdown()
3876    }
3877
3878    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
3879        self.inner.shutdown_with_epitaph(status)
3880    }
3881
3882    fn is_closed(&self) -> bool {
3883        self.inner.channel().is_closed()
3884    }
3885    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
3886        self.inner.channel().on_closed()
3887    }
3888
3889    #[cfg(target_os = "fuchsia")]
3890    fn signal_peer(
3891        &self,
3892        clear_mask: zx::Signals,
3893        set_mask: zx::Signals,
3894    ) -> Result<(), zx_status::Status> {
3895        use fidl::Peered;
3896        self.inner.channel().signal_peer(clear_mask, set_mask)
3897    }
3898}
3899
3900impl EchoControlHandle {
3901    pub fn send_echo_minimal_event(&self) -> Result<(), fidl::Error> {
3902        self.inner.send::<fidl::encoding::EmptyPayload>(
3903            (),
3904            0,
3905            0x273b2029f1a0aee2,
3906            fidl::encoding::DynamicFlags::empty(),
3907        )
3908    }
3909
3910    pub fn send_echo_event(&self, mut value: Struct) -> Result<(), fidl::Error> {
3911        self.inner.send::<EchoEchoEventRequest>(
3912            (&mut value,),
3913            0,
3914            0x1219e12e0450024,
3915            fidl::encoding::DynamicFlags::empty(),
3916        )
3917    }
3918
3919    pub fn send_on_echo_named_event(
3920        &self,
3921        mut value: &fidl_fidl_test_imported::SimpleStruct,
3922    ) -> Result<(), fidl::Error> {
3923        self.inner.send::<fidl_fidl_test_imported::ResponseStruct>(
3924            (value,),
3925            0,
3926            0x749ebde83348a374,
3927            fidl::encoding::DynamicFlags::empty(),
3928        )
3929    }
3930
3931    pub fn send_on_echo_table_payload_event(
3932        &self,
3933        mut payload: &ResponseTable,
3934    ) -> Result<(), fidl::Error> {
3935        self.inner.send::<ResponseTable>(
3936            payload,
3937            0,
3938            0x708dddea1cb98430,
3939            fidl::encoding::DynamicFlags::empty(),
3940        )
3941    }
3942
3943    pub fn send_on_echo_union_payload_event(
3944        &self,
3945        mut payload: &ResponseUnion,
3946    ) -> Result<(), fidl::Error> {
3947        self.inner.send::<ResponseUnion>(
3948            payload,
3949            0,
3950            0x642f4c265a05f4c0,
3951            fidl::encoding::DynamicFlags::empty(),
3952        )
3953    }
3954}
3955
3956#[must_use = "FIDL methods require a response to be sent"]
3957#[derive(Debug)]
3958pub struct EchoEchoTableRequestComposedResponder {
3959    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
3960    tx_id: u32,
3961}
3962
3963/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
3964/// if the responder is dropped without sending a response, so that the client
3965/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
3966impl std::ops::Drop for EchoEchoTableRequestComposedResponder {
3967    fn drop(&mut self) {
3968        self.control_handle.shutdown();
3969        // Safety: drops once, never accessed again
3970        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3971    }
3972}
3973
3974impl fidl::endpoints::Responder for EchoEchoTableRequestComposedResponder {
3975    type ControlHandle = EchoControlHandle;
3976
3977    fn control_handle(&self) -> &EchoControlHandle {
3978        &self.control_handle
3979    }
3980
3981    fn drop_without_shutdown(mut self) {
3982        // Safety: drops once, never accessed again due to mem::forget
3983        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3984        // Prevent Drop from running (which would shut down the channel)
3985        std::mem::forget(self);
3986    }
3987}
3988
3989impl EchoEchoTableRequestComposedResponder {
3990    /// Sends a response to the FIDL transaction.
3991    ///
3992    /// Sets the channel to shutdown if an error occurs.
3993    pub fn send(
3994        self,
3995        mut value: &fidl_fidl_test_imported::SimpleStruct,
3996    ) -> Result<(), fidl::Error> {
3997        let _result = self.send_raw(value);
3998        if _result.is_err() {
3999            self.control_handle.shutdown();
4000        }
4001        self.drop_without_shutdown();
4002        _result
4003    }
4004
4005    /// Similar to "send" but does not shutdown the channel if an error occurs.
4006    pub fn send_no_shutdown_on_err(
4007        self,
4008        mut value: &fidl_fidl_test_imported::SimpleStruct,
4009    ) -> Result<(), fidl::Error> {
4010        let _result = self.send_raw(value);
4011        self.drop_without_shutdown();
4012        _result
4013    }
4014
4015    fn send_raw(
4016        &self,
4017        mut value: &fidl_fidl_test_imported::SimpleStruct,
4018    ) -> Result<(), fidl::Error> {
4019        self.control_handle.inner.send::<fidl_fidl_test_imported::ResponseStruct>(
4020            (value,),
4021            self.tx_id,
4022            0x1d545c738c7a8ee,
4023            fidl::encoding::DynamicFlags::empty(),
4024        )
4025    }
4026}
4027
4028#[must_use = "FIDL methods require a response to be sent"]
4029#[derive(Debug)]
4030pub struct EchoEchoUnionResponseWithErrorComposedResponder {
4031    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4032    tx_id: u32,
4033}
4034
4035/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4036/// if the responder is dropped without sending a response, so that the client
4037/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4038impl std::ops::Drop for EchoEchoUnionResponseWithErrorComposedResponder {
4039    fn drop(&mut self) {
4040        self.control_handle.shutdown();
4041        // Safety: drops once, never accessed again
4042        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4043    }
4044}
4045
4046impl fidl::endpoints::Responder for EchoEchoUnionResponseWithErrorComposedResponder {
4047    type ControlHandle = EchoControlHandle;
4048
4049    fn control_handle(&self) -> &EchoControlHandle {
4050        &self.control_handle
4051    }
4052
4053    fn drop_without_shutdown(mut self) {
4054        // Safety: drops once, never accessed again due to mem::forget
4055        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4056        // Prevent Drop from running (which would shut down the channel)
4057        std::mem::forget(self);
4058    }
4059}
4060
4061impl EchoEchoUnionResponseWithErrorComposedResponder {
4062    /// Sends a response to the FIDL transaction.
4063    ///
4064    /// Sets the channel to shutdown if an error occurs.
4065    pub fn send(
4066        self,
4067        mut result: Result<
4068            &fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse,
4069            u32,
4070        >,
4071    ) -> Result<(), fidl::Error> {
4072        let _result = self.send_raw(result);
4073        if _result.is_err() {
4074            self.control_handle.shutdown();
4075        }
4076        self.drop_without_shutdown();
4077        _result
4078    }
4079
4080    /// Similar to "send" but does not shutdown the channel if an error occurs.
4081    pub fn send_no_shutdown_on_err(
4082        self,
4083        mut result: Result<
4084            &fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse,
4085            u32,
4086        >,
4087    ) -> Result<(), fidl::Error> {
4088        let _result = self.send_raw(result);
4089        self.drop_without_shutdown();
4090        _result
4091    }
4092
4093    fn send_raw(
4094        &self,
4095        mut result: Result<
4096            &fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse,
4097            u32,
4098        >,
4099    ) -> Result<(), fidl::Error> {
4100        self.control_handle.inner.send::<fidl::encoding::ResultType<
4101            fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse,
4102            u32,
4103        >>(
4104            result,
4105            self.tx_id,
4106            0x38a67e88d6106443,
4107            fidl::encoding::DynamicFlags::empty(),
4108        )
4109    }
4110}
4111
4112#[must_use = "FIDL methods require a response to be sent"]
4113#[derive(Debug)]
4114pub struct EchoEchoMinimalResponder {
4115    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4116    tx_id: u32,
4117}
4118
4119/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4120/// if the responder is dropped without sending a response, so that the client
4121/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4122impl std::ops::Drop for EchoEchoMinimalResponder {
4123    fn drop(&mut self) {
4124        self.control_handle.shutdown();
4125        // Safety: drops once, never accessed again
4126        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4127    }
4128}
4129
4130impl fidl::endpoints::Responder for EchoEchoMinimalResponder {
4131    type ControlHandle = EchoControlHandle;
4132
4133    fn control_handle(&self) -> &EchoControlHandle {
4134        &self.control_handle
4135    }
4136
4137    fn drop_without_shutdown(mut self) {
4138        // Safety: drops once, never accessed again due to mem::forget
4139        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4140        // Prevent Drop from running (which would shut down the channel)
4141        std::mem::forget(self);
4142    }
4143}
4144
4145impl EchoEchoMinimalResponder {
4146    /// Sends a response to the FIDL transaction.
4147    ///
4148    /// Sets the channel to shutdown if an error occurs.
4149    pub fn send(self) -> Result<(), fidl::Error> {
4150        let _result = self.send_raw();
4151        if _result.is_err() {
4152            self.control_handle.shutdown();
4153        }
4154        self.drop_without_shutdown();
4155        _result
4156    }
4157
4158    /// Similar to "send" but does not shutdown the channel if an error occurs.
4159    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
4160        let _result = self.send_raw();
4161        self.drop_without_shutdown();
4162        _result
4163    }
4164
4165    fn send_raw(&self) -> Result<(), fidl::Error> {
4166        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
4167            (),
4168            self.tx_id,
4169            0x39edd68c837482ec,
4170            fidl::encoding::DynamicFlags::empty(),
4171        )
4172    }
4173}
4174
4175#[must_use = "FIDL methods require a response to be sent"]
4176#[derive(Debug)]
4177pub struct EchoEchoMinimalWithErrorResponder {
4178    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4179    tx_id: u32,
4180}
4181
4182/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4183/// if the responder is dropped without sending a response, so that the client
4184/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4185impl std::ops::Drop for EchoEchoMinimalWithErrorResponder {
4186    fn drop(&mut self) {
4187        self.control_handle.shutdown();
4188        // Safety: drops once, never accessed again
4189        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4190    }
4191}
4192
4193impl fidl::endpoints::Responder for EchoEchoMinimalWithErrorResponder {
4194    type ControlHandle = EchoControlHandle;
4195
4196    fn control_handle(&self) -> &EchoControlHandle {
4197        &self.control_handle
4198    }
4199
4200    fn drop_without_shutdown(mut self) {
4201        // Safety: drops once, never accessed again due to mem::forget
4202        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4203        // Prevent Drop from running (which would shut down the channel)
4204        std::mem::forget(self);
4205    }
4206}
4207
4208impl EchoEchoMinimalWithErrorResponder {
4209    /// Sends a response to the FIDL transaction.
4210    ///
4211    /// Sets the channel to shutdown if an error occurs.
4212    pub fn send(self, mut result: Result<(), u32>) -> Result<(), fidl::Error> {
4213        let _result = self.send_raw(result);
4214        if _result.is_err() {
4215            self.control_handle.shutdown();
4216        }
4217        self.drop_without_shutdown();
4218        _result
4219    }
4220
4221    /// Similar to "send" but does not shutdown the channel if an error occurs.
4222    pub fn send_no_shutdown_on_err(self, mut result: Result<(), u32>) -> Result<(), fidl::Error> {
4223        let _result = self.send_raw(result);
4224        self.drop_without_shutdown();
4225        _result
4226    }
4227
4228    fn send_raw(&self, mut result: Result<(), u32>) -> Result<(), fidl::Error> {
4229        self.control_handle
4230            .inner
4231            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, u32>>(
4232                result,
4233                self.tx_id,
4234                0x36f4695996e35acc,
4235                fidl::encoding::DynamicFlags::empty(),
4236            )
4237    }
4238}
4239
4240#[must_use = "FIDL methods require a response to be sent"]
4241#[derive(Debug)]
4242pub struct EchoEchoStructResponder {
4243    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4244    tx_id: u32,
4245}
4246
4247/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4248/// if the responder is dropped without sending a response, so that the client
4249/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4250impl std::ops::Drop for EchoEchoStructResponder {
4251    fn drop(&mut self) {
4252        self.control_handle.shutdown();
4253        // Safety: drops once, never accessed again
4254        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4255    }
4256}
4257
4258impl fidl::endpoints::Responder for EchoEchoStructResponder {
4259    type ControlHandle = EchoControlHandle;
4260
4261    fn control_handle(&self) -> &EchoControlHandle {
4262        &self.control_handle
4263    }
4264
4265    fn drop_without_shutdown(mut self) {
4266        // Safety: drops once, never accessed again due to mem::forget
4267        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4268        // Prevent Drop from running (which would shut down the channel)
4269        std::mem::forget(self);
4270    }
4271}
4272
4273impl EchoEchoStructResponder {
4274    /// Sends a response to the FIDL transaction.
4275    ///
4276    /// Sets the channel to shutdown if an error occurs.
4277    pub fn send(self, mut value: Struct) -> Result<(), fidl::Error> {
4278        let _result = self.send_raw(value);
4279        if _result.is_err() {
4280            self.control_handle.shutdown();
4281        }
4282        self.drop_without_shutdown();
4283        _result
4284    }
4285
4286    /// Similar to "send" but does not shutdown the channel if an error occurs.
4287    pub fn send_no_shutdown_on_err(self, mut value: Struct) -> Result<(), fidl::Error> {
4288        let _result = self.send_raw(value);
4289        self.drop_without_shutdown();
4290        _result
4291    }
4292
4293    fn send_raw(&self, mut value: Struct) -> Result<(), fidl::Error> {
4294        self.control_handle.inner.send::<EchoEchoStructResponse>(
4295            (&mut value,),
4296            self.tx_id,
4297            0x4c2f85818cc53f37,
4298            fidl::encoding::DynamicFlags::empty(),
4299        )
4300    }
4301}
4302
4303#[must_use = "FIDL methods require a response to be sent"]
4304#[derive(Debug)]
4305pub struct EchoEchoStructWithErrorResponder {
4306    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4307    tx_id: u32,
4308}
4309
4310/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4311/// if the responder is dropped without sending a response, so that the client
4312/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4313impl std::ops::Drop for EchoEchoStructWithErrorResponder {
4314    fn drop(&mut self) {
4315        self.control_handle.shutdown();
4316        // Safety: drops once, never accessed again
4317        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4318    }
4319}
4320
4321impl fidl::endpoints::Responder for EchoEchoStructWithErrorResponder {
4322    type ControlHandle = EchoControlHandle;
4323
4324    fn control_handle(&self) -> &EchoControlHandle {
4325        &self.control_handle
4326    }
4327
4328    fn drop_without_shutdown(mut self) {
4329        // Safety: drops once, never accessed again due to mem::forget
4330        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4331        // Prevent Drop from running (which would shut down the channel)
4332        std::mem::forget(self);
4333    }
4334}
4335
4336impl EchoEchoStructWithErrorResponder {
4337    /// Sends a response to the FIDL transaction.
4338    ///
4339    /// Sets the channel to shutdown if an error occurs.
4340    pub fn send(self, mut result: Result<Struct, DefaultEnum>) -> Result<(), fidl::Error> {
4341        let _result = self.send_raw(result);
4342        if _result.is_err() {
4343            self.control_handle.shutdown();
4344        }
4345        self.drop_without_shutdown();
4346        _result
4347    }
4348
4349    /// Similar to "send" but does not shutdown the channel if an error occurs.
4350    pub fn send_no_shutdown_on_err(
4351        self,
4352        mut result: Result<Struct, DefaultEnum>,
4353    ) -> Result<(), fidl::Error> {
4354        let _result = self.send_raw(result);
4355        self.drop_without_shutdown();
4356        _result
4357    }
4358
4359    fn send_raw(&self, mut result: Result<Struct, DefaultEnum>) -> Result<(), fidl::Error> {
4360        self.control_handle.inner.send::<fidl::encoding::ResultType<
4361            EchoEchoStructWithErrorResponse,
4362            DefaultEnum,
4363        >>(
4364            result.as_mut().map_err(|e| *e).map(|value| (value,)),
4365            self.tx_id,
4366            0x46cb32652c4c0899,
4367            fidl::encoding::DynamicFlags::empty(),
4368        )
4369    }
4370}
4371
4372#[must_use = "FIDL methods require a response to be sent"]
4373#[derive(Debug)]
4374pub struct EchoEchoArraysResponder {
4375    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4376    tx_id: u32,
4377}
4378
4379/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4380/// if the responder is dropped without sending a response, so that the client
4381/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4382impl std::ops::Drop for EchoEchoArraysResponder {
4383    fn drop(&mut self) {
4384        self.control_handle.shutdown();
4385        // Safety: drops once, never accessed again
4386        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4387    }
4388}
4389
4390impl fidl::endpoints::Responder for EchoEchoArraysResponder {
4391    type ControlHandle = EchoControlHandle;
4392
4393    fn control_handle(&self) -> &EchoControlHandle {
4394        &self.control_handle
4395    }
4396
4397    fn drop_without_shutdown(mut self) {
4398        // Safety: drops once, never accessed again due to mem::forget
4399        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4400        // Prevent Drop from running (which would shut down the channel)
4401        std::mem::forget(self);
4402    }
4403}
4404
4405impl EchoEchoArraysResponder {
4406    /// Sends a response to the FIDL transaction.
4407    ///
4408    /// Sets the channel to shutdown if an error occurs.
4409    pub fn send(self, mut value: ArraysStruct) -> Result<(), fidl::Error> {
4410        let _result = self.send_raw(value);
4411        if _result.is_err() {
4412            self.control_handle.shutdown();
4413        }
4414        self.drop_without_shutdown();
4415        _result
4416    }
4417
4418    /// Similar to "send" but does not shutdown the channel if an error occurs.
4419    pub fn send_no_shutdown_on_err(self, mut value: ArraysStruct) -> Result<(), fidl::Error> {
4420        let _result = self.send_raw(value);
4421        self.drop_without_shutdown();
4422        _result
4423    }
4424
4425    fn send_raw(&self, mut value: ArraysStruct) -> Result<(), fidl::Error> {
4426        self.control_handle.inner.send::<EchoEchoArraysResponse>(
4427            (&mut value,),
4428            self.tx_id,
4429            0x1b6019d5611f2470,
4430            fidl::encoding::DynamicFlags::empty(),
4431        )
4432    }
4433}
4434
4435#[must_use = "FIDL methods require a response to be sent"]
4436#[derive(Debug)]
4437pub struct EchoEchoArraysWithErrorResponder {
4438    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4439    tx_id: u32,
4440}
4441
4442/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4443/// if the responder is dropped without sending a response, so that the client
4444/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4445impl std::ops::Drop for EchoEchoArraysWithErrorResponder {
4446    fn drop(&mut self) {
4447        self.control_handle.shutdown();
4448        // Safety: drops once, never accessed again
4449        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4450    }
4451}
4452
4453impl fidl::endpoints::Responder for EchoEchoArraysWithErrorResponder {
4454    type ControlHandle = EchoControlHandle;
4455
4456    fn control_handle(&self) -> &EchoControlHandle {
4457        &self.control_handle
4458    }
4459
4460    fn drop_without_shutdown(mut self) {
4461        // Safety: drops once, never accessed again due to mem::forget
4462        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4463        // Prevent Drop from running (which would shut down the channel)
4464        std::mem::forget(self);
4465    }
4466}
4467
4468impl EchoEchoArraysWithErrorResponder {
4469    /// Sends a response to the FIDL transaction.
4470    ///
4471    /// Sets the channel to shutdown if an error occurs.
4472    pub fn send(self, mut result: Result<ArraysStruct, DefaultEnum>) -> Result<(), fidl::Error> {
4473        let _result = self.send_raw(result);
4474        if _result.is_err() {
4475            self.control_handle.shutdown();
4476        }
4477        self.drop_without_shutdown();
4478        _result
4479    }
4480
4481    /// Similar to "send" but does not shutdown the channel if an error occurs.
4482    pub fn send_no_shutdown_on_err(
4483        self,
4484        mut result: Result<ArraysStruct, DefaultEnum>,
4485    ) -> Result<(), fidl::Error> {
4486        let _result = self.send_raw(result);
4487        self.drop_without_shutdown();
4488        _result
4489    }
4490
4491    fn send_raw(&self, mut result: Result<ArraysStruct, DefaultEnum>) -> Result<(), fidl::Error> {
4492        self.control_handle.inner.send::<fidl::encoding::ResultType<
4493            EchoEchoArraysWithErrorResponse,
4494            DefaultEnum,
4495        >>(
4496            result.as_mut().map_err(|e| *e).map(|value| (value,)),
4497            self.tx_id,
4498            0x6dbf26e67e253afa,
4499            fidl::encoding::DynamicFlags::empty(),
4500        )
4501    }
4502}
4503
4504#[must_use = "FIDL methods require a response to be sent"]
4505#[derive(Debug)]
4506pub struct EchoEchoVectorsResponder {
4507    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4508    tx_id: u32,
4509}
4510
4511/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4512/// if the responder is dropped without sending a response, so that the client
4513/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4514impl std::ops::Drop for EchoEchoVectorsResponder {
4515    fn drop(&mut self) {
4516        self.control_handle.shutdown();
4517        // Safety: drops once, never accessed again
4518        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4519    }
4520}
4521
4522impl fidl::endpoints::Responder for EchoEchoVectorsResponder {
4523    type ControlHandle = EchoControlHandle;
4524
4525    fn control_handle(&self) -> &EchoControlHandle {
4526        &self.control_handle
4527    }
4528
4529    fn drop_without_shutdown(mut self) {
4530        // Safety: drops once, never accessed again due to mem::forget
4531        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4532        // Prevent Drop from running (which would shut down the channel)
4533        std::mem::forget(self);
4534    }
4535}
4536
4537impl EchoEchoVectorsResponder {
4538    /// Sends a response to the FIDL transaction.
4539    ///
4540    /// Sets the channel to shutdown if an error occurs.
4541    pub fn send(self, mut value: VectorsStruct) -> Result<(), fidl::Error> {
4542        let _result = self.send_raw(value);
4543        if _result.is_err() {
4544            self.control_handle.shutdown();
4545        }
4546        self.drop_without_shutdown();
4547        _result
4548    }
4549
4550    /// Similar to "send" but does not shutdown the channel if an error occurs.
4551    pub fn send_no_shutdown_on_err(self, mut value: VectorsStruct) -> Result<(), fidl::Error> {
4552        let _result = self.send_raw(value);
4553        self.drop_without_shutdown();
4554        _result
4555    }
4556
4557    fn send_raw(&self, mut value: VectorsStruct) -> Result<(), fidl::Error> {
4558        self.control_handle.inner.send::<EchoEchoVectorsResponse>(
4559            (&mut value,),
4560            self.tx_id,
4561            0x1582623f0d9f6e5e,
4562            fidl::encoding::DynamicFlags::empty(),
4563        )
4564    }
4565}
4566
4567#[must_use = "FIDL methods require a response to be sent"]
4568#[derive(Debug)]
4569pub struct EchoEchoVectorsWithErrorResponder {
4570    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4571    tx_id: u32,
4572}
4573
4574/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4575/// if the responder is dropped without sending a response, so that the client
4576/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4577impl std::ops::Drop for EchoEchoVectorsWithErrorResponder {
4578    fn drop(&mut self) {
4579        self.control_handle.shutdown();
4580        // Safety: drops once, never accessed again
4581        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4582    }
4583}
4584
4585impl fidl::endpoints::Responder for EchoEchoVectorsWithErrorResponder {
4586    type ControlHandle = EchoControlHandle;
4587
4588    fn control_handle(&self) -> &EchoControlHandle {
4589        &self.control_handle
4590    }
4591
4592    fn drop_without_shutdown(mut self) {
4593        // Safety: drops once, never accessed again due to mem::forget
4594        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4595        // Prevent Drop from running (which would shut down the channel)
4596        std::mem::forget(self);
4597    }
4598}
4599
4600impl EchoEchoVectorsWithErrorResponder {
4601    /// Sends a response to the FIDL transaction.
4602    ///
4603    /// Sets the channel to shutdown if an error occurs.
4604    pub fn send(self, mut result: Result<VectorsStruct, DefaultEnum>) -> Result<(), fidl::Error> {
4605        let _result = self.send_raw(result);
4606        if _result.is_err() {
4607            self.control_handle.shutdown();
4608        }
4609        self.drop_without_shutdown();
4610        _result
4611    }
4612
4613    /// Similar to "send" but does not shutdown the channel if an error occurs.
4614    pub fn send_no_shutdown_on_err(
4615        self,
4616        mut result: Result<VectorsStruct, DefaultEnum>,
4617    ) -> Result<(), fidl::Error> {
4618        let _result = self.send_raw(result);
4619        self.drop_without_shutdown();
4620        _result
4621    }
4622
4623    fn send_raw(&self, mut result: Result<VectorsStruct, DefaultEnum>) -> Result<(), fidl::Error> {
4624        self.control_handle.inner.send::<fidl::encoding::ResultType<
4625            EchoEchoVectorsWithErrorResponse,
4626            DefaultEnum,
4627        >>(
4628            result.as_mut().map_err(|e| *e).map(|value| (value,)),
4629            self.tx_id,
4630            0x730f163401e2b3e5,
4631            fidl::encoding::DynamicFlags::empty(),
4632        )
4633    }
4634}
4635
4636#[must_use = "FIDL methods require a response to be sent"]
4637#[derive(Debug)]
4638pub struct EchoEchoTableResponder {
4639    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4640    tx_id: u32,
4641}
4642
4643/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4644/// if the responder is dropped without sending a response, so that the client
4645/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4646impl std::ops::Drop for EchoEchoTableResponder {
4647    fn drop(&mut self) {
4648        self.control_handle.shutdown();
4649        // Safety: drops once, never accessed again
4650        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4651    }
4652}
4653
4654impl fidl::endpoints::Responder for EchoEchoTableResponder {
4655    type ControlHandle = EchoControlHandle;
4656
4657    fn control_handle(&self) -> &EchoControlHandle {
4658        &self.control_handle
4659    }
4660
4661    fn drop_without_shutdown(mut self) {
4662        // Safety: drops once, never accessed again due to mem::forget
4663        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4664        // Prevent Drop from running (which would shut down the channel)
4665        std::mem::forget(self);
4666    }
4667}
4668
4669impl EchoEchoTableResponder {
4670    /// Sends a response to the FIDL transaction.
4671    ///
4672    /// Sets the channel to shutdown if an error occurs.
4673    pub fn send(self, mut value: AllTypesTable) -> Result<(), fidl::Error> {
4674        let _result = self.send_raw(value);
4675        if _result.is_err() {
4676            self.control_handle.shutdown();
4677        }
4678        self.drop_without_shutdown();
4679        _result
4680    }
4681
4682    /// Similar to "send" but does not shutdown the channel if an error occurs.
4683    pub fn send_no_shutdown_on_err(self, mut value: AllTypesTable) -> Result<(), fidl::Error> {
4684        let _result = self.send_raw(value);
4685        self.drop_without_shutdown();
4686        _result
4687    }
4688
4689    fn send_raw(&self, mut value: AllTypesTable) -> Result<(), fidl::Error> {
4690        self.control_handle.inner.send::<EchoEchoTableResponse>(
4691            (&mut value,),
4692            self.tx_id,
4693            0x4f1fb0a512f47c4b,
4694            fidl::encoding::DynamicFlags::empty(),
4695        )
4696    }
4697}
4698
4699#[must_use = "FIDL methods require a response to be sent"]
4700#[derive(Debug)]
4701pub struct EchoEchoTableWithErrorResponder {
4702    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4703    tx_id: u32,
4704}
4705
4706/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4707/// if the responder is dropped without sending a response, so that the client
4708/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4709impl std::ops::Drop for EchoEchoTableWithErrorResponder {
4710    fn drop(&mut self) {
4711        self.control_handle.shutdown();
4712        // Safety: drops once, never accessed again
4713        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4714    }
4715}
4716
4717impl fidl::endpoints::Responder for EchoEchoTableWithErrorResponder {
4718    type ControlHandle = EchoControlHandle;
4719
4720    fn control_handle(&self) -> &EchoControlHandle {
4721        &self.control_handle
4722    }
4723
4724    fn drop_without_shutdown(mut self) {
4725        // Safety: drops once, never accessed again due to mem::forget
4726        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4727        // Prevent Drop from running (which would shut down the channel)
4728        std::mem::forget(self);
4729    }
4730}
4731
4732impl EchoEchoTableWithErrorResponder {
4733    /// Sends a response to the FIDL transaction.
4734    ///
4735    /// Sets the channel to shutdown if an error occurs.
4736    pub fn send(self, mut result: Result<AllTypesTable, DefaultEnum>) -> Result<(), fidl::Error> {
4737        let _result = self.send_raw(result);
4738        if _result.is_err() {
4739            self.control_handle.shutdown();
4740        }
4741        self.drop_without_shutdown();
4742        _result
4743    }
4744
4745    /// Similar to "send" but does not shutdown the channel if an error occurs.
4746    pub fn send_no_shutdown_on_err(
4747        self,
4748        mut result: Result<AllTypesTable, DefaultEnum>,
4749    ) -> Result<(), fidl::Error> {
4750        let _result = self.send_raw(result);
4751        self.drop_without_shutdown();
4752        _result
4753    }
4754
4755    fn send_raw(&self, mut result: Result<AllTypesTable, DefaultEnum>) -> Result<(), fidl::Error> {
4756        self.control_handle.inner.send::<fidl::encoding::ResultType<
4757            EchoEchoTableWithErrorResponse,
4758            DefaultEnum,
4759        >>(
4760            result.as_mut().map_err(|e| *e).map(|value| (value,)),
4761            self.tx_id,
4762            0x44e835cb1eb9a931,
4763            fidl::encoding::DynamicFlags::empty(),
4764        )
4765    }
4766}
4767
4768#[must_use = "FIDL methods require a response to be sent"]
4769#[derive(Debug)]
4770pub struct EchoEchoXunionsResponder {
4771    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4772    tx_id: u32,
4773}
4774
4775/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4776/// if the responder is dropped without sending a response, so that the client
4777/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4778impl std::ops::Drop for EchoEchoXunionsResponder {
4779    fn drop(&mut self) {
4780        self.control_handle.shutdown();
4781        // Safety: drops once, never accessed again
4782        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4783    }
4784}
4785
4786impl fidl::endpoints::Responder for EchoEchoXunionsResponder {
4787    type ControlHandle = EchoControlHandle;
4788
4789    fn control_handle(&self) -> &EchoControlHandle {
4790        &self.control_handle
4791    }
4792
4793    fn drop_without_shutdown(mut self) {
4794        // Safety: drops once, never accessed again due to mem::forget
4795        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4796        // Prevent Drop from running (which would shut down the channel)
4797        std::mem::forget(self);
4798    }
4799}
4800
4801impl EchoEchoXunionsResponder {
4802    /// Sends a response to the FIDL transaction.
4803    ///
4804    /// Sets the channel to shutdown if an error occurs.
4805    pub fn send(self, mut value: Vec<AllTypesXunion>) -> Result<(), fidl::Error> {
4806        let _result = self.send_raw(value);
4807        if _result.is_err() {
4808            self.control_handle.shutdown();
4809        }
4810        self.drop_without_shutdown();
4811        _result
4812    }
4813
4814    /// Similar to "send" but does not shutdown the channel if an error occurs.
4815    pub fn send_no_shutdown_on_err(
4816        self,
4817        mut value: Vec<AllTypesXunion>,
4818    ) -> Result<(), fidl::Error> {
4819        let _result = self.send_raw(value);
4820        self.drop_without_shutdown();
4821        _result
4822    }
4823
4824    fn send_raw(&self, mut value: Vec<AllTypesXunion>) -> Result<(), fidl::Error> {
4825        self.control_handle.inner.send::<EchoEchoXunionsResponse>(
4826            (value.as_mut(),),
4827            self.tx_id,
4828            0x3dc181909041a583,
4829            fidl::encoding::DynamicFlags::empty(),
4830        )
4831    }
4832}
4833
4834#[must_use = "FIDL methods require a response to be sent"]
4835#[derive(Debug)]
4836pub struct EchoEchoXunionsWithErrorResponder {
4837    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4838    tx_id: u32,
4839}
4840
4841/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4842/// if the responder is dropped without sending a response, so that the client
4843/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4844impl std::ops::Drop for EchoEchoXunionsWithErrorResponder {
4845    fn drop(&mut self) {
4846        self.control_handle.shutdown();
4847        // Safety: drops once, never accessed again
4848        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4849    }
4850}
4851
4852impl fidl::endpoints::Responder for EchoEchoXunionsWithErrorResponder {
4853    type ControlHandle = EchoControlHandle;
4854
4855    fn control_handle(&self) -> &EchoControlHandle {
4856        &self.control_handle
4857    }
4858
4859    fn drop_without_shutdown(mut self) {
4860        // Safety: drops once, never accessed again due to mem::forget
4861        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4862        // Prevent Drop from running (which would shut down the channel)
4863        std::mem::forget(self);
4864    }
4865}
4866
4867impl EchoEchoXunionsWithErrorResponder {
4868    /// Sends a response to the FIDL transaction.
4869    ///
4870    /// Sets the channel to shutdown if an error occurs.
4871    pub fn send(
4872        self,
4873        mut result: Result<Vec<AllTypesXunion>, DefaultEnum>,
4874    ) -> Result<(), fidl::Error> {
4875        let _result = self.send_raw(result);
4876        if _result.is_err() {
4877            self.control_handle.shutdown();
4878        }
4879        self.drop_without_shutdown();
4880        _result
4881    }
4882
4883    /// Similar to "send" but does not shutdown the channel if an error occurs.
4884    pub fn send_no_shutdown_on_err(
4885        self,
4886        mut result: Result<Vec<AllTypesXunion>, DefaultEnum>,
4887    ) -> Result<(), fidl::Error> {
4888        let _result = self.send_raw(result);
4889        self.drop_without_shutdown();
4890        _result
4891    }
4892
4893    fn send_raw(
4894        &self,
4895        mut result: Result<Vec<AllTypesXunion>, DefaultEnum>,
4896    ) -> Result<(), fidl::Error> {
4897        self.control_handle.inner.send::<fidl::encoding::ResultType<
4898            EchoEchoXunionsWithErrorResponse,
4899            DefaultEnum,
4900        >>(
4901            result.as_mut().map_err(|e| *e).map(|value| (value.as_mut_slice(),)),
4902            self.tx_id,
4903            0x75184102667fa766,
4904            fidl::encoding::DynamicFlags::empty(),
4905        )
4906    }
4907}
4908
4909#[must_use = "FIDL methods require a response to be sent"]
4910#[derive(Debug)]
4911pub struct EchoEchoNamedStructResponder {
4912    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4913    tx_id: u32,
4914}
4915
4916/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4917/// if the responder is dropped without sending a response, so that the client
4918/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4919impl std::ops::Drop for EchoEchoNamedStructResponder {
4920    fn drop(&mut self) {
4921        self.control_handle.shutdown();
4922        // Safety: drops once, never accessed again
4923        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4924    }
4925}
4926
4927impl fidl::endpoints::Responder for EchoEchoNamedStructResponder {
4928    type ControlHandle = EchoControlHandle;
4929
4930    fn control_handle(&self) -> &EchoControlHandle {
4931        &self.control_handle
4932    }
4933
4934    fn drop_without_shutdown(mut self) {
4935        // Safety: drops once, never accessed again due to mem::forget
4936        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4937        // Prevent Drop from running (which would shut down the channel)
4938        std::mem::forget(self);
4939    }
4940}
4941
4942impl EchoEchoNamedStructResponder {
4943    /// Sends a response to the FIDL transaction.
4944    ///
4945    /// Sets the channel to shutdown if an error occurs.
4946    pub fn send(
4947        self,
4948        mut value: &fidl_fidl_test_imported::SimpleStruct,
4949    ) -> Result<(), fidl::Error> {
4950        let _result = self.send_raw(value);
4951        if _result.is_err() {
4952            self.control_handle.shutdown();
4953        }
4954        self.drop_without_shutdown();
4955        _result
4956    }
4957
4958    /// Similar to "send" but does not shutdown the channel if an error occurs.
4959    pub fn send_no_shutdown_on_err(
4960        self,
4961        mut value: &fidl_fidl_test_imported::SimpleStruct,
4962    ) -> Result<(), fidl::Error> {
4963        let _result = self.send_raw(value);
4964        self.drop_without_shutdown();
4965        _result
4966    }
4967
4968    fn send_raw(
4969        &self,
4970        mut value: &fidl_fidl_test_imported::SimpleStruct,
4971    ) -> Result<(), fidl::Error> {
4972        self.control_handle.inner.send::<fidl_fidl_test_imported::ResponseStruct>(
4973            (value,),
4974            self.tx_id,
4975            0xf2d4aa9e65f7111,
4976            fidl::encoding::DynamicFlags::empty(),
4977        )
4978    }
4979}
4980
4981#[must_use = "FIDL methods require a response to be sent"]
4982#[derive(Debug)]
4983pub struct EchoEchoNamedStructWithErrorResponder {
4984    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4985    tx_id: u32,
4986}
4987
4988/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4989/// if the responder is dropped without sending a response, so that the client
4990/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4991impl std::ops::Drop for EchoEchoNamedStructWithErrorResponder {
4992    fn drop(&mut self) {
4993        self.control_handle.shutdown();
4994        // Safety: drops once, never accessed again
4995        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4996    }
4997}
4998
4999impl fidl::endpoints::Responder for EchoEchoNamedStructWithErrorResponder {
5000    type ControlHandle = EchoControlHandle;
5001
5002    fn control_handle(&self) -> &EchoControlHandle {
5003        &self.control_handle
5004    }
5005
5006    fn drop_without_shutdown(mut self) {
5007        // Safety: drops once, never accessed again due to mem::forget
5008        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5009        // Prevent Drop from running (which would shut down the channel)
5010        std::mem::forget(self);
5011    }
5012}
5013
5014impl EchoEchoNamedStructWithErrorResponder {
5015    /// Sends a response to the FIDL transaction.
5016    ///
5017    /// Sets the channel to shutdown if an error occurs.
5018    pub fn send(
5019        self,
5020        mut result: Result<&fidl_fidl_test_imported::SimpleStruct, u32>,
5021    ) -> Result<(), fidl::Error> {
5022        let _result = self.send_raw(result);
5023        if _result.is_err() {
5024            self.control_handle.shutdown();
5025        }
5026        self.drop_without_shutdown();
5027        _result
5028    }
5029
5030    /// Similar to "send" but does not shutdown the channel if an error occurs.
5031    pub fn send_no_shutdown_on_err(
5032        self,
5033        mut result: Result<&fidl_fidl_test_imported::SimpleStruct, u32>,
5034    ) -> Result<(), fidl::Error> {
5035        let _result = self.send_raw(result);
5036        self.drop_without_shutdown();
5037        _result
5038    }
5039
5040    fn send_raw(
5041        &self,
5042        mut result: Result<&fidl_fidl_test_imported::SimpleStruct, u32>,
5043    ) -> Result<(), fidl::Error> {
5044        self.control_handle.inner.send::<fidl::encoding::ResultType<
5045            fidl_fidl_test_imported::ResponseStruct,
5046            u32,
5047        >>(
5048            result.map(|value| (value,)),
5049            self.tx_id,
5050            0x5766fee9e74442e8,
5051            fidl::encoding::DynamicFlags::empty(),
5052        )
5053    }
5054}
5055
5056#[must_use = "FIDL methods require a response to be sent"]
5057#[derive(Debug)]
5058pub struct EchoEchoTablePayloadResponder {
5059    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
5060    tx_id: u32,
5061}
5062
5063/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
5064/// if the responder is dropped without sending a response, so that the client
5065/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
5066impl std::ops::Drop for EchoEchoTablePayloadResponder {
5067    fn drop(&mut self) {
5068        self.control_handle.shutdown();
5069        // Safety: drops once, never accessed again
5070        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5071    }
5072}
5073
5074impl fidl::endpoints::Responder for EchoEchoTablePayloadResponder {
5075    type ControlHandle = EchoControlHandle;
5076
5077    fn control_handle(&self) -> &EchoControlHandle {
5078        &self.control_handle
5079    }
5080
5081    fn drop_without_shutdown(mut self) {
5082        // Safety: drops once, never accessed again due to mem::forget
5083        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5084        // Prevent Drop from running (which would shut down the channel)
5085        std::mem::forget(self);
5086    }
5087}
5088
5089impl EchoEchoTablePayloadResponder {
5090    /// Sends a response to the FIDL transaction.
5091    ///
5092    /// Sets the channel to shutdown if an error occurs.
5093    pub fn send(self, mut payload: &ResponseTable) -> Result<(), fidl::Error> {
5094        let _result = self.send_raw(payload);
5095        if _result.is_err() {
5096            self.control_handle.shutdown();
5097        }
5098        self.drop_without_shutdown();
5099        _result
5100    }
5101
5102    /// Similar to "send" but does not shutdown the channel if an error occurs.
5103    pub fn send_no_shutdown_on_err(self, mut payload: &ResponseTable) -> Result<(), fidl::Error> {
5104        let _result = self.send_raw(payload);
5105        self.drop_without_shutdown();
5106        _result
5107    }
5108
5109    fn send_raw(&self, mut payload: &ResponseTable) -> Result<(), fidl::Error> {
5110        self.control_handle.inner.send::<ResponseTable>(
5111            payload,
5112            self.tx_id,
5113            0x641d98087378c003,
5114            fidl::encoding::DynamicFlags::empty(),
5115        )
5116    }
5117}
5118
5119#[must_use = "FIDL methods require a response to be sent"]
5120#[derive(Debug)]
5121pub struct EchoEchoTablePayloadWithErrorResponder {
5122    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
5123    tx_id: u32,
5124}
5125
5126/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
5127/// if the responder is dropped without sending a response, so that the client
5128/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
5129impl std::ops::Drop for EchoEchoTablePayloadWithErrorResponder {
5130    fn drop(&mut self) {
5131        self.control_handle.shutdown();
5132        // Safety: drops once, never accessed again
5133        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5134    }
5135}
5136
5137impl fidl::endpoints::Responder for EchoEchoTablePayloadWithErrorResponder {
5138    type ControlHandle = EchoControlHandle;
5139
5140    fn control_handle(&self) -> &EchoControlHandle {
5141        &self.control_handle
5142    }
5143
5144    fn drop_without_shutdown(mut self) {
5145        // Safety: drops once, never accessed again due to mem::forget
5146        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5147        // Prevent Drop from running (which would shut down the channel)
5148        std::mem::forget(self);
5149    }
5150}
5151
5152impl EchoEchoTablePayloadWithErrorResponder {
5153    /// Sends a response to the FIDL transaction.
5154    ///
5155    /// Sets the channel to shutdown if an error occurs.
5156    pub fn send(self, mut result: Result<&ResponseTable, DefaultEnum>) -> Result<(), fidl::Error> {
5157        let _result = self.send_raw(result);
5158        if _result.is_err() {
5159            self.control_handle.shutdown();
5160        }
5161        self.drop_without_shutdown();
5162        _result
5163    }
5164
5165    /// Similar to "send" but does not shutdown the channel if an error occurs.
5166    pub fn send_no_shutdown_on_err(
5167        self,
5168        mut result: Result<&ResponseTable, DefaultEnum>,
5169    ) -> Result<(), fidl::Error> {
5170        let _result = self.send_raw(result);
5171        self.drop_without_shutdown();
5172        _result
5173    }
5174
5175    fn send_raw(&self, mut result: Result<&ResponseTable, DefaultEnum>) -> Result<(), fidl::Error> {
5176        self.control_handle.inner.send::<fidl::encoding::ResultType<ResponseTable, DefaultEnum>>(
5177            result,
5178            self.tx_id,
5179            0x636ed243761ab66d,
5180            fidl::encoding::DynamicFlags::empty(),
5181        )
5182    }
5183}
5184
5185#[must_use = "FIDL methods require a response to be sent"]
5186#[derive(Debug)]
5187pub struct EchoEchoUnionPayloadResponder {
5188    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
5189    tx_id: u32,
5190}
5191
5192/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
5193/// if the responder is dropped without sending a response, so that the client
5194/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
5195impl std::ops::Drop for EchoEchoUnionPayloadResponder {
5196    fn drop(&mut self) {
5197        self.control_handle.shutdown();
5198        // Safety: drops once, never accessed again
5199        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5200    }
5201}
5202
5203impl fidl::endpoints::Responder for EchoEchoUnionPayloadResponder {
5204    type ControlHandle = EchoControlHandle;
5205
5206    fn control_handle(&self) -> &EchoControlHandle {
5207        &self.control_handle
5208    }
5209
5210    fn drop_without_shutdown(mut self) {
5211        // Safety: drops once, never accessed again due to mem::forget
5212        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5213        // Prevent Drop from running (which would shut down the channel)
5214        std::mem::forget(self);
5215    }
5216}
5217
5218impl EchoEchoUnionPayloadResponder {
5219    /// Sends a response to the FIDL transaction.
5220    ///
5221    /// Sets the channel to shutdown if an error occurs.
5222    pub fn send(self, mut payload: &ResponseUnion) -> Result<(), fidl::Error> {
5223        let _result = self.send_raw(payload);
5224        if _result.is_err() {
5225            self.control_handle.shutdown();
5226        }
5227        self.drop_without_shutdown();
5228        _result
5229    }
5230
5231    /// Similar to "send" but does not shutdown the channel if an error occurs.
5232    pub fn send_no_shutdown_on_err(self, mut payload: &ResponseUnion) -> Result<(), fidl::Error> {
5233        let _result = self.send_raw(payload);
5234        self.drop_without_shutdown();
5235        _result
5236    }
5237
5238    fn send_raw(&self, mut payload: &ResponseUnion) -> Result<(), fidl::Error> {
5239        self.control_handle.inner.send::<ResponseUnion>(
5240            payload,
5241            self.tx_id,
5242            0x66def9e793f10c55,
5243            fidl::encoding::DynamicFlags::empty(),
5244        )
5245    }
5246}
5247
5248#[must_use = "FIDL methods require a response to be sent"]
5249#[derive(Debug)]
5250pub struct EchoEchoUnionPayloadWithErrorResponder {
5251    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
5252    tx_id: u32,
5253}
5254
5255/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
5256/// if the responder is dropped without sending a response, so that the client
5257/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
5258impl std::ops::Drop for EchoEchoUnionPayloadWithErrorResponder {
5259    fn drop(&mut self) {
5260        self.control_handle.shutdown();
5261        // Safety: drops once, never accessed again
5262        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5263    }
5264}
5265
5266impl fidl::endpoints::Responder for EchoEchoUnionPayloadWithErrorResponder {
5267    type ControlHandle = EchoControlHandle;
5268
5269    fn control_handle(&self) -> &EchoControlHandle {
5270        &self.control_handle
5271    }
5272
5273    fn drop_without_shutdown(mut self) {
5274        // Safety: drops once, never accessed again due to mem::forget
5275        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5276        // Prevent Drop from running (which would shut down the channel)
5277        std::mem::forget(self);
5278    }
5279}
5280
5281impl EchoEchoUnionPayloadWithErrorResponder {
5282    /// Sends a response to the FIDL transaction.
5283    ///
5284    /// Sets the channel to shutdown if an error occurs.
5285    pub fn send(self, mut result: Result<&ResponseUnion, DefaultEnum>) -> Result<(), fidl::Error> {
5286        let _result = self.send_raw(result);
5287        if _result.is_err() {
5288            self.control_handle.shutdown();
5289        }
5290        self.drop_without_shutdown();
5291        _result
5292    }
5293
5294    /// Similar to "send" but does not shutdown the channel if an error occurs.
5295    pub fn send_no_shutdown_on_err(
5296        self,
5297        mut result: Result<&ResponseUnion, DefaultEnum>,
5298    ) -> Result<(), fidl::Error> {
5299        let _result = self.send_raw(result);
5300        self.drop_without_shutdown();
5301        _result
5302    }
5303
5304    fn send_raw(&self, mut result: Result<&ResponseUnion, DefaultEnum>) -> Result<(), fidl::Error> {
5305        self.control_handle.inner.send::<fidl::encoding::ResultType<ResponseUnion, DefaultEnum>>(
5306            result,
5307            self.tx_id,
5308            0x1be890d6e68ef063,
5309            fidl::encoding::DynamicFlags::empty(),
5310        )
5311    }
5312}
5313
5314mod internal {
5315    use super::*;
5316
5317    impl fidl::encoding::ResourceTypeMarker for ArraysStruct {
5318        type Borrowed<'a> = &'a mut Self;
5319        fn take_or_borrow<'a>(
5320            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
5321        ) -> Self::Borrowed<'a> {
5322            value
5323        }
5324    }
5325
5326    unsafe impl fidl::encoding::TypeMarker for ArraysStruct {
5327        type Owned = Self;
5328
5329        #[inline(always)]
5330        fn inline_align(_context: fidl::encoding::Context) -> usize {
5331            8
5332        }
5333
5334        #[inline(always)]
5335        fn inline_size(_context: fidl::encoding::Context) -> usize {
5336            680
5337        }
5338    }
5339
5340    unsafe impl fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
5341        for &mut ArraysStruct
5342    {
5343        #[inline]
5344        unsafe fn encode(
5345            self,
5346            encoder: &mut fidl::encoding::Encoder<
5347                '_,
5348                fidl::encoding::DefaultFuchsiaResourceDialect,
5349            >,
5350            offset: usize,
5351            _depth: fidl::encoding::Depth,
5352        ) -> fidl::Result<()> {
5353            encoder.debug_check_bounds::<ArraysStruct>(offset);
5354            // Delegate to tuple encoding.
5355            fidl::encoding::Encode::<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
5356                (
5357                    <fidl::encoding::Array<bool, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.bools),
5358                    <fidl::encoding::Array<i8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int8s),
5359                    <fidl::encoding::Array<i16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int16s),
5360                    <fidl::encoding::Array<i32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int32s),
5361                    <fidl::encoding::Array<i64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int64s),
5362                    <fidl::encoding::Array<u8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint8s),
5363                    <fidl::encoding::Array<u16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint16s),
5364                    <fidl::encoding::Array<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint32s),
5365                    <fidl::encoding::Array<u64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint64s),
5366                    <fidl::encoding::Array<f32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.float32s),
5367                    <fidl::encoding::Array<f64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.float64s),
5368                    <fidl::encoding::Array<DefaultEnum, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.enums),
5369                    <fidl::encoding::Array<DefaultBits, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.bits),
5370                    <fidl::encoding::Array<fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 3> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handles),
5371                    <fidl::encoding::Array<fidl::encoding::Optional<fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>>, 3> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.nullable_handles),
5372                    <fidl::encoding::Array<fidl::encoding::UnboundedString, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.strings),
5373                    <fidl::encoding::Array<fidl::encoding::Optional<fidl::encoding::UnboundedString>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_strings),
5374                    <fidl::encoding::Array<ThisIsAStruct, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.structs),
5375                    <fidl::encoding::Array<fidl::encoding::Boxed<ThisIsAStruct>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_structs),
5376                    <fidl::encoding::Array<ThisIsAUnion, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.unions),
5377                    <fidl::encoding::Array<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_unions),
5378                    <fidl::encoding::Array<fidl::encoding::Array<u32, 3>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.arrays),
5379                    <fidl::encoding::Array<fidl::encoding::UnboundedVector<u32>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.vectors),
5380                    <fidl::encoding::Array<fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_vectors),
5381                    <fidl::encoding::Array<ThisIsATable, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.tables),
5382                    <fidl::encoding::Array<ThisIsAXunion, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.xunions),
5383                ),
5384                encoder, offset, _depth
5385            )
5386        }
5387    }
5388    unsafe impl<
5389        T0: fidl::encoding::Encode<
5390                fidl::encoding::Array<bool, 3>,
5391                fidl::encoding::DefaultFuchsiaResourceDialect,
5392            >,
5393        T1: fidl::encoding::Encode<
5394                fidl::encoding::Array<i8, 3>,
5395                fidl::encoding::DefaultFuchsiaResourceDialect,
5396            >,
5397        T2: fidl::encoding::Encode<
5398                fidl::encoding::Array<i16, 3>,
5399                fidl::encoding::DefaultFuchsiaResourceDialect,
5400            >,
5401        T3: fidl::encoding::Encode<
5402                fidl::encoding::Array<i32, 3>,
5403                fidl::encoding::DefaultFuchsiaResourceDialect,
5404            >,
5405        T4: fidl::encoding::Encode<
5406                fidl::encoding::Array<i64, 3>,
5407                fidl::encoding::DefaultFuchsiaResourceDialect,
5408            >,
5409        T5: fidl::encoding::Encode<
5410                fidl::encoding::Array<u8, 3>,
5411                fidl::encoding::DefaultFuchsiaResourceDialect,
5412            >,
5413        T6: fidl::encoding::Encode<
5414                fidl::encoding::Array<u16, 3>,
5415                fidl::encoding::DefaultFuchsiaResourceDialect,
5416            >,
5417        T7: fidl::encoding::Encode<
5418                fidl::encoding::Array<u32, 3>,
5419                fidl::encoding::DefaultFuchsiaResourceDialect,
5420            >,
5421        T8: fidl::encoding::Encode<
5422                fidl::encoding::Array<u64, 3>,
5423                fidl::encoding::DefaultFuchsiaResourceDialect,
5424            >,
5425        T9: fidl::encoding::Encode<
5426                fidl::encoding::Array<f32, 3>,
5427                fidl::encoding::DefaultFuchsiaResourceDialect,
5428            >,
5429        T10: fidl::encoding::Encode<
5430                fidl::encoding::Array<f64, 3>,
5431                fidl::encoding::DefaultFuchsiaResourceDialect,
5432            >,
5433        T11: fidl::encoding::Encode<
5434                fidl::encoding::Array<DefaultEnum, 3>,
5435                fidl::encoding::DefaultFuchsiaResourceDialect,
5436            >,
5437        T12: fidl::encoding::Encode<
5438                fidl::encoding::Array<DefaultBits, 3>,
5439                fidl::encoding::DefaultFuchsiaResourceDialect,
5440            >,
5441        T13: fidl::encoding::Encode<
5442                fidl::encoding::Array<
5443                    fidl::encoding::HandleType<
5444                        fidl::NullableHandle,
5445                        { fidl::ObjectType::NONE.into_raw() },
5446                        2147483648,
5447                    >,
5448                    3,
5449                >,
5450                fidl::encoding::DefaultFuchsiaResourceDialect,
5451            >,
5452        T14: fidl::encoding::Encode<
5453                fidl::encoding::Array<
5454                    fidl::encoding::Optional<
5455                        fidl::encoding::HandleType<
5456                            fidl::NullableHandle,
5457                            { fidl::ObjectType::NONE.into_raw() },
5458                            2147483648,
5459                        >,
5460                    >,
5461                    3,
5462                >,
5463                fidl::encoding::DefaultFuchsiaResourceDialect,
5464            >,
5465        T15: fidl::encoding::Encode<
5466                fidl::encoding::Array<fidl::encoding::UnboundedString, 3>,
5467                fidl::encoding::DefaultFuchsiaResourceDialect,
5468            >,
5469        T16: fidl::encoding::Encode<
5470                fidl::encoding::Array<fidl::encoding::Optional<fidl::encoding::UnboundedString>, 3>,
5471                fidl::encoding::DefaultFuchsiaResourceDialect,
5472            >,
5473        T17: fidl::encoding::Encode<
5474                fidl::encoding::Array<ThisIsAStruct, 3>,
5475                fidl::encoding::DefaultFuchsiaResourceDialect,
5476            >,
5477        T18: fidl::encoding::Encode<
5478                fidl::encoding::Array<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
5479                fidl::encoding::DefaultFuchsiaResourceDialect,
5480            >,
5481        T19: fidl::encoding::Encode<
5482                fidl::encoding::Array<ThisIsAUnion, 3>,
5483                fidl::encoding::DefaultFuchsiaResourceDialect,
5484            >,
5485        T20: fidl::encoding::Encode<
5486                fidl::encoding::Array<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
5487                fidl::encoding::DefaultFuchsiaResourceDialect,
5488            >,
5489        T21: fidl::encoding::Encode<
5490                fidl::encoding::Array<fidl::encoding::Array<u32, 3>, 3>,
5491                fidl::encoding::DefaultFuchsiaResourceDialect,
5492            >,
5493        T22: fidl::encoding::Encode<
5494                fidl::encoding::Array<fidl::encoding::UnboundedVector<u32>, 3>,
5495                fidl::encoding::DefaultFuchsiaResourceDialect,
5496            >,
5497        T23: fidl::encoding::Encode<
5498                fidl::encoding::Array<
5499                    fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
5500                    3,
5501                >,
5502                fidl::encoding::DefaultFuchsiaResourceDialect,
5503            >,
5504        T24: fidl::encoding::Encode<
5505                fidl::encoding::Array<ThisIsATable, 3>,
5506                fidl::encoding::DefaultFuchsiaResourceDialect,
5507            >,
5508        T25: fidl::encoding::Encode<
5509                fidl::encoding::Array<ThisIsAXunion, 3>,
5510                fidl::encoding::DefaultFuchsiaResourceDialect,
5511            >,
5512    > fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
5513        for (
5514            T0,
5515            T1,
5516            T2,
5517            T3,
5518            T4,
5519            T5,
5520            T6,
5521            T7,
5522            T8,
5523            T9,
5524            T10,
5525            T11,
5526            T12,
5527            T13,
5528            T14,
5529            T15,
5530            T16,
5531            T17,
5532            T18,
5533            T19,
5534            T20,
5535            T21,
5536            T22,
5537            T23,
5538            T24,
5539            T25,
5540        )
5541    {
5542        #[inline]
5543        unsafe fn encode(
5544            self,
5545            encoder: &mut fidl::encoding::Encoder<
5546                '_,
5547                fidl::encoding::DefaultFuchsiaResourceDialect,
5548            >,
5549            offset: usize,
5550            depth: fidl::encoding::Depth,
5551        ) -> fidl::Result<()> {
5552            encoder.debug_check_bounds::<ArraysStruct>(offset);
5553            // Zero out padding regions. There's no need to apply masks
5554            // because the unmasked parts will be overwritten by fields.
5555            unsafe {
5556                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(48);
5557                (ptr as *mut u64).write_unaligned(0);
5558            }
5559            unsafe {
5560                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(56);
5561                (ptr as *mut u64).write_unaligned(0);
5562            }
5563            unsafe {
5564                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(104);
5565                (ptr as *mut u64).write_unaligned(0);
5566            }
5567            unsafe {
5568                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(480);
5569                (ptr as *mut u64).write_unaligned(0);
5570            }
5571            // Write the fields.
5572            self.0.encode(encoder, offset + 0, depth)?;
5573            self.1.encode(encoder, offset + 3, depth)?;
5574            self.2.encode(encoder, offset + 6, depth)?;
5575            self.3.encode(encoder, offset + 12, depth)?;
5576            self.4.encode(encoder, offset + 24, depth)?;
5577            self.5.encode(encoder, offset + 48, depth)?;
5578            self.6.encode(encoder, offset + 52, depth)?;
5579            self.7.encode(encoder, offset + 60, depth)?;
5580            self.8.encode(encoder, offset + 72, depth)?;
5581            self.9.encode(encoder, offset + 96, depth)?;
5582            self.10.encode(encoder, offset + 112, depth)?;
5583            self.11.encode(encoder, offset + 136, depth)?;
5584            self.12.encode(encoder, offset + 148, depth)?;
5585            self.13.encode(encoder, offset + 160, depth)?;
5586            self.14.encode(encoder, offset + 172, depth)?;
5587            self.15.encode(encoder, offset + 184, depth)?;
5588            self.16.encode(encoder, offset + 232, depth)?;
5589            self.17.encode(encoder, offset + 280, depth)?;
5590            self.18.encode(encoder, offset + 328, depth)?;
5591            self.19.encode(encoder, offset + 352, depth)?;
5592            self.20.encode(encoder, offset + 400, depth)?;
5593            self.21.encode(encoder, offset + 448, depth)?;
5594            self.22.encode(encoder, offset + 488, depth)?;
5595            self.23.encode(encoder, offset + 536, depth)?;
5596            self.24.encode(encoder, offset + 584, depth)?;
5597            self.25.encode(encoder, offset + 632, depth)?;
5598            Ok(())
5599        }
5600    }
5601
5602    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for ArraysStruct {
5603        #[inline(always)]
5604        fn new_empty() -> Self {
5605            Self {
5606                bools: fidl::new_empty!(fidl::encoding::Array<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5607                int8s: fidl::new_empty!(fidl::encoding::Array<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5608                int16s: fidl::new_empty!(fidl::encoding::Array<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5609                int32s: fidl::new_empty!(fidl::encoding::Array<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5610                int64s: fidl::new_empty!(fidl::encoding::Array<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5611                uint8s: fidl::new_empty!(fidl::encoding::Array<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5612                uint16s: fidl::new_empty!(fidl::encoding::Array<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5613                uint32s: fidl::new_empty!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5614                uint64s: fidl::new_empty!(fidl::encoding::Array<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5615                float32s: fidl::new_empty!(fidl::encoding::Array<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5616                float64s: fidl::new_empty!(fidl::encoding::Array<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5617                enums: fidl::new_empty!(fidl::encoding::Array<DefaultEnum, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5618                bits: fidl::new_empty!(fidl::encoding::Array<DefaultBits, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5619                handles: fidl::new_empty!(
5620                    fidl::encoding::Array<
5621                        fidl::encoding::HandleType<
5622                            fidl::NullableHandle,
5623                            { fidl::ObjectType::NONE.into_raw() },
5624                            2147483648,
5625                        >,
5626                        3,
5627                    >,
5628                    fidl::encoding::DefaultFuchsiaResourceDialect
5629                ),
5630                nullable_handles: fidl::new_empty!(
5631                    fidl::encoding::Array<
5632                        fidl::encoding::Optional<
5633                            fidl::encoding::HandleType<
5634                                fidl::NullableHandle,
5635                                { fidl::ObjectType::NONE.into_raw() },
5636                                2147483648,
5637                            >,
5638                        >,
5639                        3,
5640                    >,
5641                    fidl::encoding::DefaultFuchsiaResourceDialect
5642                ),
5643                strings: fidl::new_empty!(fidl::encoding::Array<fidl::encoding::UnboundedString, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5644                nullable_strings: fidl::new_empty!(
5645                    fidl::encoding::Array<
5646                        fidl::encoding::Optional<fidl::encoding::UnboundedString>,
5647                        3,
5648                    >,
5649                    fidl::encoding::DefaultFuchsiaResourceDialect
5650                ),
5651                structs: fidl::new_empty!(fidl::encoding::Array<ThisIsAStruct, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5652                nullable_structs: fidl::new_empty!(
5653                    fidl::encoding::Array<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
5654                    fidl::encoding::DefaultFuchsiaResourceDialect
5655                ),
5656                unions: fidl::new_empty!(fidl::encoding::Array<ThisIsAUnion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5657                nullable_unions: fidl::new_empty!(
5658                    fidl::encoding::Array<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
5659                    fidl::encoding::DefaultFuchsiaResourceDialect
5660                ),
5661                arrays: fidl::new_empty!(
5662                    fidl::encoding::Array<fidl::encoding::Array<u32, 3>, 3>,
5663                    fidl::encoding::DefaultFuchsiaResourceDialect
5664                ),
5665                vectors: fidl::new_empty!(
5666                    fidl::encoding::Array<fidl::encoding::UnboundedVector<u32>, 3>,
5667                    fidl::encoding::DefaultFuchsiaResourceDialect
5668                ),
5669                nullable_vectors: fidl::new_empty!(
5670                    fidl::encoding::Array<
5671                        fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
5672                        3,
5673                    >,
5674                    fidl::encoding::DefaultFuchsiaResourceDialect
5675                ),
5676                tables: fidl::new_empty!(fidl::encoding::Array<ThisIsATable, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5677                xunions: fidl::new_empty!(fidl::encoding::Array<ThisIsAXunion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5678            }
5679        }
5680
5681        #[inline]
5682        unsafe fn decode(
5683            &mut self,
5684            decoder: &mut fidl::encoding::Decoder<
5685                '_,
5686                fidl::encoding::DefaultFuchsiaResourceDialect,
5687            >,
5688            offset: usize,
5689            _depth: fidl::encoding::Depth,
5690        ) -> fidl::Result<()> {
5691            decoder.debug_check_bounds::<Self>(offset);
5692            // Verify that padding bytes are zero.
5693            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(48) };
5694            let padval = unsafe { (ptr as *const u64).read_unaligned() };
5695            let mask = 0xff000000u64;
5696            let maskedval = padval & mask;
5697            if maskedval != 0 {
5698                return Err(fidl::Error::NonZeroPadding {
5699                    padding_start: offset + 48 + ((mask as u64).trailing_zeros() / 8) as usize,
5700                });
5701            }
5702            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(56) };
5703            let padval = unsafe { (ptr as *const u64).read_unaligned() };
5704            let mask = 0xffff0000u64;
5705            let maskedval = padval & mask;
5706            if maskedval != 0 {
5707                return Err(fidl::Error::NonZeroPadding {
5708                    padding_start: offset + 56 + ((mask as u64).trailing_zeros() / 8) as usize,
5709                });
5710            }
5711            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(104) };
5712            let padval = unsafe { (ptr as *const u64).read_unaligned() };
5713            let mask = 0xffffffff00000000u64;
5714            let maskedval = padval & mask;
5715            if maskedval != 0 {
5716                return Err(fidl::Error::NonZeroPadding {
5717                    padding_start: offset + 104 + ((mask as u64).trailing_zeros() / 8) as usize,
5718                });
5719            }
5720            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(480) };
5721            let padval = unsafe { (ptr as *const u64).read_unaligned() };
5722            let mask = 0xffffffff00000000u64;
5723            let maskedval = padval & mask;
5724            if maskedval != 0 {
5725                return Err(fidl::Error::NonZeroPadding {
5726                    padding_start: offset + 480 + ((mask as u64).trailing_zeros() / 8) as usize,
5727                });
5728            }
5729            fidl::decode!(fidl::encoding::Array<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.bools, decoder, offset + 0, _depth)?;
5730            fidl::decode!(fidl::encoding::Array<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int8s, decoder, offset + 3, _depth)?;
5731            fidl::decode!(fidl::encoding::Array<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int16s, decoder, offset + 6, _depth)?;
5732            fidl::decode!(fidl::encoding::Array<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int32s, decoder, offset + 12, _depth)?;
5733            fidl::decode!(fidl::encoding::Array<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int64s, decoder, offset + 24, _depth)?;
5734            fidl::decode!(fidl::encoding::Array<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint8s, decoder, offset + 48, _depth)?;
5735            fidl::decode!(fidl::encoding::Array<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint16s, decoder, offset + 52, _depth)?;
5736            fidl::decode!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint32s, decoder, offset + 60, _depth)?;
5737            fidl::decode!(fidl::encoding::Array<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint64s, decoder, offset + 72, _depth)?;
5738            fidl::decode!(fidl::encoding::Array<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.float32s, decoder, offset + 96, _depth)?;
5739            fidl::decode!(fidl::encoding::Array<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.float64s, decoder, offset + 112, _depth)?;
5740            fidl::decode!(fidl::encoding::Array<DefaultEnum, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.enums, decoder, offset + 136, _depth)?;
5741            fidl::decode!(fidl::encoding::Array<DefaultBits, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.bits, decoder, offset + 148, _depth)?;
5742            fidl::decode!(
5743                fidl::encoding::Array<
5744                    fidl::encoding::HandleType<
5745                        fidl::NullableHandle,
5746                        { fidl::ObjectType::NONE.into_raw() },
5747                        2147483648,
5748                    >,
5749                    3,
5750                >,
5751                fidl::encoding::DefaultFuchsiaResourceDialect,
5752                &mut self.handles,
5753                decoder,
5754                offset + 160,
5755                _depth
5756            )?;
5757            fidl::decode!(
5758                fidl::encoding::Array<
5759                    fidl::encoding::Optional<
5760                        fidl::encoding::HandleType<
5761                            fidl::NullableHandle,
5762                            { fidl::ObjectType::NONE.into_raw() },
5763                            2147483648,
5764                        >,
5765                    >,
5766                    3,
5767                >,
5768                fidl::encoding::DefaultFuchsiaResourceDialect,
5769                &mut self.nullable_handles,
5770                decoder,
5771                offset + 172,
5772                _depth
5773            )?;
5774            fidl::decode!(fidl::encoding::Array<fidl::encoding::UnboundedString, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.strings, decoder, offset + 184, _depth)?;
5775            fidl::decode!(
5776                fidl::encoding::Array<fidl::encoding::Optional<fidl::encoding::UnboundedString>, 3>,
5777                fidl::encoding::DefaultFuchsiaResourceDialect,
5778                &mut self.nullable_strings,
5779                decoder,
5780                offset + 232,
5781                _depth
5782            )?;
5783            fidl::decode!(fidl::encoding::Array<ThisIsAStruct, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.structs, decoder, offset + 280, _depth)?;
5784            fidl::decode!(
5785                fidl::encoding::Array<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
5786                fidl::encoding::DefaultFuchsiaResourceDialect,
5787                &mut self.nullable_structs,
5788                decoder,
5789                offset + 328,
5790                _depth
5791            )?;
5792            fidl::decode!(fidl::encoding::Array<ThisIsAUnion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.unions, decoder, offset + 352, _depth)?;
5793            fidl::decode!(
5794                fidl::encoding::Array<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
5795                fidl::encoding::DefaultFuchsiaResourceDialect,
5796                &mut self.nullable_unions,
5797                decoder,
5798                offset + 400,
5799                _depth
5800            )?;
5801            fidl::decode!(
5802                fidl::encoding::Array<fidl::encoding::Array<u32, 3>, 3>,
5803                fidl::encoding::DefaultFuchsiaResourceDialect,
5804                &mut self.arrays,
5805                decoder,
5806                offset + 448,
5807                _depth
5808            )?;
5809            fidl::decode!(
5810                fidl::encoding::Array<fidl::encoding::UnboundedVector<u32>, 3>,
5811                fidl::encoding::DefaultFuchsiaResourceDialect,
5812                &mut self.vectors,
5813                decoder,
5814                offset + 488,
5815                _depth
5816            )?;
5817            fidl::decode!(
5818                fidl::encoding::Array<
5819                    fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
5820                    3,
5821                >,
5822                fidl::encoding::DefaultFuchsiaResourceDialect,
5823                &mut self.nullable_vectors,
5824                decoder,
5825                offset + 536,
5826                _depth
5827            )?;
5828            fidl::decode!(fidl::encoding::Array<ThisIsATable, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.tables, decoder, offset + 584, _depth)?;
5829            fidl::decode!(fidl::encoding::Array<ThisIsAXunion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.xunions, decoder, offset + 632, _depth)?;
5830            Ok(())
5831        }
5832    }
5833
5834    impl fidl::encoding::ResourceTypeMarker for EchoEchoArraysRequest {
5835        type Borrowed<'a> = &'a mut Self;
5836        fn take_or_borrow<'a>(
5837            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
5838        ) -> Self::Borrowed<'a> {
5839            value
5840        }
5841    }
5842
5843    unsafe impl fidl::encoding::TypeMarker for EchoEchoArraysRequest {
5844        type Owned = Self;
5845
5846        #[inline(always)]
5847        fn inline_align(_context: fidl::encoding::Context) -> usize {
5848            8
5849        }
5850
5851        #[inline(always)]
5852        fn inline_size(_context: fidl::encoding::Context) -> usize {
5853            696
5854        }
5855    }
5856
5857    unsafe impl
5858        fidl::encoding::Encode<EchoEchoArraysRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
5859        for &mut EchoEchoArraysRequest
5860    {
5861        #[inline]
5862        unsafe fn encode(
5863            self,
5864            encoder: &mut fidl::encoding::Encoder<
5865                '_,
5866                fidl::encoding::DefaultFuchsiaResourceDialect,
5867            >,
5868            offset: usize,
5869            _depth: fidl::encoding::Depth,
5870        ) -> fidl::Result<()> {
5871            encoder.debug_check_bounds::<EchoEchoArraysRequest>(offset);
5872            // Delegate to tuple encoding.
5873            fidl::encoding::Encode::<
5874                EchoEchoArraysRequest,
5875                fidl::encoding::DefaultFuchsiaResourceDialect,
5876            >::encode(
5877                (
5878                    <ArraysStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
5879                        &mut self.value,
5880                    ),
5881                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
5882                        &self.forward_to_server,
5883                    ),
5884                ),
5885                encoder,
5886                offset,
5887                _depth,
5888            )
5889        }
5890    }
5891    unsafe impl<
5892        T0: fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
5893        T1: fidl::encoding::Encode<
5894                fidl::encoding::UnboundedString,
5895                fidl::encoding::DefaultFuchsiaResourceDialect,
5896            >,
5897    >
5898        fidl::encoding::Encode<EchoEchoArraysRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
5899        for (T0, T1)
5900    {
5901        #[inline]
5902        unsafe fn encode(
5903            self,
5904            encoder: &mut fidl::encoding::Encoder<
5905                '_,
5906                fidl::encoding::DefaultFuchsiaResourceDialect,
5907            >,
5908            offset: usize,
5909            depth: fidl::encoding::Depth,
5910        ) -> fidl::Result<()> {
5911            encoder.debug_check_bounds::<EchoEchoArraysRequest>(offset);
5912            // Zero out padding regions. There's no need to apply masks
5913            // because the unmasked parts will be overwritten by fields.
5914            // Write the fields.
5915            self.0.encode(encoder, offset + 0, depth)?;
5916            self.1.encode(encoder, offset + 680, depth)?;
5917            Ok(())
5918        }
5919    }
5920
5921    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
5922        for EchoEchoArraysRequest
5923    {
5924        #[inline(always)]
5925        fn new_empty() -> Self {
5926            Self {
5927                value: fidl::new_empty!(
5928                    ArraysStruct,
5929                    fidl::encoding::DefaultFuchsiaResourceDialect
5930                ),
5931                forward_to_server: fidl::new_empty!(
5932                    fidl::encoding::UnboundedString,
5933                    fidl::encoding::DefaultFuchsiaResourceDialect
5934                ),
5935            }
5936        }
5937
5938        #[inline]
5939        unsafe fn decode(
5940            &mut self,
5941            decoder: &mut fidl::encoding::Decoder<
5942                '_,
5943                fidl::encoding::DefaultFuchsiaResourceDialect,
5944            >,
5945            offset: usize,
5946            _depth: fidl::encoding::Depth,
5947        ) -> fidl::Result<()> {
5948            decoder.debug_check_bounds::<Self>(offset);
5949            // Verify that padding bytes are zero.
5950            fidl::decode!(
5951                ArraysStruct,
5952                fidl::encoding::DefaultFuchsiaResourceDialect,
5953                &mut self.value,
5954                decoder,
5955                offset + 0,
5956                _depth
5957            )?;
5958            fidl::decode!(
5959                fidl::encoding::UnboundedString,
5960                fidl::encoding::DefaultFuchsiaResourceDialect,
5961                &mut self.forward_to_server,
5962                decoder,
5963                offset + 680,
5964                _depth
5965            )?;
5966            Ok(())
5967        }
5968    }
5969
5970    impl fidl::encoding::ResourceTypeMarker for EchoEchoArraysResponse {
5971        type Borrowed<'a> = &'a mut Self;
5972        fn take_or_borrow<'a>(
5973            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
5974        ) -> Self::Borrowed<'a> {
5975            value
5976        }
5977    }
5978
5979    unsafe impl fidl::encoding::TypeMarker for EchoEchoArraysResponse {
5980        type Owned = Self;
5981
5982        #[inline(always)]
5983        fn inline_align(_context: fidl::encoding::Context) -> usize {
5984            8
5985        }
5986
5987        #[inline(always)]
5988        fn inline_size(_context: fidl::encoding::Context) -> usize {
5989            680
5990        }
5991    }
5992
5993    unsafe impl
5994        fidl::encoding::Encode<
5995            EchoEchoArraysResponse,
5996            fidl::encoding::DefaultFuchsiaResourceDialect,
5997        > for &mut EchoEchoArraysResponse
5998    {
5999        #[inline]
6000        unsafe fn encode(
6001            self,
6002            encoder: &mut fidl::encoding::Encoder<
6003                '_,
6004                fidl::encoding::DefaultFuchsiaResourceDialect,
6005            >,
6006            offset: usize,
6007            _depth: fidl::encoding::Depth,
6008        ) -> fidl::Result<()> {
6009            encoder.debug_check_bounds::<EchoEchoArraysResponse>(offset);
6010            // Delegate to tuple encoding.
6011            fidl::encoding::Encode::<
6012                EchoEchoArraysResponse,
6013                fidl::encoding::DefaultFuchsiaResourceDialect,
6014            >::encode(
6015                (<ArraysStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
6016                    &mut self.value,
6017                ),),
6018                encoder,
6019                offset,
6020                _depth,
6021            )
6022        }
6023    }
6024    unsafe impl<
6025        T0: fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
6026    >
6027        fidl::encoding::Encode<
6028            EchoEchoArraysResponse,
6029            fidl::encoding::DefaultFuchsiaResourceDialect,
6030        > for (T0,)
6031    {
6032        #[inline]
6033        unsafe fn encode(
6034            self,
6035            encoder: &mut fidl::encoding::Encoder<
6036                '_,
6037                fidl::encoding::DefaultFuchsiaResourceDialect,
6038            >,
6039            offset: usize,
6040            depth: fidl::encoding::Depth,
6041        ) -> fidl::Result<()> {
6042            encoder.debug_check_bounds::<EchoEchoArraysResponse>(offset);
6043            // Zero out padding regions. There's no need to apply masks
6044            // because the unmasked parts will be overwritten by fields.
6045            // Write the fields.
6046            self.0.encode(encoder, offset + 0, depth)?;
6047            Ok(())
6048        }
6049    }
6050
6051    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6052        for EchoEchoArraysResponse
6053    {
6054        #[inline(always)]
6055        fn new_empty() -> Self {
6056            Self {
6057                value: fidl::new_empty!(
6058                    ArraysStruct,
6059                    fidl::encoding::DefaultFuchsiaResourceDialect
6060                ),
6061            }
6062        }
6063
6064        #[inline]
6065        unsafe fn decode(
6066            &mut self,
6067            decoder: &mut fidl::encoding::Decoder<
6068                '_,
6069                fidl::encoding::DefaultFuchsiaResourceDialect,
6070            >,
6071            offset: usize,
6072            _depth: fidl::encoding::Depth,
6073        ) -> fidl::Result<()> {
6074            decoder.debug_check_bounds::<Self>(offset);
6075            // Verify that padding bytes are zero.
6076            fidl::decode!(
6077                ArraysStruct,
6078                fidl::encoding::DefaultFuchsiaResourceDialect,
6079                &mut self.value,
6080                decoder,
6081                offset + 0,
6082                _depth
6083            )?;
6084            Ok(())
6085        }
6086    }
6087
6088    impl fidl::encoding::ResourceTypeMarker for EchoEchoArraysWithErrorRequest {
6089        type Borrowed<'a> = &'a mut Self;
6090        fn take_or_borrow<'a>(
6091            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6092        ) -> Self::Borrowed<'a> {
6093            value
6094        }
6095    }
6096
6097    unsafe impl fidl::encoding::TypeMarker for EchoEchoArraysWithErrorRequest {
6098        type Owned = Self;
6099
6100        #[inline(always)]
6101        fn inline_align(_context: fidl::encoding::Context) -> usize {
6102            8
6103        }
6104
6105        #[inline(always)]
6106        fn inline_size(_context: fidl::encoding::Context) -> usize {
6107            712
6108        }
6109    }
6110
6111    unsafe impl
6112        fidl::encoding::Encode<
6113            EchoEchoArraysWithErrorRequest,
6114            fidl::encoding::DefaultFuchsiaResourceDialect,
6115        > for &mut EchoEchoArraysWithErrorRequest
6116    {
6117        #[inline]
6118        unsafe fn encode(
6119            self,
6120            encoder: &mut fidl::encoding::Encoder<
6121                '_,
6122                fidl::encoding::DefaultFuchsiaResourceDialect,
6123            >,
6124            offset: usize,
6125            _depth: fidl::encoding::Depth,
6126        ) -> fidl::Result<()> {
6127            encoder.debug_check_bounds::<EchoEchoArraysWithErrorRequest>(offset);
6128            // Delegate to tuple encoding.
6129            fidl::encoding::Encode::<
6130                EchoEchoArraysWithErrorRequest,
6131                fidl::encoding::DefaultFuchsiaResourceDialect,
6132            >::encode(
6133                (
6134                    <ArraysStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
6135                        &mut self.value,
6136                    ),
6137                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
6138                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
6139                        &self.forward_to_server,
6140                    ),
6141                    <RespondWith as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
6142                ),
6143                encoder,
6144                offset,
6145                _depth,
6146            )
6147        }
6148    }
6149    unsafe impl<
6150        T0: fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
6151        T1: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
6152        T2: fidl::encoding::Encode<
6153                fidl::encoding::UnboundedString,
6154                fidl::encoding::DefaultFuchsiaResourceDialect,
6155            >,
6156        T3: fidl::encoding::Encode<RespondWith, fidl::encoding::DefaultFuchsiaResourceDialect>,
6157    >
6158        fidl::encoding::Encode<
6159            EchoEchoArraysWithErrorRequest,
6160            fidl::encoding::DefaultFuchsiaResourceDialect,
6161        > for (T0, T1, T2, T3)
6162    {
6163        #[inline]
6164        unsafe fn encode(
6165            self,
6166            encoder: &mut fidl::encoding::Encoder<
6167                '_,
6168                fidl::encoding::DefaultFuchsiaResourceDialect,
6169            >,
6170            offset: usize,
6171            depth: fidl::encoding::Depth,
6172        ) -> fidl::Result<()> {
6173            encoder.debug_check_bounds::<EchoEchoArraysWithErrorRequest>(offset);
6174            // Zero out padding regions. There's no need to apply masks
6175            // because the unmasked parts will be overwritten by fields.
6176            unsafe {
6177                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(680);
6178                (ptr as *mut u64).write_unaligned(0);
6179            }
6180            unsafe {
6181                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(704);
6182                (ptr as *mut u64).write_unaligned(0);
6183            }
6184            // Write the fields.
6185            self.0.encode(encoder, offset + 0, depth)?;
6186            self.1.encode(encoder, offset + 680, depth)?;
6187            self.2.encode(encoder, offset + 688, depth)?;
6188            self.3.encode(encoder, offset + 704, depth)?;
6189            Ok(())
6190        }
6191    }
6192
6193    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6194        for EchoEchoArraysWithErrorRequest
6195    {
6196        #[inline(always)]
6197        fn new_empty() -> Self {
6198            Self {
6199                value: fidl::new_empty!(
6200                    ArraysStruct,
6201                    fidl::encoding::DefaultFuchsiaResourceDialect
6202                ),
6203                result_err: fidl::new_empty!(
6204                    DefaultEnum,
6205                    fidl::encoding::DefaultFuchsiaResourceDialect
6206                ),
6207                forward_to_server: fidl::new_empty!(
6208                    fidl::encoding::UnboundedString,
6209                    fidl::encoding::DefaultFuchsiaResourceDialect
6210                ),
6211                result_variant: fidl::new_empty!(
6212                    RespondWith,
6213                    fidl::encoding::DefaultFuchsiaResourceDialect
6214                ),
6215            }
6216        }
6217
6218        #[inline]
6219        unsafe fn decode(
6220            &mut self,
6221            decoder: &mut fidl::encoding::Decoder<
6222                '_,
6223                fidl::encoding::DefaultFuchsiaResourceDialect,
6224            >,
6225            offset: usize,
6226            _depth: fidl::encoding::Depth,
6227        ) -> fidl::Result<()> {
6228            decoder.debug_check_bounds::<Self>(offset);
6229            // Verify that padding bytes are zero.
6230            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(680) };
6231            let padval = unsafe { (ptr as *const u64).read_unaligned() };
6232            let mask = 0xffffffff00000000u64;
6233            let maskedval = padval & mask;
6234            if maskedval != 0 {
6235                return Err(fidl::Error::NonZeroPadding {
6236                    padding_start: offset + 680 + ((mask as u64).trailing_zeros() / 8) as usize,
6237                });
6238            }
6239            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(704) };
6240            let padval = unsafe { (ptr as *const u64).read_unaligned() };
6241            let mask = 0xffffffff00000000u64;
6242            let maskedval = padval & mask;
6243            if maskedval != 0 {
6244                return Err(fidl::Error::NonZeroPadding {
6245                    padding_start: offset + 704 + ((mask as u64).trailing_zeros() / 8) as usize,
6246                });
6247            }
6248            fidl::decode!(
6249                ArraysStruct,
6250                fidl::encoding::DefaultFuchsiaResourceDialect,
6251                &mut self.value,
6252                decoder,
6253                offset + 0,
6254                _depth
6255            )?;
6256            fidl::decode!(
6257                DefaultEnum,
6258                fidl::encoding::DefaultFuchsiaResourceDialect,
6259                &mut self.result_err,
6260                decoder,
6261                offset + 680,
6262                _depth
6263            )?;
6264            fidl::decode!(
6265                fidl::encoding::UnboundedString,
6266                fidl::encoding::DefaultFuchsiaResourceDialect,
6267                &mut self.forward_to_server,
6268                decoder,
6269                offset + 688,
6270                _depth
6271            )?;
6272            fidl::decode!(
6273                RespondWith,
6274                fidl::encoding::DefaultFuchsiaResourceDialect,
6275                &mut self.result_variant,
6276                decoder,
6277                offset + 704,
6278                _depth
6279            )?;
6280            Ok(())
6281        }
6282    }
6283
6284    impl fidl::encoding::ResourceTypeMarker for EchoEchoEventRequest {
6285        type Borrowed<'a> = &'a mut Self;
6286        fn take_or_borrow<'a>(
6287            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6288        ) -> Self::Borrowed<'a> {
6289            value
6290        }
6291    }
6292
6293    unsafe impl fidl::encoding::TypeMarker for EchoEchoEventRequest {
6294        type Owned = Self;
6295
6296        #[inline(always)]
6297        fn inline_align(_context: fidl::encoding::Context) -> usize {
6298            8
6299        }
6300
6301        #[inline(always)]
6302        fn inline_size(_context: fidl::encoding::Context) -> usize {
6303            2912
6304        }
6305    }
6306
6307    unsafe impl
6308        fidl::encoding::Encode<EchoEchoEventRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
6309        for &mut EchoEchoEventRequest
6310    {
6311        #[inline]
6312        unsafe fn encode(
6313            self,
6314            encoder: &mut fidl::encoding::Encoder<
6315                '_,
6316                fidl::encoding::DefaultFuchsiaResourceDialect,
6317            >,
6318            offset: usize,
6319            _depth: fidl::encoding::Depth,
6320        ) -> fidl::Result<()> {
6321            encoder.debug_check_bounds::<EchoEchoEventRequest>(offset);
6322            // Delegate to tuple encoding.
6323            fidl::encoding::Encode::<
6324                EchoEchoEventRequest,
6325                fidl::encoding::DefaultFuchsiaResourceDialect,
6326            >::encode(
6327                (<Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),),
6328                encoder,
6329                offset,
6330                _depth,
6331            )
6332        }
6333    }
6334    unsafe impl<T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>>
6335        fidl::encoding::Encode<EchoEchoEventRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
6336        for (T0,)
6337    {
6338        #[inline]
6339        unsafe fn encode(
6340            self,
6341            encoder: &mut fidl::encoding::Encoder<
6342                '_,
6343                fidl::encoding::DefaultFuchsiaResourceDialect,
6344            >,
6345            offset: usize,
6346            depth: fidl::encoding::Depth,
6347        ) -> fidl::Result<()> {
6348            encoder.debug_check_bounds::<EchoEchoEventRequest>(offset);
6349            // Zero out padding regions. There's no need to apply masks
6350            // because the unmasked parts will be overwritten by fields.
6351            // Write the fields.
6352            self.0.encode(encoder, offset + 0, depth)?;
6353            Ok(())
6354        }
6355    }
6356
6357    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6358        for EchoEchoEventRequest
6359    {
6360        #[inline(always)]
6361        fn new_empty() -> Self {
6362            Self { value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect) }
6363        }
6364
6365        #[inline]
6366        unsafe fn decode(
6367            &mut self,
6368            decoder: &mut fidl::encoding::Decoder<
6369                '_,
6370                fidl::encoding::DefaultFuchsiaResourceDialect,
6371            >,
6372            offset: usize,
6373            _depth: fidl::encoding::Depth,
6374        ) -> fidl::Result<()> {
6375            decoder.debug_check_bounds::<Self>(offset);
6376            // Verify that padding bytes are zero.
6377            fidl::decode!(
6378                Struct,
6379                fidl::encoding::DefaultFuchsiaResourceDialect,
6380                &mut self.value,
6381                decoder,
6382                offset + 0,
6383                _depth
6384            )?;
6385            Ok(())
6386        }
6387    }
6388
6389    impl fidl::encoding::ResourceTypeMarker for EchoEchoStructNoRetValRequest {
6390        type Borrowed<'a> = &'a mut Self;
6391        fn take_or_borrow<'a>(
6392            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6393        ) -> Self::Borrowed<'a> {
6394            value
6395        }
6396    }
6397
6398    unsafe impl fidl::encoding::TypeMarker for EchoEchoStructNoRetValRequest {
6399        type Owned = Self;
6400
6401        #[inline(always)]
6402        fn inline_align(_context: fidl::encoding::Context) -> usize {
6403            8
6404        }
6405
6406        #[inline(always)]
6407        fn inline_size(_context: fidl::encoding::Context) -> usize {
6408            2928
6409        }
6410    }
6411
6412    unsafe impl
6413        fidl::encoding::Encode<
6414            EchoEchoStructNoRetValRequest,
6415            fidl::encoding::DefaultFuchsiaResourceDialect,
6416        > for &mut EchoEchoStructNoRetValRequest
6417    {
6418        #[inline]
6419        unsafe fn encode(
6420            self,
6421            encoder: &mut fidl::encoding::Encoder<
6422                '_,
6423                fidl::encoding::DefaultFuchsiaResourceDialect,
6424            >,
6425            offset: usize,
6426            _depth: fidl::encoding::Depth,
6427        ) -> fidl::Result<()> {
6428            encoder.debug_check_bounds::<EchoEchoStructNoRetValRequest>(offset);
6429            // Delegate to tuple encoding.
6430            fidl::encoding::Encode::<
6431                EchoEchoStructNoRetValRequest,
6432                fidl::encoding::DefaultFuchsiaResourceDialect,
6433            >::encode(
6434                (
6435                    <Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
6436                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
6437                        &self.forward_to_server,
6438                    ),
6439                ),
6440                encoder,
6441                offset,
6442                _depth,
6443            )
6444        }
6445    }
6446    unsafe impl<
6447        T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>,
6448        T1: fidl::encoding::Encode<
6449                fidl::encoding::UnboundedString,
6450                fidl::encoding::DefaultFuchsiaResourceDialect,
6451            >,
6452    >
6453        fidl::encoding::Encode<
6454            EchoEchoStructNoRetValRequest,
6455            fidl::encoding::DefaultFuchsiaResourceDialect,
6456        > for (T0, T1)
6457    {
6458        #[inline]
6459        unsafe fn encode(
6460            self,
6461            encoder: &mut fidl::encoding::Encoder<
6462                '_,
6463                fidl::encoding::DefaultFuchsiaResourceDialect,
6464            >,
6465            offset: usize,
6466            depth: fidl::encoding::Depth,
6467        ) -> fidl::Result<()> {
6468            encoder.debug_check_bounds::<EchoEchoStructNoRetValRequest>(offset);
6469            // Zero out padding regions. There's no need to apply masks
6470            // because the unmasked parts will be overwritten by fields.
6471            // Write the fields.
6472            self.0.encode(encoder, offset + 0, depth)?;
6473            self.1.encode(encoder, offset + 2912, depth)?;
6474            Ok(())
6475        }
6476    }
6477
6478    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6479        for EchoEchoStructNoRetValRequest
6480    {
6481        #[inline(always)]
6482        fn new_empty() -> Self {
6483            Self {
6484                value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect),
6485                forward_to_server: fidl::new_empty!(
6486                    fidl::encoding::UnboundedString,
6487                    fidl::encoding::DefaultFuchsiaResourceDialect
6488                ),
6489            }
6490        }
6491
6492        #[inline]
6493        unsafe fn decode(
6494            &mut self,
6495            decoder: &mut fidl::encoding::Decoder<
6496                '_,
6497                fidl::encoding::DefaultFuchsiaResourceDialect,
6498            >,
6499            offset: usize,
6500            _depth: fidl::encoding::Depth,
6501        ) -> fidl::Result<()> {
6502            decoder.debug_check_bounds::<Self>(offset);
6503            // Verify that padding bytes are zero.
6504            fidl::decode!(
6505                Struct,
6506                fidl::encoding::DefaultFuchsiaResourceDialect,
6507                &mut self.value,
6508                decoder,
6509                offset + 0,
6510                _depth
6511            )?;
6512            fidl::decode!(
6513                fidl::encoding::UnboundedString,
6514                fidl::encoding::DefaultFuchsiaResourceDialect,
6515                &mut self.forward_to_server,
6516                decoder,
6517                offset + 2912,
6518                _depth
6519            )?;
6520            Ok(())
6521        }
6522    }
6523
6524    impl fidl::encoding::ResourceTypeMarker for EchoEchoStructRequest {
6525        type Borrowed<'a> = &'a mut Self;
6526        fn take_or_borrow<'a>(
6527            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6528        ) -> Self::Borrowed<'a> {
6529            value
6530        }
6531    }
6532
6533    unsafe impl fidl::encoding::TypeMarker for EchoEchoStructRequest {
6534        type Owned = Self;
6535
6536        #[inline(always)]
6537        fn inline_align(_context: fidl::encoding::Context) -> usize {
6538            8
6539        }
6540
6541        #[inline(always)]
6542        fn inline_size(_context: fidl::encoding::Context) -> usize {
6543            2928
6544        }
6545    }
6546
6547    unsafe impl
6548        fidl::encoding::Encode<EchoEchoStructRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
6549        for &mut EchoEchoStructRequest
6550    {
6551        #[inline]
6552        unsafe fn encode(
6553            self,
6554            encoder: &mut fidl::encoding::Encoder<
6555                '_,
6556                fidl::encoding::DefaultFuchsiaResourceDialect,
6557            >,
6558            offset: usize,
6559            _depth: fidl::encoding::Depth,
6560        ) -> fidl::Result<()> {
6561            encoder.debug_check_bounds::<EchoEchoStructRequest>(offset);
6562            // Delegate to tuple encoding.
6563            fidl::encoding::Encode::<
6564                EchoEchoStructRequest,
6565                fidl::encoding::DefaultFuchsiaResourceDialect,
6566            >::encode(
6567                (
6568                    <Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
6569                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
6570                        &self.forward_to_server,
6571                    ),
6572                ),
6573                encoder,
6574                offset,
6575                _depth,
6576            )
6577        }
6578    }
6579    unsafe impl<
6580        T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>,
6581        T1: fidl::encoding::Encode<
6582                fidl::encoding::UnboundedString,
6583                fidl::encoding::DefaultFuchsiaResourceDialect,
6584            >,
6585    >
6586        fidl::encoding::Encode<EchoEchoStructRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
6587        for (T0, T1)
6588    {
6589        #[inline]
6590        unsafe fn encode(
6591            self,
6592            encoder: &mut fidl::encoding::Encoder<
6593                '_,
6594                fidl::encoding::DefaultFuchsiaResourceDialect,
6595            >,
6596            offset: usize,
6597            depth: fidl::encoding::Depth,
6598        ) -> fidl::Result<()> {
6599            encoder.debug_check_bounds::<EchoEchoStructRequest>(offset);
6600            // Zero out padding regions. There's no need to apply masks
6601            // because the unmasked parts will be overwritten by fields.
6602            // Write the fields.
6603            self.0.encode(encoder, offset + 0, depth)?;
6604            self.1.encode(encoder, offset + 2912, depth)?;
6605            Ok(())
6606        }
6607    }
6608
6609    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6610        for EchoEchoStructRequest
6611    {
6612        #[inline(always)]
6613        fn new_empty() -> Self {
6614            Self {
6615                value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect),
6616                forward_to_server: fidl::new_empty!(
6617                    fidl::encoding::UnboundedString,
6618                    fidl::encoding::DefaultFuchsiaResourceDialect
6619                ),
6620            }
6621        }
6622
6623        #[inline]
6624        unsafe fn decode(
6625            &mut self,
6626            decoder: &mut fidl::encoding::Decoder<
6627                '_,
6628                fidl::encoding::DefaultFuchsiaResourceDialect,
6629            >,
6630            offset: usize,
6631            _depth: fidl::encoding::Depth,
6632        ) -> fidl::Result<()> {
6633            decoder.debug_check_bounds::<Self>(offset);
6634            // Verify that padding bytes are zero.
6635            fidl::decode!(
6636                Struct,
6637                fidl::encoding::DefaultFuchsiaResourceDialect,
6638                &mut self.value,
6639                decoder,
6640                offset + 0,
6641                _depth
6642            )?;
6643            fidl::decode!(
6644                fidl::encoding::UnboundedString,
6645                fidl::encoding::DefaultFuchsiaResourceDialect,
6646                &mut self.forward_to_server,
6647                decoder,
6648                offset + 2912,
6649                _depth
6650            )?;
6651            Ok(())
6652        }
6653    }
6654
6655    impl fidl::encoding::ResourceTypeMarker for EchoEchoStructResponse {
6656        type Borrowed<'a> = &'a mut Self;
6657        fn take_or_borrow<'a>(
6658            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6659        ) -> Self::Borrowed<'a> {
6660            value
6661        }
6662    }
6663
6664    unsafe impl fidl::encoding::TypeMarker for EchoEchoStructResponse {
6665        type Owned = Self;
6666
6667        #[inline(always)]
6668        fn inline_align(_context: fidl::encoding::Context) -> usize {
6669            8
6670        }
6671
6672        #[inline(always)]
6673        fn inline_size(_context: fidl::encoding::Context) -> usize {
6674            2912
6675        }
6676    }
6677
6678    unsafe impl
6679        fidl::encoding::Encode<
6680            EchoEchoStructResponse,
6681            fidl::encoding::DefaultFuchsiaResourceDialect,
6682        > for &mut EchoEchoStructResponse
6683    {
6684        #[inline]
6685        unsafe fn encode(
6686            self,
6687            encoder: &mut fidl::encoding::Encoder<
6688                '_,
6689                fidl::encoding::DefaultFuchsiaResourceDialect,
6690            >,
6691            offset: usize,
6692            _depth: fidl::encoding::Depth,
6693        ) -> fidl::Result<()> {
6694            encoder.debug_check_bounds::<EchoEchoStructResponse>(offset);
6695            // Delegate to tuple encoding.
6696            fidl::encoding::Encode::<
6697                EchoEchoStructResponse,
6698                fidl::encoding::DefaultFuchsiaResourceDialect,
6699            >::encode(
6700                (<Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),),
6701                encoder,
6702                offset,
6703                _depth,
6704            )
6705        }
6706    }
6707    unsafe impl<T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>>
6708        fidl::encoding::Encode<
6709            EchoEchoStructResponse,
6710            fidl::encoding::DefaultFuchsiaResourceDialect,
6711        > for (T0,)
6712    {
6713        #[inline]
6714        unsafe fn encode(
6715            self,
6716            encoder: &mut fidl::encoding::Encoder<
6717                '_,
6718                fidl::encoding::DefaultFuchsiaResourceDialect,
6719            >,
6720            offset: usize,
6721            depth: fidl::encoding::Depth,
6722        ) -> fidl::Result<()> {
6723            encoder.debug_check_bounds::<EchoEchoStructResponse>(offset);
6724            // Zero out padding regions. There's no need to apply masks
6725            // because the unmasked parts will be overwritten by fields.
6726            // Write the fields.
6727            self.0.encode(encoder, offset + 0, depth)?;
6728            Ok(())
6729        }
6730    }
6731
6732    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6733        for EchoEchoStructResponse
6734    {
6735        #[inline(always)]
6736        fn new_empty() -> Self {
6737            Self { value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect) }
6738        }
6739
6740        #[inline]
6741        unsafe fn decode(
6742            &mut self,
6743            decoder: &mut fidl::encoding::Decoder<
6744                '_,
6745                fidl::encoding::DefaultFuchsiaResourceDialect,
6746            >,
6747            offset: usize,
6748            _depth: fidl::encoding::Depth,
6749        ) -> fidl::Result<()> {
6750            decoder.debug_check_bounds::<Self>(offset);
6751            // Verify that padding bytes are zero.
6752            fidl::decode!(
6753                Struct,
6754                fidl::encoding::DefaultFuchsiaResourceDialect,
6755                &mut self.value,
6756                decoder,
6757                offset + 0,
6758                _depth
6759            )?;
6760            Ok(())
6761        }
6762    }
6763
6764    impl fidl::encoding::ResourceTypeMarker for EchoEchoStructWithErrorRequest {
6765        type Borrowed<'a> = &'a mut Self;
6766        fn take_or_borrow<'a>(
6767            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6768        ) -> Self::Borrowed<'a> {
6769            value
6770        }
6771    }
6772
6773    unsafe impl fidl::encoding::TypeMarker for EchoEchoStructWithErrorRequest {
6774        type Owned = Self;
6775
6776        #[inline(always)]
6777        fn inline_align(_context: fidl::encoding::Context) -> usize {
6778            8
6779        }
6780
6781        #[inline(always)]
6782        fn inline_size(_context: fidl::encoding::Context) -> usize {
6783            2944
6784        }
6785    }
6786
6787    unsafe impl
6788        fidl::encoding::Encode<
6789            EchoEchoStructWithErrorRequest,
6790            fidl::encoding::DefaultFuchsiaResourceDialect,
6791        > for &mut EchoEchoStructWithErrorRequest
6792    {
6793        #[inline]
6794        unsafe fn encode(
6795            self,
6796            encoder: &mut fidl::encoding::Encoder<
6797                '_,
6798                fidl::encoding::DefaultFuchsiaResourceDialect,
6799            >,
6800            offset: usize,
6801            _depth: fidl::encoding::Depth,
6802        ) -> fidl::Result<()> {
6803            encoder.debug_check_bounds::<EchoEchoStructWithErrorRequest>(offset);
6804            // Delegate to tuple encoding.
6805            fidl::encoding::Encode::<
6806                EchoEchoStructWithErrorRequest,
6807                fidl::encoding::DefaultFuchsiaResourceDialect,
6808            >::encode(
6809                (
6810                    <Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
6811                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
6812                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
6813                        &self.forward_to_server,
6814                    ),
6815                    <RespondWith as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
6816                ),
6817                encoder,
6818                offset,
6819                _depth,
6820            )
6821        }
6822    }
6823    unsafe impl<
6824        T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>,
6825        T1: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
6826        T2: fidl::encoding::Encode<
6827                fidl::encoding::UnboundedString,
6828                fidl::encoding::DefaultFuchsiaResourceDialect,
6829            >,
6830        T3: fidl::encoding::Encode<RespondWith, fidl::encoding::DefaultFuchsiaResourceDialect>,
6831    >
6832        fidl::encoding::Encode<
6833            EchoEchoStructWithErrorRequest,
6834            fidl::encoding::DefaultFuchsiaResourceDialect,
6835        > for (T0, T1, T2, T3)
6836    {
6837        #[inline]
6838        unsafe fn encode(
6839            self,
6840            encoder: &mut fidl::encoding::Encoder<
6841                '_,
6842                fidl::encoding::DefaultFuchsiaResourceDialect,
6843            >,
6844            offset: usize,
6845            depth: fidl::encoding::Depth,
6846        ) -> fidl::Result<()> {
6847            encoder.debug_check_bounds::<EchoEchoStructWithErrorRequest>(offset);
6848            // Zero out padding regions. There's no need to apply masks
6849            // because the unmasked parts will be overwritten by fields.
6850            unsafe {
6851                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2912);
6852                (ptr as *mut u64).write_unaligned(0);
6853            }
6854            unsafe {
6855                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2936);
6856                (ptr as *mut u64).write_unaligned(0);
6857            }
6858            // Write the fields.
6859            self.0.encode(encoder, offset + 0, depth)?;
6860            self.1.encode(encoder, offset + 2912, depth)?;
6861            self.2.encode(encoder, offset + 2920, depth)?;
6862            self.3.encode(encoder, offset + 2936, depth)?;
6863            Ok(())
6864        }
6865    }
6866
6867    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6868        for EchoEchoStructWithErrorRequest
6869    {
6870        #[inline(always)]
6871        fn new_empty() -> Self {
6872            Self {
6873                value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect),
6874                result_err: fidl::new_empty!(
6875                    DefaultEnum,
6876                    fidl::encoding::DefaultFuchsiaResourceDialect
6877                ),
6878                forward_to_server: fidl::new_empty!(
6879                    fidl::encoding::UnboundedString,
6880                    fidl::encoding::DefaultFuchsiaResourceDialect
6881                ),
6882                result_variant: fidl::new_empty!(
6883                    RespondWith,
6884                    fidl::encoding::DefaultFuchsiaResourceDialect
6885                ),
6886            }
6887        }
6888
6889        #[inline]
6890        unsafe fn decode(
6891            &mut self,
6892            decoder: &mut fidl::encoding::Decoder<
6893                '_,
6894                fidl::encoding::DefaultFuchsiaResourceDialect,
6895            >,
6896            offset: usize,
6897            _depth: fidl::encoding::Depth,
6898        ) -> fidl::Result<()> {
6899            decoder.debug_check_bounds::<Self>(offset);
6900            // Verify that padding bytes are zero.
6901            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2912) };
6902            let padval = unsafe { (ptr as *const u64).read_unaligned() };
6903            let mask = 0xffffffff00000000u64;
6904            let maskedval = padval & mask;
6905            if maskedval != 0 {
6906                return Err(fidl::Error::NonZeroPadding {
6907                    padding_start: offset + 2912 + ((mask as u64).trailing_zeros() / 8) as usize,
6908                });
6909            }
6910            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2936) };
6911            let padval = unsafe { (ptr as *const u64).read_unaligned() };
6912            let mask = 0xffffffff00000000u64;
6913            let maskedval = padval & mask;
6914            if maskedval != 0 {
6915                return Err(fidl::Error::NonZeroPadding {
6916                    padding_start: offset + 2936 + ((mask as u64).trailing_zeros() / 8) as usize,
6917                });
6918            }
6919            fidl::decode!(
6920                Struct,
6921                fidl::encoding::DefaultFuchsiaResourceDialect,
6922                &mut self.value,
6923                decoder,
6924                offset + 0,
6925                _depth
6926            )?;
6927            fidl::decode!(
6928                DefaultEnum,
6929                fidl::encoding::DefaultFuchsiaResourceDialect,
6930                &mut self.result_err,
6931                decoder,
6932                offset + 2912,
6933                _depth
6934            )?;
6935            fidl::decode!(
6936                fidl::encoding::UnboundedString,
6937                fidl::encoding::DefaultFuchsiaResourceDialect,
6938                &mut self.forward_to_server,
6939                decoder,
6940                offset + 2920,
6941                _depth
6942            )?;
6943            fidl::decode!(
6944                RespondWith,
6945                fidl::encoding::DefaultFuchsiaResourceDialect,
6946                &mut self.result_variant,
6947                decoder,
6948                offset + 2936,
6949                _depth
6950            )?;
6951            Ok(())
6952        }
6953    }
6954
6955    impl fidl::encoding::ResourceTypeMarker for EchoEchoTableRequest {
6956        type Borrowed<'a> = &'a mut Self;
6957        fn take_or_borrow<'a>(
6958            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6959        ) -> Self::Borrowed<'a> {
6960            value
6961        }
6962    }
6963
6964    unsafe impl fidl::encoding::TypeMarker for EchoEchoTableRequest {
6965        type Owned = Self;
6966
6967        #[inline(always)]
6968        fn inline_align(_context: fidl::encoding::Context) -> usize {
6969            8
6970        }
6971
6972        #[inline(always)]
6973        fn inline_size(_context: fidl::encoding::Context) -> usize {
6974            32
6975        }
6976    }
6977
6978    unsafe impl
6979        fidl::encoding::Encode<EchoEchoTableRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
6980        for &mut EchoEchoTableRequest
6981    {
6982        #[inline]
6983        unsafe fn encode(
6984            self,
6985            encoder: &mut fidl::encoding::Encoder<
6986                '_,
6987                fidl::encoding::DefaultFuchsiaResourceDialect,
6988            >,
6989            offset: usize,
6990            _depth: fidl::encoding::Depth,
6991        ) -> fidl::Result<()> {
6992            encoder.debug_check_bounds::<EchoEchoTableRequest>(offset);
6993            // Delegate to tuple encoding.
6994            fidl::encoding::Encode::<
6995                EchoEchoTableRequest,
6996                fidl::encoding::DefaultFuchsiaResourceDialect,
6997            >::encode(
6998                (
6999                    <AllTypesTable as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7000                        &mut self.value,
7001                    ),
7002                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
7003                        &self.forward_to_server,
7004                    ),
7005                ),
7006                encoder,
7007                offset,
7008                _depth,
7009            )
7010        }
7011    }
7012    unsafe impl<
7013        T0: fidl::encoding::Encode<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>,
7014        T1: fidl::encoding::Encode<
7015                fidl::encoding::UnboundedString,
7016                fidl::encoding::DefaultFuchsiaResourceDialect,
7017            >,
7018    >
7019        fidl::encoding::Encode<EchoEchoTableRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
7020        for (T0, T1)
7021    {
7022        #[inline]
7023        unsafe fn encode(
7024            self,
7025            encoder: &mut fidl::encoding::Encoder<
7026                '_,
7027                fidl::encoding::DefaultFuchsiaResourceDialect,
7028            >,
7029            offset: usize,
7030            depth: fidl::encoding::Depth,
7031        ) -> fidl::Result<()> {
7032            encoder.debug_check_bounds::<EchoEchoTableRequest>(offset);
7033            // Zero out padding regions. There's no need to apply masks
7034            // because the unmasked parts will be overwritten by fields.
7035            // Write the fields.
7036            self.0.encode(encoder, offset + 0, depth)?;
7037            self.1.encode(encoder, offset + 16, depth)?;
7038            Ok(())
7039        }
7040    }
7041
7042    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7043        for EchoEchoTableRequest
7044    {
7045        #[inline(always)]
7046        fn new_empty() -> Self {
7047            Self {
7048                value: fidl::new_empty!(
7049                    AllTypesTable,
7050                    fidl::encoding::DefaultFuchsiaResourceDialect
7051                ),
7052                forward_to_server: fidl::new_empty!(
7053                    fidl::encoding::UnboundedString,
7054                    fidl::encoding::DefaultFuchsiaResourceDialect
7055                ),
7056            }
7057        }
7058
7059        #[inline]
7060        unsafe fn decode(
7061            &mut self,
7062            decoder: &mut fidl::encoding::Decoder<
7063                '_,
7064                fidl::encoding::DefaultFuchsiaResourceDialect,
7065            >,
7066            offset: usize,
7067            _depth: fidl::encoding::Depth,
7068        ) -> fidl::Result<()> {
7069            decoder.debug_check_bounds::<Self>(offset);
7070            // Verify that padding bytes are zero.
7071            fidl::decode!(
7072                AllTypesTable,
7073                fidl::encoding::DefaultFuchsiaResourceDialect,
7074                &mut self.value,
7075                decoder,
7076                offset + 0,
7077                _depth
7078            )?;
7079            fidl::decode!(
7080                fidl::encoding::UnboundedString,
7081                fidl::encoding::DefaultFuchsiaResourceDialect,
7082                &mut self.forward_to_server,
7083                decoder,
7084                offset + 16,
7085                _depth
7086            )?;
7087            Ok(())
7088        }
7089    }
7090
7091    impl fidl::encoding::ResourceTypeMarker for EchoEchoTableResponse {
7092        type Borrowed<'a> = &'a mut Self;
7093        fn take_or_borrow<'a>(
7094            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7095        ) -> Self::Borrowed<'a> {
7096            value
7097        }
7098    }
7099
7100    unsafe impl fidl::encoding::TypeMarker for EchoEchoTableResponse {
7101        type Owned = Self;
7102
7103        #[inline(always)]
7104        fn inline_align(_context: fidl::encoding::Context) -> usize {
7105            8
7106        }
7107
7108        #[inline(always)]
7109        fn inline_size(_context: fidl::encoding::Context) -> usize {
7110            16
7111        }
7112    }
7113
7114    unsafe impl
7115        fidl::encoding::Encode<EchoEchoTableResponse, fidl::encoding::DefaultFuchsiaResourceDialect>
7116        for &mut EchoEchoTableResponse
7117    {
7118        #[inline]
7119        unsafe fn encode(
7120            self,
7121            encoder: &mut fidl::encoding::Encoder<
7122                '_,
7123                fidl::encoding::DefaultFuchsiaResourceDialect,
7124            >,
7125            offset: usize,
7126            _depth: fidl::encoding::Depth,
7127        ) -> fidl::Result<()> {
7128            encoder.debug_check_bounds::<EchoEchoTableResponse>(offset);
7129            // Delegate to tuple encoding.
7130            fidl::encoding::Encode::<
7131                EchoEchoTableResponse,
7132                fidl::encoding::DefaultFuchsiaResourceDialect,
7133            >::encode(
7134                (<AllTypesTable as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7135                    &mut self.value,
7136                ),),
7137                encoder,
7138                offset,
7139                _depth,
7140            )
7141        }
7142    }
7143    unsafe impl<
7144        T0: fidl::encoding::Encode<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>,
7145    >
7146        fidl::encoding::Encode<EchoEchoTableResponse, fidl::encoding::DefaultFuchsiaResourceDialect>
7147        for (T0,)
7148    {
7149        #[inline]
7150        unsafe fn encode(
7151            self,
7152            encoder: &mut fidl::encoding::Encoder<
7153                '_,
7154                fidl::encoding::DefaultFuchsiaResourceDialect,
7155            >,
7156            offset: usize,
7157            depth: fidl::encoding::Depth,
7158        ) -> fidl::Result<()> {
7159            encoder.debug_check_bounds::<EchoEchoTableResponse>(offset);
7160            // Zero out padding regions. There's no need to apply masks
7161            // because the unmasked parts will be overwritten by fields.
7162            // Write the fields.
7163            self.0.encode(encoder, offset + 0, depth)?;
7164            Ok(())
7165        }
7166    }
7167
7168    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7169        for EchoEchoTableResponse
7170    {
7171        #[inline(always)]
7172        fn new_empty() -> Self {
7173            Self {
7174                value: fidl::new_empty!(
7175                    AllTypesTable,
7176                    fidl::encoding::DefaultFuchsiaResourceDialect
7177                ),
7178            }
7179        }
7180
7181        #[inline]
7182        unsafe fn decode(
7183            &mut self,
7184            decoder: &mut fidl::encoding::Decoder<
7185                '_,
7186                fidl::encoding::DefaultFuchsiaResourceDialect,
7187            >,
7188            offset: usize,
7189            _depth: fidl::encoding::Depth,
7190        ) -> fidl::Result<()> {
7191            decoder.debug_check_bounds::<Self>(offset);
7192            // Verify that padding bytes are zero.
7193            fidl::decode!(
7194                AllTypesTable,
7195                fidl::encoding::DefaultFuchsiaResourceDialect,
7196                &mut self.value,
7197                decoder,
7198                offset + 0,
7199                _depth
7200            )?;
7201            Ok(())
7202        }
7203    }
7204
7205    impl fidl::encoding::ResourceTypeMarker for EchoEchoTableWithErrorRequest {
7206        type Borrowed<'a> = &'a mut Self;
7207        fn take_or_borrow<'a>(
7208            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7209        ) -> Self::Borrowed<'a> {
7210            value
7211        }
7212    }
7213
7214    unsafe impl fidl::encoding::TypeMarker for EchoEchoTableWithErrorRequest {
7215        type Owned = Self;
7216
7217        #[inline(always)]
7218        fn inline_align(_context: fidl::encoding::Context) -> usize {
7219            8
7220        }
7221
7222        #[inline(always)]
7223        fn inline_size(_context: fidl::encoding::Context) -> usize {
7224            48
7225        }
7226    }
7227
7228    unsafe impl
7229        fidl::encoding::Encode<
7230            EchoEchoTableWithErrorRequest,
7231            fidl::encoding::DefaultFuchsiaResourceDialect,
7232        > for &mut EchoEchoTableWithErrorRequest
7233    {
7234        #[inline]
7235        unsafe fn encode(
7236            self,
7237            encoder: &mut fidl::encoding::Encoder<
7238                '_,
7239                fidl::encoding::DefaultFuchsiaResourceDialect,
7240            >,
7241            offset: usize,
7242            _depth: fidl::encoding::Depth,
7243        ) -> fidl::Result<()> {
7244            encoder.debug_check_bounds::<EchoEchoTableWithErrorRequest>(offset);
7245            // Delegate to tuple encoding.
7246            fidl::encoding::Encode::<
7247                EchoEchoTableWithErrorRequest,
7248                fidl::encoding::DefaultFuchsiaResourceDialect,
7249            >::encode(
7250                (
7251                    <AllTypesTable as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7252                        &mut self.value,
7253                    ),
7254                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
7255                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
7256                        &self.forward_to_server,
7257                    ),
7258                    <RespondWith as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
7259                ),
7260                encoder,
7261                offset,
7262                _depth,
7263            )
7264        }
7265    }
7266    unsafe impl<
7267        T0: fidl::encoding::Encode<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>,
7268        T1: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
7269        T2: fidl::encoding::Encode<
7270                fidl::encoding::UnboundedString,
7271                fidl::encoding::DefaultFuchsiaResourceDialect,
7272            >,
7273        T3: fidl::encoding::Encode<RespondWith, fidl::encoding::DefaultFuchsiaResourceDialect>,
7274    >
7275        fidl::encoding::Encode<
7276            EchoEchoTableWithErrorRequest,
7277            fidl::encoding::DefaultFuchsiaResourceDialect,
7278        > for (T0, T1, T2, T3)
7279    {
7280        #[inline]
7281        unsafe fn encode(
7282            self,
7283            encoder: &mut fidl::encoding::Encoder<
7284                '_,
7285                fidl::encoding::DefaultFuchsiaResourceDialect,
7286            >,
7287            offset: usize,
7288            depth: fidl::encoding::Depth,
7289        ) -> fidl::Result<()> {
7290            encoder.debug_check_bounds::<EchoEchoTableWithErrorRequest>(offset);
7291            // Zero out padding regions. There's no need to apply masks
7292            // because the unmasked parts will be overwritten by fields.
7293            unsafe {
7294                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
7295                (ptr as *mut u64).write_unaligned(0);
7296            }
7297            unsafe {
7298                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
7299                (ptr as *mut u64).write_unaligned(0);
7300            }
7301            // Write the fields.
7302            self.0.encode(encoder, offset + 0, depth)?;
7303            self.1.encode(encoder, offset + 16, depth)?;
7304            self.2.encode(encoder, offset + 24, depth)?;
7305            self.3.encode(encoder, offset + 40, depth)?;
7306            Ok(())
7307        }
7308    }
7309
7310    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7311        for EchoEchoTableWithErrorRequest
7312    {
7313        #[inline(always)]
7314        fn new_empty() -> Self {
7315            Self {
7316                value: fidl::new_empty!(
7317                    AllTypesTable,
7318                    fidl::encoding::DefaultFuchsiaResourceDialect
7319                ),
7320                result_err: fidl::new_empty!(
7321                    DefaultEnum,
7322                    fidl::encoding::DefaultFuchsiaResourceDialect
7323                ),
7324                forward_to_server: fidl::new_empty!(
7325                    fidl::encoding::UnboundedString,
7326                    fidl::encoding::DefaultFuchsiaResourceDialect
7327                ),
7328                result_variant: fidl::new_empty!(
7329                    RespondWith,
7330                    fidl::encoding::DefaultFuchsiaResourceDialect
7331                ),
7332            }
7333        }
7334
7335        #[inline]
7336        unsafe fn decode(
7337            &mut self,
7338            decoder: &mut fidl::encoding::Decoder<
7339                '_,
7340                fidl::encoding::DefaultFuchsiaResourceDialect,
7341            >,
7342            offset: usize,
7343            _depth: fidl::encoding::Depth,
7344        ) -> fidl::Result<()> {
7345            decoder.debug_check_bounds::<Self>(offset);
7346            // Verify that padding bytes are zero.
7347            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
7348            let padval = unsafe { (ptr as *const u64).read_unaligned() };
7349            let mask = 0xffffffff00000000u64;
7350            let maskedval = padval & mask;
7351            if maskedval != 0 {
7352                return Err(fidl::Error::NonZeroPadding {
7353                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
7354                });
7355            }
7356            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
7357            let padval = unsafe { (ptr as *const u64).read_unaligned() };
7358            let mask = 0xffffffff00000000u64;
7359            let maskedval = padval & mask;
7360            if maskedval != 0 {
7361                return Err(fidl::Error::NonZeroPadding {
7362                    padding_start: offset + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
7363                });
7364            }
7365            fidl::decode!(
7366                AllTypesTable,
7367                fidl::encoding::DefaultFuchsiaResourceDialect,
7368                &mut self.value,
7369                decoder,
7370                offset + 0,
7371                _depth
7372            )?;
7373            fidl::decode!(
7374                DefaultEnum,
7375                fidl::encoding::DefaultFuchsiaResourceDialect,
7376                &mut self.result_err,
7377                decoder,
7378                offset + 16,
7379                _depth
7380            )?;
7381            fidl::decode!(
7382                fidl::encoding::UnboundedString,
7383                fidl::encoding::DefaultFuchsiaResourceDialect,
7384                &mut self.forward_to_server,
7385                decoder,
7386                offset + 24,
7387                _depth
7388            )?;
7389            fidl::decode!(
7390                RespondWith,
7391                fidl::encoding::DefaultFuchsiaResourceDialect,
7392                &mut self.result_variant,
7393                decoder,
7394                offset + 40,
7395                _depth
7396            )?;
7397            Ok(())
7398        }
7399    }
7400
7401    impl fidl::encoding::ResourceTypeMarker for EchoEchoVectorsRequest {
7402        type Borrowed<'a> = &'a mut Self;
7403        fn take_or_borrow<'a>(
7404            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7405        ) -> Self::Borrowed<'a> {
7406            value
7407        }
7408    }
7409
7410    unsafe impl fidl::encoding::TypeMarker for EchoEchoVectorsRequest {
7411        type Owned = Self;
7412
7413        #[inline(always)]
7414        fn inline_align(_context: fidl::encoding::Context) -> usize {
7415            8
7416        }
7417
7418        #[inline(always)]
7419        fn inline_size(_context: fidl::encoding::Context) -> usize {
7420            432
7421        }
7422    }
7423
7424    unsafe impl
7425        fidl::encoding::Encode<
7426            EchoEchoVectorsRequest,
7427            fidl::encoding::DefaultFuchsiaResourceDialect,
7428        > for &mut EchoEchoVectorsRequest
7429    {
7430        #[inline]
7431        unsafe fn encode(
7432            self,
7433            encoder: &mut fidl::encoding::Encoder<
7434                '_,
7435                fidl::encoding::DefaultFuchsiaResourceDialect,
7436            >,
7437            offset: usize,
7438            _depth: fidl::encoding::Depth,
7439        ) -> fidl::Result<()> {
7440            encoder.debug_check_bounds::<EchoEchoVectorsRequest>(offset);
7441            // Delegate to tuple encoding.
7442            fidl::encoding::Encode::<
7443                EchoEchoVectorsRequest,
7444                fidl::encoding::DefaultFuchsiaResourceDialect,
7445            >::encode(
7446                (
7447                    <VectorsStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7448                        &mut self.value,
7449                    ),
7450                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
7451                        &self.forward_to_server,
7452                    ),
7453                ),
7454                encoder,
7455                offset,
7456                _depth,
7457            )
7458        }
7459    }
7460    unsafe impl<
7461        T0: fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
7462        T1: fidl::encoding::Encode<
7463                fidl::encoding::UnboundedString,
7464                fidl::encoding::DefaultFuchsiaResourceDialect,
7465            >,
7466    >
7467        fidl::encoding::Encode<
7468            EchoEchoVectorsRequest,
7469            fidl::encoding::DefaultFuchsiaResourceDialect,
7470        > for (T0, T1)
7471    {
7472        #[inline]
7473        unsafe fn encode(
7474            self,
7475            encoder: &mut fidl::encoding::Encoder<
7476                '_,
7477                fidl::encoding::DefaultFuchsiaResourceDialect,
7478            >,
7479            offset: usize,
7480            depth: fidl::encoding::Depth,
7481        ) -> fidl::Result<()> {
7482            encoder.debug_check_bounds::<EchoEchoVectorsRequest>(offset);
7483            // Zero out padding regions. There's no need to apply masks
7484            // because the unmasked parts will be overwritten by fields.
7485            // Write the fields.
7486            self.0.encode(encoder, offset + 0, depth)?;
7487            self.1.encode(encoder, offset + 416, depth)?;
7488            Ok(())
7489        }
7490    }
7491
7492    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7493        for EchoEchoVectorsRequest
7494    {
7495        #[inline(always)]
7496        fn new_empty() -> Self {
7497            Self {
7498                value: fidl::new_empty!(
7499                    VectorsStruct,
7500                    fidl::encoding::DefaultFuchsiaResourceDialect
7501                ),
7502                forward_to_server: fidl::new_empty!(
7503                    fidl::encoding::UnboundedString,
7504                    fidl::encoding::DefaultFuchsiaResourceDialect
7505                ),
7506            }
7507        }
7508
7509        #[inline]
7510        unsafe fn decode(
7511            &mut self,
7512            decoder: &mut fidl::encoding::Decoder<
7513                '_,
7514                fidl::encoding::DefaultFuchsiaResourceDialect,
7515            >,
7516            offset: usize,
7517            _depth: fidl::encoding::Depth,
7518        ) -> fidl::Result<()> {
7519            decoder.debug_check_bounds::<Self>(offset);
7520            // Verify that padding bytes are zero.
7521            fidl::decode!(
7522                VectorsStruct,
7523                fidl::encoding::DefaultFuchsiaResourceDialect,
7524                &mut self.value,
7525                decoder,
7526                offset + 0,
7527                _depth
7528            )?;
7529            fidl::decode!(
7530                fidl::encoding::UnboundedString,
7531                fidl::encoding::DefaultFuchsiaResourceDialect,
7532                &mut self.forward_to_server,
7533                decoder,
7534                offset + 416,
7535                _depth
7536            )?;
7537            Ok(())
7538        }
7539    }
7540
7541    impl fidl::encoding::ResourceTypeMarker for EchoEchoVectorsResponse {
7542        type Borrowed<'a> = &'a mut Self;
7543        fn take_or_borrow<'a>(
7544            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7545        ) -> Self::Borrowed<'a> {
7546            value
7547        }
7548    }
7549
7550    unsafe impl fidl::encoding::TypeMarker for EchoEchoVectorsResponse {
7551        type Owned = Self;
7552
7553        #[inline(always)]
7554        fn inline_align(_context: fidl::encoding::Context) -> usize {
7555            8
7556        }
7557
7558        #[inline(always)]
7559        fn inline_size(_context: fidl::encoding::Context) -> usize {
7560            416
7561        }
7562    }
7563
7564    unsafe impl
7565        fidl::encoding::Encode<
7566            EchoEchoVectorsResponse,
7567            fidl::encoding::DefaultFuchsiaResourceDialect,
7568        > for &mut EchoEchoVectorsResponse
7569    {
7570        #[inline]
7571        unsafe fn encode(
7572            self,
7573            encoder: &mut fidl::encoding::Encoder<
7574                '_,
7575                fidl::encoding::DefaultFuchsiaResourceDialect,
7576            >,
7577            offset: usize,
7578            _depth: fidl::encoding::Depth,
7579        ) -> fidl::Result<()> {
7580            encoder.debug_check_bounds::<EchoEchoVectorsResponse>(offset);
7581            // Delegate to tuple encoding.
7582            fidl::encoding::Encode::<
7583                EchoEchoVectorsResponse,
7584                fidl::encoding::DefaultFuchsiaResourceDialect,
7585            >::encode(
7586                (<VectorsStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7587                    &mut self.value,
7588                ),),
7589                encoder,
7590                offset,
7591                _depth,
7592            )
7593        }
7594    }
7595    unsafe impl<
7596        T0: fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
7597    >
7598        fidl::encoding::Encode<
7599            EchoEchoVectorsResponse,
7600            fidl::encoding::DefaultFuchsiaResourceDialect,
7601        > for (T0,)
7602    {
7603        #[inline]
7604        unsafe fn encode(
7605            self,
7606            encoder: &mut fidl::encoding::Encoder<
7607                '_,
7608                fidl::encoding::DefaultFuchsiaResourceDialect,
7609            >,
7610            offset: usize,
7611            depth: fidl::encoding::Depth,
7612        ) -> fidl::Result<()> {
7613            encoder.debug_check_bounds::<EchoEchoVectorsResponse>(offset);
7614            // Zero out padding regions. There's no need to apply masks
7615            // because the unmasked parts will be overwritten by fields.
7616            // Write the fields.
7617            self.0.encode(encoder, offset + 0, depth)?;
7618            Ok(())
7619        }
7620    }
7621
7622    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7623        for EchoEchoVectorsResponse
7624    {
7625        #[inline(always)]
7626        fn new_empty() -> Self {
7627            Self {
7628                value: fidl::new_empty!(
7629                    VectorsStruct,
7630                    fidl::encoding::DefaultFuchsiaResourceDialect
7631                ),
7632            }
7633        }
7634
7635        #[inline]
7636        unsafe fn decode(
7637            &mut self,
7638            decoder: &mut fidl::encoding::Decoder<
7639                '_,
7640                fidl::encoding::DefaultFuchsiaResourceDialect,
7641            >,
7642            offset: usize,
7643            _depth: fidl::encoding::Depth,
7644        ) -> fidl::Result<()> {
7645            decoder.debug_check_bounds::<Self>(offset);
7646            // Verify that padding bytes are zero.
7647            fidl::decode!(
7648                VectorsStruct,
7649                fidl::encoding::DefaultFuchsiaResourceDialect,
7650                &mut self.value,
7651                decoder,
7652                offset + 0,
7653                _depth
7654            )?;
7655            Ok(())
7656        }
7657    }
7658
7659    impl fidl::encoding::ResourceTypeMarker for EchoEchoVectorsWithErrorRequest {
7660        type Borrowed<'a> = &'a mut Self;
7661        fn take_or_borrow<'a>(
7662            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7663        ) -> Self::Borrowed<'a> {
7664            value
7665        }
7666    }
7667
7668    unsafe impl fidl::encoding::TypeMarker for EchoEchoVectorsWithErrorRequest {
7669        type Owned = Self;
7670
7671        #[inline(always)]
7672        fn inline_align(_context: fidl::encoding::Context) -> usize {
7673            8
7674        }
7675
7676        #[inline(always)]
7677        fn inline_size(_context: fidl::encoding::Context) -> usize {
7678            448
7679        }
7680    }
7681
7682    unsafe impl
7683        fidl::encoding::Encode<
7684            EchoEchoVectorsWithErrorRequest,
7685            fidl::encoding::DefaultFuchsiaResourceDialect,
7686        > for &mut EchoEchoVectorsWithErrorRequest
7687    {
7688        #[inline]
7689        unsafe fn encode(
7690            self,
7691            encoder: &mut fidl::encoding::Encoder<
7692                '_,
7693                fidl::encoding::DefaultFuchsiaResourceDialect,
7694            >,
7695            offset: usize,
7696            _depth: fidl::encoding::Depth,
7697        ) -> fidl::Result<()> {
7698            encoder.debug_check_bounds::<EchoEchoVectorsWithErrorRequest>(offset);
7699            // Delegate to tuple encoding.
7700            fidl::encoding::Encode::<
7701                EchoEchoVectorsWithErrorRequest,
7702                fidl::encoding::DefaultFuchsiaResourceDialect,
7703            >::encode(
7704                (
7705                    <VectorsStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7706                        &mut self.value,
7707                    ),
7708                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
7709                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
7710                        &self.forward_to_server,
7711                    ),
7712                    <RespondWith as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
7713                ),
7714                encoder,
7715                offset,
7716                _depth,
7717            )
7718        }
7719    }
7720    unsafe impl<
7721        T0: fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
7722        T1: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
7723        T2: fidl::encoding::Encode<
7724                fidl::encoding::UnboundedString,
7725                fidl::encoding::DefaultFuchsiaResourceDialect,
7726            >,
7727        T3: fidl::encoding::Encode<RespondWith, fidl::encoding::DefaultFuchsiaResourceDialect>,
7728    >
7729        fidl::encoding::Encode<
7730            EchoEchoVectorsWithErrorRequest,
7731            fidl::encoding::DefaultFuchsiaResourceDialect,
7732        > for (T0, T1, T2, T3)
7733    {
7734        #[inline]
7735        unsafe fn encode(
7736            self,
7737            encoder: &mut fidl::encoding::Encoder<
7738                '_,
7739                fidl::encoding::DefaultFuchsiaResourceDialect,
7740            >,
7741            offset: usize,
7742            depth: fidl::encoding::Depth,
7743        ) -> fidl::Result<()> {
7744            encoder.debug_check_bounds::<EchoEchoVectorsWithErrorRequest>(offset);
7745            // Zero out padding regions. There's no need to apply masks
7746            // because the unmasked parts will be overwritten by fields.
7747            unsafe {
7748                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(416);
7749                (ptr as *mut u64).write_unaligned(0);
7750            }
7751            unsafe {
7752                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(440);
7753                (ptr as *mut u64).write_unaligned(0);
7754            }
7755            // Write the fields.
7756            self.0.encode(encoder, offset + 0, depth)?;
7757            self.1.encode(encoder, offset + 416, depth)?;
7758            self.2.encode(encoder, offset + 424, depth)?;
7759            self.3.encode(encoder, offset + 440, depth)?;
7760            Ok(())
7761        }
7762    }
7763
7764    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7765        for EchoEchoVectorsWithErrorRequest
7766    {
7767        #[inline(always)]
7768        fn new_empty() -> Self {
7769            Self {
7770                value: fidl::new_empty!(
7771                    VectorsStruct,
7772                    fidl::encoding::DefaultFuchsiaResourceDialect
7773                ),
7774                result_err: fidl::new_empty!(
7775                    DefaultEnum,
7776                    fidl::encoding::DefaultFuchsiaResourceDialect
7777                ),
7778                forward_to_server: fidl::new_empty!(
7779                    fidl::encoding::UnboundedString,
7780                    fidl::encoding::DefaultFuchsiaResourceDialect
7781                ),
7782                result_variant: fidl::new_empty!(
7783                    RespondWith,
7784                    fidl::encoding::DefaultFuchsiaResourceDialect
7785                ),
7786            }
7787        }
7788
7789        #[inline]
7790        unsafe fn decode(
7791            &mut self,
7792            decoder: &mut fidl::encoding::Decoder<
7793                '_,
7794                fidl::encoding::DefaultFuchsiaResourceDialect,
7795            >,
7796            offset: usize,
7797            _depth: fidl::encoding::Depth,
7798        ) -> fidl::Result<()> {
7799            decoder.debug_check_bounds::<Self>(offset);
7800            // Verify that padding bytes are zero.
7801            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(416) };
7802            let padval = unsafe { (ptr as *const u64).read_unaligned() };
7803            let mask = 0xffffffff00000000u64;
7804            let maskedval = padval & mask;
7805            if maskedval != 0 {
7806                return Err(fidl::Error::NonZeroPadding {
7807                    padding_start: offset + 416 + ((mask as u64).trailing_zeros() / 8) as usize,
7808                });
7809            }
7810            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(440) };
7811            let padval = unsafe { (ptr as *const u64).read_unaligned() };
7812            let mask = 0xffffffff00000000u64;
7813            let maskedval = padval & mask;
7814            if maskedval != 0 {
7815                return Err(fidl::Error::NonZeroPadding {
7816                    padding_start: offset + 440 + ((mask as u64).trailing_zeros() / 8) as usize,
7817                });
7818            }
7819            fidl::decode!(
7820                VectorsStruct,
7821                fidl::encoding::DefaultFuchsiaResourceDialect,
7822                &mut self.value,
7823                decoder,
7824                offset + 0,
7825                _depth
7826            )?;
7827            fidl::decode!(
7828                DefaultEnum,
7829                fidl::encoding::DefaultFuchsiaResourceDialect,
7830                &mut self.result_err,
7831                decoder,
7832                offset + 416,
7833                _depth
7834            )?;
7835            fidl::decode!(
7836                fidl::encoding::UnboundedString,
7837                fidl::encoding::DefaultFuchsiaResourceDialect,
7838                &mut self.forward_to_server,
7839                decoder,
7840                offset + 424,
7841                _depth
7842            )?;
7843            fidl::decode!(
7844                RespondWith,
7845                fidl::encoding::DefaultFuchsiaResourceDialect,
7846                &mut self.result_variant,
7847                decoder,
7848                offset + 440,
7849                _depth
7850            )?;
7851            Ok(())
7852        }
7853    }
7854
7855    impl fidl::encoding::ResourceTypeMarker for EchoEchoXunionsRequest {
7856        type Borrowed<'a> = &'a mut Self;
7857        fn take_or_borrow<'a>(
7858            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7859        ) -> Self::Borrowed<'a> {
7860            value
7861        }
7862    }
7863
7864    unsafe impl fidl::encoding::TypeMarker for EchoEchoXunionsRequest {
7865        type Owned = Self;
7866
7867        #[inline(always)]
7868        fn inline_align(_context: fidl::encoding::Context) -> usize {
7869            8
7870        }
7871
7872        #[inline(always)]
7873        fn inline_size(_context: fidl::encoding::Context) -> usize {
7874            32
7875        }
7876    }
7877
7878    unsafe impl
7879        fidl::encoding::Encode<
7880            EchoEchoXunionsRequest,
7881            fidl::encoding::DefaultFuchsiaResourceDialect,
7882        > for &mut EchoEchoXunionsRequest
7883    {
7884        #[inline]
7885        unsafe fn encode(
7886            self,
7887            encoder: &mut fidl::encoding::Encoder<
7888                '_,
7889                fidl::encoding::DefaultFuchsiaResourceDialect,
7890            >,
7891            offset: usize,
7892            _depth: fidl::encoding::Depth,
7893        ) -> fidl::Result<()> {
7894            encoder.debug_check_bounds::<EchoEchoXunionsRequest>(offset);
7895            // Delegate to tuple encoding.
7896            fidl::encoding::Encode::<EchoEchoXunionsRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
7897                (
7898                    <fidl::encoding::UnboundedVector<AllTypesXunion> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
7899                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(&self.forward_to_server),
7900                ),
7901                encoder, offset, _depth
7902            )
7903        }
7904    }
7905    unsafe impl<
7906        T0: fidl::encoding::Encode<
7907                fidl::encoding::UnboundedVector<AllTypesXunion>,
7908                fidl::encoding::DefaultFuchsiaResourceDialect,
7909            >,
7910        T1: fidl::encoding::Encode<
7911                fidl::encoding::UnboundedString,
7912                fidl::encoding::DefaultFuchsiaResourceDialect,
7913            >,
7914    >
7915        fidl::encoding::Encode<
7916            EchoEchoXunionsRequest,
7917            fidl::encoding::DefaultFuchsiaResourceDialect,
7918        > for (T0, T1)
7919    {
7920        #[inline]
7921        unsafe fn encode(
7922            self,
7923            encoder: &mut fidl::encoding::Encoder<
7924                '_,
7925                fidl::encoding::DefaultFuchsiaResourceDialect,
7926            >,
7927            offset: usize,
7928            depth: fidl::encoding::Depth,
7929        ) -> fidl::Result<()> {
7930            encoder.debug_check_bounds::<EchoEchoXunionsRequest>(offset);
7931            // Zero out padding regions. There's no need to apply masks
7932            // because the unmasked parts will be overwritten by fields.
7933            // Write the fields.
7934            self.0.encode(encoder, offset + 0, depth)?;
7935            self.1.encode(encoder, offset + 16, depth)?;
7936            Ok(())
7937        }
7938    }
7939
7940    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7941        for EchoEchoXunionsRequest
7942    {
7943        #[inline(always)]
7944        fn new_empty() -> Self {
7945            Self {
7946                value: fidl::new_empty!(
7947                    fidl::encoding::UnboundedVector<AllTypesXunion>,
7948                    fidl::encoding::DefaultFuchsiaResourceDialect
7949                ),
7950                forward_to_server: fidl::new_empty!(
7951                    fidl::encoding::UnboundedString,
7952                    fidl::encoding::DefaultFuchsiaResourceDialect
7953                ),
7954            }
7955        }
7956
7957        #[inline]
7958        unsafe fn decode(
7959            &mut self,
7960            decoder: &mut fidl::encoding::Decoder<
7961                '_,
7962                fidl::encoding::DefaultFuchsiaResourceDialect,
7963            >,
7964            offset: usize,
7965            _depth: fidl::encoding::Depth,
7966        ) -> fidl::Result<()> {
7967            decoder.debug_check_bounds::<Self>(offset);
7968            // Verify that padding bytes are zero.
7969            fidl::decode!(
7970                fidl::encoding::UnboundedVector<AllTypesXunion>,
7971                fidl::encoding::DefaultFuchsiaResourceDialect,
7972                &mut self.value,
7973                decoder,
7974                offset + 0,
7975                _depth
7976            )?;
7977            fidl::decode!(
7978                fidl::encoding::UnboundedString,
7979                fidl::encoding::DefaultFuchsiaResourceDialect,
7980                &mut self.forward_to_server,
7981                decoder,
7982                offset + 16,
7983                _depth
7984            )?;
7985            Ok(())
7986        }
7987    }
7988
7989    impl fidl::encoding::ResourceTypeMarker for EchoEchoXunionsResponse {
7990        type Borrowed<'a> = &'a mut Self;
7991        fn take_or_borrow<'a>(
7992            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7993        ) -> Self::Borrowed<'a> {
7994            value
7995        }
7996    }
7997
7998    unsafe impl fidl::encoding::TypeMarker for EchoEchoXunionsResponse {
7999        type Owned = Self;
8000
8001        #[inline(always)]
8002        fn inline_align(_context: fidl::encoding::Context) -> usize {
8003            8
8004        }
8005
8006        #[inline(always)]
8007        fn inline_size(_context: fidl::encoding::Context) -> usize {
8008            16
8009        }
8010    }
8011
8012    unsafe impl
8013        fidl::encoding::Encode<
8014            EchoEchoXunionsResponse,
8015            fidl::encoding::DefaultFuchsiaResourceDialect,
8016        > for &mut EchoEchoXunionsResponse
8017    {
8018        #[inline]
8019        unsafe fn encode(
8020            self,
8021            encoder: &mut fidl::encoding::Encoder<
8022                '_,
8023                fidl::encoding::DefaultFuchsiaResourceDialect,
8024            >,
8025            offset: usize,
8026            _depth: fidl::encoding::Depth,
8027        ) -> fidl::Result<()> {
8028            encoder.debug_check_bounds::<EchoEchoXunionsResponse>(offset);
8029            // Delegate to tuple encoding.
8030            fidl::encoding::Encode::<EchoEchoXunionsResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
8031                (
8032                    <fidl::encoding::UnboundedVector<AllTypesXunion> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
8033                ),
8034                encoder, offset, _depth
8035            )
8036        }
8037    }
8038    unsafe impl<
8039        T0: fidl::encoding::Encode<
8040                fidl::encoding::UnboundedVector<AllTypesXunion>,
8041                fidl::encoding::DefaultFuchsiaResourceDialect,
8042            >,
8043    >
8044        fidl::encoding::Encode<
8045            EchoEchoXunionsResponse,
8046            fidl::encoding::DefaultFuchsiaResourceDialect,
8047        > for (T0,)
8048    {
8049        #[inline]
8050        unsafe fn encode(
8051            self,
8052            encoder: &mut fidl::encoding::Encoder<
8053                '_,
8054                fidl::encoding::DefaultFuchsiaResourceDialect,
8055            >,
8056            offset: usize,
8057            depth: fidl::encoding::Depth,
8058        ) -> fidl::Result<()> {
8059            encoder.debug_check_bounds::<EchoEchoXunionsResponse>(offset);
8060            // Zero out padding regions. There's no need to apply masks
8061            // because the unmasked parts will be overwritten by fields.
8062            // Write the fields.
8063            self.0.encode(encoder, offset + 0, depth)?;
8064            Ok(())
8065        }
8066    }
8067
8068    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8069        for EchoEchoXunionsResponse
8070    {
8071        #[inline(always)]
8072        fn new_empty() -> Self {
8073            Self {
8074                value: fidl::new_empty!(
8075                    fidl::encoding::UnboundedVector<AllTypesXunion>,
8076                    fidl::encoding::DefaultFuchsiaResourceDialect
8077                ),
8078            }
8079        }
8080
8081        #[inline]
8082        unsafe fn decode(
8083            &mut self,
8084            decoder: &mut fidl::encoding::Decoder<
8085                '_,
8086                fidl::encoding::DefaultFuchsiaResourceDialect,
8087            >,
8088            offset: usize,
8089            _depth: fidl::encoding::Depth,
8090        ) -> fidl::Result<()> {
8091            decoder.debug_check_bounds::<Self>(offset);
8092            // Verify that padding bytes are zero.
8093            fidl::decode!(
8094                fidl::encoding::UnboundedVector<AllTypesXunion>,
8095                fidl::encoding::DefaultFuchsiaResourceDialect,
8096                &mut self.value,
8097                decoder,
8098                offset + 0,
8099                _depth
8100            )?;
8101            Ok(())
8102        }
8103    }
8104
8105    impl fidl::encoding::ResourceTypeMarker for EchoEchoXunionsWithErrorRequest {
8106        type Borrowed<'a> = &'a mut Self;
8107        fn take_or_borrow<'a>(
8108            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8109        ) -> Self::Borrowed<'a> {
8110            value
8111        }
8112    }
8113
8114    unsafe impl fidl::encoding::TypeMarker for EchoEchoXunionsWithErrorRequest {
8115        type Owned = Self;
8116
8117        #[inline(always)]
8118        fn inline_align(_context: fidl::encoding::Context) -> usize {
8119            8
8120        }
8121
8122        #[inline(always)]
8123        fn inline_size(_context: fidl::encoding::Context) -> usize {
8124            48
8125        }
8126    }
8127
8128    unsafe impl
8129        fidl::encoding::Encode<
8130            EchoEchoXunionsWithErrorRequest,
8131            fidl::encoding::DefaultFuchsiaResourceDialect,
8132        > for &mut EchoEchoXunionsWithErrorRequest
8133    {
8134        #[inline]
8135        unsafe fn encode(
8136            self,
8137            encoder: &mut fidl::encoding::Encoder<
8138                '_,
8139                fidl::encoding::DefaultFuchsiaResourceDialect,
8140            >,
8141            offset: usize,
8142            _depth: fidl::encoding::Depth,
8143        ) -> fidl::Result<()> {
8144            encoder.debug_check_bounds::<EchoEchoXunionsWithErrorRequest>(offset);
8145            // Delegate to tuple encoding.
8146            fidl::encoding::Encode::<EchoEchoXunionsWithErrorRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
8147                (
8148                    <fidl::encoding::UnboundedVector<AllTypesXunion> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
8149                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
8150                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(&self.forward_to_server),
8151                    <RespondWith as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
8152                ),
8153                encoder, offset, _depth
8154            )
8155        }
8156    }
8157    unsafe impl<
8158        T0: fidl::encoding::Encode<
8159                fidl::encoding::UnboundedVector<AllTypesXunion>,
8160                fidl::encoding::DefaultFuchsiaResourceDialect,
8161            >,
8162        T1: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8163        T2: fidl::encoding::Encode<
8164                fidl::encoding::UnboundedString,
8165                fidl::encoding::DefaultFuchsiaResourceDialect,
8166            >,
8167        T3: fidl::encoding::Encode<RespondWith, fidl::encoding::DefaultFuchsiaResourceDialect>,
8168    >
8169        fidl::encoding::Encode<
8170            EchoEchoXunionsWithErrorRequest,
8171            fidl::encoding::DefaultFuchsiaResourceDialect,
8172        > for (T0, T1, T2, T3)
8173    {
8174        #[inline]
8175        unsafe fn encode(
8176            self,
8177            encoder: &mut fidl::encoding::Encoder<
8178                '_,
8179                fidl::encoding::DefaultFuchsiaResourceDialect,
8180            >,
8181            offset: usize,
8182            depth: fidl::encoding::Depth,
8183        ) -> fidl::Result<()> {
8184            encoder.debug_check_bounds::<EchoEchoXunionsWithErrorRequest>(offset);
8185            // Zero out padding regions. There's no need to apply masks
8186            // because the unmasked parts will be overwritten by fields.
8187            unsafe {
8188                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
8189                (ptr as *mut u64).write_unaligned(0);
8190            }
8191            unsafe {
8192                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
8193                (ptr as *mut u64).write_unaligned(0);
8194            }
8195            // Write the fields.
8196            self.0.encode(encoder, offset + 0, depth)?;
8197            self.1.encode(encoder, offset + 16, depth)?;
8198            self.2.encode(encoder, offset + 24, depth)?;
8199            self.3.encode(encoder, offset + 40, depth)?;
8200            Ok(())
8201        }
8202    }
8203
8204    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8205        for EchoEchoXunionsWithErrorRequest
8206    {
8207        #[inline(always)]
8208        fn new_empty() -> Self {
8209            Self {
8210                value: fidl::new_empty!(
8211                    fidl::encoding::UnboundedVector<AllTypesXunion>,
8212                    fidl::encoding::DefaultFuchsiaResourceDialect
8213                ),
8214                result_err: fidl::new_empty!(
8215                    DefaultEnum,
8216                    fidl::encoding::DefaultFuchsiaResourceDialect
8217                ),
8218                forward_to_server: fidl::new_empty!(
8219                    fidl::encoding::UnboundedString,
8220                    fidl::encoding::DefaultFuchsiaResourceDialect
8221                ),
8222                result_variant: fidl::new_empty!(
8223                    RespondWith,
8224                    fidl::encoding::DefaultFuchsiaResourceDialect
8225                ),
8226            }
8227        }
8228
8229        #[inline]
8230        unsafe fn decode(
8231            &mut self,
8232            decoder: &mut fidl::encoding::Decoder<
8233                '_,
8234                fidl::encoding::DefaultFuchsiaResourceDialect,
8235            >,
8236            offset: usize,
8237            _depth: fidl::encoding::Depth,
8238        ) -> fidl::Result<()> {
8239            decoder.debug_check_bounds::<Self>(offset);
8240            // Verify that padding bytes are zero.
8241            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
8242            let padval = unsafe { (ptr as *const u64).read_unaligned() };
8243            let mask = 0xffffffff00000000u64;
8244            let maskedval = padval & mask;
8245            if maskedval != 0 {
8246                return Err(fidl::Error::NonZeroPadding {
8247                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
8248                });
8249            }
8250            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
8251            let padval = unsafe { (ptr as *const u64).read_unaligned() };
8252            let mask = 0xffffffff00000000u64;
8253            let maskedval = padval & mask;
8254            if maskedval != 0 {
8255                return Err(fidl::Error::NonZeroPadding {
8256                    padding_start: offset + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
8257                });
8258            }
8259            fidl::decode!(
8260                fidl::encoding::UnboundedVector<AllTypesXunion>,
8261                fidl::encoding::DefaultFuchsiaResourceDialect,
8262                &mut self.value,
8263                decoder,
8264                offset + 0,
8265                _depth
8266            )?;
8267            fidl::decode!(
8268                DefaultEnum,
8269                fidl::encoding::DefaultFuchsiaResourceDialect,
8270                &mut self.result_err,
8271                decoder,
8272                offset + 16,
8273                _depth
8274            )?;
8275            fidl::decode!(
8276                fidl::encoding::UnboundedString,
8277                fidl::encoding::DefaultFuchsiaResourceDialect,
8278                &mut self.forward_to_server,
8279                decoder,
8280                offset + 24,
8281                _depth
8282            )?;
8283            fidl::decode!(
8284                RespondWith,
8285                fidl::encoding::DefaultFuchsiaResourceDialect,
8286                &mut self.result_variant,
8287                decoder,
8288                offset + 40,
8289                _depth
8290            )?;
8291            Ok(())
8292        }
8293    }
8294
8295    impl fidl::encoding::ResourceTypeMarker for EchoEchoArraysWithErrorResponse {
8296        type Borrowed<'a> = &'a mut Self;
8297        fn take_or_borrow<'a>(
8298            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8299        ) -> Self::Borrowed<'a> {
8300            value
8301        }
8302    }
8303
8304    unsafe impl fidl::encoding::TypeMarker for EchoEchoArraysWithErrorResponse {
8305        type Owned = Self;
8306
8307        #[inline(always)]
8308        fn inline_align(_context: fidl::encoding::Context) -> usize {
8309            8
8310        }
8311
8312        #[inline(always)]
8313        fn inline_size(_context: fidl::encoding::Context) -> usize {
8314            680
8315        }
8316    }
8317
8318    unsafe impl
8319        fidl::encoding::Encode<
8320            EchoEchoArraysWithErrorResponse,
8321            fidl::encoding::DefaultFuchsiaResourceDialect,
8322        > for &mut EchoEchoArraysWithErrorResponse
8323    {
8324        #[inline]
8325        unsafe fn encode(
8326            self,
8327            encoder: &mut fidl::encoding::Encoder<
8328                '_,
8329                fidl::encoding::DefaultFuchsiaResourceDialect,
8330            >,
8331            offset: usize,
8332            _depth: fidl::encoding::Depth,
8333        ) -> fidl::Result<()> {
8334            encoder.debug_check_bounds::<EchoEchoArraysWithErrorResponse>(offset);
8335            // Delegate to tuple encoding.
8336            fidl::encoding::Encode::<
8337                EchoEchoArraysWithErrorResponse,
8338                fidl::encoding::DefaultFuchsiaResourceDialect,
8339            >::encode(
8340                (<ArraysStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8341                    &mut self.value,
8342                ),),
8343                encoder,
8344                offset,
8345                _depth,
8346            )
8347        }
8348    }
8349    unsafe impl<
8350        T0: fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
8351    >
8352        fidl::encoding::Encode<
8353            EchoEchoArraysWithErrorResponse,
8354            fidl::encoding::DefaultFuchsiaResourceDialect,
8355        > for (T0,)
8356    {
8357        #[inline]
8358        unsafe fn encode(
8359            self,
8360            encoder: &mut fidl::encoding::Encoder<
8361                '_,
8362                fidl::encoding::DefaultFuchsiaResourceDialect,
8363            >,
8364            offset: usize,
8365            depth: fidl::encoding::Depth,
8366        ) -> fidl::Result<()> {
8367            encoder.debug_check_bounds::<EchoEchoArraysWithErrorResponse>(offset);
8368            // Zero out padding regions. There's no need to apply masks
8369            // because the unmasked parts will be overwritten by fields.
8370            // Write the fields.
8371            self.0.encode(encoder, offset + 0, depth)?;
8372            Ok(())
8373        }
8374    }
8375
8376    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8377        for EchoEchoArraysWithErrorResponse
8378    {
8379        #[inline(always)]
8380        fn new_empty() -> Self {
8381            Self {
8382                value: fidl::new_empty!(
8383                    ArraysStruct,
8384                    fidl::encoding::DefaultFuchsiaResourceDialect
8385                ),
8386            }
8387        }
8388
8389        #[inline]
8390        unsafe fn decode(
8391            &mut self,
8392            decoder: &mut fidl::encoding::Decoder<
8393                '_,
8394                fidl::encoding::DefaultFuchsiaResourceDialect,
8395            >,
8396            offset: usize,
8397            _depth: fidl::encoding::Depth,
8398        ) -> fidl::Result<()> {
8399            decoder.debug_check_bounds::<Self>(offset);
8400            // Verify that padding bytes are zero.
8401            fidl::decode!(
8402                ArraysStruct,
8403                fidl::encoding::DefaultFuchsiaResourceDialect,
8404                &mut self.value,
8405                decoder,
8406                offset + 0,
8407                _depth
8408            )?;
8409            Ok(())
8410        }
8411    }
8412
8413    impl fidl::encoding::ResourceTypeMarker for EchoEchoStructWithErrorResponse {
8414        type Borrowed<'a> = &'a mut Self;
8415        fn take_or_borrow<'a>(
8416            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8417        ) -> Self::Borrowed<'a> {
8418            value
8419        }
8420    }
8421
8422    unsafe impl fidl::encoding::TypeMarker for EchoEchoStructWithErrorResponse {
8423        type Owned = Self;
8424
8425        #[inline(always)]
8426        fn inline_align(_context: fidl::encoding::Context) -> usize {
8427            8
8428        }
8429
8430        #[inline(always)]
8431        fn inline_size(_context: fidl::encoding::Context) -> usize {
8432            2912
8433        }
8434    }
8435
8436    unsafe impl
8437        fidl::encoding::Encode<
8438            EchoEchoStructWithErrorResponse,
8439            fidl::encoding::DefaultFuchsiaResourceDialect,
8440        > for &mut EchoEchoStructWithErrorResponse
8441    {
8442        #[inline]
8443        unsafe fn encode(
8444            self,
8445            encoder: &mut fidl::encoding::Encoder<
8446                '_,
8447                fidl::encoding::DefaultFuchsiaResourceDialect,
8448            >,
8449            offset: usize,
8450            _depth: fidl::encoding::Depth,
8451        ) -> fidl::Result<()> {
8452            encoder.debug_check_bounds::<EchoEchoStructWithErrorResponse>(offset);
8453            // Delegate to tuple encoding.
8454            fidl::encoding::Encode::<
8455                EchoEchoStructWithErrorResponse,
8456                fidl::encoding::DefaultFuchsiaResourceDialect,
8457            >::encode(
8458                (<Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),),
8459                encoder,
8460                offset,
8461                _depth,
8462            )
8463        }
8464    }
8465    unsafe impl<T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>>
8466        fidl::encoding::Encode<
8467            EchoEchoStructWithErrorResponse,
8468            fidl::encoding::DefaultFuchsiaResourceDialect,
8469        > for (T0,)
8470    {
8471        #[inline]
8472        unsafe fn encode(
8473            self,
8474            encoder: &mut fidl::encoding::Encoder<
8475                '_,
8476                fidl::encoding::DefaultFuchsiaResourceDialect,
8477            >,
8478            offset: usize,
8479            depth: fidl::encoding::Depth,
8480        ) -> fidl::Result<()> {
8481            encoder.debug_check_bounds::<EchoEchoStructWithErrorResponse>(offset);
8482            // Zero out padding regions. There's no need to apply masks
8483            // because the unmasked parts will be overwritten by fields.
8484            // Write the fields.
8485            self.0.encode(encoder, offset + 0, depth)?;
8486            Ok(())
8487        }
8488    }
8489
8490    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8491        for EchoEchoStructWithErrorResponse
8492    {
8493        #[inline(always)]
8494        fn new_empty() -> Self {
8495            Self { value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect) }
8496        }
8497
8498        #[inline]
8499        unsafe fn decode(
8500            &mut self,
8501            decoder: &mut fidl::encoding::Decoder<
8502                '_,
8503                fidl::encoding::DefaultFuchsiaResourceDialect,
8504            >,
8505            offset: usize,
8506            _depth: fidl::encoding::Depth,
8507        ) -> fidl::Result<()> {
8508            decoder.debug_check_bounds::<Self>(offset);
8509            // Verify that padding bytes are zero.
8510            fidl::decode!(
8511                Struct,
8512                fidl::encoding::DefaultFuchsiaResourceDialect,
8513                &mut self.value,
8514                decoder,
8515                offset + 0,
8516                _depth
8517            )?;
8518            Ok(())
8519        }
8520    }
8521
8522    impl fidl::encoding::ResourceTypeMarker for EchoEchoTableWithErrorResponse {
8523        type Borrowed<'a> = &'a mut Self;
8524        fn take_or_borrow<'a>(
8525            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8526        ) -> Self::Borrowed<'a> {
8527            value
8528        }
8529    }
8530
8531    unsafe impl fidl::encoding::TypeMarker for EchoEchoTableWithErrorResponse {
8532        type Owned = Self;
8533
8534        #[inline(always)]
8535        fn inline_align(_context: fidl::encoding::Context) -> usize {
8536            8
8537        }
8538
8539        #[inline(always)]
8540        fn inline_size(_context: fidl::encoding::Context) -> usize {
8541            16
8542        }
8543    }
8544
8545    unsafe impl
8546        fidl::encoding::Encode<
8547            EchoEchoTableWithErrorResponse,
8548            fidl::encoding::DefaultFuchsiaResourceDialect,
8549        > for &mut EchoEchoTableWithErrorResponse
8550    {
8551        #[inline]
8552        unsafe fn encode(
8553            self,
8554            encoder: &mut fidl::encoding::Encoder<
8555                '_,
8556                fidl::encoding::DefaultFuchsiaResourceDialect,
8557            >,
8558            offset: usize,
8559            _depth: fidl::encoding::Depth,
8560        ) -> fidl::Result<()> {
8561            encoder.debug_check_bounds::<EchoEchoTableWithErrorResponse>(offset);
8562            // Delegate to tuple encoding.
8563            fidl::encoding::Encode::<
8564                EchoEchoTableWithErrorResponse,
8565                fidl::encoding::DefaultFuchsiaResourceDialect,
8566            >::encode(
8567                (<AllTypesTable as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8568                    &mut self.value,
8569                ),),
8570                encoder,
8571                offset,
8572                _depth,
8573            )
8574        }
8575    }
8576    unsafe impl<
8577        T0: fidl::encoding::Encode<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>,
8578    >
8579        fidl::encoding::Encode<
8580            EchoEchoTableWithErrorResponse,
8581            fidl::encoding::DefaultFuchsiaResourceDialect,
8582        > for (T0,)
8583    {
8584        #[inline]
8585        unsafe fn encode(
8586            self,
8587            encoder: &mut fidl::encoding::Encoder<
8588                '_,
8589                fidl::encoding::DefaultFuchsiaResourceDialect,
8590            >,
8591            offset: usize,
8592            depth: fidl::encoding::Depth,
8593        ) -> fidl::Result<()> {
8594            encoder.debug_check_bounds::<EchoEchoTableWithErrorResponse>(offset);
8595            // Zero out padding regions. There's no need to apply masks
8596            // because the unmasked parts will be overwritten by fields.
8597            // Write the fields.
8598            self.0.encode(encoder, offset + 0, depth)?;
8599            Ok(())
8600        }
8601    }
8602
8603    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8604        for EchoEchoTableWithErrorResponse
8605    {
8606        #[inline(always)]
8607        fn new_empty() -> Self {
8608            Self {
8609                value: fidl::new_empty!(
8610                    AllTypesTable,
8611                    fidl::encoding::DefaultFuchsiaResourceDialect
8612                ),
8613            }
8614        }
8615
8616        #[inline]
8617        unsafe fn decode(
8618            &mut self,
8619            decoder: &mut fidl::encoding::Decoder<
8620                '_,
8621                fidl::encoding::DefaultFuchsiaResourceDialect,
8622            >,
8623            offset: usize,
8624            _depth: fidl::encoding::Depth,
8625        ) -> fidl::Result<()> {
8626            decoder.debug_check_bounds::<Self>(offset);
8627            // Verify that padding bytes are zero.
8628            fidl::decode!(
8629                AllTypesTable,
8630                fidl::encoding::DefaultFuchsiaResourceDialect,
8631                &mut self.value,
8632                decoder,
8633                offset + 0,
8634                _depth
8635            )?;
8636            Ok(())
8637        }
8638    }
8639
8640    impl fidl::encoding::ResourceTypeMarker for EchoEchoVectorsWithErrorResponse {
8641        type Borrowed<'a> = &'a mut Self;
8642        fn take_or_borrow<'a>(
8643            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8644        ) -> Self::Borrowed<'a> {
8645            value
8646        }
8647    }
8648
8649    unsafe impl fidl::encoding::TypeMarker for EchoEchoVectorsWithErrorResponse {
8650        type Owned = Self;
8651
8652        #[inline(always)]
8653        fn inline_align(_context: fidl::encoding::Context) -> usize {
8654            8
8655        }
8656
8657        #[inline(always)]
8658        fn inline_size(_context: fidl::encoding::Context) -> usize {
8659            416
8660        }
8661    }
8662
8663    unsafe impl
8664        fidl::encoding::Encode<
8665            EchoEchoVectorsWithErrorResponse,
8666            fidl::encoding::DefaultFuchsiaResourceDialect,
8667        > for &mut EchoEchoVectorsWithErrorResponse
8668    {
8669        #[inline]
8670        unsafe fn encode(
8671            self,
8672            encoder: &mut fidl::encoding::Encoder<
8673                '_,
8674                fidl::encoding::DefaultFuchsiaResourceDialect,
8675            >,
8676            offset: usize,
8677            _depth: fidl::encoding::Depth,
8678        ) -> fidl::Result<()> {
8679            encoder.debug_check_bounds::<EchoEchoVectorsWithErrorResponse>(offset);
8680            // Delegate to tuple encoding.
8681            fidl::encoding::Encode::<
8682                EchoEchoVectorsWithErrorResponse,
8683                fidl::encoding::DefaultFuchsiaResourceDialect,
8684            >::encode(
8685                (<VectorsStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8686                    &mut self.value,
8687                ),),
8688                encoder,
8689                offset,
8690                _depth,
8691            )
8692        }
8693    }
8694    unsafe impl<
8695        T0: fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
8696    >
8697        fidl::encoding::Encode<
8698            EchoEchoVectorsWithErrorResponse,
8699            fidl::encoding::DefaultFuchsiaResourceDialect,
8700        > for (T0,)
8701    {
8702        #[inline]
8703        unsafe fn encode(
8704            self,
8705            encoder: &mut fidl::encoding::Encoder<
8706                '_,
8707                fidl::encoding::DefaultFuchsiaResourceDialect,
8708            >,
8709            offset: usize,
8710            depth: fidl::encoding::Depth,
8711        ) -> fidl::Result<()> {
8712            encoder.debug_check_bounds::<EchoEchoVectorsWithErrorResponse>(offset);
8713            // Zero out padding regions. There's no need to apply masks
8714            // because the unmasked parts will be overwritten by fields.
8715            // Write the fields.
8716            self.0.encode(encoder, offset + 0, depth)?;
8717            Ok(())
8718        }
8719    }
8720
8721    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8722        for EchoEchoVectorsWithErrorResponse
8723    {
8724        #[inline(always)]
8725        fn new_empty() -> Self {
8726            Self {
8727                value: fidl::new_empty!(
8728                    VectorsStruct,
8729                    fidl::encoding::DefaultFuchsiaResourceDialect
8730                ),
8731            }
8732        }
8733
8734        #[inline]
8735        unsafe fn decode(
8736            &mut self,
8737            decoder: &mut fidl::encoding::Decoder<
8738                '_,
8739                fidl::encoding::DefaultFuchsiaResourceDialect,
8740            >,
8741            offset: usize,
8742            _depth: fidl::encoding::Depth,
8743        ) -> fidl::Result<()> {
8744            decoder.debug_check_bounds::<Self>(offset);
8745            // Verify that padding bytes are zero.
8746            fidl::decode!(
8747                VectorsStruct,
8748                fidl::encoding::DefaultFuchsiaResourceDialect,
8749                &mut self.value,
8750                decoder,
8751                offset + 0,
8752                _depth
8753            )?;
8754            Ok(())
8755        }
8756    }
8757
8758    impl fidl::encoding::ResourceTypeMarker for EchoEchoXunionsWithErrorResponse {
8759        type Borrowed<'a> = &'a mut Self;
8760        fn take_or_borrow<'a>(
8761            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8762        ) -> Self::Borrowed<'a> {
8763            value
8764        }
8765    }
8766
8767    unsafe impl fidl::encoding::TypeMarker for EchoEchoXunionsWithErrorResponse {
8768        type Owned = Self;
8769
8770        #[inline(always)]
8771        fn inline_align(_context: fidl::encoding::Context) -> usize {
8772            8
8773        }
8774
8775        #[inline(always)]
8776        fn inline_size(_context: fidl::encoding::Context) -> usize {
8777            16
8778        }
8779    }
8780
8781    unsafe impl
8782        fidl::encoding::Encode<
8783            EchoEchoXunionsWithErrorResponse,
8784            fidl::encoding::DefaultFuchsiaResourceDialect,
8785        > for &mut EchoEchoXunionsWithErrorResponse
8786    {
8787        #[inline]
8788        unsafe fn encode(
8789            self,
8790            encoder: &mut fidl::encoding::Encoder<
8791                '_,
8792                fidl::encoding::DefaultFuchsiaResourceDialect,
8793            >,
8794            offset: usize,
8795            _depth: fidl::encoding::Depth,
8796        ) -> fidl::Result<()> {
8797            encoder.debug_check_bounds::<EchoEchoXunionsWithErrorResponse>(offset);
8798            // Delegate to tuple encoding.
8799            fidl::encoding::Encode::<EchoEchoXunionsWithErrorResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
8800                (
8801                    <fidl::encoding::UnboundedVector<AllTypesXunion> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
8802                ),
8803                encoder, offset, _depth
8804            )
8805        }
8806    }
8807    unsafe impl<
8808        T0: fidl::encoding::Encode<
8809                fidl::encoding::UnboundedVector<AllTypesXunion>,
8810                fidl::encoding::DefaultFuchsiaResourceDialect,
8811            >,
8812    >
8813        fidl::encoding::Encode<
8814            EchoEchoXunionsWithErrorResponse,
8815            fidl::encoding::DefaultFuchsiaResourceDialect,
8816        > for (T0,)
8817    {
8818        #[inline]
8819        unsafe fn encode(
8820            self,
8821            encoder: &mut fidl::encoding::Encoder<
8822                '_,
8823                fidl::encoding::DefaultFuchsiaResourceDialect,
8824            >,
8825            offset: usize,
8826            depth: fidl::encoding::Depth,
8827        ) -> fidl::Result<()> {
8828            encoder.debug_check_bounds::<EchoEchoXunionsWithErrorResponse>(offset);
8829            // Zero out padding regions. There's no need to apply masks
8830            // because the unmasked parts will be overwritten by fields.
8831            // Write the fields.
8832            self.0.encode(encoder, offset + 0, depth)?;
8833            Ok(())
8834        }
8835    }
8836
8837    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8838        for EchoEchoXunionsWithErrorResponse
8839    {
8840        #[inline(always)]
8841        fn new_empty() -> Self {
8842            Self {
8843                value: fidl::new_empty!(
8844                    fidl::encoding::UnboundedVector<AllTypesXunion>,
8845                    fidl::encoding::DefaultFuchsiaResourceDialect
8846                ),
8847            }
8848        }
8849
8850        #[inline]
8851        unsafe fn decode(
8852            &mut self,
8853            decoder: &mut fidl::encoding::Decoder<
8854                '_,
8855                fidl::encoding::DefaultFuchsiaResourceDialect,
8856            >,
8857            offset: usize,
8858            _depth: fidl::encoding::Depth,
8859        ) -> fidl::Result<()> {
8860            decoder.debug_check_bounds::<Self>(offset);
8861            // Verify that padding bytes are zero.
8862            fidl::decode!(
8863                fidl::encoding::UnboundedVector<AllTypesXunion>,
8864                fidl::encoding::DefaultFuchsiaResourceDialect,
8865                &mut self.value,
8866                decoder,
8867                offset + 0,
8868                _depth
8869            )?;
8870            Ok(())
8871        }
8872    }
8873
8874    impl fidl::encoding::ResourceTypeMarker for Struct {
8875        type Borrowed<'a> = &'a mut Self;
8876        fn take_or_borrow<'a>(
8877            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8878        ) -> Self::Borrowed<'a> {
8879            value
8880        }
8881    }
8882
8883    unsafe impl fidl::encoding::TypeMarker for Struct {
8884        type Owned = Self;
8885
8886        #[inline(always)]
8887        fn inline_align(_context: fidl::encoding::Context) -> usize {
8888            8
8889        }
8890
8891        #[inline(always)]
8892        fn inline_size(_context: fidl::encoding::Context) -> usize {
8893            2912
8894        }
8895    }
8896
8897    unsafe impl fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>
8898        for &mut Struct
8899    {
8900        #[inline]
8901        unsafe fn encode(
8902            self,
8903            encoder: &mut fidl::encoding::Encoder<
8904                '_,
8905                fidl::encoding::DefaultFuchsiaResourceDialect,
8906            >,
8907            offset: usize,
8908            _depth: fidl::encoding::Depth,
8909        ) -> fidl::Result<()> {
8910            encoder.debug_check_bounds::<Struct>(offset);
8911            // Delegate to tuple encoding.
8912            fidl::encoding::Encode::<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
8913                (
8914                    <PrimitiveTypes as fidl::encoding::ValueTypeMarker>::borrow(
8915                        &self.primitive_types,
8916                    ),
8917                    <DefaultValues as fidl::encoding::ValueTypeMarker>::borrow(
8918                        &self.default_values,
8919                    ),
8920                    <Arrays as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8921                        &mut self.arrays,
8922                    ),
8923                    <Arrays2d as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8924                        &mut self.arrays_2d,
8925                    ),
8926                    <Vectors as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8927                        &mut self.vectors,
8928                    ),
8929                    <Handles as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8930                        &mut self.handles,
8931                    ),
8932                    <Strings as fidl::encoding::ValueTypeMarker>::borrow(&self.strings),
8933                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.default_enum),
8934                    <I8Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_enum),
8935                    <I16Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_enum),
8936                    <I32Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_enum),
8937                    <I64Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_enum),
8938                    <U8Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_enum),
8939                    <U16Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_enum),
8940                    <U32Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_enum),
8941                    <U64Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_enum),
8942                    <DefaultBits as fidl::encoding::ValueTypeMarker>::borrow(&self.default_bits),
8943                    <U8Bits as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_bits),
8944                    <U16Bits as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_bits),
8945                    <U32Bits as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_bits),
8946                    <U64Bits as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_bits),
8947                    <Structs as fidl::encoding::ValueTypeMarker>::borrow(&self.structs),
8948                    <Unions as fidl::encoding::ValueTypeMarker>::borrow(&self.unions),
8949                    <ThisIsATable as fidl::encoding::ValueTypeMarker>::borrow(&self.table),
8950                    <ThisIsAXunion as fidl::encoding::ValueTypeMarker>::borrow(&self.xunion),
8951                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.b),
8952                ),
8953                encoder,
8954                offset,
8955                _depth,
8956            )
8957        }
8958    }
8959    unsafe impl<
8960        T0: fidl::encoding::Encode<PrimitiveTypes, fidl::encoding::DefaultFuchsiaResourceDialect>,
8961        T1: fidl::encoding::Encode<DefaultValues, fidl::encoding::DefaultFuchsiaResourceDialect>,
8962        T2: fidl::encoding::Encode<Arrays, fidl::encoding::DefaultFuchsiaResourceDialect>,
8963        T3: fidl::encoding::Encode<Arrays2d, fidl::encoding::DefaultFuchsiaResourceDialect>,
8964        T4: fidl::encoding::Encode<Vectors, fidl::encoding::DefaultFuchsiaResourceDialect>,
8965        T5: fidl::encoding::Encode<Handles, fidl::encoding::DefaultFuchsiaResourceDialect>,
8966        T6: fidl::encoding::Encode<Strings, fidl::encoding::DefaultFuchsiaResourceDialect>,
8967        T7: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8968        T8: fidl::encoding::Encode<I8Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8969        T9: fidl::encoding::Encode<I16Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8970        T10: fidl::encoding::Encode<I32Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8971        T11: fidl::encoding::Encode<I64Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8972        T12: fidl::encoding::Encode<U8Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8973        T13: fidl::encoding::Encode<U16Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8974        T14: fidl::encoding::Encode<U32Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8975        T15: fidl::encoding::Encode<U64Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8976        T16: fidl::encoding::Encode<DefaultBits, fidl::encoding::DefaultFuchsiaResourceDialect>,
8977        T17: fidl::encoding::Encode<U8Bits, fidl::encoding::DefaultFuchsiaResourceDialect>,
8978        T18: fidl::encoding::Encode<U16Bits, fidl::encoding::DefaultFuchsiaResourceDialect>,
8979        T19: fidl::encoding::Encode<U32Bits, fidl::encoding::DefaultFuchsiaResourceDialect>,
8980        T20: fidl::encoding::Encode<U64Bits, fidl::encoding::DefaultFuchsiaResourceDialect>,
8981        T21: fidl::encoding::Encode<Structs, fidl::encoding::DefaultFuchsiaResourceDialect>,
8982        T22: fidl::encoding::Encode<Unions, fidl::encoding::DefaultFuchsiaResourceDialect>,
8983        T23: fidl::encoding::Encode<ThisIsATable, fidl::encoding::DefaultFuchsiaResourceDialect>,
8984        T24: fidl::encoding::Encode<ThisIsAXunion, fidl::encoding::DefaultFuchsiaResourceDialect>,
8985        T25: fidl::encoding::Encode<bool, fidl::encoding::DefaultFuchsiaResourceDialect>,
8986    > fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>
8987        for (
8988            T0,
8989            T1,
8990            T2,
8991            T3,
8992            T4,
8993            T5,
8994            T6,
8995            T7,
8996            T8,
8997            T9,
8998            T10,
8999            T11,
9000            T12,
9001            T13,
9002            T14,
9003            T15,
9004            T16,
9005            T17,
9006            T18,
9007            T19,
9008            T20,
9009            T21,
9010            T22,
9011            T23,
9012            T24,
9013            T25,
9014        )
9015    {
9016        #[inline]
9017        unsafe fn encode(
9018            self,
9019            encoder: &mut fidl::encoding::Encoder<
9020                '_,
9021                fidl::encoding::DefaultFuchsiaResourceDialect,
9022            >,
9023            offset: usize,
9024            depth: fidl::encoding::Depth,
9025        ) -> fidl::Result<()> {
9026            encoder.debug_check_bounds::<Struct>(offset);
9027            // Zero out padding regions. There's no need to apply masks
9028            // because the unmasked parts will be overwritten by fields.
9029            unsafe {
9030                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2640);
9031                (ptr as *mut u64).write_unaligned(0);
9032            }
9033            unsafe {
9034                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2744);
9035                (ptr as *mut u64).write_unaligned(0);
9036            }
9037            unsafe {
9038                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2752);
9039                (ptr as *mut u64).write_unaligned(0);
9040            }
9041            unsafe {
9042                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2768);
9043                (ptr as *mut u64).write_unaligned(0);
9044            }
9045            unsafe {
9046                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2784);
9047                (ptr as *mut u64).write_unaligned(0);
9048            }
9049            unsafe {
9050                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2792);
9051                (ptr as *mut u64).write_unaligned(0);
9052            }
9053            unsafe {
9054                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2904);
9055                (ptr as *mut u64).write_unaligned(0);
9056            }
9057            // Write the fields.
9058            self.0.encode(encoder, offset + 0, depth)?;
9059            self.1.encode(encoder, offset + 48, depth)?;
9060            self.2.encode(encoder, offset + 120, depth)?;
9061            self.3.encode(encoder, offset + 328, depth)?;
9062            self.4.encode(encoder, offset + 616, depth)?;
9063            self.5.encode(encoder, offset + 2536, depth)?;
9064            self.6.encode(encoder, offset + 2648, depth)?;
9065            self.7.encode(encoder, offset + 2744, depth)?;
9066            self.8.encode(encoder, offset + 2748, depth)?;
9067            self.9.encode(encoder, offset + 2750, depth)?;
9068            self.10.encode(encoder, offset + 2752, depth)?;
9069            self.11.encode(encoder, offset + 2760, depth)?;
9070            self.12.encode(encoder, offset + 2768, depth)?;
9071            self.13.encode(encoder, offset + 2770, depth)?;
9072            self.14.encode(encoder, offset + 2772, depth)?;
9073            self.15.encode(encoder, offset + 2776, depth)?;
9074            self.16.encode(encoder, offset + 2784, depth)?;
9075            self.17.encode(encoder, offset + 2788, depth)?;
9076            self.18.encode(encoder, offset + 2790, depth)?;
9077            self.19.encode(encoder, offset + 2792, depth)?;
9078            self.20.encode(encoder, offset + 2800, depth)?;
9079            self.21.encode(encoder, offset + 2808, depth)?;
9080            self.22.encode(encoder, offset + 2840, depth)?;
9081            self.23.encode(encoder, offset + 2872, depth)?;
9082            self.24.encode(encoder, offset + 2888, depth)?;
9083            self.25.encode(encoder, offset + 2904, depth)?;
9084            Ok(())
9085        }
9086    }
9087
9088    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Struct {
9089        #[inline(always)]
9090        fn new_empty() -> Self {
9091            Self {
9092                primitive_types: fidl::new_empty!(
9093                    PrimitiveTypes,
9094                    fidl::encoding::DefaultFuchsiaResourceDialect
9095                ),
9096                default_values: fidl::new_empty!(
9097                    DefaultValues,
9098                    fidl::encoding::DefaultFuchsiaResourceDialect
9099                ),
9100                arrays: fidl::new_empty!(Arrays, fidl::encoding::DefaultFuchsiaResourceDialect),
9101                arrays_2d: fidl::new_empty!(
9102                    Arrays2d,
9103                    fidl::encoding::DefaultFuchsiaResourceDialect
9104                ),
9105                vectors: fidl::new_empty!(Vectors, fidl::encoding::DefaultFuchsiaResourceDialect),
9106                handles: fidl::new_empty!(Handles, fidl::encoding::DefaultFuchsiaResourceDialect),
9107                strings: fidl::new_empty!(Strings, fidl::encoding::DefaultFuchsiaResourceDialect),
9108                default_enum: fidl::new_empty!(
9109                    DefaultEnum,
9110                    fidl::encoding::DefaultFuchsiaResourceDialect
9111                ),
9112                i8_enum: fidl::new_empty!(I8Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9113                i16_enum: fidl::new_empty!(I16Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9114                i32_enum: fidl::new_empty!(I32Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9115                i64_enum: fidl::new_empty!(I64Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9116                u8_enum: fidl::new_empty!(U8Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9117                u16_enum: fidl::new_empty!(U16Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9118                u32_enum: fidl::new_empty!(U32Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9119                u64_enum: fidl::new_empty!(U64Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9120                default_bits: fidl::new_empty!(
9121                    DefaultBits,
9122                    fidl::encoding::DefaultFuchsiaResourceDialect
9123                ),
9124                u8_bits: fidl::new_empty!(U8Bits, fidl::encoding::DefaultFuchsiaResourceDialect),
9125                u16_bits: fidl::new_empty!(U16Bits, fidl::encoding::DefaultFuchsiaResourceDialect),
9126                u32_bits: fidl::new_empty!(U32Bits, fidl::encoding::DefaultFuchsiaResourceDialect),
9127                u64_bits: fidl::new_empty!(U64Bits, fidl::encoding::DefaultFuchsiaResourceDialect),
9128                structs: fidl::new_empty!(Structs, fidl::encoding::DefaultFuchsiaResourceDialect),
9129                unions: fidl::new_empty!(Unions, fidl::encoding::DefaultFuchsiaResourceDialect),
9130                table: fidl::new_empty!(
9131                    ThisIsATable,
9132                    fidl::encoding::DefaultFuchsiaResourceDialect
9133                ),
9134                xunion: fidl::new_empty!(
9135                    ThisIsAXunion,
9136                    fidl::encoding::DefaultFuchsiaResourceDialect
9137                ),
9138                b: fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect),
9139            }
9140        }
9141
9142        #[inline]
9143        unsafe fn decode(
9144            &mut self,
9145            decoder: &mut fidl::encoding::Decoder<
9146                '_,
9147                fidl::encoding::DefaultFuchsiaResourceDialect,
9148            >,
9149            offset: usize,
9150            _depth: fidl::encoding::Depth,
9151        ) -> fidl::Result<()> {
9152            decoder.debug_check_bounds::<Self>(offset);
9153            // Verify that padding bytes are zero.
9154            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2640) };
9155            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9156            let mask = 0xffffffff00000000u64;
9157            let maskedval = padval & mask;
9158            if maskedval != 0 {
9159                return Err(fidl::Error::NonZeroPadding {
9160                    padding_start: offset + 2640 + ((mask as u64).trailing_zeros() / 8) as usize,
9161                });
9162            }
9163            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2744) };
9164            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9165            let mask = 0xff0000000000u64;
9166            let maskedval = padval & mask;
9167            if maskedval != 0 {
9168                return Err(fidl::Error::NonZeroPadding {
9169                    padding_start: offset + 2744 + ((mask as u64).trailing_zeros() / 8) as usize,
9170                });
9171            }
9172            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2752) };
9173            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9174            let mask = 0xffffffff00000000u64;
9175            let maskedval = padval & mask;
9176            if maskedval != 0 {
9177                return Err(fidl::Error::NonZeroPadding {
9178                    padding_start: offset + 2752 + ((mask as u64).trailing_zeros() / 8) as usize,
9179                });
9180            }
9181            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2768) };
9182            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9183            let mask = 0xff00u64;
9184            let maskedval = padval & mask;
9185            if maskedval != 0 {
9186                return Err(fidl::Error::NonZeroPadding {
9187                    padding_start: offset + 2768 + ((mask as u64).trailing_zeros() / 8) as usize,
9188                });
9189            }
9190            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2784) };
9191            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9192            let mask = 0xff0000000000u64;
9193            let maskedval = padval & mask;
9194            if maskedval != 0 {
9195                return Err(fidl::Error::NonZeroPadding {
9196                    padding_start: offset + 2784 + ((mask as u64).trailing_zeros() / 8) as usize,
9197                });
9198            }
9199            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2792) };
9200            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9201            let mask = 0xffffffff00000000u64;
9202            let maskedval = padval & mask;
9203            if maskedval != 0 {
9204                return Err(fidl::Error::NonZeroPadding {
9205                    padding_start: offset + 2792 + ((mask as u64).trailing_zeros() / 8) as usize,
9206                });
9207            }
9208            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2904) };
9209            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9210            let mask = 0xffffffffffffff00u64;
9211            let maskedval = padval & mask;
9212            if maskedval != 0 {
9213                return Err(fidl::Error::NonZeroPadding {
9214                    padding_start: offset + 2904 + ((mask as u64).trailing_zeros() / 8) as usize,
9215                });
9216            }
9217            fidl::decode!(
9218                PrimitiveTypes,
9219                fidl::encoding::DefaultFuchsiaResourceDialect,
9220                &mut self.primitive_types,
9221                decoder,
9222                offset + 0,
9223                _depth
9224            )?;
9225            fidl::decode!(
9226                DefaultValues,
9227                fidl::encoding::DefaultFuchsiaResourceDialect,
9228                &mut self.default_values,
9229                decoder,
9230                offset + 48,
9231                _depth
9232            )?;
9233            fidl::decode!(
9234                Arrays,
9235                fidl::encoding::DefaultFuchsiaResourceDialect,
9236                &mut self.arrays,
9237                decoder,
9238                offset + 120,
9239                _depth
9240            )?;
9241            fidl::decode!(
9242                Arrays2d,
9243                fidl::encoding::DefaultFuchsiaResourceDialect,
9244                &mut self.arrays_2d,
9245                decoder,
9246                offset + 328,
9247                _depth
9248            )?;
9249            fidl::decode!(
9250                Vectors,
9251                fidl::encoding::DefaultFuchsiaResourceDialect,
9252                &mut self.vectors,
9253                decoder,
9254                offset + 616,
9255                _depth
9256            )?;
9257            fidl::decode!(
9258                Handles,
9259                fidl::encoding::DefaultFuchsiaResourceDialect,
9260                &mut self.handles,
9261                decoder,
9262                offset + 2536,
9263                _depth
9264            )?;
9265            fidl::decode!(
9266                Strings,
9267                fidl::encoding::DefaultFuchsiaResourceDialect,
9268                &mut self.strings,
9269                decoder,
9270                offset + 2648,
9271                _depth
9272            )?;
9273            fidl::decode!(
9274                DefaultEnum,
9275                fidl::encoding::DefaultFuchsiaResourceDialect,
9276                &mut self.default_enum,
9277                decoder,
9278                offset + 2744,
9279                _depth
9280            )?;
9281            fidl::decode!(
9282                I8Enum,
9283                fidl::encoding::DefaultFuchsiaResourceDialect,
9284                &mut self.i8_enum,
9285                decoder,
9286                offset + 2748,
9287                _depth
9288            )?;
9289            fidl::decode!(
9290                I16Enum,
9291                fidl::encoding::DefaultFuchsiaResourceDialect,
9292                &mut self.i16_enum,
9293                decoder,
9294                offset + 2750,
9295                _depth
9296            )?;
9297            fidl::decode!(
9298                I32Enum,
9299                fidl::encoding::DefaultFuchsiaResourceDialect,
9300                &mut self.i32_enum,
9301                decoder,
9302                offset + 2752,
9303                _depth
9304            )?;
9305            fidl::decode!(
9306                I64Enum,
9307                fidl::encoding::DefaultFuchsiaResourceDialect,
9308                &mut self.i64_enum,
9309                decoder,
9310                offset + 2760,
9311                _depth
9312            )?;
9313            fidl::decode!(
9314                U8Enum,
9315                fidl::encoding::DefaultFuchsiaResourceDialect,
9316                &mut self.u8_enum,
9317                decoder,
9318                offset + 2768,
9319                _depth
9320            )?;
9321            fidl::decode!(
9322                U16Enum,
9323                fidl::encoding::DefaultFuchsiaResourceDialect,
9324                &mut self.u16_enum,
9325                decoder,
9326                offset + 2770,
9327                _depth
9328            )?;
9329            fidl::decode!(
9330                U32Enum,
9331                fidl::encoding::DefaultFuchsiaResourceDialect,
9332                &mut self.u32_enum,
9333                decoder,
9334                offset + 2772,
9335                _depth
9336            )?;
9337            fidl::decode!(
9338                U64Enum,
9339                fidl::encoding::DefaultFuchsiaResourceDialect,
9340                &mut self.u64_enum,
9341                decoder,
9342                offset + 2776,
9343                _depth
9344            )?;
9345            fidl::decode!(
9346                DefaultBits,
9347                fidl::encoding::DefaultFuchsiaResourceDialect,
9348                &mut self.default_bits,
9349                decoder,
9350                offset + 2784,
9351                _depth
9352            )?;
9353            fidl::decode!(
9354                U8Bits,
9355                fidl::encoding::DefaultFuchsiaResourceDialect,
9356                &mut self.u8_bits,
9357                decoder,
9358                offset + 2788,
9359                _depth
9360            )?;
9361            fidl::decode!(
9362                U16Bits,
9363                fidl::encoding::DefaultFuchsiaResourceDialect,
9364                &mut self.u16_bits,
9365                decoder,
9366                offset + 2790,
9367                _depth
9368            )?;
9369            fidl::decode!(
9370                U32Bits,
9371                fidl::encoding::DefaultFuchsiaResourceDialect,
9372                &mut self.u32_bits,
9373                decoder,
9374                offset + 2792,
9375                _depth
9376            )?;
9377            fidl::decode!(
9378                U64Bits,
9379                fidl::encoding::DefaultFuchsiaResourceDialect,
9380                &mut self.u64_bits,
9381                decoder,
9382                offset + 2800,
9383                _depth
9384            )?;
9385            fidl::decode!(
9386                Structs,
9387                fidl::encoding::DefaultFuchsiaResourceDialect,
9388                &mut self.structs,
9389                decoder,
9390                offset + 2808,
9391                _depth
9392            )?;
9393            fidl::decode!(
9394                Unions,
9395                fidl::encoding::DefaultFuchsiaResourceDialect,
9396                &mut self.unions,
9397                decoder,
9398                offset + 2840,
9399                _depth
9400            )?;
9401            fidl::decode!(
9402                ThisIsATable,
9403                fidl::encoding::DefaultFuchsiaResourceDialect,
9404                &mut self.table,
9405                decoder,
9406                offset + 2872,
9407                _depth
9408            )?;
9409            fidl::decode!(
9410                ThisIsAXunion,
9411                fidl::encoding::DefaultFuchsiaResourceDialect,
9412                &mut self.xunion,
9413                decoder,
9414                offset + 2888,
9415                _depth
9416            )?;
9417            fidl::decode!(
9418                bool,
9419                fidl::encoding::DefaultFuchsiaResourceDialect,
9420                &mut self.b,
9421                decoder,
9422                offset + 2904,
9423                _depth
9424            )?;
9425            Ok(())
9426        }
9427    }
9428
9429    impl fidl::encoding::ResourceTypeMarker for VectorsStruct {
9430        type Borrowed<'a> = &'a mut Self;
9431        fn take_or_borrow<'a>(
9432            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
9433        ) -> Self::Borrowed<'a> {
9434            value
9435        }
9436    }
9437
9438    unsafe impl fidl::encoding::TypeMarker for VectorsStruct {
9439        type Owned = Self;
9440
9441        #[inline(always)]
9442        fn inline_align(_context: fidl::encoding::Context) -> usize {
9443            8
9444        }
9445
9446        #[inline(always)]
9447        fn inline_size(_context: fidl::encoding::Context) -> usize {
9448            416
9449        }
9450    }
9451
9452    unsafe impl fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
9453        for &mut VectorsStruct
9454    {
9455        #[inline]
9456        unsafe fn encode(
9457            self,
9458            encoder: &mut fidl::encoding::Encoder<
9459                '_,
9460                fidl::encoding::DefaultFuchsiaResourceDialect,
9461            >,
9462            offset: usize,
9463            _depth: fidl::encoding::Depth,
9464        ) -> fidl::Result<()> {
9465            encoder.debug_check_bounds::<VectorsStruct>(offset);
9466            // Delegate to tuple encoding.
9467            fidl::encoding::Encode::<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
9468                (
9469                    <fidl::encoding::Vector<bool, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.bools),
9470                    <fidl::encoding::Vector<i8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int8s),
9471                    <fidl::encoding::Vector<i16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int16s),
9472                    <fidl::encoding::Vector<i32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int32s),
9473                    <fidl::encoding::Vector<i64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int64s),
9474                    <fidl::encoding::Vector<u8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint8s),
9475                    <fidl::encoding::Vector<u16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint16s),
9476                    <fidl::encoding::Vector<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint32s),
9477                    <fidl::encoding::Vector<u64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint64s),
9478                    <fidl::encoding::Vector<f32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.float32s),
9479                    <fidl::encoding::Vector<f64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.float64s),
9480                    <fidl::encoding::Vector<DefaultEnum, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.enums),
9481                    <fidl::encoding::Vector<DefaultBits, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.bits),
9482                    <fidl::encoding::Vector<fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 3> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handles),
9483                    <fidl::encoding::Vector<fidl::encoding::Optional<fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>>, 3> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.nullable_handles),
9484                    <fidl::encoding::Vector<fidl::encoding::UnboundedString, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.strings),
9485                    <fidl::encoding::Vector<fidl::encoding::Optional<fidl::encoding::UnboundedString>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_strings),
9486                    <fidl::encoding::Vector<ThisIsAStruct, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.structs),
9487                    <fidl::encoding::Vector<fidl::encoding::Boxed<ThisIsAStruct>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_structs),
9488                    <fidl::encoding::Vector<ThisIsAUnion, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.unions),
9489                    <fidl::encoding::Vector<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_unions),
9490                    <fidl::encoding::Vector<fidl::encoding::Array<u32, 3>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.arrays),
9491                    <fidl::encoding::Vector<fidl::encoding::UnboundedVector<u32>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.vectors),
9492                    <fidl::encoding::Vector<fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_vectors),
9493                    <fidl::encoding::Vector<ThisIsATable, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.tables),
9494                    <fidl::encoding::Vector<ThisIsAXunion, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.xunions),
9495                ),
9496                encoder, offset, _depth
9497            )
9498        }
9499    }
9500    unsafe impl<
9501        T0: fidl::encoding::Encode<
9502                fidl::encoding::Vector<bool, 3>,
9503                fidl::encoding::DefaultFuchsiaResourceDialect,
9504            >,
9505        T1: fidl::encoding::Encode<
9506                fidl::encoding::Vector<i8, 3>,
9507                fidl::encoding::DefaultFuchsiaResourceDialect,
9508            >,
9509        T2: fidl::encoding::Encode<
9510                fidl::encoding::Vector<i16, 3>,
9511                fidl::encoding::DefaultFuchsiaResourceDialect,
9512            >,
9513        T3: fidl::encoding::Encode<
9514                fidl::encoding::Vector<i32, 3>,
9515                fidl::encoding::DefaultFuchsiaResourceDialect,
9516            >,
9517        T4: fidl::encoding::Encode<
9518                fidl::encoding::Vector<i64, 3>,
9519                fidl::encoding::DefaultFuchsiaResourceDialect,
9520            >,
9521        T5: fidl::encoding::Encode<
9522                fidl::encoding::Vector<u8, 3>,
9523                fidl::encoding::DefaultFuchsiaResourceDialect,
9524            >,
9525        T6: fidl::encoding::Encode<
9526                fidl::encoding::Vector<u16, 3>,
9527                fidl::encoding::DefaultFuchsiaResourceDialect,
9528            >,
9529        T7: fidl::encoding::Encode<
9530                fidl::encoding::Vector<u32, 3>,
9531                fidl::encoding::DefaultFuchsiaResourceDialect,
9532            >,
9533        T8: fidl::encoding::Encode<
9534                fidl::encoding::Vector<u64, 3>,
9535                fidl::encoding::DefaultFuchsiaResourceDialect,
9536            >,
9537        T9: fidl::encoding::Encode<
9538                fidl::encoding::Vector<f32, 3>,
9539                fidl::encoding::DefaultFuchsiaResourceDialect,
9540            >,
9541        T10: fidl::encoding::Encode<
9542                fidl::encoding::Vector<f64, 3>,
9543                fidl::encoding::DefaultFuchsiaResourceDialect,
9544            >,
9545        T11: fidl::encoding::Encode<
9546                fidl::encoding::Vector<DefaultEnum, 3>,
9547                fidl::encoding::DefaultFuchsiaResourceDialect,
9548            >,
9549        T12: fidl::encoding::Encode<
9550                fidl::encoding::Vector<DefaultBits, 3>,
9551                fidl::encoding::DefaultFuchsiaResourceDialect,
9552            >,
9553        T13: fidl::encoding::Encode<
9554                fidl::encoding::Vector<
9555                    fidl::encoding::HandleType<
9556                        fidl::NullableHandle,
9557                        { fidl::ObjectType::NONE.into_raw() },
9558                        2147483648,
9559                    >,
9560                    3,
9561                >,
9562                fidl::encoding::DefaultFuchsiaResourceDialect,
9563            >,
9564        T14: fidl::encoding::Encode<
9565                fidl::encoding::Vector<
9566                    fidl::encoding::Optional<
9567                        fidl::encoding::HandleType<
9568                            fidl::NullableHandle,
9569                            { fidl::ObjectType::NONE.into_raw() },
9570                            2147483648,
9571                        >,
9572                    >,
9573                    3,
9574                >,
9575                fidl::encoding::DefaultFuchsiaResourceDialect,
9576            >,
9577        T15: fidl::encoding::Encode<
9578                fidl::encoding::Vector<fidl::encoding::UnboundedString, 3>,
9579                fidl::encoding::DefaultFuchsiaResourceDialect,
9580            >,
9581        T16: fidl::encoding::Encode<
9582                fidl::encoding::Vector<
9583                    fidl::encoding::Optional<fidl::encoding::UnboundedString>,
9584                    3,
9585                >,
9586                fidl::encoding::DefaultFuchsiaResourceDialect,
9587            >,
9588        T17: fidl::encoding::Encode<
9589                fidl::encoding::Vector<ThisIsAStruct, 3>,
9590                fidl::encoding::DefaultFuchsiaResourceDialect,
9591            >,
9592        T18: fidl::encoding::Encode<
9593                fidl::encoding::Vector<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
9594                fidl::encoding::DefaultFuchsiaResourceDialect,
9595            >,
9596        T19: fidl::encoding::Encode<
9597                fidl::encoding::Vector<ThisIsAUnion, 3>,
9598                fidl::encoding::DefaultFuchsiaResourceDialect,
9599            >,
9600        T20: fidl::encoding::Encode<
9601                fidl::encoding::Vector<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
9602                fidl::encoding::DefaultFuchsiaResourceDialect,
9603            >,
9604        T21: fidl::encoding::Encode<
9605                fidl::encoding::Vector<fidl::encoding::Array<u32, 3>, 3>,
9606                fidl::encoding::DefaultFuchsiaResourceDialect,
9607            >,
9608        T22: fidl::encoding::Encode<
9609                fidl::encoding::Vector<fidl::encoding::UnboundedVector<u32>, 3>,
9610                fidl::encoding::DefaultFuchsiaResourceDialect,
9611            >,
9612        T23: fidl::encoding::Encode<
9613                fidl::encoding::Vector<
9614                    fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
9615                    3,
9616                >,
9617                fidl::encoding::DefaultFuchsiaResourceDialect,
9618            >,
9619        T24: fidl::encoding::Encode<
9620                fidl::encoding::Vector<ThisIsATable, 3>,
9621                fidl::encoding::DefaultFuchsiaResourceDialect,
9622            >,
9623        T25: fidl::encoding::Encode<
9624                fidl::encoding::Vector<ThisIsAXunion, 3>,
9625                fidl::encoding::DefaultFuchsiaResourceDialect,
9626            >,
9627    > fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
9628        for (
9629            T0,
9630            T1,
9631            T2,
9632            T3,
9633            T4,
9634            T5,
9635            T6,
9636            T7,
9637            T8,
9638            T9,
9639            T10,
9640            T11,
9641            T12,
9642            T13,
9643            T14,
9644            T15,
9645            T16,
9646            T17,
9647            T18,
9648            T19,
9649            T20,
9650            T21,
9651            T22,
9652            T23,
9653            T24,
9654            T25,
9655        )
9656    {
9657        #[inline]
9658        unsafe fn encode(
9659            self,
9660            encoder: &mut fidl::encoding::Encoder<
9661                '_,
9662                fidl::encoding::DefaultFuchsiaResourceDialect,
9663            >,
9664            offset: usize,
9665            depth: fidl::encoding::Depth,
9666        ) -> fidl::Result<()> {
9667            encoder.debug_check_bounds::<VectorsStruct>(offset);
9668            // Zero out padding regions. There's no need to apply masks
9669            // because the unmasked parts will be overwritten by fields.
9670            // Write the fields.
9671            self.0.encode(encoder, offset + 0, depth)?;
9672            self.1.encode(encoder, offset + 16, depth)?;
9673            self.2.encode(encoder, offset + 32, depth)?;
9674            self.3.encode(encoder, offset + 48, depth)?;
9675            self.4.encode(encoder, offset + 64, depth)?;
9676            self.5.encode(encoder, offset + 80, depth)?;
9677            self.6.encode(encoder, offset + 96, depth)?;
9678            self.7.encode(encoder, offset + 112, depth)?;
9679            self.8.encode(encoder, offset + 128, depth)?;
9680            self.9.encode(encoder, offset + 144, depth)?;
9681            self.10.encode(encoder, offset + 160, depth)?;
9682            self.11.encode(encoder, offset + 176, depth)?;
9683            self.12.encode(encoder, offset + 192, depth)?;
9684            self.13.encode(encoder, offset + 208, depth)?;
9685            self.14.encode(encoder, offset + 224, depth)?;
9686            self.15.encode(encoder, offset + 240, depth)?;
9687            self.16.encode(encoder, offset + 256, depth)?;
9688            self.17.encode(encoder, offset + 272, depth)?;
9689            self.18.encode(encoder, offset + 288, depth)?;
9690            self.19.encode(encoder, offset + 304, depth)?;
9691            self.20.encode(encoder, offset + 320, depth)?;
9692            self.21.encode(encoder, offset + 336, depth)?;
9693            self.22.encode(encoder, offset + 352, depth)?;
9694            self.23.encode(encoder, offset + 368, depth)?;
9695            self.24.encode(encoder, offset + 384, depth)?;
9696            self.25.encode(encoder, offset + 400, depth)?;
9697            Ok(())
9698        }
9699    }
9700
9701    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for VectorsStruct {
9702        #[inline(always)]
9703        fn new_empty() -> Self {
9704            Self {
9705                bools: fidl::new_empty!(fidl::encoding::Vector<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9706                int8s: fidl::new_empty!(fidl::encoding::Vector<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9707                int16s: fidl::new_empty!(fidl::encoding::Vector<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9708                int32s: fidl::new_empty!(fidl::encoding::Vector<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9709                int64s: fidl::new_empty!(fidl::encoding::Vector<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9710                uint8s: fidl::new_empty!(fidl::encoding::Vector<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9711                uint16s: fidl::new_empty!(fidl::encoding::Vector<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9712                uint32s: fidl::new_empty!(fidl::encoding::Vector<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9713                uint64s: fidl::new_empty!(fidl::encoding::Vector<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9714                float32s: fidl::new_empty!(fidl::encoding::Vector<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9715                float64s: fidl::new_empty!(fidl::encoding::Vector<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9716                enums: fidl::new_empty!(fidl::encoding::Vector<DefaultEnum, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9717                bits: fidl::new_empty!(fidl::encoding::Vector<DefaultBits, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9718                handles: fidl::new_empty!(
9719                    fidl::encoding::Vector<
9720                        fidl::encoding::HandleType<
9721                            fidl::NullableHandle,
9722                            { fidl::ObjectType::NONE.into_raw() },
9723                            2147483648,
9724                        >,
9725                        3,
9726                    >,
9727                    fidl::encoding::DefaultFuchsiaResourceDialect
9728                ),
9729                nullable_handles: fidl::new_empty!(
9730                    fidl::encoding::Vector<
9731                        fidl::encoding::Optional<
9732                            fidl::encoding::HandleType<
9733                                fidl::NullableHandle,
9734                                { fidl::ObjectType::NONE.into_raw() },
9735                                2147483648,
9736                            >,
9737                        >,
9738                        3,
9739                    >,
9740                    fidl::encoding::DefaultFuchsiaResourceDialect
9741                ),
9742                strings: fidl::new_empty!(fidl::encoding::Vector<fidl::encoding::UnboundedString, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9743                nullable_strings: fidl::new_empty!(
9744                    fidl::encoding::Vector<
9745                        fidl::encoding::Optional<fidl::encoding::UnboundedString>,
9746                        3,
9747                    >,
9748                    fidl::encoding::DefaultFuchsiaResourceDialect
9749                ),
9750                structs: fidl::new_empty!(fidl::encoding::Vector<ThisIsAStruct, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9751                nullable_structs: fidl::new_empty!(
9752                    fidl::encoding::Vector<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
9753                    fidl::encoding::DefaultFuchsiaResourceDialect
9754                ),
9755                unions: fidl::new_empty!(fidl::encoding::Vector<ThisIsAUnion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9756                nullable_unions: fidl::new_empty!(
9757                    fidl::encoding::Vector<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
9758                    fidl::encoding::DefaultFuchsiaResourceDialect
9759                ),
9760                arrays: fidl::new_empty!(
9761                    fidl::encoding::Vector<fidl::encoding::Array<u32, 3>, 3>,
9762                    fidl::encoding::DefaultFuchsiaResourceDialect
9763                ),
9764                vectors: fidl::new_empty!(
9765                    fidl::encoding::Vector<fidl::encoding::UnboundedVector<u32>, 3>,
9766                    fidl::encoding::DefaultFuchsiaResourceDialect
9767                ),
9768                nullable_vectors: fidl::new_empty!(
9769                    fidl::encoding::Vector<
9770                        fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
9771                        3,
9772                    >,
9773                    fidl::encoding::DefaultFuchsiaResourceDialect
9774                ),
9775                tables: fidl::new_empty!(fidl::encoding::Vector<ThisIsATable, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9776                xunions: fidl::new_empty!(fidl::encoding::Vector<ThisIsAXunion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9777            }
9778        }
9779
9780        #[inline]
9781        unsafe fn decode(
9782            &mut self,
9783            decoder: &mut fidl::encoding::Decoder<
9784                '_,
9785                fidl::encoding::DefaultFuchsiaResourceDialect,
9786            >,
9787            offset: usize,
9788            _depth: fidl::encoding::Depth,
9789        ) -> fidl::Result<()> {
9790            decoder.debug_check_bounds::<Self>(offset);
9791            // Verify that padding bytes are zero.
9792            fidl::decode!(fidl::encoding::Vector<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.bools, decoder, offset + 0, _depth)?;
9793            fidl::decode!(fidl::encoding::Vector<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int8s, decoder, offset + 16, _depth)?;
9794            fidl::decode!(fidl::encoding::Vector<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int16s, decoder, offset + 32, _depth)?;
9795            fidl::decode!(fidl::encoding::Vector<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int32s, decoder, offset + 48, _depth)?;
9796            fidl::decode!(fidl::encoding::Vector<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int64s, decoder, offset + 64, _depth)?;
9797            fidl::decode!(fidl::encoding::Vector<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint8s, decoder, offset + 80, _depth)?;
9798            fidl::decode!(fidl::encoding::Vector<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint16s, decoder, offset + 96, _depth)?;
9799            fidl::decode!(fidl::encoding::Vector<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint32s, decoder, offset + 112, _depth)?;
9800            fidl::decode!(fidl::encoding::Vector<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint64s, decoder, offset + 128, _depth)?;
9801            fidl::decode!(fidl::encoding::Vector<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.float32s, decoder, offset + 144, _depth)?;
9802            fidl::decode!(fidl::encoding::Vector<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.float64s, decoder, offset + 160, _depth)?;
9803            fidl::decode!(fidl::encoding::Vector<DefaultEnum, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.enums, decoder, offset + 176, _depth)?;
9804            fidl::decode!(fidl::encoding::Vector<DefaultBits, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.bits, decoder, offset + 192, _depth)?;
9805            fidl::decode!(
9806                fidl::encoding::Vector<
9807                    fidl::encoding::HandleType<
9808                        fidl::NullableHandle,
9809                        { fidl::ObjectType::NONE.into_raw() },
9810                        2147483648,
9811                    >,
9812                    3,
9813                >,
9814                fidl::encoding::DefaultFuchsiaResourceDialect,
9815                &mut self.handles,
9816                decoder,
9817                offset + 208,
9818                _depth
9819            )?;
9820            fidl::decode!(
9821                fidl::encoding::Vector<
9822                    fidl::encoding::Optional<
9823                        fidl::encoding::HandleType<
9824                            fidl::NullableHandle,
9825                            { fidl::ObjectType::NONE.into_raw() },
9826                            2147483648,
9827                        >,
9828                    >,
9829                    3,
9830                >,
9831                fidl::encoding::DefaultFuchsiaResourceDialect,
9832                &mut self.nullable_handles,
9833                decoder,
9834                offset + 224,
9835                _depth
9836            )?;
9837            fidl::decode!(fidl::encoding::Vector<fidl::encoding::UnboundedString, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.strings, decoder, offset + 240, _depth)?;
9838            fidl::decode!(
9839                fidl::encoding::Vector<
9840                    fidl::encoding::Optional<fidl::encoding::UnboundedString>,
9841                    3,
9842                >,
9843                fidl::encoding::DefaultFuchsiaResourceDialect,
9844                &mut self.nullable_strings,
9845                decoder,
9846                offset + 256,
9847                _depth
9848            )?;
9849            fidl::decode!(fidl::encoding::Vector<ThisIsAStruct, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.structs, decoder, offset + 272, _depth)?;
9850            fidl::decode!(
9851                fidl::encoding::Vector<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
9852                fidl::encoding::DefaultFuchsiaResourceDialect,
9853                &mut self.nullable_structs,
9854                decoder,
9855                offset + 288,
9856                _depth
9857            )?;
9858            fidl::decode!(fidl::encoding::Vector<ThisIsAUnion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.unions, decoder, offset + 304, _depth)?;
9859            fidl::decode!(
9860                fidl::encoding::Vector<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
9861                fidl::encoding::DefaultFuchsiaResourceDialect,
9862                &mut self.nullable_unions,
9863                decoder,
9864                offset + 320,
9865                _depth
9866            )?;
9867            fidl::decode!(
9868                fidl::encoding::Vector<fidl::encoding::Array<u32, 3>, 3>,
9869                fidl::encoding::DefaultFuchsiaResourceDialect,
9870                &mut self.arrays,
9871                decoder,
9872                offset + 336,
9873                _depth
9874            )?;
9875            fidl::decode!(
9876                fidl::encoding::Vector<fidl::encoding::UnboundedVector<u32>, 3>,
9877                fidl::encoding::DefaultFuchsiaResourceDialect,
9878                &mut self.vectors,
9879                decoder,
9880                offset + 352,
9881                _depth
9882            )?;
9883            fidl::decode!(
9884                fidl::encoding::Vector<
9885                    fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
9886                    3,
9887                >,
9888                fidl::encoding::DefaultFuchsiaResourceDialect,
9889                &mut self.nullable_vectors,
9890                decoder,
9891                offset + 368,
9892                _depth
9893            )?;
9894            fidl::decode!(fidl::encoding::Vector<ThisIsATable, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.tables, decoder, offset + 384, _depth)?;
9895            fidl::decode!(fidl::encoding::Vector<ThisIsAXunion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.xunions, decoder, offset + 400, _depth)?;
9896            Ok(())
9897        }
9898    }
9899
9900    impl fidl::encoding::ResourceTypeMarker for Arrays {
9901        type Borrowed<'a> = &'a mut Self;
9902        fn take_or_borrow<'a>(
9903            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
9904        ) -> Self::Borrowed<'a> {
9905            value
9906        }
9907    }
9908
9909    unsafe impl fidl::encoding::TypeMarker for Arrays {
9910        type Owned = Self;
9911
9912        #[inline(always)]
9913        fn inline_align(_context: fidl::encoding::Context) -> usize {
9914            8
9915        }
9916
9917        #[inline(always)]
9918        fn inline_size(_context: fidl::encoding::Context) -> usize {
9919            208
9920        }
9921    }
9922
9923    unsafe impl fidl::encoding::Encode<Arrays, fidl::encoding::DefaultFuchsiaResourceDialect>
9924        for &mut Arrays
9925    {
9926        #[inline]
9927        unsafe fn encode(
9928            self,
9929            encoder: &mut fidl::encoding::Encoder<
9930                '_,
9931                fidl::encoding::DefaultFuchsiaResourceDialect,
9932            >,
9933            offset: usize,
9934            _depth: fidl::encoding::Depth,
9935        ) -> fidl::Result<()> {
9936            encoder.debug_check_bounds::<Arrays>(offset);
9937            // Delegate to tuple encoding.
9938            fidl::encoding::Encode::<Arrays, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
9939                (
9940                    <fidl::encoding::Array<bool, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9941                        &self.b_0,
9942                    ),
9943                    <fidl::encoding::Array<i8, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9944                        &self.i8_0,
9945                    ),
9946                    <fidl::encoding::Array<i16, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9947                        &self.i16_0,
9948                    ),
9949                    <fidl::encoding::Array<i32, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9950                        &self.i32_0,
9951                    ),
9952                    <fidl::encoding::Array<i64, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9953                        &self.i64_0,
9954                    ),
9955                    <fidl::encoding::Array<u8, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9956                        &self.u8_0,
9957                    ),
9958                    <fidl::encoding::Array<u16, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9959                        &self.u16_0,
9960                    ),
9961                    <fidl::encoding::Array<u32, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9962                        &self.u32_0,
9963                    ),
9964                    <fidl::encoding::Array<u64, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9965                        &self.u64_0,
9966                    ),
9967                    <fidl::encoding::Array<f32, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9968                        &self.f32_0,
9969                    ),
9970                    <fidl::encoding::Array<f64, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9971                        &self.f64_0,
9972                    ),
9973                    <fidl::encoding::Array<
9974                        fidl::encoding::HandleType<
9975                            fidl::NullableHandle,
9976                            { fidl::ObjectType::NONE.into_raw() },
9977                            2147483648,
9978                        >,
9979                        1,
9980                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
9981                        &mut self.handle_0
9982                    ),
9983                    <fidl::encoding::Array<bool, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9984                        &self.b_1,
9985                    ),
9986                    <fidl::encoding::Array<i8, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9987                        &self.i8_1,
9988                    ),
9989                    <fidl::encoding::Array<i16, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9990                        &self.i16_1,
9991                    ),
9992                    <fidl::encoding::Array<i32, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9993                        &self.i32_1,
9994                    ),
9995                    <fidl::encoding::Array<i64, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9996                        &self.i64_1,
9997                    ),
9998                    <fidl::encoding::Array<u8, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9999                        &self.u8_1,
10000                    ),
10001                    <fidl::encoding::Array<u16, 3> as fidl::encoding::ValueTypeMarker>::borrow(
10002                        &self.u16_1,
10003                    ),
10004                    <fidl::encoding::Array<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow(
10005                        &self.u32_1,
10006                    ),
10007                    <fidl::encoding::Array<u64, 3> as fidl::encoding::ValueTypeMarker>::borrow(
10008                        &self.u64_1,
10009                    ),
10010                    <fidl::encoding::Array<f32, 3> as fidl::encoding::ValueTypeMarker>::borrow(
10011                        &self.f32_1,
10012                    ),
10013                    <fidl::encoding::Array<f64, 3> as fidl::encoding::ValueTypeMarker>::borrow(
10014                        &self.f64_1,
10015                    ),
10016                    <fidl::encoding::Array<
10017                        fidl::encoding::HandleType<
10018                            fidl::NullableHandle,
10019                            { fidl::ObjectType::NONE.into_raw() },
10020                            2147483648,
10021                        >,
10022                        3,
10023                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10024                        &mut self.handle_1
10025                    ),
10026                ),
10027                encoder,
10028                offset,
10029                _depth,
10030            )
10031        }
10032    }
10033    unsafe impl<
10034        T0: fidl::encoding::Encode<
10035                fidl::encoding::Array<bool, 1>,
10036                fidl::encoding::DefaultFuchsiaResourceDialect,
10037            >,
10038        T1: fidl::encoding::Encode<
10039                fidl::encoding::Array<i8, 1>,
10040                fidl::encoding::DefaultFuchsiaResourceDialect,
10041            >,
10042        T2: fidl::encoding::Encode<
10043                fidl::encoding::Array<i16, 1>,
10044                fidl::encoding::DefaultFuchsiaResourceDialect,
10045            >,
10046        T3: fidl::encoding::Encode<
10047                fidl::encoding::Array<i32, 1>,
10048                fidl::encoding::DefaultFuchsiaResourceDialect,
10049            >,
10050        T4: fidl::encoding::Encode<
10051                fidl::encoding::Array<i64, 1>,
10052                fidl::encoding::DefaultFuchsiaResourceDialect,
10053            >,
10054        T5: fidl::encoding::Encode<
10055                fidl::encoding::Array<u8, 1>,
10056                fidl::encoding::DefaultFuchsiaResourceDialect,
10057            >,
10058        T6: fidl::encoding::Encode<
10059                fidl::encoding::Array<u16, 1>,
10060                fidl::encoding::DefaultFuchsiaResourceDialect,
10061            >,
10062        T7: fidl::encoding::Encode<
10063                fidl::encoding::Array<u32, 1>,
10064                fidl::encoding::DefaultFuchsiaResourceDialect,
10065            >,
10066        T8: fidl::encoding::Encode<
10067                fidl::encoding::Array<u64, 1>,
10068                fidl::encoding::DefaultFuchsiaResourceDialect,
10069            >,
10070        T9: fidl::encoding::Encode<
10071                fidl::encoding::Array<f32, 1>,
10072                fidl::encoding::DefaultFuchsiaResourceDialect,
10073            >,
10074        T10: fidl::encoding::Encode<
10075                fidl::encoding::Array<f64, 1>,
10076                fidl::encoding::DefaultFuchsiaResourceDialect,
10077            >,
10078        T11: fidl::encoding::Encode<
10079                fidl::encoding::Array<
10080                    fidl::encoding::HandleType<
10081                        fidl::NullableHandle,
10082                        { fidl::ObjectType::NONE.into_raw() },
10083                        2147483648,
10084                    >,
10085                    1,
10086                >,
10087                fidl::encoding::DefaultFuchsiaResourceDialect,
10088            >,
10089        T12: fidl::encoding::Encode<
10090                fidl::encoding::Array<bool, 3>,
10091                fidl::encoding::DefaultFuchsiaResourceDialect,
10092            >,
10093        T13: fidl::encoding::Encode<
10094                fidl::encoding::Array<i8, 3>,
10095                fidl::encoding::DefaultFuchsiaResourceDialect,
10096            >,
10097        T14: fidl::encoding::Encode<
10098                fidl::encoding::Array<i16, 3>,
10099                fidl::encoding::DefaultFuchsiaResourceDialect,
10100            >,
10101        T15: fidl::encoding::Encode<
10102                fidl::encoding::Array<i32, 3>,
10103                fidl::encoding::DefaultFuchsiaResourceDialect,
10104            >,
10105        T16: fidl::encoding::Encode<
10106                fidl::encoding::Array<i64, 3>,
10107                fidl::encoding::DefaultFuchsiaResourceDialect,
10108            >,
10109        T17: fidl::encoding::Encode<
10110                fidl::encoding::Array<u8, 3>,
10111                fidl::encoding::DefaultFuchsiaResourceDialect,
10112            >,
10113        T18: fidl::encoding::Encode<
10114                fidl::encoding::Array<u16, 3>,
10115                fidl::encoding::DefaultFuchsiaResourceDialect,
10116            >,
10117        T19: fidl::encoding::Encode<
10118                fidl::encoding::Array<u32, 3>,
10119                fidl::encoding::DefaultFuchsiaResourceDialect,
10120            >,
10121        T20: fidl::encoding::Encode<
10122                fidl::encoding::Array<u64, 3>,
10123                fidl::encoding::DefaultFuchsiaResourceDialect,
10124            >,
10125        T21: fidl::encoding::Encode<
10126                fidl::encoding::Array<f32, 3>,
10127                fidl::encoding::DefaultFuchsiaResourceDialect,
10128            >,
10129        T22: fidl::encoding::Encode<
10130                fidl::encoding::Array<f64, 3>,
10131                fidl::encoding::DefaultFuchsiaResourceDialect,
10132            >,
10133        T23: fidl::encoding::Encode<
10134                fidl::encoding::Array<
10135                    fidl::encoding::HandleType<
10136                        fidl::NullableHandle,
10137                        { fidl::ObjectType::NONE.into_raw() },
10138                        2147483648,
10139                    >,
10140                    3,
10141                >,
10142                fidl::encoding::DefaultFuchsiaResourceDialect,
10143            >,
10144    > fidl::encoding::Encode<Arrays, fidl::encoding::DefaultFuchsiaResourceDialect>
10145        for (
10146            T0,
10147            T1,
10148            T2,
10149            T3,
10150            T4,
10151            T5,
10152            T6,
10153            T7,
10154            T8,
10155            T9,
10156            T10,
10157            T11,
10158            T12,
10159            T13,
10160            T14,
10161            T15,
10162            T16,
10163            T17,
10164            T18,
10165            T19,
10166            T20,
10167            T21,
10168            T22,
10169            T23,
10170        )
10171    {
10172        #[inline]
10173        unsafe fn encode(
10174            self,
10175            encoder: &mut fidl::encoding::Encoder<
10176                '_,
10177                fidl::encoding::DefaultFuchsiaResourceDialect,
10178            >,
10179            offset: usize,
10180            depth: fidl::encoding::Depth,
10181        ) -> fidl::Result<()> {
10182            encoder.debug_check_bounds::<Arrays>(offset);
10183            // Zero out padding regions. There's no need to apply masks
10184            // because the unmasked parts will be overwritten by fields.
10185            unsafe {
10186                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
10187                (ptr as *mut u64).write_unaligned(0);
10188            }
10189            unsafe {
10190                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
10191                (ptr as *mut u64).write_unaligned(0);
10192            }
10193            unsafe {
10194                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(72);
10195                (ptr as *mut u64).write_unaligned(0);
10196            }
10197            unsafe {
10198                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(104);
10199                (ptr as *mut u64).write_unaligned(0);
10200            }
10201            unsafe {
10202                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(112);
10203                (ptr as *mut u64).write_unaligned(0);
10204            }
10205            unsafe {
10206                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(160);
10207                (ptr as *mut u64).write_unaligned(0);
10208            }
10209            unsafe {
10210                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(200);
10211                (ptr as *mut u64).write_unaligned(0);
10212            }
10213            // Write the fields.
10214            self.0.encode(encoder, offset + 0, depth)?;
10215            self.1.encode(encoder, offset + 1, depth)?;
10216            self.2.encode(encoder, offset + 2, depth)?;
10217            self.3.encode(encoder, offset + 4, depth)?;
10218            self.4.encode(encoder, offset + 8, depth)?;
10219            self.5.encode(encoder, offset + 16, depth)?;
10220            self.6.encode(encoder, offset + 18, depth)?;
10221            self.7.encode(encoder, offset + 20, depth)?;
10222            self.8.encode(encoder, offset + 24, depth)?;
10223            self.9.encode(encoder, offset + 32, depth)?;
10224            self.10.encode(encoder, offset + 40, depth)?;
10225            self.11.encode(encoder, offset + 48, depth)?;
10226            self.12.encode(encoder, offset + 52, depth)?;
10227            self.13.encode(encoder, offset + 55, depth)?;
10228            self.14.encode(encoder, offset + 58, depth)?;
10229            self.15.encode(encoder, offset + 64, depth)?;
10230            self.16.encode(encoder, offset + 80, depth)?;
10231            self.17.encode(encoder, offset + 104, depth)?;
10232            self.18.encode(encoder, offset + 108, depth)?;
10233            self.19.encode(encoder, offset + 116, depth)?;
10234            self.20.encode(encoder, offset + 128, depth)?;
10235            self.21.encode(encoder, offset + 152, depth)?;
10236            self.22.encode(encoder, offset + 168, depth)?;
10237            self.23.encode(encoder, offset + 192, depth)?;
10238            Ok(())
10239        }
10240    }
10241
10242    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Arrays {
10243        #[inline(always)]
10244        fn new_empty() -> Self {
10245            Self {
10246                b_0: fidl::new_empty!(fidl::encoding::Array<bool, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10247                i8_0: fidl::new_empty!(fidl::encoding::Array<i8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10248                i16_0: fidl::new_empty!(fidl::encoding::Array<i16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10249                i32_0: fidl::new_empty!(fidl::encoding::Array<i32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10250                i64_0: fidl::new_empty!(fidl::encoding::Array<i64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10251                u8_0: fidl::new_empty!(fidl::encoding::Array<u8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10252                u16_0: fidl::new_empty!(fidl::encoding::Array<u16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10253                u32_0: fidl::new_empty!(fidl::encoding::Array<u32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10254                u64_0: fidl::new_empty!(fidl::encoding::Array<u64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10255                f32_0: fidl::new_empty!(fidl::encoding::Array<f32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10256                f64_0: fidl::new_empty!(fidl::encoding::Array<f64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10257                handle_0: fidl::new_empty!(
10258                    fidl::encoding::Array<
10259                        fidl::encoding::HandleType<
10260                            fidl::NullableHandle,
10261                            { fidl::ObjectType::NONE.into_raw() },
10262                            2147483648,
10263                        >,
10264                        1,
10265                    >,
10266                    fidl::encoding::DefaultFuchsiaResourceDialect
10267                ),
10268                b_1: fidl::new_empty!(fidl::encoding::Array<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10269                i8_1: fidl::new_empty!(fidl::encoding::Array<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10270                i16_1: fidl::new_empty!(fidl::encoding::Array<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10271                i32_1: fidl::new_empty!(fidl::encoding::Array<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10272                i64_1: fidl::new_empty!(fidl::encoding::Array<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10273                u8_1: fidl::new_empty!(fidl::encoding::Array<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10274                u16_1: fidl::new_empty!(fidl::encoding::Array<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10275                u32_1: fidl::new_empty!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10276                u64_1: fidl::new_empty!(fidl::encoding::Array<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10277                f32_1: fidl::new_empty!(fidl::encoding::Array<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10278                f64_1: fidl::new_empty!(fidl::encoding::Array<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10279                handle_1: fidl::new_empty!(
10280                    fidl::encoding::Array<
10281                        fidl::encoding::HandleType<
10282                            fidl::NullableHandle,
10283                            { fidl::ObjectType::NONE.into_raw() },
10284                            2147483648,
10285                        >,
10286                        3,
10287                    >,
10288                    fidl::encoding::DefaultFuchsiaResourceDialect
10289                ),
10290            }
10291        }
10292
10293        #[inline]
10294        unsafe fn decode(
10295            &mut self,
10296            decoder: &mut fidl::encoding::Decoder<
10297                '_,
10298                fidl::encoding::DefaultFuchsiaResourceDialect,
10299            >,
10300            offset: usize,
10301            _depth: fidl::encoding::Depth,
10302        ) -> fidl::Result<()> {
10303            decoder.debug_check_bounds::<Self>(offset);
10304            // Verify that padding bytes are zero.
10305            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
10306            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10307            let mask = 0xff00u64;
10308            let maskedval = padval & mask;
10309            if maskedval != 0 {
10310                return Err(fidl::Error::NonZeroPadding {
10311                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
10312                });
10313            }
10314            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
10315            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10316            let mask = 0xffffffff00000000u64;
10317            let maskedval = padval & mask;
10318            if maskedval != 0 {
10319                return Err(fidl::Error::NonZeroPadding {
10320                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
10321                });
10322            }
10323            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(72) };
10324            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10325            let mask = 0xffffffff00000000u64;
10326            let maskedval = padval & mask;
10327            if maskedval != 0 {
10328                return Err(fidl::Error::NonZeroPadding {
10329                    padding_start: offset + 72 + ((mask as u64).trailing_zeros() / 8) as usize,
10330                });
10331            }
10332            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(104) };
10333            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10334            let mask = 0xff000000u64;
10335            let maskedval = padval & mask;
10336            if maskedval != 0 {
10337                return Err(fidl::Error::NonZeroPadding {
10338                    padding_start: offset + 104 + ((mask as u64).trailing_zeros() / 8) as usize,
10339                });
10340            }
10341            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(112) };
10342            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10343            let mask = 0xffff0000u64;
10344            let maskedval = padval & mask;
10345            if maskedval != 0 {
10346                return Err(fidl::Error::NonZeroPadding {
10347                    padding_start: offset + 112 + ((mask as u64).trailing_zeros() / 8) as usize,
10348                });
10349            }
10350            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(160) };
10351            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10352            let mask = 0xffffffff00000000u64;
10353            let maskedval = padval & mask;
10354            if maskedval != 0 {
10355                return Err(fidl::Error::NonZeroPadding {
10356                    padding_start: offset + 160 + ((mask as u64).trailing_zeros() / 8) as usize,
10357                });
10358            }
10359            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(200) };
10360            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10361            let mask = 0xffffffff00000000u64;
10362            let maskedval = padval & mask;
10363            if maskedval != 0 {
10364                return Err(fidl::Error::NonZeroPadding {
10365                    padding_start: offset + 200 + ((mask as u64).trailing_zeros() / 8) as usize,
10366                });
10367            }
10368            fidl::decode!(fidl::encoding::Array<bool, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.b_0, decoder, offset + 0, _depth)?;
10369            fidl::decode!(fidl::encoding::Array<i8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i8_0, decoder, offset + 1, _depth)?;
10370            fidl::decode!(fidl::encoding::Array<i16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i16_0, decoder, offset + 2, _depth)?;
10371            fidl::decode!(fidl::encoding::Array<i32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i32_0, decoder, offset + 4, _depth)?;
10372            fidl::decode!(fidl::encoding::Array<i64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i64_0, decoder, offset + 8, _depth)?;
10373            fidl::decode!(fidl::encoding::Array<u8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u8_0, decoder, offset + 16, _depth)?;
10374            fidl::decode!(fidl::encoding::Array<u16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u16_0, decoder, offset + 18, _depth)?;
10375            fidl::decode!(fidl::encoding::Array<u32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u32_0, decoder, offset + 20, _depth)?;
10376            fidl::decode!(fidl::encoding::Array<u64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u64_0, decoder, offset + 24, _depth)?;
10377            fidl::decode!(fidl::encoding::Array<f32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f32_0, decoder, offset + 32, _depth)?;
10378            fidl::decode!(fidl::encoding::Array<f64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f64_0, decoder, offset + 40, _depth)?;
10379            fidl::decode!(
10380                fidl::encoding::Array<
10381                    fidl::encoding::HandleType<
10382                        fidl::NullableHandle,
10383                        { fidl::ObjectType::NONE.into_raw() },
10384                        2147483648,
10385                    >,
10386                    1,
10387                >,
10388                fidl::encoding::DefaultFuchsiaResourceDialect,
10389                &mut self.handle_0,
10390                decoder,
10391                offset + 48,
10392                _depth
10393            )?;
10394            fidl::decode!(fidl::encoding::Array<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.b_1, decoder, offset + 52, _depth)?;
10395            fidl::decode!(fidl::encoding::Array<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i8_1, decoder, offset + 55, _depth)?;
10396            fidl::decode!(fidl::encoding::Array<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i16_1, decoder, offset + 58, _depth)?;
10397            fidl::decode!(fidl::encoding::Array<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i32_1, decoder, offset + 64, _depth)?;
10398            fidl::decode!(fidl::encoding::Array<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i64_1, decoder, offset + 80, _depth)?;
10399            fidl::decode!(fidl::encoding::Array<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u8_1, decoder, offset + 104, _depth)?;
10400            fidl::decode!(fidl::encoding::Array<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u16_1, decoder, offset + 108, _depth)?;
10401            fidl::decode!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u32_1, decoder, offset + 116, _depth)?;
10402            fidl::decode!(fidl::encoding::Array<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u64_1, decoder, offset + 128, _depth)?;
10403            fidl::decode!(fidl::encoding::Array<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f32_1, decoder, offset + 152, _depth)?;
10404            fidl::decode!(fidl::encoding::Array<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f64_1, decoder, offset + 168, _depth)?;
10405            fidl::decode!(
10406                fidl::encoding::Array<
10407                    fidl::encoding::HandleType<
10408                        fidl::NullableHandle,
10409                        { fidl::ObjectType::NONE.into_raw() },
10410                        2147483648,
10411                    >,
10412                    3,
10413                >,
10414                fidl::encoding::DefaultFuchsiaResourceDialect,
10415                &mut self.handle_1,
10416                decoder,
10417                offset + 192,
10418                _depth
10419            )?;
10420            Ok(())
10421        }
10422    }
10423
10424    impl fidl::encoding::ResourceTypeMarker for Arrays2d {
10425        type Borrowed<'a> = &'a mut Self;
10426        fn take_or_borrow<'a>(
10427            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
10428        ) -> Self::Borrowed<'a> {
10429            value
10430        }
10431    }
10432
10433    unsafe impl fidl::encoding::TypeMarker for Arrays2d {
10434        type Owned = Self;
10435
10436        #[inline(always)]
10437        fn inline_align(_context: fidl::encoding::Context) -> usize {
10438            8
10439        }
10440
10441        #[inline(always)]
10442        fn inline_size(_context: fidl::encoding::Context) -> usize {
10443            288
10444        }
10445    }
10446
10447    unsafe impl fidl::encoding::Encode<Arrays2d, fidl::encoding::DefaultFuchsiaResourceDialect>
10448        for &mut Arrays2d
10449    {
10450        #[inline]
10451        unsafe fn encode(
10452            self,
10453            encoder: &mut fidl::encoding::Encoder<
10454                '_,
10455                fidl::encoding::DefaultFuchsiaResourceDialect,
10456            >,
10457            offset: usize,
10458            _depth: fidl::encoding::Depth,
10459        ) -> fidl::Result<()> {
10460            encoder.debug_check_bounds::<Arrays2d>(offset);
10461            // Delegate to tuple encoding.
10462            fidl::encoding::Encode::<Arrays2d, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
10463                (
10464                    <fidl::encoding::Array<fidl::encoding::Array<bool, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.b),
10465                    <fidl::encoding::Array<fidl::encoding::Array<i8, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8),
10466                    <fidl::encoding::Array<fidl::encoding::Array<i16, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16),
10467                    <fidl::encoding::Array<fidl::encoding::Array<i32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32),
10468                    <fidl::encoding::Array<fidl::encoding::Array<i64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64),
10469                    <fidl::encoding::Array<fidl::encoding::Array<u8, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8),
10470                    <fidl::encoding::Array<fidl::encoding::Array<u16, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16),
10471                    <fidl::encoding::Array<fidl::encoding::Array<u32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32),
10472                    <fidl::encoding::Array<fidl::encoding::Array<u64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64),
10473                    <fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32),
10474                    <fidl::encoding::Array<fidl::encoding::Array<f64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64),
10475                    <fidl::encoding::Array<fidl::encoding::Array<fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 2>, 3> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_handle),
10476                ),
10477                encoder, offset, _depth
10478            )
10479        }
10480    }
10481    unsafe impl<
10482        T0: fidl::encoding::Encode<
10483                fidl::encoding::Array<fidl::encoding::Array<bool, 2>, 3>,
10484                fidl::encoding::DefaultFuchsiaResourceDialect,
10485            >,
10486        T1: fidl::encoding::Encode<
10487                fidl::encoding::Array<fidl::encoding::Array<i8, 2>, 3>,
10488                fidl::encoding::DefaultFuchsiaResourceDialect,
10489            >,
10490        T2: fidl::encoding::Encode<
10491                fidl::encoding::Array<fidl::encoding::Array<i16, 2>, 3>,
10492                fidl::encoding::DefaultFuchsiaResourceDialect,
10493            >,
10494        T3: fidl::encoding::Encode<
10495                fidl::encoding::Array<fidl::encoding::Array<i32, 2>, 3>,
10496                fidl::encoding::DefaultFuchsiaResourceDialect,
10497            >,
10498        T4: fidl::encoding::Encode<
10499                fidl::encoding::Array<fidl::encoding::Array<i64, 2>, 3>,
10500                fidl::encoding::DefaultFuchsiaResourceDialect,
10501            >,
10502        T5: fidl::encoding::Encode<
10503                fidl::encoding::Array<fidl::encoding::Array<u8, 2>, 3>,
10504                fidl::encoding::DefaultFuchsiaResourceDialect,
10505            >,
10506        T6: fidl::encoding::Encode<
10507                fidl::encoding::Array<fidl::encoding::Array<u16, 2>, 3>,
10508                fidl::encoding::DefaultFuchsiaResourceDialect,
10509            >,
10510        T7: fidl::encoding::Encode<
10511                fidl::encoding::Array<fidl::encoding::Array<u32, 2>, 3>,
10512                fidl::encoding::DefaultFuchsiaResourceDialect,
10513            >,
10514        T8: fidl::encoding::Encode<
10515                fidl::encoding::Array<fidl::encoding::Array<u64, 2>, 3>,
10516                fidl::encoding::DefaultFuchsiaResourceDialect,
10517            >,
10518        T9: fidl::encoding::Encode<
10519                fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 3>,
10520                fidl::encoding::DefaultFuchsiaResourceDialect,
10521            >,
10522        T10: fidl::encoding::Encode<
10523                fidl::encoding::Array<fidl::encoding::Array<f64, 2>, 3>,
10524                fidl::encoding::DefaultFuchsiaResourceDialect,
10525            >,
10526        T11: fidl::encoding::Encode<
10527                fidl::encoding::Array<
10528                    fidl::encoding::Array<
10529                        fidl::encoding::HandleType<
10530                            fidl::NullableHandle,
10531                            { fidl::ObjectType::NONE.into_raw() },
10532                            2147483648,
10533                        >,
10534                        2,
10535                    >,
10536                    3,
10537                >,
10538                fidl::encoding::DefaultFuchsiaResourceDialect,
10539            >,
10540    > fidl::encoding::Encode<Arrays2d, fidl::encoding::DefaultFuchsiaResourceDialect>
10541        for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
10542    {
10543        #[inline]
10544        unsafe fn encode(
10545            self,
10546            encoder: &mut fidl::encoding::Encoder<
10547                '_,
10548                fidl::encoding::DefaultFuchsiaResourceDialect,
10549            >,
10550            offset: usize,
10551            depth: fidl::encoding::Depth,
10552        ) -> fidl::Result<()> {
10553            encoder.debug_check_bounds::<Arrays2d>(offset);
10554            // Zero out padding regions. There's no need to apply masks
10555            // because the unmasked parts will be overwritten by fields.
10556            unsafe {
10557                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(112);
10558                (ptr as *mut u64).write_unaligned(0);
10559            }
10560            unsafe {
10561                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(136);
10562                (ptr as *mut u64).write_unaligned(0);
10563            }
10564            // Write the fields.
10565            self.0.encode(encoder, offset + 0, depth)?;
10566            self.1.encode(encoder, offset + 6, depth)?;
10567            self.2.encode(encoder, offset + 12, depth)?;
10568            self.3.encode(encoder, offset + 24, depth)?;
10569            self.4.encode(encoder, offset + 48, depth)?;
10570            self.5.encode(encoder, offset + 96, depth)?;
10571            self.6.encode(encoder, offset + 102, depth)?;
10572            self.7.encode(encoder, offset + 116, depth)?;
10573            self.8.encode(encoder, offset + 144, depth)?;
10574            self.9.encode(encoder, offset + 192, depth)?;
10575            self.10.encode(encoder, offset + 216, depth)?;
10576            self.11.encode(encoder, offset + 264, depth)?;
10577            Ok(())
10578        }
10579    }
10580
10581    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Arrays2d {
10582        #[inline(always)]
10583        fn new_empty() -> Self {
10584            Self {
10585                b: fidl::new_empty!(
10586                    fidl::encoding::Array<fidl::encoding::Array<bool, 2>, 3>,
10587                    fidl::encoding::DefaultFuchsiaResourceDialect
10588                ),
10589                i8: fidl::new_empty!(
10590                    fidl::encoding::Array<fidl::encoding::Array<i8, 2>, 3>,
10591                    fidl::encoding::DefaultFuchsiaResourceDialect
10592                ),
10593                i16: fidl::new_empty!(
10594                    fidl::encoding::Array<fidl::encoding::Array<i16, 2>, 3>,
10595                    fidl::encoding::DefaultFuchsiaResourceDialect
10596                ),
10597                i32: fidl::new_empty!(
10598                    fidl::encoding::Array<fidl::encoding::Array<i32, 2>, 3>,
10599                    fidl::encoding::DefaultFuchsiaResourceDialect
10600                ),
10601                i64: fidl::new_empty!(
10602                    fidl::encoding::Array<fidl::encoding::Array<i64, 2>, 3>,
10603                    fidl::encoding::DefaultFuchsiaResourceDialect
10604                ),
10605                u8: fidl::new_empty!(
10606                    fidl::encoding::Array<fidl::encoding::Array<u8, 2>, 3>,
10607                    fidl::encoding::DefaultFuchsiaResourceDialect
10608                ),
10609                u16: fidl::new_empty!(
10610                    fidl::encoding::Array<fidl::encoding::Array<u16, 2>, 3>,
10611                    fidl::encoding::DefaultFuchsiaResourceDialect
10612                ),
10613                u32: fidl::new_empty!(
10614                    fidl::encoding::Array<fidl::encoding::Array<u32, 2>, 3>,
10615                    fidl::encoding::DefaultFuchsiaResourceDialect
10616                ),
10617                u64: fidl::new_empty!(
10618                    fidl::encoding::Array<fidl::encoding::Array<u64, 2>, 3>,
10619                    fidl::encoding::DefaultFuchsiaResourceDialect
10620                ),
10621                f32: fidl::new_empty!(
10622                    fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 3>,
10623                    fidl::encoding::DefaultFuchsiaResourceDialect
10624                ),
10625                f64: fidl::new_empty!(
10626                    fidl::encoding::Array<fidl::encoding::Array<f64, 2>, 3>,
10627                    fidl::encoding::DefaultFuchsiaResourceDialect
10628                ),
10629                handle_handle: fidl::new_empty!(
10630                    fidl::encoding::Array<
10631                        fidl::encoding::Array<
10632                            fidl::encoding::HandleType<
10633                                fidl::NullableHandle,
10634                                { fidl::ObjectType::NONE.into_raw() },
10635                                2147483648,
10636                            >,
10637                            2,
10638                        >,
10639                        3,
10640                    >,
10641                    fidl::encoding::DefaultFuchsiaResourceDialect
10642                ),
10643            }
10644        }
10645
10646        #[inline]
10647        unsafe fn decode(
10648            &mut self,
10649            decoder: &mut fidl::encoding::Decoder<
10650                '_,
10651                fidl::encoding::DefaultFuchsiaResourceDialect,
10652            >,
10653            offset: usize,
10654            _depth: fidl::encoding::Depth,
10655        ) -> fidl::Result<()> {
10656            decoder.debug_check_bounds::<Self>(offset);
10657            // Verify that padding bytes are zero.
10658            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(112) };
10659            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10660            let mask = 0xffff0000u64;
10661            let maskedval = padval & mask;
10662            if maskedval != 0 {
10663                return Err(fidl::Error::NonZeroPadding {
10664                    padding_start: offset + 112 + ((mask as u64).trailing_zeros() / 8) as usize,
10665                });
10666            }
10667            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(136) };
10668            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10669            let mask = 0xffffffff00000000u64;
10670            let maskedval = padval & mask;
10671            if maskedval != 0 {
10672                return Err(fidl::Error::NonZeroPadding {
10673                    padding_start: offset + 136 + ((mask as u64).trailing_zeros() / 8) as usize,
10674                });
10675            }
10676            fidl::decode!(
10677                fidl::encoding::Array<fidl::encoding::Array<bool, 2>, 3>,
10678                fidl::encoding::DefaultFuchsiaResourceDialect,
10679                &mut self.b,
10680                decoder,
10681                offset + 0,
10682                _depth
10683            )?;
10684            fidl::decode!(
10685                fidl::encoding::Array<fidl::encoding::Array<i8, 2>, 3>,
10686                fidl::encoding::DefaultFuchsiaResourceDialect,
10687                &mut self.i8,
10688                decoder,
10689                offset + 6,
10690                _depth
10691            )?;
10692            fidl::decode!(
10693                fidl::encoding::Array<fidl::encoding::Array<i16, 2>, 3>,
10694                fidl::encoding::DefaultFuchsiaResourceDialect,
10695                &mut self.i16,
10696                decoder,
10697                offset + 12,
10698                _depth
10699            )?;
10700            fidl::decode!(
10701                fidl::encoding::Array<fidl::encoding::Array<i32, 2>, 3>,
10702                fidl::encoding::DefaultFuchsiaResourceDialect,
10703                &mut self.i32,
10704                decoder,
10705                offset + 24,
10706                _depth
10707            )?;
10708            fidl::decode!(
10709                fidl::encoding::Array<fidl::encoding::Array<i64, 2>, 3>,
10710                fidl::encoding::DefaultFuchsiaResourceDialect,
10711                &mut self.i64,
10712                decoder,
10713                offset + 48,
10714                _depth
10715            )?;
10716            fidl::decode!(
10717                fidl::encoding::Array<fidl::encoding::Array<u8, 2>, 3>,
10718                fidl::encoding::DefaultFuchsiaResourceDialect,
10719                &mut self.u8,
10720                decoder,
10721                offset + 96,
10722                _depth
10723            )?;
10724            fidl::decode!(
10725                fidl::encoding::Array<fidl::encoding::Array<u16, 2>, 3>,
10726                fidl::encoding::DefaultFuchsiaResourceDialect,
10727                &mut self.u16,
10728                decoder,
10729                offset + 102,
10730                _depth
10731            )?;
10732            fidl::decode!(
10733                fidl::encoding::Array<fidl::encoding::Array<u32, 2>, 3>,
10734                fidl::encoding::DefaultFuchsiaResourceDialect,
10735                &mut self.u32,
10736                decoder,
10737                offset + 116,
10738                _depth
10739            )?;
10740            fidl::decode!(
10741                fidl::encoding::Array<fidl::encoding::Array<u64, 2>, 3>,
10742                fidl::encoding::DefaultFuchsiaResourceDialect,
10743                &mut self.u64,
10744                decoder,
10745                offset + 144,
10746                _depth
10747            )?;
10748            fidl::decode!(
10749                fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 3>,
10750                fidl::encoding::DefaultFuchsiaResourceDialect,
10751                &mut self.f32,
10752                decoder,
10753                offset + 192,
10754                _depth
10755            )?;
10756            fidl::decode!(
10757                fidl::encoding::Array<fidl::encoding::Array<f64, 2>, 3>,
10758                fidl::encoding::DefaultFuchsiaResourceDialect,
10759                &mut self.f64,
10760                decoder,
10761                offset + 216,
10762                _depth
10763            )?;
10764            fidl::decode!(
10765                fidl::encoding::Array<
10766                    fidl::encoding::Array<
10767                        fidl::encoding::HandleType<
10768                            fidl::NullableHandle,
10769                            { fidl::ObjectType::NONE.into_raw() },
10770                            2147483648,
10771                        >,
10772                        2,
10773                    >,
10774                    3,
10775                >,
10776                fidl::encoding::DefaultFuchsiaResourceDialect,
10777                &mut self.handle_handle,
10778                decoder,
10779                offset + 264,
10780                _depth
10781            )?;
10782            Ok(())
10783        }
10784    }
10785
10786    impl fidl::encoding::ResourceTypeMarker for Handles {
10787        type Borrowed<'a> = &'a mut Self;
10788        fn take_or_borrow<'a>(
10789            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
10790        ) -> Self::Borrowed<'a> {
10791            value
10792        }
10793    }
10794
10795    unsafe impl fidl::encoding::TypeMarker for Handles {
10796        type Owned = Self;
10797
10798        #[inline(always)]
10799        fn inline_align(_context: fidl::encoding::Context) -> usize {
10800            4
10801        }
10802
10803        #[inline(always)]
10804        fn inline_size(_context: fidl::encoding::Context) -> usize {
10805            108
10806        }
10807    }
10808
10809    unsafe impl fidl::encoding::Encode<Handles, fidl::encoding::DefaultFuchsiaResourceDialect>
10810        for &mut Handles
10811    {
10812        #[inline]
10813        unsafe fn encode(
10814            self,
10815            encoder: &mut fidl::encoding::Encoder<
10816                '_,
10817                fidl::encoding::DefaultFuchsiaResourceDialect,
10818            >,
10819            offset: usize,
10820            _depth: fidl::encoding::Depth,
10821        ) -> fidl::Result<()> {
10822            encoder.debug_check_bounds::<Handles>(offset);
10823            // Delegate to tuple encoding.
10824            fidl::encoding::Encode::<Handles, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
10825                (
10826                    <fidl::encoding::HandleType<
10827                        fidl::NullableHandle,
10828                        { fidl::ObjectType::NONE.into_raw() },
10829                        2147483648,
10830                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10831                        &mut self.handle_handle,
10832                    ),
10833                    <fidl::encoding::HandleType<
10834                        fidl::Process,
10835                        { fidl::ObjectType::PROCESS.into_raw() },
10836                        2147483648,
10837                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10838                        &mut self.process_handle,
10839                    ),
10840                    <fidl::encoding::HandleType<
10841                        fidl::Thread,
10842                        { fidl::ObjectType::THREAD.into_raw() },
10843                        2147483648,
10844                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10845                        &mut self.thread_handle,
10846                    ),
10847                    <fidl::encoding::HandleType<
10848                        fidl::Vmo,
10849                        { fidl::ObjectType::VMO.into_raw() },
10850                        2147483648,
10851                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10852                        &mut self.vmo_handle
10853                    ),
10854                    <fidl::encoding::HandleType<
10855                        fidl::Event,
10856                        { fidl::ObjectType::EVENT.into_raw() },
10857                        2147483648,
10858                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10859                        &mut self.event_handle,
10860                    ),
10861                    <fidl::encoding::HandleType<
10862                        fidl::Port,
10863                        { fidl::ObjectType::PORT.into_raw() },
10864                        2147483648,
10865                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10866                        &mut self.port_handle
10867                    ),
10868                    <fidl::encoding::HandleType<
10869                        fidl::Socket,
10870                        { fidl::ObjectType::SOCKET.into_raw() },
10871                        2147483648,
10872                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10873                        &mut self.socket_handle,
10874                    ),
10875                    <fidl::encoding::HandleType<
10876                        fidl::EventPair,
10877                        { fidl::ObjectType::EVENTPAIR.into_raw() },
10878                        2147483648,
10879                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10880                        &mut self.eventpair_handle,
10881                    ),
10882                    <fidl::encoding::HandleType<
10883                        fidl::Job,
10884                        { fidl::ObjectType::JOB.into_raw() },
10885                        2147483648,
10886                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10887                        &mut self.job_handle
10888                    ),
10889                    <fidl::encoding::HandleType<
10890                        fidl::Vmar,
10891                        { fidl::ObjectType::VMAR.into_raw() },
10892                        2147483648,
10893                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10894                        &mut self.vmar_handle
10895                    ),
10896                    <fidl::encoding::HandleType<
10897                        fidl::Fifo,
10898                        { fidl::ObjectType::FIFO.into_raw() },
10899                        2147483648,
10900                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10901                        &mut self.fifo_handle
10902                    ),
10903                    <fidl::encoding::HandleType<
10904                        fidl::Timer,
10905                        { fidl::ObjectType::TIMER.into_raw() },
10906                        2147483648,
10907                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10908                        &mut self.timer_handle,
10909                    ),
10910                    <fidl::encoding::Optional<
10911                        fidl::encoding::HandleType<
10912                            fidl::NullableHandle,
10913                            { fidl::ObjectType::NONE.into_raw() },
10914                            2147483648,
10915                        >,
10916                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10917                        &mut self.nullable_handle_handle,
10918                    ),
10919                    <fidl::encoding::Optional<
10920                        fidl::encoding::HandleType<
10921                            fidl::Process,
10922                            { fidl::ObjectType::PROCESS.into_raw() },
10923                            2147483648,
10924                        >,
10925                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10926                        &mut self.nullable_process_handle,
10927                    ),
10928                    <fidl::encoding::Optional<
10929                        fidl::encoding::HandleType<
10930                            fidl::Thread,
10931                            { fidl::ObjectType::THREAD.into_raw() },
10932                            2147483648,
10933                        >,
10934                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10935                        &mut self.nullable_thread_handle,
10936                    ),
10937                    <fidl::encoding::Optional<
10938                        fidl::encoding::HandleType<
10939                            fidl::Vmo,
10940                            { fidl::ObjectType::VMO.into_raw() },
10941                            2147483648,
10942                        >,
10943                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10944                        &mut self.nullable_vmo_handle,
10945                    ),
10946                    <fidl::encoding::Optional<
10947                        fidl::encoding::HandleType<
10948                            fidl::Channel,
10949                            { fidl::ObjectType::CHANNEL.into_raw() },
10950                            2147483648,
10951                        >,
10952                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10953                        &mut self.nullable_channel_handle,
10954                    ),
10955                    <fidl::encoding::Optional<
10956                        fidl::encoding::HandleType<
10957                            fidl::Event,
10958                            { fidl::ObjectType::EVENT.into_raw() },
10959                            2147483648,
10960                        >,
10961                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10962                        &mut self.nullable_event_handle,
10963                    ),
10964                    <fidl::encoding::Optional<
10965                        fidl::encoding::HandleType<
10966                            fidl::Port,
10967                            { fidl::ObjectType::PORT.into_raw() },
10968                            2147483648,
10969                        >,
10970                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10971                        &mut self.nullable_port_handle,
10972                    ),
10973                    <fidl::encoding::Optional<
10974                        fidl::encoding::HandleType<
10975                            fidl::Interrupt,
10976                            { fidl::ObjectType::INTERRUPT.into_raw() },
10977                            2147483648,
10978                        >,
10979                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10980                        &mut self.nullable_interrupt_handle,
10981                    ),
10982                    <fidl::encoding::Optional<
10983                        fidl::encoding::HandleType<
10984                            fidl::DebugLog,
10985                            { fidl::ObjectType::DEBUGLOG.into_raw() },
10986                            2147483648,
10987                        >,
10988                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10989                        &mut self.nullable_log_handle,
10990                    ),
10991                    <fidl::encoding::Optional<
10992                        fidl::encoding::HandleType<
10993                            fidl::Socket,
10994                            { fidl::ObjectType::SOCKET.into_raw() },
10995                            2147483648,
10996                        >,
10997                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10998                        &mut self.nullable_socket_handle,
10999                    ),
11000                    <fidl::encoding::Optional<
11001                        fidl::encoding::HandleType<
11002                            fidl::EventPair,
11003                            { fidl::ObjectType::EVENTPAIR.into_raw() },
11004                            2147483648,
11005                        >,
11006                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
11007                        &mut self.nullable_eventpair_handle,
11008                    ),
11009                    <fidl::encoding::Optional<
11010                        fidl::encoding::HandleType<
11011                            fidl::Job,
11012                            { fidl::ObjectType::JOB.into_raw() },
11013                            2147483648,
11014                        >,
11015                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
11016                        &mut self.nullable_job_handle,
11017                    ),
11018                    <fidl::encoding::Optional<
11019                        fidl::encoding::HandleType<
11020                            fidl::Vmar,
11021                            { fidl::ObjectType::VMAR.into_raw() },
11022                            2147483648,
11023                        >,
11024                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
11025                        &mut self.nullable_vmar_handle,
11026                    ),
11027                    <fidl::encoding::Optional<
11028                        fidl::encoding::HandleType<
11029                            fidl::Fifo,
11030                            { fidl::ObjectType::FIFO.into_raw() },
11031                            2147483648,
11032                        >,
11033                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
11034                        &mut self.nullable_fifo_handle,
11035                    ),
11036                    <fidl::encoding::Optional<
11037                        fidl::encoding::HandleType<
11038                            fidl::Timer,
11039                            { fidl::ObjectType::TIMER.into_raw() },
11040                            2147483648,
11041                        >,
11042                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
11043                        &mut self.nullable_timer_handle,
11044                    ),
11045                ),
11046                encoder,
11047                offset,
11048                _depth,
11049            )
11050        }
11051    }
11052    unsafe impl<
11053        T0: fidl::encoding::Encode<
11054                fidl::encoding::HandleType<
11055                    fidl::NullableHandle,
11056                    { fidl::ObjectType::NONE.into_raw() },
11057                    2147483648,
11058                >,
11059                fidl::encoding::DefaultFuchsiaResourceDialect,
11060            >,
11061        T1: fidl::encoding::Encode<
11062                fidl::encoding::HandleType<
11063                    fidl::Process,
11064                    { fidl::ObjectType::PROCESS.into_raw() },
11065                    2147483648,
11066                >,
11067                fidl::encoding::DefaultFuchsiaResourceDialect,
11068            >,
11069        T2: fidl::encoding::Encode<
11070                fidl::encoding::HandleType<
11071                    fidl::Thread,
11072                    { fidl::ObjectType::THREAD.into_raw() },
11073                    2147483648,
11074                >,
11075                fidl::encoding::DefaultFuchsiaResourceDialect,
11076            >,
11077        T3: fidl::encoding::Encode<
11078                fidl::encoding::HandleType<
11079                    fidl::Vmo,
11080                    { fidl::ObjectType::VMO.into_raw() },
11081                    2147483648,
11082                >,
11083                fidl::encoding::DefaultFuchsiaResourceDialect,
11084            >,
11085        T4: fidl::encoding::Encode<
11086                fidl::encoding::HandleType<
11087                    fidl::Event,
11088                    { fidl::ObjectType::EVENT.into_raw() },
11089                    2147483648,
11090                >,
11091                fidl::encoding::DefaultFuchsiaResourceDialect,
11092            >,
11093        T5: fidl::encoding::Encode<
11094                fidl::encoding::HandleType<
11095                    fidl::Port,
11096                    { fidl::ObjectType::PORT.into_raw() },
11097                    2147483648,
11098                >,
11099                fidl::encoding::DefaultFuchsiaResourceDialect,
11100            >,
11101        T6: fidl::encoding::Encode<
11102                fidl::encoding::HandleType<
11103                    fidl::Socket,
11104                    { fidl::ObjectType::SOCKET.into_raw() },
11105                    2147483648,
11106                >,
11107                fidl::encoding::DefaultFuchsiaResourceDialect,
11108            >,
11109        T7: fidl::encoding::Encode<
11110                fidl::encoding::HandleType<
11111                    fidl::EventPair,
11112                    { fidl::ObjectType::EVENTPAIR.into_raw() },
11113                    2147483648,
11114                >,
11115                fidl::encoding::DefaultFuchsiaResourceDialect,
11116            >,
11117        T8: fidl::encoding::Encode<
11118                fidl::encoding::HandleType<
11119                    fidl::Job,
11120                    { fidl::ObjectType::JOB.into_raw() },
11121                    2147483648,
11122                >,
11123                fidl::encoding::DefaultFuchsiaResourceDialect,
11124            >,
11125        T9: fidl::encoding::Encode<
11126                fidl::encoding::HandleType<
11127                    fidl::Vmar,
11128                    { fidl::ObjectType::VMAR.into_raw() },
11129                    2147483648,
11130                >,
11131                fidl::encoding::DefaultFuchsiaResourceDialect,
11132            >,
11133        T10: fidl::encoding::Encode<
11134                fidl::encoding::HandleType<
11135                    fidl::Fifo,
11136                    { fidl::ObjectType::FIFO.into_raw() },
11137                    2147483648,
11138                >,
11139                fidl::encoding::DefaultFuchsiaResourceDialect,
11140            >,
11141        T11: fidl::encoding::Encode<
11142                fidl::encoding::HandleType<
11143                    fidl::Timer,
11144                    { fidl::ObjectType::TIMER.into_raw() },
11145                    2147483648,
11146                >,
11147                fidl::encoding::DefaultFuchsiaResourceDialect,
11148            >,
11149        T12: fidl::encoding::Encode<
11150                fidl::encoding::Optional<
11151                    fidl::encoding::HandleType<
11152                        fidl::NullableHandle,
11153                        { fidl::ObjectType::NONE.into_raw() },
11154                        2147483648,
11155                    >,
11156                >,
11157                fidl::encoding::DefaultFuchsiaResourceDialect,
11158            >,
11159        T13: fidl::encoding::Encode<
11160                fidl::encoding::Optional<
11161                    fidl::encoding::HandleType<
11162                        fidl::Process,
11163                        { fidl::ObjectType::PROCESS.into_raw() },
11164                        2147483648,
11165                    >,
11166                >,
11167                fidl::encoding::DefaultFuchsiaResourceDialect,
11168            >,
11169        T14: fidl::encoding::Encode<
11170                fidl::encoding::Optional<
11171                    fidl::encoding::HandleType<
11172                        fidl::Thread,
11173                        { fidl::ObjectType::THREAD.into_raw() },
11174                        2147483648,
11175                    >,
11176                >,
11177                fidl::encoding::DefaultFuchsiaResourceDialect,
11178            >,
11179        T15: fidl::encoding::Encode<
11180                fidl::encoding::Optional<
11181                    fidl::encoding::HandleType<
11182                        fidl::Vmo,
11183                        { fidl::ObjectType::VMO.into_raw() },
11184                        2147483648,
11185                    >,
11186                >,
11187                fidl::encoding::DefaultFuchsiaResourceDialect,
11188            >,
11189        T16: fidl::encoding::Encode<
11190                fidl::encoding::Optional<
11191                    fidl::encoding::HandleType<
11192                        fidl::Channel,
11193                        { fidl::ObjectType::CHANNEL.into_raw() },
11194                        2147483648,
11195                    >,
11196                >,
11197                fidl::encoding::DefaultFuchsiaResourceDialect,
11198            >,
11199        T17: fidl::encoding::Encode<
11200                fidl::encoding::Optional<
11201                    fidl::encoding::HandleType<
11202                        fidl::Event,
11203                        { fidl::ObjectType::EVENT.into_raw() },
11204                        2147483648,
11205                    >,
11206                >,
11207                fidl::encoding::DefaultFuchsiaResourceDialect,
11208            >,
11209        T18: fidl::encoding::Encode<
11210                fidl::encoding::Optional<
11211                    fidl::encoding::HandleType<
11212                        fidl::Port,
11213                        { fidl::ObjectType::PORT.into_raw() },
11214                        2147483648,
11215                    >,
11216                >,
11217                fidl::encoding::DefaultFuchsiaResourceDialect,
11218            >,
11219        T19: fidl::encoding::Encode<
11220                fidl::encoding::Optional<
11221                    fidl::encoding::HandleType<
11222                        fidl::Interrupt,
11223                        { fidl::ObjectType::INTERRUPT.into_raw() },
11224                        2147483648,
11225                    >,
11226                >,
11227                fidl::encoding::DefaultFuchsiaResourceDialect,
11228            >,
11229        T20: fidl::encoding::Encode<
11230                fidl::encoding::Optional<
11231                    fidl::encoding::HandleType<
11232                        fidl::DebugLog,
11233                        { fidl::ObjectType::DEBUGLOG.into_raw() },
11234                        2147483648,
11235                    >,
11236                >,
11237                fidl::encoding::DefaultFuchsiaResourceDialect,
11238            >,
11239        T21: fidl::encoding::Encode<
11240                fidl::encoding::Optional<
11241                    fidl::encoding::HandleType<
11242                        fidl::Socket,
11243                        { fidl::ObjectType::SOCKET.into_raw() },
11244                        2147483648,
11245                    >,
11246                >,
11247                fidl::encoding::DefaultFuchsiaResourceDialect,
11248            >,
11249        T22: fidl::encoding::Encode<
11250                fidl::encoding::Optional<
11251                    fidl::encoding::HandleType<
11252                        fidl::EventPair,
11253                        { fidl::ObjectType::EVENTPAIR.into_raw() },
11254                        2147483648,
11255                    >,
11256                >,
11257                fidl::encoding::DefaultFuchsiaResourceDialect,
11258            >,
11259        T23: fidl::encoding::Encode<
11260                fidl::encoding::Optional<
11261                    fidl::encoding::HandleType<
11262                        fidl::Job,
11263                        { fidl::ObjectType::JOB.into_raw() },
11264                        2147483648,
11265                    >,
11266                >,
11267                fidl::encoding::DefaultFuchsiaResourceDialect,
11268            >,
11269        T24: fidl::encoding::Encode<
11270                fidl::encoding::Optional<
11271                    fidl::encoding::HandleType<
11272                        fidl::Vmar,
11273                        { fidl::ObjectType::VMAR.into_raw() },
11274                        2147483648,
11275                    >,
11276                >,
11277                fidl::encoding::DefaultFuchsiaResourceDialect,
11278            >,
11279        T25: fidl::encoding::Encode<
11280                fidl::encoding::Optional<
11281                    fidl::encoding::HandleType<
11282                        fidl::Fifo,
11283                        { fidl::ObjectType::FIFO.into_raw() },
11284                        2147483648,
11285                    >,
11286                >,
11287                fidl::encoding::DefaultFuchsiaResourceDialect,
11288            >,
11289        T26: fidl::encoding::Encode<
11290                fidl::encoding::Optional<
11291                    fidl::encoding::HandleType<
11292                        fidl::Timer,
11293                        { fidl::ObjectType::TIMER.into_raw() },
11294                        2147483648,
11295                    >,
11296                >,
11297                fidl::encoding::DefaultFuchsiaResourceDialect,
11298            >,
11299    > fidl::encoding::Encode<Handles, fidl::encoding::DefaultFuchsiaResourceDialect>
11300        for (
11301            T0,
11302            T1,
11303            T2,
11304            T3,
11305            T4,
11306            T5,
11307            T6,
11308            T7,
11309            T8,
11310            T9,
11311            T10,
11312            T11,
11313            T12,
11314            T13,
11315            T14,
11316            T15,
11317            T16,
11318            T17,
11319            T18,
11320            T19,
11321            T20,
11322            T21,
11323            T22,
11324            T23,
11325            T24,
11326            T25,
11327            T26,
11328        )
11329    {
11330        #[inline]
11331        unsafe fn encode(
11332            self,
11333            encoder: &mut fidl::encoding::Encoder<
11334                '_,
11335                fidl::encoding::DefaultFuchsiaResourceDialect,
11336            >,
11337            offset: usize,
11338            depth: fidl::encoding::Depth,
11339        ) -> fidl::Result<()> {
11340            encoder.debug_check_bounds::<Handles>(offset);
11341            // Zero out padding regions. There's no need to apply masks
11342            // because the unmasked parts will be overwritten by fields.
11343            // Write the fields.
11344            self.0.encode(encoder, offset + 0, depth)?;
11345            self.1.encode(encoder, offset + 4, depth)?;
11346            self.2.encode(encoder, offset + 8, depth)?;
11347            self.3.encode(encoder, offset + 12, depth)?;
11348            self.4.encode(encoder, offset + 16, depth)?;
11349            self.5.encode(encoder, offset + 20, depth)?;
11350            self.6.encode(encoder, offset + 24, depth)?;
11351            self.7.encode(encoder, offset + 28, depth)?;
11352            self.8.encode(encoder, offset + 32, depth)?;
11353            self.9.encode(encoder, offset + 36, depth)?;
11354            self.10.encode(encoder, offset + 40, depth)?;
11355            self.11.encode(encoder, offset + 44, depth)?;
11356            self.12.encode(encoder, offset + 48, depth)?;
11357            self.13.encode(encoder, offset + 52, depth)?;
11358            self.14.encode(encoder, offset + 56, depth)?;
11359            self.15.encode(encoder, offset + 60, depth)?;
11360            self.16.encode(encoder, offset + 64, depth)?;
11361            self.17.encode(encoder, offset + 68, depth)?;
11362            self.18.encode(encoder, offset + 72, depth)?;
11363            self.19.encode(encoder, offset + 76, depth)?;
11364            self.20.encode(encoder, offset + 80, depth)?;
11365            self.21.encode(encoder, offset + 84, depth)?;
11366            self.22.encode(encoder, offset + 88, depth)?;
11367            self.23.encode(encoder, offset + 92, depth)?;
11368            self.24.encode(encoder, offset + 96, depth)?;
11369            self.25.encode(encoder, offset + 100, depth)?;
11370            self.26.encode(encoder, offset + 104, depth)?;
11371            Ok(())
11372        }
11373    }
11374
11375    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Handles {
11376        #[inline(always)]
11377        fn new_empty() -> Self {
11378            Self {
11379                handle_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11380                process_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Process, { fidl::ObjectType::PROCESS.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11381                thread_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Thread, { fidl::ObjectType::THREAD.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11382                vmo_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11383                event_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11384                port_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Port, { fidl::ObjectType::PORT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11385                socket_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11386                eventpair_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11387                job_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Job, { fidl::ObjectType::JOB.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11388                vmar_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmar, { fidl::ObjectType::VMAR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11389                fifo_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Fifo, { fidl::ObjectType::FIFO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11390                timer_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Timer, { fidl::ObjectType::TIMER.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11391                nullable_handle_handle: fidl::new_empty!(
11392                    fidl::encoding::Optional<
11393                        fidl::encoding::HandleType<
11394                            fidl::NullableHandle,
11395                            { fidl::ObjectType::NONE.into_raw() },
11396                            2147483648,
11397                        >,
11398                    >,
11399                    fidl::encoding::DefaultFuchsiaResourceDialect
11400                ),
11401                nullable_process_handle: fidl::new_empty!(
11402                    fidl::encoding::Optional<
11403                        fidl::encoding::HandleType<
11404                            fidl::Process,
11405                            { fidl::ObjectType::PROCESS.into_raw() },
11406                            2147483648,
11407                        >,
11408                    >,
11409                    fidl::encoding::DefaultFuchsiaResourceDialect
11410                ),
11411                nullable_thread_handle: fidl::new_empty!(
11412                    fidl::encoding::Optional<
11413                        fidl::encoding::HandleType<
11414                            fidl::Thread,
11415                            { fidl::ObjectType::THREAD.into_raw() },
11416                            2147483648,
11417                        >,
11418                    >,
11419                    fidl::encoding::DefaultFuchsiaResourceDialect
11420                ),
11421                nullable_vmo_handle: fidl::new_empty!(
11422                    fidl::encoding::Optional<
11423                        fidl::encoding::HandleType<
11424                            fidl::Vmo,
11425                            { fidl::ObjectType::VMO.into_raw() },
11426                            2147483648,
11427                        >,
11428                    >,
11429                    fidl::encoding::DefaultFuchsiaResourceDialect
11430                ),
11431                nullable_channel_handle: fidl::new_empty!(
11432                    fidl::encoding::Optional<
11433                        fidl::encoding::HandleType<
11434                            fidl::Channel,
11435                            { fidl::ObjectType::CHANNEL.into_raw() },
11436                            2147483648,
11437                        >,
11438                    >,
11439                    fidl::encoding::DefaultFuchsiaResourceDialect
11440                ),
11441                nullable_event_handle: fidl::new_empty!(
11442                    fidl::encoding::Optional<
11443                        fidl::encoding::HandleType<
11444                            fidl::Event,
11445                            { fidl::ObjectType::EVENT.into_raw() },
11446                            2147483648,
11447                        >,
11448                    >,
11449                    fidl::encoding::DefaultFuchsiaResourceDialect
11450                ),
11451                nullable_port_handle: fidl::new_empty!(
11452                    fidl::encoding::Optional<
11453                        fidl::encoding::HandleType<
11454                            fidl::Port,
11455                            { fidl::ObjectType::PORT.into_raw() },
11456                            2147483648,
11457                        >,
11458                    >,
11459                    fidl::encoding::DefaultFuchsiaResourceDialect
11460                ),
11461                nullable_interrupt_handle: fidl::new_empty!(
11462                    fidl::encoding::Optional<
11463                        fidl::encoding::HandleType<
11464                            fidl::Interrupt,
11465                            { fidl::ObjectType::INTERRUPT.into_raw() },
11466                            2147483648,
11467                        >,
11468                    >,
11469                    fidl::encoding::DefaultFuchsiaResourceDialect
11470                ),
11471                nullable_log_handle: fidl::new_empty!(
11472                    fidl::encoding::Optional<
11473                        fidl::encoding::HandleType<
11474                            fidl::DebugLog,
11475                            { fidl::ObjectType::DEBUGLOG.into_raw() },
11476                            2147483648,
11477                        >,
11478                    >,
11479                    fidl::encoding::DefaultFuchsiaResourceDialect
11480                ),
11481                nullable_socket_handle: fidl::new_empty!(
11482                    fidl::encoding::Optional<
11483                        fidl::encoding::HandleType<
11484                            fidl::Socket,
11485                            { fidl::ObjectType::SOCKET.into_raw() },
11486                            2147483648,
11487                        >,
11488                    >,
11489                    fidl::encoding::DefaultFuchsiaResourceDialect
11490                ),
11491                nullable_eventpair_handle: fidl::new_empty!(
11492                    fidl::encoding::Optional<
11493                        fidl::encoding::HandleType<
11494                            fidl::EventPair,
11495                            { fidl::ObjectType::EVENTPAIR.into_raw() },
11496                            2147483648,
11497                        >,
11498                    >,
11499                    fidl::encoding::DefaultFuchsiaResourceDialect
11500                ),
11501                nullable_job_handle: fidl::new_empty!(
11502                    fidl::encoding::Optional<
11503                        fidl::encoding::HandleType<
11504                            fidl::Job,
11505                            { fidl::ObjectType::JOB.into_raw() },
11506                            2147483648,
11507                        >,
11508                    >,
11509                    fidl::encoding::DefaultFuchsiaResourceDialect
11510                ),
11511                nullable_vmar_handle: fidl::new_empty!(
11512                    fidl::encoding::Optional<
11513                        fidl::encoding::HandleType<
11514                            fidl::Vmar,
11515                            { fidl::ObjectType::VMAR.into_raw() },
11516                            2147483648,
11517                        >,
11518                    >,
11519                    fidl::encoding::DefaultFuchsiaResourceDialect
11520                ),
11521                nullable_fifo_handle: fidl::new_empty!(
11522                    fidl::encoding::Optional<
11523                        fidl::encoding::HandleType<
11524                            fidl::Fifo,
11525                            { fidl::ObjectType::FIFO.into_raw() },
11526                            2147483648,
11527                        >,
11528                    >,
11529                    fidl::encoding::DefaultFuchsiaResourceDialect
11530                ),
11531                nullable_timer_handle: fidl::new_empty!(
11532                    fidl::encoding::Optional<
11533                        fidl::encoding::HandleType<
11534                            fidl::Timer,
11535                            { fidl::ObjectType::TIMER.into_raw() },
11536                            2147483648,
11537                        >,
11538                    >,
11539                    fidl::encoding::DefaultFuchsiaResourceDialect
11540                ),
11541            }
11542        }
11543
11544        #[inline]
11545        unsafe fn decode(
11546            &mut self,
11547            decoder: &mut fidl::encoding::Decoder<
11548                '_,
11549                fidl::encoding::DefaultFuchsiaResourceDialect,
11550            >,
11551            offset: usize,
11552            _depth: fidl::encoding::Depth,
11553        ) -> fidl::Result<()> {
11554            decoder.debug_check_bounds::<Self>(offset);
11555            // Verify that padding bytes are zero.
11556            fidl::decode!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.handle_handle, decoder, offset + 0, _depth)?;
11557            fidl::decode!(fidl::encoding::HandleType<fidl::Process, { fidl::ObjectType::PROCESS.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.process_handle, decoder, offset + 4, _depth)?;
11558            fidl::decode!(fidl::encoding::HandleType<fidl::Thread, { fidl::ObjectType::THREAD.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.thread_handle, decoder, offset + 8, _depth)?;
11559            fidl::decode!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.vmo_handle, decoder, offset + 12, _depth)?;
11560            fidl::decode!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.event_handle, decoder, offset + 16, _depth)?;
11561            fidl::decode!(fidl::encoding::HandleType<fidl::Port, { fidl::ObjectType::PORT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.port_handle, decoder, offset + 20, _depth)?;
11562            fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.socket_handle, decoder, offset + 24, _depth)?;
11563            fidl::decode!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.eventpair_handle, decoder, offset + 28, _depth)?;
11564            fidl::decode!(fidl::encoding::HandleType<fidl::Job, { fidl::ObjectType::JOB.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.job_handle, decoder, offset + 32, _depth)?;
11565            fidl::decode!(fidl::encoding::HandleType<fidl::Vmar, { fidl::ObjectType::VMAR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.vmar_handle, decoder, offset + 36, _depth)?;
11566            fidl::decode!(fidl::encoding::HandleType<fidl::Fifo, { fidl::ObjectType::FIFO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.fifo_handle, decoder, offset + 40, _depth)?;
11567            fidl::decode!(fidl::encoding::HandleType<fidl::Timer, { fidl::ObjectType::TIMER.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.timer_handle, decoder, offset + 44, _depth)?;
11568            fidl::decode!(
11569                fidl::encoding::Optional<
11570                    fidl::encoding::HandleType<
11571                        fidl::NullableHandle,
11572                        { fidl::ObjectType::NONE.into_raw() },
11573                        2147483648,
11574                    >,
11575                >,
11576                fidl::encoding::DefaultFuchsiaResourceDialect,
11577                &mut self.nullable_handle_handle,
11578                decoder,
11579                offset + 48,
11580                _depth
11581            )?;
11582            fidl::decode!(
11583                fidl::encoding::Optional<
11584                    fidl::encoding::HandleType<
11585                        fidl::Process,
11586                        { fidl::ObjectType::PROCESS.into_raw() },
11587                        2147483648,
11588                    >,
11589                >,
11590                fidl::encoding::DefaultFuchsiaResourceDialect,
11591                &mut self.nullable_process_handle,
11592                decoder,
11593                offset + 52,
11594                _depth
11595            )?;
11596            fidl::decode!(
11597                fidl::encoding::Optional<
11598                    fidl::encoding::HandleType<
11599                        fidl::Thread,
11600                        { fidl::ObjectType::THREAD.into_raw() },
11601                        2147483648,
11602                    >,
11603                >,
11604                fidl::encoding::DefaultFuchsiaResourceDialect,
11605                &mut self.nullable_thread_handle,
11606                decoder,
11607                offset + 56,
11608                _depth
11609            )?;
11610            fidl::decode!(
11611                fidl::encoding::Optional<
11612                    fidl::encoding::HandleType<
11613                        fidl::Vmo,
11614                        { fidl::ObjectType::VMO.into_raw() },
11615                        2147483648,
11616                    >,
11617                >,
11618                fidl::encoding::DefaultFuchsiaResourceDialect,
11619                &mut self.nullable_vmo_handle,
11620                decoder,
11621                offset + 60,
11622                _depth
11623            )?;
11624            fidl::decode!(
11625                fidl::encoding::Optional<
11626                    fidl::encoding::HandleType<
11627                        fidl::Channel,
11628                        { fidl::ObjectType::CHANNEL.into_raw() },
11629                        2147483648,
11630                    >,
11631                >,
11632                fidl::encoding::DefaultFuchsiaResourceDialect,
11633                &mut self.nullable_channel_handle,
11634                decoder,
11635                offset + 64,
11636                _depth
11637            )?;
11638            fidl::decode!(
11639                fidl::encoding::Optional<
11640                    fidl::encoding::HandleType<
11641                        fidl::Event,
11642                        { fidl::ObjectType::EVENT.into_raw() },
11643                        2147483648,
11644                    >,
11645                >,
11646                fidl::encoding::DefaultFuchsiaResourceDialect,
11647                &mut self.nullable_event_handle,
11648                decoder,
11649                offset + 68,
11650                _depth
11651            )?;
11652            fidl::decode!(
11653                fidl::encoding::Optional<
11654                    fidl::encoding::HandleType<
11655                        fidl::Port,
11656                        { fidl::ObjectType::PORT.into_raw() },
11657                        2147483648,
11658                    >,
11659                >,
11660                fidl::encoding::DefaultFuchsiaResourceDialect,
11661                &mut self.nullable_port_handle,
11662                decoder,
11663                offset + 72,
11664                _depth
11665            )?;
11666            fidl::decode!(
11667                fidl::encoding::Optional<
11668                    fidl::encoding::HandleType<
11669                        fidl::Interrupt,
11670                        { fidl::ObjectType::INTERRUPT.into_raw() },
11671                        2147483648,
11672                    >,
11673                >,
11674                fidl::encoding::DefaultFuchsiaResourceDialect,
11675                &mut self.nullable_interrupt_handle,
11676                decoder,
11677                offset + 76,
11678                _depth
11679            )?;
11680            fidl::decode!(
11681                fidl::encoding::Optional<
11682                    fidl::encoding::HandleType<
11683                        fidl::DebugLog,
11684                        { fidl::ObjectType::DEBUGLOG.into_raw() },
11685                        2147483648,
11686                    >,
11687                >,
11688                fidl::encoding::DefaultFuchsiaResourceDialect,
11689                &mut self.nullable_log_handle,
11690                decoder,
11691                offset + 80,
11692                _depth
11693            )?;
11694            fidl::decode!(
11695                fidl::encoding::Optional<
11696                    fidl::encoding::HandleType<
11697                        fidl::Socket,
11698                        { fidl::ObjectType::SOCKET.into_raw() },
11699                        2147483648,
11700                    >,
11701                >,
11702                fidl::encoding::DefaultFuchsiaResourceDialect,
11703                &mut self.nullable_socket_handle,
11704                decoder,
11705                offset + 84,
11706                _depth
11707            )?;
11708            fidl::decode!(
11709                fidl::encoding::Optional<
11710                    fidl::encoding::HandleType<
11711                        fidl::EventPair,
11712                        { fidl::ObjectType::EVENTPAIR.into_raw() },
11713                        2147483648,
11714                    >,
11715                >,
11716                fidl::encoding::DefaultFuchsiaResourceDialect,
11717                &mut self.nullable_eventpair_handle,
11718                decoder,
11719                offset + 88,
11720                _depth
11721            )?;
11722            fidl::decode!(
11723                fidl::encoding::Optional<
11724                    fidl::encoding::HandleType<
11725                        fidl::Job,
11726                        { fidl::ObjectType::JOB.into_raw() },
11727                        2147483648,
11728                    >,
11729                >,
11730                fidl::encoding::DefaultFuchsiaResourceDialect,
11731                &mut self.nullable_job_handle,
11732                decoder,
11733                offset + 92,
11734                _depth
11735            )?;
11736            fidl::decode!(
11737                fidl::encoding::Optional<
11738                    fidl::encoding::HandleType<
11739                        fidl::Vmar,
11740                        { fidl::ObjectType::VMAR.into_raw() },
11741                        2147483648,
11742                    >,
11743                >,
11744                fidl::encoding::DefaultFuchsiaResourceDialect,
11745                &mut self.nullable_vmar_handle,
11746                decoder,
11747                offset + 96,
11748                _depth
11749            )?;
11750            fidl::decode!(
11751                fidl::encoding::Optional<
11752                    fidl::encoding::HandleType<
11753                        fidl::Fifo,
11754                        { fidl::ObjectType::FIFO.into_raw() },
11755                        2147483648,
11756                    >,
11757                >,
11758                fidl::encoding::DefaultFuchsiaResourceDialect,
11759                &mut self.nullable_fifo_handle,
11760                decoder,
11761                offset + 100,
11762                _depth
11763            )?;
11764            fidl::decode!(
11765                fidl::encoding::Optional<
11766                    fidl::encoding::HandleType<
11767                        fidl::Timer,
11768                        { fidl::ObjectType::TIMER.into_raw() },
11769                        2147483648,
11770                    >,
11771                >,
11772                fidl::encoding::DefaultFuchsiaResourceDialect,
11773                &mut self.nullable_timer_handle,
11774                decoder,
11775                offset + 104,
11776                _depth
11777            )?;
11778            Ok(())
11779        }
11780    }
11781
11782    impl fidl::encoding::ResourceTypeMarker for Vectors {
11783        type Borrowed<'a> = &'a mut Self;
11784        fn take_or_borrow<'a>(
11785            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
11786        ) -> Self::Borrowed<'a> {
11787            value
11788        }
11789    }
11790
11791    unsafe impl fidl::encoding::TypeMarker for Vectors {
11792        type Owned = Self;
11793
11794        #[inline(always)]
11795        fn inline_align(_context: fidl::encoding::Context) -> usize {
11796            8
11797        }
11798
11799        #[inline(always)]
11800        fn inline_size(_context: fidl::encoding::Context) -> usize {
11801            1920
11802        }
11803    }
11804
11805    unsafe impl fidl::encoding::Encode<Vectors, fidl::encoding::DefaultFuchsiaResourceDialect>
11806        for &mut Vectors
11807    {
11808        #[inline]
11809        unsafe fn encode(
11810            self,
11811            encoder: &mut fidl::encoding::Encoder<
11812                '_,
11813                fidl::encoding::DefaultFuchsiaResourceDialect,
11814            >,
11815            offset: usize,
11816            _depth: fidl::encoding::Depth,
11817        ) -> fidl::Result<()> {
11818            encoder.debug_check_bounds::<Vectors>(offset);
11819            // Delegate to tuple encoding.
11820            fidl::encoding::Encode::<Vectors, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
11821                (
11822                    <fidl::encoding::UnboundedVector<bool> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_0),
11823                    <fidl::encoding::UnboundedVector<i8> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_0),
11824                    <fidl::encoding::UnboundedVector<i16> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_0),
11825                    <fidl::encoding::UnboundedVector<i32> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_0),
11826                    <fidl::encoding::UnboundedVector<i64> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_0),
11827                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_0),
11828                    <fidl::encoding::UnboundedVector<u16> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_0),
11829                    <fidl::encoding::UnboundedVector<u32> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_0),
11830                    <fidl::encoding::UnboundedVector<u64> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_0),
11831                    <fidl::encoding::UnboundedVector<f32> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_0),
11832                    <fidl::encoding::UnboundedVector<f64> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_0),
11833                    <fidl::encoding::UnboundedVector<fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_0),
11834                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_1),
11835                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_1),
11836                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_1),
11837                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_1),
11838                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_1),
11839                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_1),
11840                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_1),
11841                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_1),
11842                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_1),
11843                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_1),
11844                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_1),
11845                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 2>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_1),
11846                    <fidl::encoding::Vector<bool, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_sized_0),
11847                    <fidl::encoding::Vector<i8, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_sized_0),
11848                    <fidl::encoding::Vector<i16, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_sized_0),
11849                    <fidl::encoding::Vector<i32, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_sized_0),
11850                    <fidl::encoding::Vector<i64, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_sized_0),
11851                    <fidl::encoding::Vector<u8, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_sized_0),
11852                    <fidl::encoding::Vector<u16, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_sized_0),
11853                    <fidl::encoding::Vector<u32, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_sized_0),
11854                    <fidl::encoding::Vector<u64, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_sized_0),
11855                    <fidl::encoding::Vector<f32, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_sized_0),
11856                    <fidl::encoding::Vector<f64, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_sized_0),
11857                    <fidl::encoding::Vector<fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 1> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_sized_0),
11858                    <fidl::encoding::Vector<bool, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_sized_1),
11859                    <fidl::encoding::Vector<i8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_sized_1),
11860                    <fidl::encoding::Vector<i16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_sized_1),
11861                    <fidl::encoding::Vector<i32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_sized_1),
11862                    <fidl::encoding::Vector<i64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_sized_1),
11863                    <fidl::encoding::Vector<u8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_sized_1),
11864                    <fidl::encoding::Vector<u16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_sized_1),
11865                    <fidl::encoding::Vector<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_sized_1),
11866                    <fidl::encoding::Vector<u64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_sized_1),
11867                    <fidl::encoding::Vector<f32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_sized_1),
11868                    <fidl::encoding::Vector<f64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_sized_1),
11869                    <fidl::encoding::Vector<fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 3> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_sized_1),
11870                    <fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_sized_2),
11871                    <fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_sized_2),
11872                    <fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_sized_2),
11873                    <fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_sized_2),
11874                    <fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_sized_2),
11875                    <fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_sized_2),
11876                    <fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_sized_2),
11877                    <fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_sized_2),
11878                    <fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_sized_2),
11879                    <fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_sized_2),
11880                    <fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_sized_2),
11881                    <fidl::encoding::Vector<fidl::encoding::Vector<fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 2>, 3> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_sized_2),
11882                    <fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_nullable_0),
11883                    <fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_nullable_0),
11884                    <fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_nullable_0),
11885                    <fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_nullable_0),
11886                    <fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_nullable_0),
11887                    <fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_nullable_0),
11888                    <fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_nullable_0),
11889                    <fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_nullable_0),
11890                    <fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_nullable_0),
11891                    <fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_nullable_0),
11892                    <fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_nullable_0),
11893                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 1>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_nullable_0),
11894                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_nullable_1),
11895                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_nullable_1),
11896                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_nullable_1),
11897                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_nullable_1),
11898                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_nullable_1),
11899                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_nullable_1),
11900                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_nullable_1),
11901                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_nullable_1),
11902                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_nullable_1),
11903                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_nullable_1),
11904                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_nullable_1),
11905                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 2>>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_nullable_1),
11906                    <fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_nullable_sized_0),
11907                    <fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_nullable_sized_0),
11908                    <fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_nullable_sized_0),
11909                    <fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_nullable_sized_0),
11910                    <fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_nullable_sized_0),
11911                    <fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_nullable_sized_0),
11912                    <fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_nullable_sized_0),
11913                    <fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_nullable_sized_0),
11914                    <fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_nullable_sized_0),
11915                    <fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_nullable_sized_0),
11916                    <fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_nullable_sized_0),
11917                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 1>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_nullable_sized_0),
11918                    <fidl::encoding::Optional<fidl::encoding::Vector<bool, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_nullable_sized_1),
11919                    <fidl::encoding::Optional<fidl::encoding::Vector<i8, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_nullable_sized_1),
11920                    <fidl::encoding::Optional<fidl::encoding::Vector<i16, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_nullable_sized_1),
11921                    <fidl::encoding::Optional<fidl::encoding::Vector<i32, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_nullable_sized_1),
11922                    <fidl::encoding::Optional<fidl::encoding::Vector<i64, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_nullable_sized_1),
11923                    <fidl::encoding::Optional<fidl::encoding::Vector<u8, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_nullable_sized_1),
11924                    <fidl::encoding::Optional<fidl::encoding::Vector<u16, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_nullable_sized_1),
11925                    <fidl::encoding::Optional<fidl::encoding::Vector<u32, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_nullable_sized_1),
11926                    <fidl::encoding::Optional<fidl::encoding::Vector<u64, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_nullable_sized_1),
11927                    <fidl::encoding::Optional<fidl::encoding::Vector<f32, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_nullable_sized_1),
11928                    <fidl::encoding::Optional<fidl::encoding::Vector<f64, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_nullable_sized_1),
11929                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 3>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_nullable_sized_1),
11930                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_nullable_sized_2),
11931                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_nullable_sized_2),
11932                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_nullable_sized_2),
11933                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_nullable_sized_2),
11934                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_nullable_sized_2),
11935                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_nullable_sized_2),
11936                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_nullable_sized_2),
11937                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_nullable_sized_2),
11938                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_nullable_sized_2),
11939                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_nullable_sized_2),
11940                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_nullable_sized_2),
11941                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 2>, 3>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_nullable_sized_2),
11942                ),
11943                encoder, offset, _depth
11944            )
11945        }
11946    }
11947    unsafe impl<
11948        T0: fidl::encoding::Encode<
11949                fidl::encoding::UnboundedVector<bool>,
11950                fidl::encoding::DefaultFuchsiaResourceDialect,
11951            >,
11952        T1: fidl::encoding::Encode<
11953                fidl::encoding::UnboundedVector<i8>,
11954                fidl::encoding::DefaultFuchsiaResourceDialect,
11955            >,
11956        T2: fidl::encoding::Encode<
11957                fidl::encoding::UnboundedVector<i16>,
11958                fidl::encoding::DefaultFuchsiaResourceDialect,
11959            >,
11960        T3: fidl::encoding::Encode<
11961                fidl::encoding::UnboundedVector<i32>,
11962                fidl::encoding::DefaultFuchsiaResourceDialect,
11963            >,
11964        T4: fidl::encoding::Encode<
11965                fidl::encoding::UnboundedVector<i64>,
11966                fidl::encoding::DefaultFuchsiaResourceDialect,
11967            >,
11968        T5: fidl::encoding::Encode<
11969                fidl::encoding::UnboundedVector<u8>,
11970                fidl::encoding::DefaultFuchsiaResourceDialect,
11971            >,
11972        T6: fidl::encoding::Encode<
11973                fidl::encoding::UnboundedVector<u16>,
11974                fidl::encoding::DefaultFuchsiaResourceDialect,
11975            >,
11976        T7: fidl::encoding::Encode<
11977                fidl::encoding::UnboundedVector<u32>,
11978                fidl::encoding::DefaultFuchsiaResourceDialect,
11979            >,
11980        T8: fidl::encoding::Encode<
11981                fidl::encoding::UnboundedVector<u64>,
11982                fidl::encoding::DefaultFuchsiaResourceDialect,
11983            >,
11984        T9: fidl::encoding::Encode<
11985                fidl::encoding::UnboundedVector<f32>,
11986                fidl::encoding::DefaultFuchsiaResourceDialect,
11987            >,
11988        T10: fidl::encoding::Encode<
11989                fidl::encoding::UnboundedVector<f64>,
11990                fidl::encoding::DefaultFuchsiaResourceDialect,
11991            >,
11992        T11: fidl::encoding::Encode<
11993                fidl::encoding::UnboundedVector<
11994                    fidl::encoding::HandleType<
11995                        fidl::NullableHandle,
11996                        { fidl::ObjectType::NONE.into_raw() },
11997                        2147483648,
11998                    >,
11999                >,
12000                fidl::encoding::DefaultFuchsiaResourceDialect,
12001            >,
12002        T12: fidl::encoding::Encode<
12003                fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
12004                fidl::encoding::DefaultFuchsiaResourceDialect,
12005            >,
12006        T13: fidl::encoding::Encode<
12007                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
12008                fidl::encoding::DefaultFuchsiaResourceDialect,
12009            >,
12010        T14: fidl::encoding::Encode<
12011                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
12012                fidl::encoding::DefaultFuchsiaResourceDialect,
12013            >,
12014        T15: fidl::encoding::Encode<
12015                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
12016                fidl::encoding::DefaultFuchsiaResourceDialect,
12017            >,
12018        T16: fidl::encoding::Encode<
12019                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
12020                fidl::encoding::DefaultFuchsiaResourceDialect,
12021            >,
12022        T17: fidl::encoding::Encode<
12023                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
12024                fidl::encoding::DefaultFuchsiaResourceDialect,
12025            >,
12026        T18: fidl::encoding::Encode<
12027                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
12028                fidl::encoding::DefaultFuchsiaResourceDialect,
12029            >,
12030        T19: fidl::encoding::Encode<
12031                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
12032                fidl::encoding::DefaultFuchsiaResourceDialect,
12033            >,
12034        T20: fidl::encoding::Encode<
12035                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
12036                fidl::encoding::DefaultFuchsiaResourceDialect,
12037            >,
12038        T21: fidl::encoding::Encode<
12039                fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
12040                fidl::encoding::DefaultFuchsiaResourceDialect,
12041            >,
12042        T22: fidl::encoding::Encode<
12043                fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
12044                fidl::encoding::DefaultFuchsiaResourceDialect,
12045            >,
12046        T23: fidl::encoding::Encode<
12047                fidl::encoding::UnboundedVector<
12048                    fidl::encoding::Vector<
12049                        fidl::encoding::HandleType<
12050                            fidl::NullableHandle,
12051                            { fidl::ObjectType::NONE.into_raw() },
12052                            2147483648,
12053                        >,
12054                        2,
12055                    >,
12056                >,
12057                fidl::encoding::DefaultFuchsiaResourceDialect,
12058            >,
12059        T24: fidl::encoding::Encode<
12060                fidl::encoding::Vector<bool, 1>,
12061                fidl::encoding::DefaultFuchsiaResourceDialect,
12062            >,
12063        T25: fidl::encoding::Encode<
12064                fidl::encoding::Vector<i8, 1>,
12065                fidl::encoding::DefaultFuchsiaResourceDialect,
12066            >,
12067        T26: fidl::encoding::Encode<
12068                fidl::encoding::Vector<i16, 1>,
12069                fidl::encoding::DefaultFuchsiaResourceDialect,
12070            >,
12071        T27: fidl::encoding::Encode<
12072                fidl::encoding::Vector<i32, 1>,
12073                fidl::encoding::DefaultFuchsiaResourceDialect,
12074            >,
12075        T28: fidl::encoding::Encode<
12076                fidl::encoding::Vector<i64, 1>,
12077                fidl::encoding::DefaultFuchsiaResourceDialect,
12078            >,
12079        T29: fidl::encoding::Encode<
12080                fidl::encoding::Vector<u8, 1>,
12081                fidl::encoding::DefaultFuchsiaResourceDialect,
12082            >,
12083        T30: fidl::encoding::Encode<
12084                fidl::encoding::Vector<u16, 1>,
12085                fidl::encoding::DefaultFuchsiaResourceDialect,
12086            >,
12087        T31: fidl::encoding::Encode<
12088                fidl::encoding::Vector<u32, 1>,
12089                fidl::encoding::DefaultFuchsiaResourceDialect,
12090            >,
12091        T32: fidl::encoding::Encode<
12092                fidl::encoding::Vector<u64, 1>,
12093                fidl::encoding::DefaultFuchsiaResourceDialect,
12094            >,
12095        T33: fidl::encoding::Encode<
12096                fidl::encoding::Vector<f32, 1>,
12097                fidl::encoding::DefaultFuchsiaResourceDialect,
12098            >,
12099        T34: fidl::encoding::Encode<
12100                fidl::encoding::Vector<f64, 1>,
12101                fidl::encoding::DefaultFuchsiaResourceDialect,
12102            >,
12103        T35: fidl::encoding::Encode<
12104                fidl::encoding::Vector<
12105                    fidl::encoding::HandleType<
12106                        fidl::NullableHandle,
12107                        { fidl::ObjectType::NONE.into_raw() },
12108                        2147483648,
12109                    >,
12110                    1,
12111                >,
12112                fidl::encoding::DefaultFuchsiaResourceDialect,
12113            >,
12114        T36: fidl::encoding::Encode<
12115                fidl::encoding::Vector<bool, 3>,
12116                fidl::encoding::DefaultFuchsiaResourceDialect,
12117            >,
12118        T37: fidl::encoding::Encode<
12119                fidl::encoding::Vector<i8, 3>,
12120                fidl::encoding::DefaultFuchsiaResourceDialect,
12121            >,
12122        T38: fidl::encoding::Encode<
12123                fidl::encoding::Vector<i16, 3>,
12124                fidl::encoding::DefaultFuchsiaResourceDialect,
12125            >,
12126        T39: fidl::encoding::Encode<
12127                fidl::encoding::Vector<i32, 3>,
12128                fidl::encoding::DefaultFuchsiaResourceDialect,
12129            >,
12130        T40: fidl::encoding::Encode<
12131                fidl::encoding::Vector<i64, 3>,
12132                fidl::encoding::DefaultFuchsiaResourceDialect,
12133            >,
12134        T41: fidl::encoding::Encode<
12135                fidl::encoding::Vector<u8, 3>,
12136                fidl::encoding::DefaultFuchsiaResourceDialect,
12137            >,
12138        T42: fidl::encoding::Encode<
12139                fidl::encoding::Vector<u16, 3>,
12140                fidl::encoding::DefaultFuchsiaResourceDialect,
12141            >,
12142        T43: fidl::encoding::Encode<
12143                fidl::encoding::Vector<u32, 3>,
12144                fidl::encoding::DefaultFuchsiaResourceDialect,
12145            >,
12146        T44: fidl::encoding::Encode<
12147                fidl::encoding::Vector<u64, 3>,
12148                fidl::encoding::DefaultFuchsiaResourceDialect,
12149            >,
12150        T45: fidl::encoding::Encode<
12151                fidl::encoding::Vector<f32, 3>,
12152                fidl::encoding::DefaultFuchsiaResourceDialect,
12153            >,
12154        T46: fidl::encoding::Encode<
12155                fidl::encoding::Vector<f64, 3>,
12156                fidl::encoding::DefaultFuchsiaResourceDialect,
12157            >,
12158        T47: fidl::encoding::Encode<
12159                fidl::encoding::Vector<
12160                    fidl::encoding::HandleType<
12161                        fidl::NullableHandle,
12162                        { fidl::ObjectType::NONE.into_raw() },
12163                        2147483648,
12164                    >,
12165                    3,
12166                >,
12167                fidl::encoding::DefaultFuchsiaResourceDialect,
12168            >,
12169        T48: fidl::encoding::Encode<
12170                fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
12171                fidl::encoding::DefaultFuchsiaResourceDialect,
12172            >,
12173        T49: fidl::encoding::Encode<
12174                fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>,
12175                fidl::encoding::DefaultFuchsiaResourceDialect,
12176            >,
12177        T50: fidl::encoding::Encode<
12178                fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>,
12179                fidl::encoding::DefaultFuchsiaResourceDialect,
12180            >,
12181        T51: fidl::encoding::Encode<
12182                fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>,
12183                fidl::encoding::DefaultFuchsiaResourceDialect,
12184            >,
12185        T52: fidl::encoding::Encode<
12186                fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>,
12187                fidl::encoding::DefaultFuchsiaResourceDialect,
12188            >,
12189        T53: fidl::encoding::Encode<
12190                fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>,
12191                fidl::encoding::DefaultFuchsiaResourceDialect,
12192            >,
12193        T54: fidl::encoding::Encode<
12194                fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>,
12195                fidl::encoding::DefaultFuchsiaResourceDialect,
12196            >,
12197        T55: fidl::encoding::Encode<
12198                fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>,
12199                fidl::encoding::DefaultFuchsiaResourceDialect,
12200            >,
12201        T56: fidl::encoding::Encode<
12202                fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>,
12203                fidl::encoding::DefaultFuchsiaResourceDialect,
12204            >,
12205        T57: fidl::encoding::Encode<
12206                fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>,
12207                fidl::encoding::DefaultFuchsiaResourceDialect,
12208            >,
12209        T58: fidl::encoding::Encode<
12210                fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>,
12211                fidl::encoding::DefaultFuchsiaResourceDialect,
12212            >,
12213        T59: fidl::encoding::Encode<
12214                fidl::encoding::Vector<
12215                    fidl::encoding::Vector<
12216                        fidl::encoding::HandleType<
12217                            fidl::NullableHandle,
12218                            { fidl::ObjectType::NONE.into_raw() },
12219                            2147483648,
12220                        >,
12221                        2,
12222                    >,
12223                    3,
12224                >,
12225                fidl::encoding::DefaultFuchsiaResourceDialect,
12226            >,
12227        T60: fidl::encoding::Encode<
12228                fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
12229                fidl::encoding::DefaultFuchsiaResourceDialect,
12230            >,
12231        T61: fidl::encoding::Encode<
12232                fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
12233                fidl::encoding::DefaultFuchsiaResourceDialect,
12234            >,
12235        T62: fidl::encoding::Encode<
12236                fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
12237                fidl::encoding::DefaultFuchsiaResourceDialect,
12238            >,
12239        T63: fidl::encoding::Encode<
12240                fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
12241                fidl::encoding::DefaultFuchsiaResourceDialect,
12242            >,
12243        T64: fidl::encoding::Encode<
12244                fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
12245                fidl::encoding::DefaultFuchsiaResourceDialect,
12246            >,
12247        T65: fidl::encoding::Encode<
12248                fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
12249                fidl::encoding::DefaultFuchsiaResourceDialect,
12250            >,
12251        T66: fidl::encoding::Encode<
12252                fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
12253                fidl::encoding::DefaultFuchsiaResourceDialect,
12254            >,
12255        T67: fidl::encoding::Encode<
12256                fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
12257                fidl::encoding::DefaultFuchsiaResourceDialect,
12258            >,
12259        T68: fidl::encoding::Encode<
12260                fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
12261                fidl::encoding::DefaultFuchsiaResourceDialect,
12262            >,
12263        T69: fidl::encoding::Encode<
12264                fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
12265                fidl::encoding::DefaultFuchsiaResourceDialect,
12266            >,
12267        T70: fidl::encoding::Encode<
12268                fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
12269                fidl::encoding::DefaultFuchsiaResourceDialect,
12270            >,
12271        T71: fidl::encoding::Encode<
12272                fidl::encoding::Optional<
12273                    fidl::encoding::Vector<
12274                        fidl::encoding::HandleType<
12275                            fidl::NullableHandle,
12276                            { fidl::ObjectType::NONE.into_raw() },
12277                            2147483648,
12278                        >,
12279                        1,
12280                    >,
12281                >,
12282                fidl::encoding::DefaultFuchsiaResourceDialect,
12283            >,
12284        T72: fidl::encoding::Encode<
12285                fidl::encoding::Optional<
12286                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
12287                >,
12288                fidl::encoding::DefaultFuchsiaResourceDialect,
12289            >,
12290        T73: fidl::encoding::Encode<
12291                fidl::encoding::Optional<
12292                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
12293                >,
12294                fidl::encoding::DefaultFuchsiaResourceDialect,
12295            >,
12296        T74: fidl::encoding::Encode<
12297                fidl::encoding::Optional<
12298                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
12299                >,
12300                fidl::encoding::DefaultFuchsiaResourceDialect,
12301            >,
12302        T75: fidl::encoding::Encode<
12303                fidl::encoding::Optional<
12304                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
12305                >,
12306                fidl::encoding::DefaultFuchsiaResourceDialect,
12307            >,
12308        T76: fidl::encoding::Encode<
12309                fidl::encoding::Optional<
12310                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
12311                >,
12312                fidl::encoding::DefaultFuchsiaResourceDialect,
12313            >,
12314        T77: fidl::encoding::Encode<
12315                fidl::encoding::Optional<
12316                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
12317                >,
12318                fidl::encoding::DefaultFuchsiaResourceDialect,
12319            >,
12320        T78: fidl::encoding::Encode<
12321                fidl::encoding::Optional<
12322                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
12323                >,
12324                fidl::encoding::DefaultFuchsiaResourceDialect,
12325            >,
12326        T79: fidl::encoding::Encode<
12327                fidl::encoding::Optional<
12328                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
12329                >,
12330                fidl::encoding::DefaultFuchsiaResourceDialect,
12331            >,
12332        T80: fidl::encoding::Encode<
12333                fidl::encoding::Optional<
12334                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
12335                >,
12336                fidl::encoding::DefaultFuchsiaResourceDialect,
12337            >,
12338        T81: fidl::encoding::Encode<
12339                fidl::encoding::Optional<
12340                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
12341                >,
12342                fidl::encoding::DefaultFuchsiaResourceDialect,
12343            >,
12344        T82: fidl::encoding::Encode<
12345                fidl::encoding::Optional<
12346                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
12347                >,
12348                fidl::encoding::DefaultFuchsiaResourceDialect,
12349            >,
12350        T83: fidl::encoding::Encode<
12351                fidl::encoding::Optional<
12352                    fidl::encoding::UnboundedVector<
12353                        fidl::encoding::Vector<
12354                            fidl::encoding::HandleType<
12355                                fidl::NullableHandle,
12356                                { fidl::ObjectType::NONE.into_raw() },
12357                                2147483648,
12358                            >,
12359                            2,
12360                        >,
12361                    >,
12362                >,
12363                fidl::encoding::DefaultFuchsiaResourceDialect,
12364            >,
12365        T84: fidl::encoding::Encode<
12366                fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
12367                fidl::encoding::DefaultFuchsiaResourceDialect,
12368            >,
12369        T85: fidl::encoding::Encode<
12370                fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
12371                fidl::encoding::DefaultFuchsiaResourceDialect,
12372            >,
12373        T86: fidl::encoding::Encode<
12374                fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
12375                fidl::encoding::DefaultFuchsiaResourceDialect,
12376            >,
12377        T87: fidl::encoding::Encode<
12378                fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
12379                fidl::encoding::DefaultFuchsiaResourceDialect,
12380            >,
12381        T88: fidl::encoding::Encode<
12382                fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
12383                fidl::encoding::DefaultFuchsiaResourceDialect,
12384            >,
12385        T89: fidl::encoding::Encode<
12386                fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
12387                fidl::encoding::DefaultFuchsiaResourceDialect,
12388            >,
12389        T90: fidl::encoding::Encode<
12390                fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
12391                fidl::encoding::DefaultFuchsiaResourceDialect,
12392            >,
12393        T91: fidl::encoding::Encode<
12394                fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
12395                fidl::encoding::DefaultFuchsiaResourceDialect,
12396            >,
12397        T92: fidl::encoding::Encode<
12398                fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
12399                fidl::encoding::DefaultFuchsiaResourceDialect,
12400            >,
12401        T93: fidl::encoding::Encode<
12402                fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
12403                fidl::encoding::DefaultFuchsiaResourceDialect,
12404            >,
12405        T94: fidl::encoding::Encode<
12406                fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
12407                fidl::encoding::DefaultFuchsiaResourceDialect,
12408            >,
12409        T95: fidl::encoding::Encode<
12410                fidl::encoding::Optional<
12411                    fidl::encoding::Vector<
12412                        fidl::encoding::HandleType<
12413                            fidl::NullableHandle,
12414                            { fidl::ObjectType::NONE.into_raw() },
12415                            2147483648,
12416                        >,
12417                        1,
12418                    >,
12419                >,
12420                fidl::encoding::DefaultFuchsiaResourceDialect,
12421            >,
12422        T96: fidl::encoding::Encode<
12423                fidl::encoding::Optional<fidl::encoding::Vector<bool, 3>>,
12424                fidl::encoding::DefaultFuchsiaResourceDialect,
12425            >,
12426        T97: fidl::encoding::Encode<
12427                fidl::encoding::Optional<fidl::encoding::Vector<i8, 3>>,
12428                fidl::encoding::DefaultFuchsiaResourceDialect,
12429            >,
12430        T98: fidl::encoding::Encode<
12431                fidl::encoding::Optional<fidl::encoding::Vector<i16, 3>>,
12432                fidl::encoding::DefaultFuchsiaResourceDialect,
12433            >,
12434        T99: fidl::encoding::Encode<
12435                fidl::encoding::Optional<fidl::encoding::Vector<i32, 3>>,
12436                fidl::encoding::DefaultFuchsiaResourceDialect,
12437            >,
12438        T100: fidl::encoding::Encode<
12439                fidl::encoding::Optional<fidl::encoding::Vector<i64, 3>>,
12440                fidl::encoding::DefaultFuchsiaResourceDialect,
12441            >,
12442        T101: fidl::encoding::Encode<
12443                fidl::encoding::Optional<fidl::encoding::Vector<u8, 3>>,
12444                fidl::encoding::DefaultFuchsiaResourceDialect,
12445            >,
12446        T102: fidl::encoding::Encode<
12447                fidl::encoding::Optional<fidl::encoding::Vector<u16, 3>>,
12448                fidl::encoding::DefaultFuchsiaResourceDialect,
12449            >,
12450        T103: fidl::encoding::Encode<
12451                fidl::encoding::Optional<fidl::encoding::Vector<u32, 3>>,
12452                fidl::encoding::DefaultFuchsiaResourceDialect,
12453            >,
12454        T104: fidl::encoding::Encode<
12455                fidl::encoding::Optional<fidl::encoding::Vector<u64, 3>>,
12456                fidl::encoding::DefaultFuchsiaResourceDialect,
12457            >,
12458        T105: fidl::encoding::Encode<
12459                fidl::encoding::Optional<fidl::encoding::Vector<f32, 3>>,
12460                fidl::encoding::DefaultFuchsiaResourceDialect,
12461            >,
12462        T106: fidl::encoding::Encode<
12463                fidl::encoding::Optional<fidl::encoding::Vector<f64, 3>>,
12464                fidl::encoding::DefaultFuchsiaResourceDialect,
12465            >,
12466        T107: fidl::encoding::Encode<
12467                fidl::encoding::Optional<
12468                    fidl::encoding::Vector<
12469                        fidl::encoding::HandleType<
12470                            fidl::NullableHandle,
12471                            { fidl::ObjectType::NONE.into_raw() },
12472                            2147483648,
12473                        >,
12474                        3,
12475                    >,
12476                >,
12477                fidl::encoding::DefaultFuchsiaResourceDialect,
12478            >,
12479        T108: fidl::encoding::Encode<
12480                fidl::encoding::Optional<
12481                    fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
12482                >,
12483                fidl::encoding::DefaultFuchsiaResourceDialect,
12484            >,
12485        T109: fidl::encoding::Encode<
12486                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>>,
12487                fidl::encoding::DefaultFuchsiaResourceDialect,
12488            >,
12489        T110: fidl::encoding::Encode<
12490                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>>,
12491                fidl::encoding::DefaultFuchsiaResourceDialect,
12492            >,
12493        T111: fidl::encoding::Encode<
12494                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>>,
12495                fidl::encoding::DefaultFuchsiaResourceDialect,
12496            >,
12497        T112: fidl::encoding::Encode<
12498                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>>,
12499                fidl::encoding::DefaultFuchsiaResourceDialect,
12500            >,
12501        T113: fidl::encoding::Encode<
12502                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>>,
12503                fidl::encoding::DefaultFuchsiaResourceDialect,
12504            >,
12505        T114: fidl::encoding::Encode<
12506                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>>,
12507                fidl::encoding::DefaultFuchsiaResourceDialect,
12508            >,
12509        T115: fidl::encoding::Encode<
12510                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>>,
12511                fidl::encoding::DefaultFuchsiaResourceDialect,
12512            >,
12513        T116: fidl::encoding::Encode<
12514                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>>,
12515                fidl::encoding::DefaultFuchsiaResourceDialect,
12516            >,
12517        T117: fidl::encoding::Encode<
12518                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>>,
12519                fidl::encoding::DefaultFuchsiaResourceDialect,
12520            >,
12521        T118: fidl::encoding::Encode<
12522                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>>,
12523                fidl::encoding::DefaultFuchsiaResourceDialect,
12524            >,
12525        T119: fidl::encoding::Encode<
12526                fidl::encoding::Optional<
12527                    fidl::encoding::Vector<
12528                        fidl::encoding::Vector<
12529                            fidl::encoding::HandleType<
12530                                fidl::NullableHandle,
12531                                { fidl::ObjectType::NONE.into_raw() },
12532                                2147483648,
12533                            >,
12534                            2,
12535                        >,
12536                        3,
12537                    >,
12538                >,
12539                fidl::encoding::DefaultFuchsiaResourceDialect,
12540            >,
12541    > fidl::encoding::Encode<Vectors, fidl::encoding::DefaultFuchsiaResourceDialect>
12542        for (
12543            T0,
12544            T1,
12545            T2,
12546            T3,
12547            T4,
12548            T5,
12549            T6,
12550            T7,
12551            T8,
12552            T9,
12553            T10,
12554            T11,
12555            T12,
12556            T13,
12557            T14,
12558            T15,
12559            T16,
12560            T17,
12561            T18,
12562            T19,
12563            T20,
12564            T21,
12565            T22,
12566            T23,
12567            T24,
12568            T25,
12569            T26,
12570            T27,
12571            T28,
12572            T29,
12573            T30,
12574            T31,
12575            T32,
12576            T33,
12577            T34,
12578            T35,
12579            T36,
12580            T37,
12581            T38,
12582            T39,
12583            T40,
12584            T41,
12585            T42,
12586            T43,
12587            T44,
12588            T45,
12589            T46,
12590            T47,
12591            T48,
12592            T49,
12593            T50,
12594            T51,
12595            T52,
12596            T53,
12597            T54,
12598            T55,
12599            T56,
12600            T57,
12601            T58,
12602            T59,
12603            T60,
12604            T61,
12605            T62,
12606            T63,
12607            T64,
12608            T65,
12609            T66,
12610            T67,
12611            T68,
12612            T69,
12613            T70,
12614            T71,
12615            T72,
12616            T73,
12617            T74,
12618            T75,
12619            T76,
12620            T77,
12621            T78,
12622            T79,
12623            T80,
12624            T81,
12625            T82,
12626            T83,
12627            T84,
12628            T85,
12629            T86,
12630            T87,
12631            T88,
12632            T89,
12633            T90,
12634            T91,
12635            T92,
12636            T93,
12637            T94,
12638            T95,
12639            T96,
12640            T97,
12641            T98,
12642            T99,
12643            T100,
12644            T101,
12645            T102,
12646            T103,
12647            T104,
12648            T105,
12649            T106,
12650            T107,
12651            T108,
12652            T109,
12653            T110,
12654            T111,
12655            T112,
12656            T113,
12657            T114,
12658            T115,
12659            T116,
12660            T117,
12661            T118,
12662            T119,
12663        )
12664    {
12665        #[inline]
12666        unsafe fn encode(
12667            self,
12668            encoder: &mut fidl::encoding::Encoder<
12669                '_,
12670                fidl::encoding::DefaultFuchsiaResourceDialect,
12671            >,
12672            offset: usize,
12673            depth: fidl::encoding::Depth,
12674        ) -> fidl::Result<()> {
12675            encoder.debug_check_bounds::<Vectors>(offset);
12676            // Zero out padding regions. There's no need to apply masks
12677            // because the unmasked parts will be overwritten by fields.
12678            // Write the fields.
12679            self.0.encode(encoder, offset + 0, depth)?;
12680            self.1.encode(encoder, offset + 16, depth)?;
12681            self.2.encode(encoder, offset + 32, depth)?;
12682            self.3.encode(encoder, offset + 48, depth)?;
12683            self.4.encode(encoder, offset + 64, depth)?;
12684            self.5.encode(encoder, offset + 80, depth)?;
12685            self.6.encode(encoder, offset + 96, depth)?;
12686            self.7.encode(encoder, offset + 112, depth)?;
12687            self.8.encode(encoder, offset + 128, depth)?;
12688            self.9.encode(encoder, offset + 144, depth)?;
12689            self.10.encode(encoder, offset + 160, depth)?;
12690            self.11.encode(encoder, offset + 176, depth)?;
12691            self.12.encode(encoder, offset + 192, depth)?;
12692            self.13.encode(encoder, offset + 208, depth)?;
12693            self.14.encode(encoder, offset + 224, depth)?;
12694            self.15.encode(encoder, offset + 240, depth)?;
12695            self.16.encode(encoder, offset + 256, depth)?;
12696            self.17.encode(encoder, offset + 272, depth)?;
12697            self.18.encode(encoder, offset + 288, depth)?;
12698            self.19.encode(encoder, offset + 304, depth)?;
12699            self.20.encode(encoder, offset + 320, depth)?;
12700            self.21.encode(encoder, offset + 336, depth)?;
12701            self.22.encode(encoder, offset + 352, depth)?;
12702            self.23.encode(encoder, offset + 368, depth)?;
12703            self.24.encode(encoder, offset + 384, depth)?;
12704            self.25.encode(encoder, offset + 400, depth)?;
12705            self.26.encode(encoder, offset + 416, depth)?;
12706            self.27.encode(encoder, offset + 432, depth)?;
12707            self.28.encode(encoder, offset + 448, depth)?;
12708            self.29.encode(encoder, offset + 464, depth)?;
12709            self.30.encode(encoder, offset + 480, depth)?;
12710            self.31.encode(encoder, offset + 496, depth)?;
12711            self.32.encode(encoder, offset + 512, depth)?;
12712            self.33.encode(encoder, offset + 528, depth)?;
12713            self.34.encode(encoder, offset + 544, depth)?;
12714            self.35.encode(encoder, offset + 560, depth)?;
12715            self.36.encode(encoder, offset + 576, depth)?;
12716            self.37.encode(encoder, offset + 592, depth)?;
12717            self.38.encode(encoder, offset + 608, depth)?;
12718            self.39.encode(encoder, offset + 624, depth)?;
12719            self.40.encode(encoder, offset + 640, depth)?;
12720            self.41.encode(encoder, offset + 656, depth)?;
12721            self.42.encode(encoder, offset + 672, depth)?;
12722            self.43.encode(encoder, offset + 688, depth)?;
12723            self.44.encode(encoder, offset + 704, depth)?;
12724            self.45.encode(encoder, offset + 720, depth)?;
12725            self.46.encode(encoder, offset + 736, depth)?;
12726            self.47.encode(encoder, offset + 752, depth)?;
12727            self.48.encode(encoder, offset + 768, depth)?;
12728            self.49.encode(encoder, offset + 784, depth)?;
12729            self.50.encode(encoder, offset + 800, depth)?;
12730            self.51.encode(encoder, offset + 816, depth)?;
12731            self.52.encode(encoder, offset + 832, depth)?;
12732            self.53.encode(encoder, offset + 848, depth)?;
12733            self.54.encode(encoder, offset + 864, depth)?;
12734            self.55.encode(encoder, offset + 880, depth)?;
12735            self.56.encode(encoder, offset + 896, depth)?;
12736            self.57.encode(encoder, offset + 912, depth)?;
12737            self.58.encode(encoder, offset + 928, depth)?;
12738            self.59.encode(encoder, offset + 944, depth)?;
12739            self.60.encode(encoder, offset + 960, depth)?;
12740            self.61.encode(encoder, offset + 976, depth)?;
12741            self.62.encode(encoder, offset + 992, depth)?;
12742            self.63.encode(encoder, offset + 1008, depth)?;
12743            self.64.encode(encoder, offset + 1024, depth)?;
12744            self.65.encode(encoder, offset + 1040, depth)?;
12745            self.66.encode(encoder, offset + 1056, depth)?;
12746            self.67.encode(encoder, offset + 1072, depth)?;
12747            self.68.encode(encoder, offset + 1088, depth)?;
12748            self.69.encode(encoder, offset + 1104, depth)?;
12749            self.70.encode(encoder, offset + 1120, depth)?;
12750            self.71.encode(encoder, offset + 1136, depth)?;
12751            self.72.encode(encoder, offset + 1152, depth)?;
12752            self.73.encode(encoder, offset + 1168, depth)?;
12753            self.74.encode(encoder, offset + 1184, depth)?;
12754            self.75.encode(encoder, offset + 1200, depth)?;
12755            self.76.encode(encoder, offset + 1216, depth)?;
12756            self.77.encode(encoder, offset + 1232, depth)?;
12757            self.78.encode(encoder, offset + 1248, depth)?;
12758            self.79.encode(encoder, offset + 1264, depth)?;
12759            self.80.encode(encoder, offset + 1280, depth)?;
12760            self.81.encode(encoder, offset + 1296, depth)?;
12761            self.82.encode(encoder, offset + 1312, depth)?;
12762            self.83.encode(encoder, offset + 1328, depth)?;
12763            self.84.encode(encoder, offset + 1344, depth)?;
12764            self.85.encode(encoder, offset + 1360, depth)?;
12765            self.86.encode(encoder, offset + 1376, depth)?;
12766            self.87.encode(encoder, offset + 1392, depth)?;
12767            self.88.encode(encoder, offset + 1408, depth)?;
12768            self.89.encode(encoder, offset + 1424, depth)?;
12769            self.90.encode(encoder, offset + 1440, depth)?;
12770            self.91.encode(encoder, offset + 1456, depth)?;
12771            self.92.encode(encoder, offset + 1472, depth)?;
12772            self.93.encode(encoder, offset + 1488, depth)?;
12773            self.94.encode(encoder, offset + 1504, depth)?;
12774            self.95.encode(encoder, offset + 1520, depth)?;
12775            self.96.encode(encoder, offset + 1536, depth)?;
12776            self.97.encode(encoder, offset + 1552, depth)?;
12777            self.98.encode(encoder, offset + 1568, depth)?;
12778            self.99.encode(encoder, offset + 1584, depth)?;
12779            self.100.encode(encoder, offset + 1600, depth)?;
12780            self.101.encode(encoder, offset + 1616, depth)?;
12781            self.102.encode(encoder, offset + 1632, depth)?;
12782            self.103.encode(encoder, offset + 1648, depth)?;
12783            self.104.encode(encoder, offset + 1664, depth)?;
12784            self.105.encode(encoder, offset + 1680, depth)?;
12785            self.106.encode(encoder, offset + 1696, depth)?;
12786            self.107.encode(encoder, offset + 1712, depth)?;
12787            self.108.encode(encoder, offset + 1728, depth)?;
12788            self.109.encode(encoder, offset + 1744, depth)?;
12789            self.110.encode(encoder, offset + 1760, depth)?;
12790            self.111.encode(encoder, offset + 1776, depth)?;
12791            self.112.encode(encoder, offset + 1792, depth)?;
12792            self.113.encode(encoder, offset + 1808, depth)?;
12793            self.114.encode(encoder, offset + 1824, depth)?;
12794            self.115.encode(encoder, offset + 1840, depth)?;
12795            self.116.encode(encoder, offset + 1856, depth)?;
12796            self.117.encode(encoder, offset + 1872, depth)?;
12797            self.118.encode(encoder, offset + 1888, depth)?;
12798            self.119.encode(encoder, offset + 1904, depth)?;
12799            Ok(())
12800        }
12801    }
12802
12803    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Vectors {
12804        #[inline(always)]
12805        fn new_empty() -> Self {
12806            Self {
12807                b_0: fidl::new_empty!(
12808                    fidl::encoding::UnboundedVector<bool>,
12809                    fidl::encoding::DefaultFuchsiaResourceDialect
12810                ),
12811                i8_0: fidl::new_empty!(
12812                    fidl::encoding::UnboundedVector<i8>,
12813                    fidl::encoding::DefaultFuchsiaResourceDialect
12814                ),
12815                i16_0: fidl::new_empty!(
12816                    fidl::encoding::UnboundedVector<i16>,
12817                    fidl::encoding::DefaultFuchsiaResourceDialect
12818                ),
12819                i32_0: fidl::new_empty!(
12820                    fidl::encoding::UnboundedVector<i32>,
12821                    fidl::encoding::DefaultFuchsiaResourceDialect
12822                ),
12823                i64_0: fidl::new_empty!(
12824                    fidl::encoding::UnboundedVector<i64>,
12825                    fidl::encoding::DefaultFuchsiaResourceDialect
12826                ),
12827                u8_0: fidl::new_empty!(
12828                    fidl::encoding::UnboundedVector<u8>,
12829                    fidl::encoding::DefaultFuchsiaResourceDialect
12830                ),
12831                u16_0: fidl::new_empty!(
12832                    fidl::encoding::UnboundedVector<u16>,
12833                    fidl::encoding::DefaultFuchsiaResourceDialect
12834                ),
12835                u32_0: fidl::new_empty!(
12836                    fidl::encoding::UnboundedVector<u32>,
12837                    fidl::encoding::DefaultFuchsiaResourceDialect
12838                ),
12839                u64_0: fidl::new_empty!(
12840                    fidl::encoding::UnboundedVector<u64>,
12841                    fidl::encoding::DefaultFuchsiaResourceDialect
12842                ),
12843                f32_0: fidl::new_empty!(
12844                    fidl::encoding::UnboundedVector<f32>,
12845                    fidl::encoding::DefaultFuchsiaResourceDialect
12846                ),
12847                f64_0: fidl::new_empty!(
12848                    fidl::encoding::UnboundedVector<f64>,
12849                    fidl::encoding::DefaultFuchsiaResourceDialect
12850                ),
12851                handle_0: fidl::new_empty!(
12852                    fidl::encoding::UnboundedVector<
12853                        fidl::encoding::HandleType<
12854                            fidl::NullableHandle,
12855                            { fidl::ObjectType::NONE.into_raw() },
12856                            2147483648,
12857                        >,
12858                    >,
12859                    fidl::encoding::DefaultFuchsiaResourceDialect
12860                ),
12861                b_1: fidl::new_empty!(
12862                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
12863                    fidl::encoding::DefaultFuchsiaResourceDialect
12864                ),
12865                i8_1: fidl::new_empty!(
12866                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
12867                    fidl::encoding::DefaultFuchsiaResourceDialect
12868                ),
12869                i16_1: fidl::new_empty!(
12870                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
12871                    fidl::encoding::DefaultFuchsiaResourceDialect
12872                ),
12873                i32_1: fidl::new_empty!(
12874                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
12875                    fidl::encoding::DefaultFuchsiaResourceDialect
12876                ),
12877                i64_1: fidl::new_empty!(
12878                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
12879                    fidl::encoding::DefaultFuchsiaResourceDialect
12880                ),
12881                u8_1: fidl::new_empty!(
12882                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
12883                    fidl::encoding::DefaultFuchsiaResourceDialect
12884                ),
12885                u16_1: fidl::new_empty!(
12886                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
12887                    fidl::encoding::DefaultFuchsiaResourceDialect
12888                ),
12889                u32_1: fidl::new_empty!(
12890                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
12891                    fidl::encoding::DefaultFuchsiaResourceDialect
12892                ),
12893                u64_1: fidl::new_empty!(
12894                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
12895                    fidl::encoding::DefaultFuchsiaResourceDialect
12896                ),
12897                f32_1: fidl::new_empty!(
12898                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
12899                    fidl::encoding::DefaultFuchsiaResourceDialect
12900                ),
12901                f64_1: fidl::new_empty!(
12902                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
12903                    fidl::encoding::DefaultFuchsiaResourceDialect
12904                ),
12905                handle_1: fidl::new_empty!(
12906                    fidl::encoding::UnboundedVector<
12907                        fidl::encoding::Vector<
12908                            fidl::encoding::HandleType<
12909                                fidl::NullableHandle,
12910                                { fidl::ObjectType::NONE.into_raw() },
12911                                2147483648,
12912                            >,
12913                            2,
12914                        >,
12915                    >,
12916                    fidl::encoding::DefaultFuchsiaResourceDialect
12917                ),
12918                b_sized_0: fidl::new_empty!(fidl::encoding::Vector<bool, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12919                i8_sized_0: fidl::new_empty!(fidl::encoding::Vector<i8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12920                i16_sized_0: fidl::new_empty!(fidl::encoding::Vector<i16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12921                i32_sized_0: fidl::new_empty!(fidl::encoding::Vector<i32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12922                i64_sized_0: fidl::new_empty!(fidl::encoding::Vector<i64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12923                u8_sized_0: fidl::new_empty!(fidl::encoding::Vector<u8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12924                u16_sized_0: fidl::new_empty!(fidl::encoding::Vector<u16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12925                u32_sized_0: fidl::new_empty!(fidl::encoding::Vector<u32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12926                u64_sized_0: fidl::new_empty!(fidl::encoding::Vector<u64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12927                f32_sized_0: fidl::new_empty!(fidl::encoding::Vector<f32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12928                f64_sized_0: fidl::new_empty!(fidl::encoding::Vector<f64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12929                handle_sized_0: fidl::new_empty!(
12930                    fidl::encoding::Vector<
12931                        fidl::encoding::HandleType<
12932                            fidl::NullableHandle,
12933                            { fidl::ObjectType::NONE.into_raw() },
12934                            2147483648,
12935                        >,
12936                        1,
12937                    >,
12938                    fidl::encoding::DefaultFuchsiaResourceDialect
12939                ),
12940                b_sized_1: fidl::new_empty!(fidl::encoding::Vector<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12941                i8_sized_1: fidl::new_empty!(fidl::encoding::Vector<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12942                i16_sized_1: fidl::new_empty!(fidl::encoding::Vector<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12943                i32_sized_1: fidl::new_empty!(fidl::encoding::Vector<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12944                i64_sized_1: fidl::new_empty!(fidl::encoding::Vector<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12945                u8_sized_1: fidl::new_empty!(fidl::encoding::Vector<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12946                u16_sized_1: fidl::new_empty!(fidl::encoding::Vector<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12947                u32_sized_1: fidl::new_empty!(fidl::encoding::Vector<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12948                u64_sized_1: fidl::new_empty!(fidl::encoding::Vector<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12949                f32_sized_1: fidl::new_empty!(fidl::encoding::Vector<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12950                f64_sized_1: fidl::new_empty!(fidl::encoding::Vector<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12951                handle_sized_1: fidl::new_empty!(
12952                    fidl::encoding::Vector<
12953                        fidl::encoding::HandleType<
12954                            fidl::NullableHandle,
12955                            { fidl::ObjectType::NONE.into_raw() },
12956                            2147483648,
12957                        >,
12958                        3,
12959                    >,
12960                    fidl::encoding::DefaultFuchsiaResourceDialect
12961                ),
12962                b_sized_2: fidl::new_empty!(
12963                    fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
12964                    fidl::encoding::DefaultFuchsiaResourceDialect
12965                ),
12966                i8_sized_2: fidl::new_empty!(
12967                    fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>,
12968                    fidl::encoding::DefaultFuchsiaResourceDialect
12969                ),
12970                i16_sized_2: fidl::new_empty!(
12971                    fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>,
12972                    fidl::encoding::DefaultFuchsiaResourceDialect
12973                ),
12974                i32_sized_2: fidl::new_empty!(
12975                    fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>,
12976                    fidl::encoding::DefaultFuchsiaResourceDialect
12977                ),
12978                i64_sized_2: fidl::new_empty!(
12979                    fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>,
12980                    fidl::encoding::DefaultFuchsiaResourceDialect
12981                ),
12982                u8_sized_2: fidl::new_empty!(
12983                    fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>,
12984                    fidl::encoding::DefaultFuchsiaResourceDialect
12985                ),
12986                u16_sized_2: fidl::new_empty!(
12987                    fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>,
12988                    fidl::encoding::DefaultFuchsiaResourceDialect
12989                ),
12990                u32_sized_2: fidl::new_empty!(
12991                    fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>,
12992                    fidl::encoding::DefaultFuchsiaResourceDialect
12993                ),
12994                u64_sized_2: fidl::new_empty!(
12995                    fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>,
12996                    fidl::encoding::DefaultFuchsiaResourceDialect
12997                ),
12998                f32_sized_2: fidl::new_empty!(
12999                    fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>,
13000                    fidl::encoding::DefaultFuchsiaResourceDialect
13001                ),
13002                f64_sized_2: fidl::new_empty!(
13003                    fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>,
13004                    fidl::encoding::DefaultFuchsiaResourceDialect
13005                ),
13006                handle_sized_2: fidl::new_empty!(
13007                    fidl::encoding::Vector<
13008                        fidl::encoding::Vector<
13009                            fidl::encoding::HandleType<
13010                                fidl::NullableHandle,
13011                                { fidl::ObjectType::NONE.into_raw() },
13012                                2147483648,
13013                            >,
13014                            2,
13015                        >,
13016                        3,
13017                    >,
13018                    fidl::encoding::DefaultFuchsiaResourceDialect
13019                ),
13020                b_nullable_0: fidl::new_empty!(
13021                    fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
13022                    fidl::encoding::DefaultFuchsiaResourceDialect
13023                ),
13024                i8_nullable_0: fidl::new_empty!(
13025                    fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
13026                    fidl::encoding::DefaultFuchsiaResourceDialect
13027                ),
13028                i16_nullable_0: fidl::new_empty!(
13029                    fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
13030                    fidl::encoding::DefaultFuchsiaResourceDialect
13031                ),
13032                i32_nullable_0: fidl::new_empty!(
13033                    fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
13034                    fidl::encoding::DefaultFuchsiaResourceDialect
13035                ),
13036                i64_nullable_0: fidl::new_empty!(
13037                    fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
13038                    fidl::encoding::DefaultFuchsiaResourceDialect
13039                ),
13040                u8_nullable_0: fidl::new_empty!(
13041                    fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
13042                    fidl::encoding::DefaultFuchsiaResourceDialect
13043                ),
13044                u16_nullable_0: fidl::new_empty!(
13045                    fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
13046                    fidl::encoding::DefaultFuchsiaResourceDialect
13047                ),
13048                u32_nullable_0: fidl::new_empty!(
13049                    fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
13050                    fidl::encoding::DefaultFuchsiaResourceDialect
13051                ),
13052                u64_nullable_0: fidl::new_empty!(
13053                    fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
13054                    fidl::encoding::DefaultFuchsiaResourceDialect
13055                ),
13056                f32_nullable_0: fidl::new_empty!(
13057                    fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
13058                    fidl::encoding::DefaultFuchsiaResourceDialect
13059                ),
13060                f64_nullable_0: fidl::new_empty!(
13061                    fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
13062                    fidl::encoding::DefaultFuchsiaResourceDialect
13063                ),
13064                handle_nullable_0: fidl::new_empty!(
13065                    fidl::encoding::Optional<
13066                        fidl::encoding::Vector<
13067                            fidl::encoding::HandleType<
13068                                fidl::NullableHandle,
13069                                { fidl::ObjectType::NONE.into_raw() },
13070                                2147483648,
13071                            >,
13072                            1,
13073                        >,
13074                    >,
13075                    fidl::encoding::DefaultFuchsiaResourceDialect
13076                ),
13077                b_nullable_1: fidl::new_empty!(
13078                    fidl::encoding::Optional<
13079                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
13080                    >,
13081                    fidl::encoding::DefaultFuchsiaResourceDialect
13082                ),
13083                i8_nullable_1: fidl::new_empty!(
13084                    fidl::encoding::Optional<
13085                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
13086                    >,
13087                    fidl::encoding::DefaultFuchsiaResourceDialect
13088                ),
13089                i16_nullable_1: fidl::new_empty!(
13090                    fidl::encoding::Optional<
13091                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
13092                    >,
13093                    fidl::encoding::DefaultFuchsiaResourceDialect
13094                ),
13095                i32_nullable_1: fidl::new_empty!(
13096                    fidl::encoding::Optional<
13097                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
13098                    >,
13099                    fidl::encoding::DefaultFuchsiaResourceDialect
13100                ),
13101                i64_nullable_1: fidl::new_empty!(
13102                    fidl::encoding::Optional<
13103                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
13104                    >,
13105                    fidl::encoding::DefaultFuchsiaResourceDialect
13106                ),
13107                u8_nullable_1: fidl::new_empty!(
13108                    fidl::encoding::Optional<
13109                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
13110                    >,
13111                    fidl::encoding::DefaultFuchsiaResourceDialect
13112                ),
13113                u16_nullable_1: fidl::new_empty!(
13114                    fidl::encoding::Optional<
13115                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
13116                    >,
13117                    fidl::encoding::DefaultFuchsiaResourceDialect
13118                ),
13119                u32_nullable_1: fidl::new_empty!(
13120                    fidl::encoding::Optional<
13121                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
13122                    >,
13123                    fidl::encoding::DefaultFuchsiaResourceDialect
13124                ),
13125                u64_nullable_1: fidl::new_empty!(
13126                    fidl::encoding::Optional<
13127                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
13128                    >,
13129                    fidl::encoding::DefaultFuchsiaResourceDialect
13130                ),
13131                f32_nullable_1: fidl::new_empty!(
13132                    fidl::encoding::Optional<
13133                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
13134                    >,
13135                    fidl::encoding::DefaultFuchsiaResourceDialect
13136                ),
13137                f64_nullable_1: fidl::new_empty!(
13138                    fidl::encoding::Optional<
13139                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
13140                    >,
13141                    fidl::encoding::DefaultFuchsiaResourceDialect
13142                ),
13143                handle_nullable_1: fidl::new_empty!(
13144                    fidl::encoding::Optional<
13145                        fidl::encoding::UnboundedVector<
13146                            fidl::encoding::Vector<
13147                                fidl::encoding::HandleType<
13148                                    fidl::NullableHandle,
13149                                    { fidl::ObjectType::NONE.into_raw() },
13150                                    2147483648,
13151                                >,
13152                                2,
13153                            >,
13154                        >,
13155                    >,
13156                    fidl::encoding::DefaultFuchsiaResourceDialect
13157                ),
13158                b_nullable_sized_0: fidl::new_empty!(
13159                    fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
13160                    fidl::encoding::DefaultFuchsiaResourceDialect
13161                ),
13162                i8_nullable_sized_0: fidl::new_empty!(
13163                    fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
13164                    fidl::encoding::DefaultFuchsiaResourceDialect
13165                ),
13166                i16_nullable_sized_0: fidl::new_empty!(
13167                    fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
13168                    fidl::encoding::DefaultFuchsiaResourceDialect
13169                ),
13170                i32_nullable_sized_0: fidl::new_empty!(
13171                    fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
13172                    fidl::encoding::DefaultFuchsiaResourceDialect
13173                ),
13174                i64_nullable_sized_0: fidl::new_empty!(
13175                    fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
13176                    fidl::encoding::DefaultFuchsiaResourceDialect
13177                ),
13178                u8_nullable_sized_0: fidl::new_empty!(
13179                    fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
13180                    fidl::encoding::DefaultFuchsiaResourceDialect
13181                ),
13182                u16_nullable_sized_0: fidl::new_empty!(
13183                    fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
13184                    fidl::encoding::DefaultFuchsiaResourceDialect
13185                ),
13186                u32_nullable_sized_0: fidl::new_empty!(
13187                    fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
13188                    fidl::encoding::DefaultFuchsiaResourceDialect
13189                ),
13190                u64_nullable_sized_0: fidl::new_empty!(
13191                    fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
13192                    fidl::encoding::DefaultFuchsiaResourceDialect
13193                ),
13194                f32_nullable_sized_0: fidl::new_empty!(
13195                    fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
13196                    fidl::encoding::DefaultFuchsiaResourceDialect
13197                ),
13198                f64_nullable_sized_0: fidl::new_empty!(
13199                    fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
13200                    fidl::encoding::DefaultFuchsiaResourceDialect
13201                ),
13202                handle_nullable_sized_0: fidl::new_empty!(
13203                    fidl::encoding::Optional<
13204                        fidl::encoding::Vector<
13205                            fidl::encoding::HandleType<
13206                                fidl::NullableHandle,
13207                                { fidl::ObjectType::NONE.into_raw() },
13208                                2147483648,
13209                            >,
13210                            1,
13211                        >,
13212                    >,
13213                    fidl::encoding::DefaultFuchsiaResourceDialect
13214                ),
13215                b_nullable_sized_1: fidl::new_empty!(
13216                    fidl::encoding::Optional<fidl::encoding::Vector<bool, 3>>,
13217                    fidl::encoding::DefaultFuchsiaResourceDialect
13218                ),
13219                i8_nullable_sized_1: fidl::new_empty!(
13220                    fidl::encoding::Optional<fidl::encoding::Vector<i8, 3>>,
13221                    fidl::encoding::DefaultFuchsiaResourceDialect
13222                ),
13223                i16_nullable_sized_1: fidl::new_empty!(
13224                    fidl::encoding::Optional<fidl::encoding::Vector<i16, 3>>,
13225                    fidl::encoding::DefaultFuchsiaResourceDialect
13226                ),
13227                i32_nullable_sized_1: fidl::new_empty!(
13228                    fidl::encoding::Optional<fidl::encoding::Vector<i32, 3>>,
13229                    fidl::encoding::DefaultFuchsiaResourceDialect
13230                ),
13231                i64_nullable_sized_1: fidl::new_empty!(
13232                    fidl::encoding::Optional<fidl::encoding::Vector<i64, 3>>,
13233                    fidl::encoding::DefaultFuchsiaResourceDialect
13234                ),
13235                u8_nullable_sized_1: fidl::new_empty!(
13236                    fidl::encoding::Optional<fidl::encoding::Vector<u8, 3>>,
13237                    fidl::encoding::DefaultFuchsiaResourceDialect
13238                ),
13239                u16_nullable_sized_1: fidl::new_empty!(
13240                    fidl::encoding::Optional<fidl::encoding::Vector<u16, 3>>,
13241                    fidl::encoding::DefaultFuchsiaResourceDialect
13242                ),
13243                u32_nullable_sized_1: fidl::new_empty!(
13244                    fidl::encoding::Optional<fidl::encoding::Vector<u32, 3>>,
13245                    fidl::encoding::DefaultFuchsiaResourceDialect
13246                ),
13247                u64_nullable_sized_1: fidl::new_empty!(
13248                    fidl::encoding::Optional<fidl::encoding::Vector<u64, 3>>,
13249                    fidl::encoding::DefaultFuchsiaResourceDialect
13250                ),
13251                f32_nullable_sized_1: fidl::new_empty!(
13252                    fidl::encoding::Optional<fidl::encoding::Vector<f32, 3>>,
13253                    fidl::encoding::DefaultFuchsiaResourceDialect
13254                ),
13255                f64_nullable_sized_1: fidl::new_empty!(
13256                    fidl::encoding::Optional<fidl::encoding::Vector<f64, 3>>,
13257                    fidl::encoding::DefaultFuchsiaResourceDialect
13258                ),
13259                handle_nullable_sized_1: fidl::new_empty!(
13260                    fidl::encoding::Optional<
13261                        fidl::encoding::Vector<
13262                            fidl::encoding::HandleType<
13263                                fidl::NullableHandle,
13264                                { fidl::ObjectType::NONE.into_raw() },
13265                                2147483648,
13266                            >,
13267                            3,
13268                        >,
13269                    >,
13270                    fidl::encoding::DefaultFuchsiaResourceDialect
13271                ),
13272                b_nullable_sized_2: fidl::new_empty!(
13273                    fidl::encoding::Optional<
13274                        fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
13275                    >,
13276                    fidl::encoding::DefaultFuchsiaResourceDialect
13277                ),
13278                i8_nullable_sized_2: fidl::new_empty!(
13279                    fidl::encoding::Optional<
13280                        fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>,
13281                    >,
13282                    fidl::encoding::DefaultFuchsiaResourceDialect
13283                ),
13284                i16_nullable_sized_2: fidl::new_empty!(
13285                    fidl::encoding::Optional<
13286                        fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>,
13287                    >,
13288                    fidl::encoding::DefaultFuchsiaResourceDialect
13289                ),
13290                i32_nullable_sized_2: fidl::new_empty!(
13291                    fidl::encoding::Optional<
13292                        fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>,
13293                    >,
13294                    fidl::encoding::DefaultFuchsiaResourceDialect
13295                ),
13296                i64_nullable_sized_2: fidl::new_empty!(
13297                    fidl::encoding::Optional<
13298                        fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>,
13299                    >,
13300                    fidl::encoding::DefaultFuchsiaResourceDialect
13301                ),
13302                u8_nullable_sized_2: fidl::new_empty!(
13303                    fidl::encoding::Optional<
13304                        fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>,
13305                    >,
13306                    fidl::encoding::DefaultFuchsiaResourceDialect
13307                ),
13308                u16_nullable_sized_2: fidl::new_empty!(
13309                    fidl::encoding::Optional<
13310                        fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>,
13311                    >,
13312                    fidl::encoding::DefaultFuchsiaResourceDialect
13313                ),
13314                u32_nullable_sized_2: fidl::new_empty!(
13315                    fidl::encoding::Optional<
13316                        fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>,
13317                    >,
13318                    fidl::encoding::DefaultFuchsiaResourceDialect
13319                ),
13320                u64_nullable_sized_2: fidl::new_empty!(
13321                    fidl::encoding::Optional<
13322                        fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>,
13323                    >,
13324                    fidl::encoding::DefaultFuchsiaResourceDialect
13325                ),
13326                f32_nullable_sized_2: fidl::new_empty!(
13327                    fidl::encoding::Optional<
13328                        fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>,
13329                    >,
13330                    fidl::encoding::DefaultFuchsiaResourceDialect
13331                ),
13332                f64_nullable_sized_2: fidl::new_empty!(
13333                    fidl::encoding::Optional<
13334                        fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>,
13335                    >,
13336                    fidl::encoding::DefaultFuchsiaResourceDialect
13337                ),
13338                handle_nullable_sized_2: fidl::new_empty!(
13339                    fidl::encoding::Optional<
13340                        fidl::encoding::Vector<
13341                            fidl::encoding::Vector<
13342                                fidl::encoding::HandleType<
13343                                    fidl::NullableHandle,
13344                                    { fidl::ObjectType::NONE.into_raw() },
13345                                    2147483648,
13346                                >,
13347                                2,
13348                            >,
13349                            3,
13350                        >,
13351                    >,
13352                    fidl::encoding::DefaultFuchsiaResourceDialect
13353                ),
13354            }
13355        }
13356
13357        #[inline]
13358        unsafe fn decode(
13359            &mut self,
13360            decoder: &mut fidl::encoding::Decoder<
13361                '_,
13362                fidl::encoding::DefaultFuchsiaResourceDialect,
13363            >,
13364            offset: usize,
13365            _depth: fidl::encoding::Depth,
13366        ) -> fidl::Result<()> {
13367            decoder.debug_check_bounds::<Self>(offset);
13368            // Verify that padding bytes are zero.
13369            fidl::decode!(
13370                fidl::encoding::UnboundedVector<bool>,
13371                fidl::encoding::DefaultFuchsiaResourceDialect,
13372                &mut self.b_0,
13373                decoder,
13374                offset + 0,
13375                _depth
13376            )?;
13377            fidl::decode!(
13378                fidl::encoding::UnboundedVector<i8>,
13379                fidl::encoding::DefaultFuchsiaResourceDialect,
13380                &mut self.i8_0,
13381                decoder,
13382                offset + 16,
13383                _depth
13384            )?;
13385            fidl::decode!(
13386                fidl::encoding::UnboundedVector<i16>,
13387                fidl::encoding::DefaultFuchsiaResourceDialect,
13388                &mut self.i16_0,
13389                decoder,
13390                offset + 32,
13391                _depth
13392            )?;
13393            fidl::decode!(
13394                fidl::encoding::UnboundedVector<i32>,
13395                fidl::encoding::DefaultFuchsiaResourceDialect,
13396                &mut self.i32_0,
13397                decoder,
13398                offset + 48,
13399                _depth
13400            )?;
13401            fidl::decode!(
13402                fidl::encoding::UnboundedVector<i64>,
13403                fidl::encoding::DefaultFuchsiaResourceDialect,
13404                &mut self.i64_0,
13405                decoder,
13406                offset + 64,
13407                _depth
13408            )?;
13409            fidl::decode!(
13410                fidl::encoding::UnboundedVector<u8>,
13411                fidl::encoding::DefaultFuchsiaResourceDialect,
13412                &mut self.u8_0,
13413                decoder,
13414                offset + 80,
13415                _depth
13416            )?;
13417            fidl::decode!(
13418                fidl::encoding::UnboundedVector<u16>,
13419                fidl::encoding::DefaultFuchsiaResourceDialect,
13420                &mut self.u16_0,
13421                decoder,
13422                offset + 96,
13423                _depth
13424            )?;
13425            fidl::decode!(
13426                fidl::encoding::UnboundedVector<u32>,
13427                fidl::encoding::DefaultFuchsiaResourceDialect,
13428                &mut self.u32_0,
13429                decoder,
13430                offset + 112,
13431                _depth
13432            )?;
13433            fidl::decode!(
13434                fidl::encoding::UnboundedVector<u64>,
13435                fidl::encoding::DefaultFuchsiaResourceDialect,
13436                &mut self.u64_0,
13437                decoder,
13438                offset + 128,
13439                _depth
13440            )?;
13441            fidl::decode!(
13442                fidl::encoding::UnboundedVector<f32>,
13443                fidl::encoding::DefaultFuchsiaResourceDialect,
13444                &mut self.f32_0,
13445                decoder,
13446                offset + 144,
13447                _depth
13448            )?;
13449            fidl::decode!(
13450                fidl::encoding::UnboundedVector<f64>,
13451                fidl::encoding::DefaultFuchsiaResourceDialect,
13452                &mut self.f64_0,
13453                decoder,
13454                offset + 160,
13455                _depth
13456            )?;
13457            fidl::decode!(
13458                fidl::encoding::UnboundedVector<
13459                    fidl::encoding::HandleType<
13460                        fidl::NullableHandle,
13461                        { fidl::ObjectType::NONE.into_raw() },
13462                        2147483648,
13463                    >,
13464                >,
13465                fidl::encoding::DefaultFuchsiaResourceDialect,
13466                &mut self.handle_0,
13467                decoder,
13468                offset + 176,
13469                _depth
13470            )?;
13471            fidl::decode!(
13472                fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
13473                fidl::encoding::DefaultFuchsiaResourceDialect,
13474                &mut self.b_1,
13475                decoder,
13476                offset + 192,
13477                _depth
13478            )?;
13479            fidl::decode!(
13480                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
13481                fidl::encoding::DefaultFuchsiaResourceDialect,
13482                &mut self.i8_1,
13483                decoder,
13484                offset + 208,
13485                _depth
13486            )?;
13487            fidl::decode!(
13488                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
13489                fidl::encoding::DefaultFuchsiaResourceDialect,
13490                &mut self.i16_1,
13491                decoder,
13492                offset + 224,
13493                _depth
13494            )?;
13495            fidl::decode!(
13496                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
13497                fidl::encoding::DefaultFuchsiaResourceDialect,
13498                &mut self.i32_1,
13499                decoder,
13500                offset + 240,
13501                _depth
13502            )?;
13503            fidl::decode!(
13504                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
13505                fidl::encoding::DefaultFuchsiaResourceDialect,
13506                &mut self.i64_1,
13507                decoder,
13508                offset + 256,
13509                _depth
13510            )?;
13511            fidl::decode!(
13512                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
13513                fidl::encoding::DefaultFuchsiaResourceDialect,
13514                &mut self.u8_1,
13515                decoder,
13516                offset + 272,
13517                _depth
13518            )?;
13519            fidl::decode!(
13520                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
13521                fidl::encoding::DefaultFuchsiaResourceDialect,
13522                &mut self.u16_1,
13523                decoder,
13524                offset + 288,
13525                _depth
13526            )?;
13527            fidl::decode!(
13528                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
13529                fidl::encoding::DefaultFuchsiaResourceDialect,
13530                &mut self.u32_1,
13531                decoder,
13532                offset + 304,
13533                _depth
13534            )?;
13535            fidl::decode!(
13536                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
13537                fidl::encoding::DefaultFuchsiaResourceDialect,
13538                &mut self.u64_1,
13539                decoder,
13540                offset + 320,
13541                _depth
13542            )?;
13543            fidl::decode!(
13544                fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
13545                fidl::encoding::DefaultFuchsiaResourceDialect,
13546                &mut self.f32_1,
13547                decoder,
13548                offset + 336,
13549                _depth
13550            )?;
13551            fidl::decode!(
13552                fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
13553                fidl::encoding::DefaultFuchsiaResourceDialect,
13554                &mut self.f64_1,
13555                decoder,
13556                offset + 352,
13557                _depth
13558            )?;
13559            fidl::decode!(
13560                fidl::encoding::UnboundedVector<
13561                    fidl::encoding::Vector<
13562                        fidl::encoding::HandleType<
13563                            fidl::NullableHandle,
13564                            { fidl::ObjectType::NONE.into_raw() },
13565                            2147483648,
13566                        >,
13567                        2,
13568                    >,
13569                >,
13570                fidl::encoding::DefaultFuchsiaResourceDialect,
13571                &mut self.handle_1,
13572                decoder,
13573                offset + 368,
13574                _depth
13575            )?;
13576            fidl::decode!(fidl::encoding::Vector<bool, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.b_sized_0, decoder, offset + 384, _depth)?;
13577            fidl::decode!(fidl::encoding::Vector<i8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i8_sized_0, decoder, offset + 400, _depth)?;
13578            fidl::decode!(fidl::encoding::Vector<i16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i16_sized_0, decoder, offset + 416, _depth)?;
13579            fidl::decode!(fidl::encoding::Vector<i32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i32_sized_0, decoder, offset + 432, _depth)?;
13580            fidl::decode!(fidl::encoding::Vector<i64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i64_sized_0, decoder, offset + 448, _depth)?;
13581            fidl::decode!(fidl::encoding::Vector<u8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u8_sized_0, decoder, offset + 464, _depth)?;
13582            fidl::decode!(fidl::encoding::Vector<u16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u16_sized_0, decoder, offset + 480, _depth)?;
13583            fidl::decode!(fidl::encoding::Vector<u32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u32_sized_0, decoder, offset + 496, _depth)?;
13584            fidl::decode!(fidl::encoding::Vector<u64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u64_sized_0, decoder, offset + 512, _depth)?;
13585            fidl::decode!(fidl::encoding::Vector<f32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f32_sized_0, decoder, offset + 528, _depth)?;
13586            fidl::decode!(fidl::encoding::Vector<f64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f64_sized_0, decoder, offset + 544, _depth)?;
13587            fidl::decode!(
13588                fidl::encoding::Vector<
13589                    fidl::encoding::HandleType<
13590                        fidl::NullableHandle,
13591                        { fidl::ObjectType::NONE.into_raw() },
13592                        2147483648,
13593                    >,
13594                    1,
13595                >,
13596                fidl::encoding::DefaultFuchsiaResourceDialect,
13597                &mut self.handle_sized_0,
13598                decoder,
13599                offset + 560,
13600                _depth
13601            )?;
13602            fidl::decode!(fidl::encoding::Vector<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.b_sized_1, decoder, offset + 576, _depth)?;
13603            fidl::decode!(fidl::encoding::Vector<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i8_sized_1, decoder, offset + 592, _depth)?;
13604            fidl::decode!(fidl::encoding::Vector<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i16_sized_1, decoder, offset + 608, _depth)?;
13605            fidl::decode!(fidl::encoding::Vector<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i32_sized_1, decoder, offset + 624, _depth)?;
13606            fidl::decode!(fidl::encoding::Vector<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i64_sized_1, decoder, offset + 640, _depth)?;
13607            fidl::decode!(fidl::encoding::Vector<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u8_sized_1, decoder, offset + 656, _depth)?;
13608            fidl::decode!(fidl::encoding::Vector<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u16_sized_1, decoder, offset + 672, _depth)?;
13609            fidl::decode!(fidl::encoding::Vector<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u32_sized_1, decoder, offset + 688, _depth)?;
13610            fidl::decode!(fidl::encoding::Vector<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u64_sized_1, decoder, offset + 704, _depth)?;
13611            fidl::decode!(fidl::encoding::Vector<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f32_sized_1, decoder, offset + 720, _depth)?;
13612            fidl::decode!(fidl::encoding::Vector<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f64_sized_1, decoder, offset + 736, _depth)?;
13613            fidl::decode!(
13614                fidl::encoding::Vector<
13615                    fidl::encoding::HandleType<
13616                        fidl::NullableHandle,
13617                        { fidl::ObjectType::NONE.into_raw() },
13618                        2147483648,
13619                    >,
13620                    3,
13621                >,
13622                fidl::encoding::DefaultFuchsiaResourceDialect,
13623                &mut self.handle_sized_1,
13624                decoder,
13625                offset + 752,
13626                _depth
13627            )?;
13628            fidl::decode!(
13629                fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
13630                fidl::encoding::DefaultFuchsiaResourceDialect,
13631                &mut self.b_sized_2,
13632                decoder,
13633                offset + 768,
13634                _depth
13635            )?;
13636            fidl::decode!(
13637                fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>,
13638                fidl::encoding::DefaultFuchsiaResourceDialect,
13639                &mut self.i8_sized_2,
13640                decoder,
13641                offset + 784,
13642                _depth
13643            )?;
13644            fidl::decode!(
13645                fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>,
13646                fidl::encoding::DefaultFuchsiaResourceDialect,
13647                &mut self.i16_sized_2,
13648                decoder,
13649                offset + 800,
13650                _depth
13651            )?;
13652            fidl::decode!(
13653                fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>,
13654                fidl::encoding::DefaultFuchsiaResourceDialect,
13655                &mut self.i32_sized_2,
13656                decoder,
13657                offset + 816,
13658                _depth
13659            )?;
13660            fidl::decode!(
13661                fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>,
13662                fidl::encoding::DefaultFuchsiaResourceDialect,
13663                &mut self.i64_sized_2,
13664                decoder,
13665                offset + 832,
13666                _depth
13667            )?;
13668            fidl::decode!(
13669                fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>,
13670                fidl::encoding::DefaultFuchsiaResourceDialect,
13671                &mut self.u8_sized_2,
13672                decoder,
13673                offset + 848,
13674                _depth
13675            )?;
13676            fidl::decode!(
13677                fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>,
13678                fidl::encoding::DefaultFuchsiaResourceDialect,
13679                &mut self.u16_sized_2,
13680                decoder,
13681                offset + 864,
13682                _depth
13683            )?;
13684            fidl::decode!(
13685                fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>,
13686                fidl::encoding::DefaultFuchsiaResourceDialect,
13687                &mut self.u32_sized_2,
13688                decoder,
13689                offset + 880,
13690                _depth
13691            )?;
13692            fidl::decode!(
13693                fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>,
13694                fidl::encoding::DefaultFuchsiaResourceDialect,
13695                &mut self.u64_sized_2,
13696                decoder,
13697                offset + 896,
13698                _depth
13699            )?;
13700            fidl::decode!(
13701                fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>,
13702                fidl::encoding::DefaultFuchsiaResourceDialect,
13703                &mut self.f32_sized_2,
13704                decoder,
13705                offset + 912,
13706                _depth
13707            )?;
13708            fidl::decode!(
13709                fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>,
13710                fidl::encoding::DefaultFuchsiaResourceDialect,
13711                &mut self.f64_sized_2,
13712                decoder,
13713                offset + 928,
13714                _depth
13715            )?;
13716            fidl::decode!(
13717                fidl::encoding::Vector<
13718                    fidl::encoding::Vector<
13719                        fidl::encoding::HandleType<
13720                            fidl::NullableHandle,
13721                            { fidl::ObjectType::NONE.into_raw() },
13722                            2147483648,
13723                        >,
13724                        2,
13725                    >,
13726                    3,
13727                >,
13728                fidl::encoding::DefaultFuchsiaResourceDialect,
13729                &mut self.handle_sized_2,
13730                decoder,
13731                offset + 944,
13732                _depth
13733            )?;
13734            fidl::decode!(
13735                fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
13736                fidl::encoding::DefaultFuchsiaResourceDialect,
13737                &mut self.b_nullable_0,
13738                decoder,
13739                offset + 960,
13740                _depth
13741            )?;
13742            fidl::decode!(
13743                fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
13744                fidl::encoding::DefaultFuchsiaResourceDialect,
13745                &mut self.i8_nullable_0,
13746                decoder,
13747                offset + 976,
13748                _depth
13749            )?;
13750            fidl::decode!(
13751                fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
13752                fidl::encoding::DefaultFuchsiaResourceDialect,
13753                &mut self.i16_nullable_0,
13754                decoder,
13755                offset + 992,
13756                _depth
13757            )?;
13758            fidl::decode!(
13759                fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
13760                fidl::encoding::DefaultFuchsiaResourceDialect,
13761                &mut self.i32_nullable_0,
13762                decoder,
13763                offset + 1008,
13764                _depth
13765            )?;
13766            fidl::decode!(
13767                fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
13768                fidl::encoding::DefaultFuchsiaResourceDialect,
13769                &mut self.i64_nullable_0,
13770                decoder,
13771                offset + 1024,
13772                _depth
13773            )?;
13774            fidl::decode!(
13775                fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
13776                fidl::encoding::DefaultFuchsiaResourceDialect,
13777                &mut self.u8_nullable_0,
13778                decoder,
13779                offset + 1040,
13780                _depth
13781            )?;
13782            fidl::decode!(
13783                fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
13784                fidl::encoding::DefaultFuchsiaResourceDialect,
13785                &mut self.u16_nullable_0,
13786                decoder,
13787                offset + 1056,
13788                _depth
13789            )?;
13790            fidl::decode!(
13791                fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
13792                fidl::encoding::DefaultFuchsiaResourceDialect,
13793                &mut self.u32_nullable_0,
13794                decoder,
13795                offset + 1072,
13796                _depth
13797            )?;
13798            fidl::decode!(
13799                fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
13800                fidl::encoding::DefaultFuchsiaResourceDialect,
13801                &mut self.u64_nullable_0,
13802                decoder,
13803                offset + 1088,
13804                _depth
13805            )?;
13806            fidl::decode!(
13807                fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
13808                fidl::encoding::DefaultFuchsiaResourceDialect,
13809                &mut self.f32_nullable_0,
13810                decoder,
13811                offset + 1104,
13812                _depth
13813            )?;
13814            fidl::decode!(
13815                fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
13816                fidl::encoding::DefaultFuchsiaResourceDialect,
13817                &mut self.f64_nullable_0,
13818                decoder,
13819                offset + 1120,
13820                _depth
13821            )?;
13822            fidl::decode!(
13823                fidl::encoding::Optional<
13824                    fidl::encoding::Vector<
13825                        fidl::encoding::HandleType<
13826                            fidl::NullableHandle,
13827                            { fidl::ObjectType::NONE.into_raw() },
13828                            2147483648,
13829                        >,
13830                        1,
13831                    >,
13832                >,
13833                fidl::encoding::DefaultFuchsiaResourceDialect,
13834                &mut self.handle_nullable_0,
13835                decoder,
13836                offset + 1136,
13837                _depth
13838            )?;
13839            fidl::decode!(
13840                fidl::encoding::Optional<
13841                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
13842                >,
13843                fidl::encoding::DefaultFuchsiaResourceDialect,
13844                &mut self.b_nullable_1,
13845                decoder,
13846                offset + 1152,
13847                _depth
13848            )?;
13849            fidl::decode!(
13850                fidl::encoding::Optional<
13851                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
13852                >,
13853                fidl::encoding::DefaultFuchsiaResourceDialect,
13854                &mut self.i8_nullable_1,
13855                decoder,
13856                offset + 1168,
13857                _depth
13858            )?;
13859            fidl::decode!(
13860                fidl::encoding::Optional<
13861                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
13862                >,
13863                fidl::encoding::DefaultFuchsiaResourceDialect,
13864                &mut self.i16_nullable_1,
13865                decoder,
13866                offset + 1184,
13867                _depth
13868            )?;
13869            fidl::decode!(
13870                fidl::encoding::Optional<
13871                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
13872                >,
13873                fidl::encoding::DefaultFuchsiaResourceDialect,
13874                &mut self.i32_nullable_1,
13875                decoder,
13876                offset + 1200,
13877                _depth
13878            )?;
13879            fidl::decode!(
13880                fidl::encoding::Optional<
13881                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
13882                >,
13883                fidl::encoding::DefaultFuchsiaResourceDialect,
13884                &mut self.i64_nullable_1,
13885                decoder,
13886                offset + 1216,
13887                _depth
13888            )?;
13889            fidl::decode!(
13890                fidl::encoding::Optional<
13891                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
13892                >,
13893                fidl::encoding::DefaultFuchsiaResourceDialect,
13894                &mut self.u8_nullable_1,
13895                decoder,
13896                offset + 1232,
13897                _depth
13898            )?;
13899            fidl::decode!(
13900                fidl::encoding::Optional<
13901                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
13902                >,
13903                fidl::encoding::DefaultFuchsiaResourceDialect,
13904                &mut self.u16_nullable_1,
13905                decoder,
13906                offset + 1248,
13907                _depth
13908            )?;
13909            fidl::decode!(
13910                fidl::encoding::Optional<
13911                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
13912                >,
13913                fidl::encoding::DefaultFuchsiaResourceDialect,
13914                &mut self.u32_nullable_1,
13915                decoder,
13916                offset + 1264,
13917                _depth
13918            )?;
13919            fidl::decode!(
13920                fidl::encoding::Optional<
13921                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
13922                >,
13923                fidl::encoding::DefaultFuchsiaResourceDialect,
13924                &mut self.u64_nullable_1,
13925                decoder,
13926                offset + 1280,
13927                _depth
13928            )?;
13929            fidl::decode!(
13930                fidl::encoding::Optional<
13931                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
13932                >,
13933                fidl::encoding::DefaultFuchsiaResourceDialect,
13934                &mut self.f32_nullable_1,
13935                decoder,
13936                offset + 1296,
13937                _depth
13938            )?;
13939            fidl::decode!(
13940                fidl::encoding::Optional<
13941                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
13942                >,
13943                fidl::encoding::DefaultFuchsiaResourceDialect,
13944                &mut self.f64_nullable_1,
13945                decoder,
13946                offset + 1312,
13947                _depth
13948            )?;
13949            fidl::decode!(
13950                fidl::encoding::Optional<
13951                    fidl::encoding::UnboundedVector<
13952                        fidl::encoding::Vector<
13953                            fidl::encoding::HandleType<
13954                                fidl::NullableHandle,
13955                                { fidl::ObjectType::NONE.into_raw() },
13956                                2147483648,
13957                            >,
13958                            2,
13959                        >,
13960                    >,
13961                >,
13962                fidl::encoding::DefaultFuchsiaResourceDialect,
13963                &mut self.handle_nullable_1,
13964                decoder,
13965                offset + 1328,
13966                _depth
13967            )?;
13968            fidl::decode!(
13969                fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
13970                fidl::encoding::DefaultFuchsiaResourceDialect,
13971                &mut self.b_nullable_sized_0,
13972                decoder,
13973                offset + 1344,
13974                _depth
13975            )?;
13976            fidl::decode!(
13977                fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
13978                fidl::encoding::DefaultFuchsiaResourceDialect,
13979                &mut self.i8_nullable_sized_0,
13980                decoder,
13981                offset + 1360,
13982                _depth
13983            )?;
13984            fidl::decode!(
13985                fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
13986                fidl::encoding::DefaultFuchsiaResourceDialect,
13987                &mut self.i16_nullable_sized_0,
13988                decoder,
13989                offset + 1376,
13990                _depth
13991            )?;
13992            fidl::decode!(
13993                fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
13994                fidl::encoding::DefaultFuchsiaResourceDialect,
13995                &mut self.i32_nullable_sized_0,
13996                decoder,
13997                offset + 1392,
13998                _depth
13999            )?;
14000            fidl::decode!(
14001                fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
14002                fidl::encoding::DefaultFuchsiaResourceDialect,
14003                &mut self.i64_nullable_sized_0,
14004                decoder,
14005                offset + 1408,
14006                _depth
14007            )?;
14008            fidl::decode!(
14009                fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
14010                fidl::encoding::DefaultFuchsiaResourceDialect,
14011                &mut self.u8_nullable_sized_0,
14012                decoder,
14013                offset + 1424,
14014                _depth
14015            )?;
14016            fidl::decode!(
14017                fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
14018                fidl::encoding::DefaultFuchsiaResourceDialect,
14019                &mut self.u16_nullable_sized_0,
14020                decoder,
14021                offset + 1440,
14022                _depth
14023            )?;
14024            fidl::decode!(
14025                fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
14026                fidl::encoding::DefaultFuchsiaResourceDialect,
14027                &mut self.u32_nullable_sized_0,
14028                decoder,
14029                offset + 1456,
14030                _depth
14031            )?;
14032            fidl::decode!(
14033                fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
14034                fidl::encoding::DefaultFuchsiaResourceDialect,
14035                &mut self.u64_nullable_sized_0,
14036                decoder,
14037                offset + 1472,
14038                _depth
14039            )?;
14040            fidl::decode!(
14041                fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
14042                fidl::encoding::DefaultFuchsiaResourceDialect,
14043                &mut self.f32_nullable_sized_0,
14044                decoder,
14045                offset + 1488,
14046                _depth
14047            )?;
14048            fidl::decode!(
14049                fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
14050                fidl::encoding::DefaultFuchsiaResourceDialect,
14051                &mut self.f64_nullable_sized_0,
14052                decoder,
14053                offset + 1504,
14054                _depth
14055            )?;
14056            fidl::decode!(
14057                fidl::encoding::Optional<
14058                    fidl::encoding::Vector<
14059                        fidl::encoding::HandleType<
14060                            fidl::NullableHandle,
14061                            { fidl::ObjectType::NONE.into_raw() },
14062                            2147483648,
14063                        >,
14064                        1,
14065                    >,
14066                >,
14067                fidl::encoding::DefaultFuchsiaResourceDialect,
14068                &mut self.handle_nullable_sized_0,
14069                decoder,
14070                offset + 1520,
14071                _depth
14072            )?;
14073            fidl::decode!(
14074                fidl::encoding::Optional<fidl::encoding::Vector<bool, 3>>,
14075                fidl::encoding::DefaultFuchsiaResourceDialect,
14076                &mut self.b_nullable_sized_1,
14077                decoder,
14078                offset + 1536,
14079                _depth
14080            )?;
14081            fidl::decode!(
14082                fidl::encoding::Optional<fidl::encoding::Vector<i8, 3>>,
14083                fidl::encoding::DefaultFuchsiaResourceDialect,
14084                &mut self.i8_nullable_sized_1,
14085                decoder,
14086                offset + 1552,
14087                _depth
14088            )?;
14089            fidl::decode!(
14090                fidl::encoding::Optional<fidl::encoding::Vector<i16, 3>>,
14091                fidl::encoding::DefaultFuchsiaResourceDialect,
14092                &mut self.i16_nullable_sized_1,
14093                decoder,
14094                offset + 1568,
14095                _depth
14096            )?;
14097            fidl::decode!(
14098                fidl::encoding::Optional<fidl::encoding::Vector<i32, 3>>,
14099                fidl::encoding::DefaultFuchsiaResourceDialect,
14100                &mut self.i32_nullable_sized_1,
14101                decoder,
14102                offset + 1584,
14103                _depth
14104            )?;
14105            fidl::decode!(
14106                fidl::encoding::Optional<fidl::encoding::Vector<i64, 3>>,
14107                fidl::encoding::DefaultFuchsiaResourceDialect,
14108                &mut self.i64_nullable_sized_1,
14109                decoder,
14110                offset + 1600,
14111                _depth
14112            )?;
14113            fidl::decode!(
14114                fidl::encoding::Optional<fidl::encoding::Vector<u8, 3>>,
14115                fidl::encoding::DefaultFuchsiaResourceDialect,
14116                &mut self.u8_nullable_sized_1,
14117                decoder,
14118                offset + 1616,
14119                _depth
14120            )?;
14121            fidl::decode!(
14122                fidl::encoding::Optional<fidl::encoding::Vector<u16, 3>>,
14123                fidl::encoding::DefaultFuchsiaResourceDialect,
14124                &mut self.u16_nullable_sized_1,
14125                decoder,
14126                offset + 1632,
14127                _depth
14128            )?;
14129            fidl::decode!(
14130                fidl::encoding::Optional<fidl::encoding::Vector<u32, 3>>,
14131                fidl::encoding::DefaultFuchsiaResourceDialect,
14132                &mut self.u32_nullable_sized_1,
14133                decoder,
14134                offset + 1648,
14135                _depth
14136            )?;
14137            fidl::decode!(
14138                fidl::encoding::Optional<fidl::encoding::Vector<u64, 3>>,
14139                fidl::encoding::DefaultFuchsiaResourceDialect,
14140                &mut self.u64_nullable_sized_1,
14141                decoder,
14142                offset + 1664,
14143                _depth
14144            )?;
14145            fidl::decode!(
14146                fidl::encoding::Optional<fidl::encoding::Vector<f32, 3>>,
14147                fidl::encoding::DefaultFuchsiaResourceDialect,
14148                &mut self.f32_nullable_sized_1,
14149                decoder,
14150                offset + 1680,
14151                _depth
14152            )?;
14153            fidl::decode!(
14154                fidl::encoding::Optional<fidl::encoding::Vector<f64, 3>>,
14155                fidl::encoding::DefaultFuchsiaResourceDialect,
14156                &mut self.f64_nullable_sized_1,
14157                decoder,
14158                offset + 1696,
14159                _depth
14160            )?;
14161            fidl::decode!(
14162                fidl::encoding::Optional<
14163                    fidl::encoding::Vector<
14164                        fidl::encoding::HandleType<
14165                            fidl::NullableHandle,
14166                            { fidl::ObjectType::NONE.into_raw() },
14167                            2147483648,
14168                        >,
14169                        3,
14170                    >,
14171                >,
14172                fidl::encoding::DefaultFuchsiaResourceDialect,
14173                &mut self.handle_nullable_sized_1,
14174                decoder,
14175                offset + 1712,
14176                _depth
14177            )?;
14178            fidl::decode!(
14179                fidl::encoding::Optional<
14180                    fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
14181                >,
14182                fidl::encoding::DefaultFuchsiaResourceDialect,
14183                &mut self.b_nullable_sized_2,
14184                decoder,
14185                offset + 1728,
14186                _depth
14187            )?;
14188            fidl::decode!(
14189                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>>,
14190                fidl::encoding::DefaultFuchsiaResourceDialect,
14191                &mut self.i8_nullable_sized_2,
14192                decoder,
14193                offset + 1744,
14194                _depth
14195            )?;
14196            fidl::decode!(
14197                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>>,
14198                fidl::encoding::DefaultFuchsiaResourceDialect,
14199                &mut self.i16_nullable_sized_2,
14200                decoder,
14201                offset + 1760,
14202                _depth
14203            )?;
14204            fidl::decode!(
14205                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>>,
14206                fidl::encoding::DefaultFuchsiaResourceDialect,
14207                &mut self.i32_nullable_sized_2,
14208                decoder,
14209                offset + 1776,
14210                _depth
14211            )?;
14212            fidl::decode!(
14213                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>>,
14214                fidl::encoding::DefaultFuchsiaResourceDialect,
14215                &mut self.i64_nullable_sized_2,
14216                decoder,
14217                offset + 1792,
14218                _depth
14219            )?;
14220            fidl::decode!(
14221                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>>,
14222                fidl::encoding::DefaultFuchsiaResourceDialect,
14223                &mut self.u8_nullable_sized_2,
14224                decoder,
14225                offset + 1808,
14226                _depth
14227            )?;
14228            fidl::decode!(
14229                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>>,
14230                fidl::encoding::DefaultFuchsiaResourceDialect,
14231                &mut self.u16_nullable_sized_2,
14232                decoder,
14233                offset + 1824,
14234                _depth
14235            )?;
14236            fidl::decode!(
14237                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>>,
14238                fidl::encoding::DefaultFuchsiaResourceDialect,
14239                &mut self.u32_nullable_sized_2,
14240                decoder,
14241                offset + 1840,
14242                _depth
14243            )?;
14244            fidl::decode!(
14245                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>>,
14246                fidl::encoding::DefaultFuchsiaResourceDialect,
14247                &mut self.u64_nullable_sized_2,
14248                decoder,
14249                offset + 1856,
14250                _depth
14251            )?;
14252            fidl::decode!(
14253                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>>,
14254                fidl::encoding::DefaultFuchsiaResourceDialect,
14255                &mut self.f32_nullable_sized_2,
14256                decoder,
14257                offset + 1872,
14258                _depth
14259            )?;
14260            fidl::decode!(
14261                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>>,
14262                fidl::encoding::DefaultFuchsiaResourceDialect,
14263                &mut self.f64_nullable_sized_2,
14264                decoder,
14265                offset + 1888,
14266                _depth
14267            )?;
14268            fidl::decode!(
14269                fidl::encoding::Optional<
14270                    fidl::encoding::Vector<
14271                        fidl::encoding::Vector<
14272                            fidl::encoding::HandleType<
14273                                fidl::NullableHandle,
14274                                { fidl::ObjectType::NONE.into_raw() },
14275                                2147483648,
14276                            >,
14277                            2,
14278                        >,
14279                        3,
14280                    >,
14281                >,
14282                fidl::encoding::DefaultFuchsiaResourceDialect,
14283                &mut self.handle_nullable_sized_2,
14284                decoder,
14285                offset + 1904,
14286                _depth
14287            )?;
14288            Ok(())
14289        }
14290    }
14291
14292    impl AllTypesTable {
14293        #[inline(always)]
14294        fn max_ordinal_present(&self) -> u64 {
14295            if let Some(_) = self.xunion_member {
14296                return 21;
14297            }
14298            if let Some(_) = self.table_member {
14299                return 20;
14300            }
14301            if let Some(_) = self.vector_member {
14302                return 19;
14303            }
14304            if let Some(_) = self.array_member {
14305                return 18;
14306            }
14307            if let Some(_) = self.union_member {
14308                return 17;
14309            }
14310            if let Some(_) = self.struct_member {
14311                return 16;
14312            }
14313            if let Some(_) = self.string_member {
14314                return 15;
14315            }
14316            if let Some(_) = self.handle_member {
14317                return 14;
14318            }
14319            if let Some(_) = self.bits_member {
14320                return 13;
14321            }
14322            if let Some(_) = self.enum_member {
14323                return 12;
14324            }
14325            if let Some(_) = self.float64_member {
14326                return 11;
14327            }
14328            if let Some(_) = self.float32_member {
14329                return 10;
14330            }
14331            if let Some(_) = self.uint64_member {
14332                return 9;
14333            }
14334            if let Some(_) = self.uint32_member {
14335                return 8;
14336            }
14337            if let Some(_) = self.uint16_member {
14338                return 7;
14339            }
14340            if let Some(_) = self.uint8_member {
14341                return 6;
14342            }
14343            if let Some(_) = self.int64_member {
14344                return 5;
14345            }
14346            if let Some(_) = self.int32_member {
14347                return 4;
14348            }
14349            if let Some(_) = self.int16_member {
14350                return 3;
14351            }
14352            if let Some(_) = self.int8_member {
14353                return 2;
14354            }
14355            if let Some(_) = self.bool_member {
14356                return 1;
14357            }
14358            0
14359        }
14360    }
14361
14362    impl fidl::encoding::ResourceTypeMarker for AllTypesTable {
14363        type Borrowed<'a> = &'a mut Self;
14364        fn take_or_borrow<'a>(
14365            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
14366        ) -> Self::Borrowed<'a> {
14367            value
14368        }
14369    }
14370
14371    unsafe impl fidl::encoding::TypeMarker for AllTypesTable {
14372        type Owned = Self;
14373
14374        #[inline(always)]
14375        fn inline_align(_context: fidl::encoding::Context) -> usize {
14376            8
14377        }
14378
14379        #[inline(always)]
14380        fn inline_size(_context: fidl::encoding::Context) -> usize {
14381            16
14382        }
14383    }
14384
14385    unsafe impl fidl::encoding::Encode<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>
14386        for &mut AllTypesTable
14387    {
14388        unsafe fn encode(
14389            self,
14390            encoder: &mut fidl::encoding::Encoder<
14391                '_,
14392                fidl::encoding::DefaultFuchsiaResourceDialect,
14393            >,
14394            offset: usize,
14395            mut depth: fidl::encoding::Depth,
14396        ) -> fidl::Result<()> {
14397            encoder.debug_check_bounds::<AllTypesTable>(offset);
14398            // Vector header
14399            let max_ordinal: u64 = self.max_ordinal_present();
14400            encoder.write_num(max_ordinal, offset);
14401            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
14402            // Calling encoder.out_of_line_offset(0) is not allowed.
14403            if max_ordinal == 0 {
14404                return Ok(());
14405            }
14406            depth.increment()?;
14407            let envelope_size = 8;
14408            let bytes_len = max_ordinal as usize * envelope_size;
14409            #[allow(unused_variables)]
14410            let offset = encoder.out_of_line_offset(bytes_len);
14411            let mut _prev_end_offset: usize = 0;
14412            if 1 > max_ordinal {
14413                return Ok(());
14414            }
14415
14416            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14417            // are envelope_size bytes.
14418            let cur_offset: usize = (1 - 1) * envelope_size;
14419
14420            // Zero reserved fields.
14421            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14422
14423            // Safety:
14424            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14425            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14426            //   envelope_size bytes, there is always sufficient room.
14427            fidl::encoding::encode_in_envelope_optional::<
14428                bool,
14429                fidl::encoding::DefaultFuchsiaResourceDialect,
14430            >(
14431                self.bool_member.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
14432                encoder,
14433                offset + cur_offset,
14434                depth,
14435            )?;
14436
14437            _prev_end_offset = cur_offset + envelope_size;
14438            if 2 > max_ordinal {
14439                return Ok(());
14440            }
14441
14442            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14443            // are envelope_size bytes.
14444            let cur_offset: usize = (2 - 1) * envelope_size;
14445
14446            // Zero reserved fields.
14447            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14448
14449            // Safety:
14450            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14451            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14452            //   envelope_size bytes, there is always sufficient room.
14453            fidl::encoding::encode_in_envelope_optional::<
14454                i8,
14455                fidl::encoding::DefaultFuchsiaResourceDialect,
14456            >(
14457                self.int8_member.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
14458                encoder,
14459                offset + cur_offset,
14460                depth,
14461            )?;
14462
14463            _prev_end_offset = cur_offset + envelope_size;
14464            if 3 > max_ordinal {
14465                return Ok(());
14466            }
14467
14468            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14469            // are envelope_size bytes.
14470            let cur_offset: usize = (3 - 1) * envelope_size;
14471
14472            // Zero reserved fields.
14473            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14474
14475            // Safety:
14476            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14477            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14478            //   envelope_size bytes, there is always sufficient room.
14479            fidl::encoding::encode_in_envelope_optional::<
14480                i16,
14481                fidl::encoding::DefaultFuchsiaResourceDialect,
14482            >(
14483                self.int16_member.as_ref().map(<i16 as fidl::encoding::ValueTypeMarker>::borrow),
14484                encoder,
14485                offset + cur_offset,
14486                depth,
14487            )?;
14488
14489            _prev_end_offset = cur_offset + envelope_size;
14490            if 4 > max_ordinal {
14491                return Ok(());
14492            }
14493
14494            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14495            // are envelope_size bytes.
14496            let cur_offset: usize = (4 - 1) * envelope_size;
14497
14498            // Zero reserved fields.
14499            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14500
14501            // Safety:
14502            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14503            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14504            //   envelope_size bytes, there is always sufficient room.
14505            fidl::encoding::encode_in_envelope_optional::<
14506                i32,
14507                fidl::encoding::DefaultFuchsiaResourceDialect,
14508            >(
14509                self.int32_member.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
14510                encoder,
14511                offset + cur_offset,
14512                depth,
14513            )?;
14514
14515            _prev_end_offset = cur_offset + envelope_size;
14516            if 5 > max_ordinal {
14517                return Ok(());
14518            }
14519
14520            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14521            // are envelope_size bytes.
14522            let cur_offset: usize = (5 - 1) * envelope_size;
14523
14524            // Zero reserved fields.
14525            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14526
14527            // Safety:
14528            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14529            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14530            //   envelope_size bytes, there is always sufficient room.
14531            fidl::encoding::encode_in_envelope_optional::<
14532                i64,
14533                fidl::encoding::DefaultFuchsiaResourceDialect,
14534            >(
14535                self.int64_member.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
14536                encoder,
14537                offset + cur_offset,
14538                depth,
14539            )?;
14540
14541            _prev_end_offset = cur_offset + envelope_size;
14542            if 6 > max_ordinal {
14543                return Ok(());
14544            }
14545
14546            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14547            // are envelope_size bytes.
14548            let cur_offset: usize = (6 - 1) * envelope_size;
14549
14550            // Zero reserved fields.
14551            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14552
14553            // Safety:
14554            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14555            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14556            //   envelope_size bytes, there is always sufficient room.
14557            fidl::encoding::encode_in_envelope_optional::<
14558                u8,
14559                fidl::encoding::DefaultFuchsiaResourceDialect,
14560            >(
14561                self.uint8_member.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
14562                encoder,
14563                offset + cur_offset,
14564                depth,
14565            )?;
14566
14567            _prev_end_offset = cur_offset + envelope_size;
14568            if 7 > max_ordinal {
14569                return Ok(());
14570            }
14571
14572            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14573            // are envelope_size bytes.
14574            let cur_offset: usize = (7 - 1) * envelope_size;
14575
14576            // Zero reserved fields.
14577            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14578
14579            // Safety:
14580            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14581            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14582            //   envelope_size bytes, there is always sufficient room.
14583            fidl::encoding::encode_in_envelope_optional::<
14584                u16,
14585                fidl::encoding::DefaultFuchsiaResourceDialect,
14586            >(
14587                self.uint16_member.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
14588                encoder,
14589                offset + cur_offset,
14590                depth,
14591            )?;
14592
14593            _prev_end_offset = cur_offset + envelope_size;
14594            if 8 > max_ordinal {
14595                return Ok(());
14596            }
14597
14598            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14599            // are envelope_size bytes.
14600            let cur_offset: usize = (8 - 1) * envelope_size;
14601
14602            // Zero reserved fields.
14603            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14604
14605            // Safety:
14606            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14607            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14608            //   envelope_size bytes, there is always sufficient room.
14609            fidl::encoding::encode_in_envelope_optional::<
14610                u32,
14611                fidl::encoding::DefaultFuchsiaResourceDialect,
14612            >(
14613                self.uint32_member.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
14614                encoder,
14615                offset + cur_offset,
14616                depth,
14617            )?;
14618
14619            _prev_end_offset = cur_offset + envelope_size;
14620            if 9 > max_ordinal {
14621                return Ok(());
14622            }
14623
14624            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14625            // are envelope_size bytes.
14626            let cur_offset: usize = (9 - 1) * envelope_size;
14627
14628            // Zero reserved fields.
14629            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14630
14631            // Safety:
14632            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14633            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14634            //   envelope_size bytes, there is always sufficient room.
14635            fidl::encoding::encode_in_envelope_optional::<
14636                u64,
14637                fidl::encoding::DefaultFuchsiaResourceDialect,
14638            >(
14639                self.uint64_member.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
14640                encoder,
14641                offset + cur_offset,
14642                depth,
14643            )?;
14644
14645            _prev_end_offset = cur_offset + envelope_size;
14646            if 10 > max_ordinal {
14647                return Ok(());
14648            }
14649
14650            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14651            // are envelope_size bytes.
14652            let cur_offset: usize = (10 - 1) * envelope_size;
14653
14654            // Zero reserved fields.
14655            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14656
14657            // Safety:
14658            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14659            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14660            //   envelope_size bytes, there is always sufficient room.
14661            fidl::encoding::encode_in_envelope_optional::<
14662                f32,
14663                fidl::encoding::DefaultFuchsiaResourceDialect,
14664            >(
14665                self.float32_member.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
14666                encoder,
14667                offset + cur_offset,
14668                depth,
14669            )?;
14670
14671            _prev_end_offset = cur_offset + envelope_size;
14672            if 11 > max_ordinal {
14673                return Ok(());
14674            }
14675
14676            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14677            // are envelope_size bytes.
14678            let cur_offset: usize = (11 - 1) * envelope_size;
14679
14680            // Zero reserved fields.
14681            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14682
14683            // Safety:
14684            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14685            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14686            //   envelope_size bytes, there is always sufficient room.
14687            fidl::encoding::encode_in_envelope_optional::<
14688                f64,
14689                fidl::encoding::DefaultFuchsiaResourceDialect,
14690            >(
14691                self.float64_member.as_ref().map(<f64 as fidl::encoding::ValueTypeMarker>::borrow),
14692                encoder,
14693                offset + cur_offset,
14694                depth,
14695            )?;
14696
14697            _prev_end_offset = cur_offset + envelope_size;
14698            if 12 > max_ordinal {
14699                return Ok(());
14700            }
14701
14702            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14703            // are envelope_size bytes.
14704            let cur_offset: usize = (12 - 1) * envelope_size;
14705
14706            // Zero reserved fields.
14707            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14708
14709            // Safety:
14710            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14711            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14712            //   envelope_size bytes, there is always sufficient room.
14713            fidl::encoding::encode_in_envelope_optional::<
14714                DefaultEnum,
14715                fidl::encoding::DefaultFuchsiaResourceDialect,
14716            >(
14717                self.enum_member
14718                    .as_ref()
14719                    .map(<DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow),
14720                encoder,
14721                offset + cur_offset,
14722                depth,
14723            )?;
14724
14725            _prev_end_offset = cur_offset + envelope_size;
14726            if 13 > max_ordinal {
14727                return Ok(());
14728            }
14729
14730            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14731            // are envelope_size bytes.
14732            let cur_offset: usize = (13 - 1) * envelope_size;
14733
14734            // Zero reserved fields.
14735            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14736
14737            // Safety:
14738            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14739            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14740            //   envelope_size bytes, there is always sufficient room.
14741            fidl::encoding::encode_in_envelope_optional::<
14742                DefaultBits,
14743                fidl::encoding::DefaultFuchsiaResourceDialect,
14744            >(
14745                self.bits_member
14746                    .as_ref()
14747                    .map(<DefaultBits as fidl::encoding::ValueTypeMarker>::borrow),
14748                encoder,
14749                offset + cur_offset,
14750                depth,
14751            )?;
14752
14753            _prev_end_offset = cur_offset + envelope_size;
14754            if 14 > max_ordinal {
14755                return Ok(());
14756            }
14757
14758            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14759            // are envelope_size bytes.
14760            let cur_offset: usize = (14 - 1) * envelope_size;
14761
14762            // Zero reserved fields.
14763            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14764
14765            // Safety:
14766            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14767            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14768            //   envelope_size bytes, there is always sufficient room.
14769            fidl::encoding::encode_in_envelope_optional::<
14770                fidl::encoding::HandleType<
14771                    fidl::NullableHandle,
14772                    { fidl::ObjectType::NONE.into_raw() },
14773                    2147483648,
14774                >,
14775                fidl::encoding::DefaultFuchsiaResourceDialect,
14776            >(
14777                self.handle_member.as_mut().map(
14778                    <fidl::encoding::HandleType<
14779                        fidl::NullableHandle,
14780                        { fidl::ObjectType::NONE.into_raw() },
14781                        2147483648,
14782                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
14783                ),
14784                encoder,
14785                offset + cur_offset,
14786                depth,
14787            )?;
14788
14789            _prev_end_offset = cur_offset + envelope_size;
14790            if 15 > max_ordinal {
14791                return Ok(());
14792            }
14793
14794            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14795            // are envelope_size bytes.
14796            let cur_offset: usize = (15 - 1) * envelope_size;
14797
14798            // Zero reserved fields.
14799            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14800
14801            // Safety:
14802            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14803            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14804            //   envelope_size bytes, there is always sufficient room.
14805            fidl::encoding::encode_in_envelope_optional::<
14806                fidl::encoding::UnboundedString,
14807                fidl::encoding::DefaultFuchsiaResourceDialect,
14808            >(
14809                self.string_member.as_ref().map(
14810                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
14811                ),
14812                encoder,
14813                offset + cur_offset,
14814                depth,
14815            )?;
14816
14817            _prev_end_offset = cur_offset + envelope_size;
14818            if 16 > max_ordinal {
14819                return Ok(());
14820            }
14821
14822            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14823            // are envelope_size bytes.
14824            let cur_offset: usize = (16 - 1) * envelope_size;
14825
14826            // Zero reserved fields.
14827            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14828
14829            // Safety:
14830            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14831            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14832            //   envelope_size bytes, there is always sufficient room.
14833            fidl::encoding::encode_in_envelope_optional::<
14834                ThisIsAStruct,
14835                fidl::encoding::DefaultFuchsiaResourceDialect,
14836            >(
14837                self.struct_member
14838                    .as_ref()
14839                    .map(<ThisIsAStruct as fidl::encoding::ValueTypeMarker>::borrow),
14840                encoder,
14841                offset + cur_offset,
14842                depth,
14843            )?;
14844
14845            _prev_end_offset = cur_offset + envelope_size;
14846            if 17 > max_ordinal {
14847                return Ok(());
14848            }
14849
14850            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14851            // are envelope_size bytes.
14852            let cur_offset: usize = (17 - 1) * envelope_size;
14853
14854            // Zero reserved fields.
14855            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14856
14857            // Safety:
14858            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14859            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14860            //   envelope_size bytes, there is always sufficient room.
14861            fidl::encoding::encode_in_envelope_optional::<
14862                ThisIsAUnion,
14863                fidl::encoding::DefaultFuchsiaResourceDialect,
14864            >(
14865                self.union_member
14866                    .as_ref()
14867                    .map(<ThisIsAUnion as fidl::encoding::ValueTypeMarker>::borrow),
14868                encoder,
14869                offset + cur_offset,
14870                depth,
14871            )?;
14872
14873            _prev_end_offset = cur_offset + envelope_size;
14874            if 18 > max_ordinal {
14875                return Ok(());
14876            }
14877
14878            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14879            // are envelope_size bytes.
14880            let cur_offset: usize = (18 - 1) * envelope_size;
14881
14882            // Zero reserved fields.
14883            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14884
14885            // Safety:
14886            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14887            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14888            //   envelope_size bytes, there is always sufficient room.
14889            fidl::encoding::encode_in_envelope_optional::<
14890                fidl::encoding::Array<u32, 3>,
14891                fidl::encoding::DefaultFuchsiaResourceDialect,
14892            >(
14893                self.array_member.as_ref().map(
14894                    <fidl::encoding::Array<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow,
14895                ),
14896                encoder,
14897                offset + cur_offset,
14898                depth,
14899            )?;
14900
14901            _prev_end_offset = cur_offset + envelope_size;
14902            if 19 > max_ordinal {
14903                return Ok(());
14904            }
14905
14906            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14907            // are envelope_size bytes.
14908            let cur_offset: usize = (19 - 1) * envelope_size;
14909
14910            // Zero reserved fields.
14911            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14912
14913            // Safety:
14914            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14915            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14916            //   envelope_size bytes, there is always sufficient room.
14917            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u32>, fidl::encoding::DefaultFuchsiaResourceDialect>(
14918            self.vector_member.as_ref().map(<fidl::encoding::UnboundedVector<u32> as fidl::encoding::ValueTypeMarker>::borrow),
14919            encoder, offset + cur_offset, depth
14920        )?;
14921
14922            _prev_end_offset = cur_offset + envelope_size;
14923            if 20 > max_ordinal {
14924                return Ok(());
14925            }
14926
14927            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14928            // are envelope_size bytes.
14929            let cur_offset: usize = (20 - 1) * envelope_size;
14930
14931            // Zero reserved fields.
14932            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14933
14934            // Safety:
14935            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14936            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14937            //   envelope_size bytes, there is always sufficient room.
14938            fidl::encoding::encode_in_envelope_optional::<
14939                ThisIsATable,
14940                fidl::encoding::DefaultFuchsiaResourceDialect,
14941            >(
14942                self.table_member
14943                    .as_ref()
14944                    .map(<ThisIsATable as fidl::encoding::ValueTypeMarker>::borrow),
14945                encoder,
14946                offset + cur_offset,
14947                depth,
14948            )?;
14949
14950            _prev_end_offset = cur_offset + envelope_size;
14951            if 21 > max_ordinal {
14952                return Ok(());
14953            }
14954
14955            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14956            // are envelope_size bytes.
14957            let cur_offset: usize = (21 - 1) * envelope_size;
14958
14959            // Zero reserved fields.
14960            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14961
14962            // Safety:
14963            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14964            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14965            //   envelope_size bytes, there is always sufficient room.
14966            fidl::encoding::encode_in_envelope_optional::<
14967                ThisIsAXunion,
14968                fidl::encoding::DefaultFuchsiaResourceDialect,
14969            >(
14970                self.xunion_member
14971                    .as_ref()
14972                    .map(<ThisIsAXunion as fidl::encoding::ValueTypeMarker>::borrow),
14973                encoder,
14974                offset + cur_offset,
14975                depth,
14976            )?;
14977
14978            _prev_end_offset = cur_offset + envelope_size;
14979
14980            Ok(())
14981        }
14982    }
14983
14984    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for AllTypesTable {
14985        #[inline(always)]
14986        fn new_empty() -> Self {
14987            Self::default()
14988        }
14989
14990        unsafe fn decode(
14991            &mut self,
14992            decoder: &mut fidl::encoding::Decoder<
14993                '_,
14994                fidl::encoding::DefaultFuchsiaResourceDialect,
14995            >,
14996            offset: usize,
14997            mut depth: fidl::encoding::Depth,
14998        ) -> fidl::Result<()> {
14999            decoder.debug_check_bounds::<Self>(offset);
15000            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15001                None => return Err(fidl::Error::NotNullable),
15002                Some(len) => len,
15003            };
15004            // Calling decoder.out_of_line_offset(0) is not allowed.
15005            if len == 0 {
15006                return Ok(());
15007            };
15008            depth.increment()?;
15009            let envelope_size = 8;
15010            let bytes_len = len * envelope_size;
15011            let offset = decoder.out_of_line_offset(bytes_len)?;
15012            // Decode the envelope for each type.
15013            let mut _next_ordinal_to_read = 0;
15014            let mut next_offset = offset;
15015            let end_offset = offset + bytes_len;
15016            _next_ordinal_to_read += 1;
15017            if next_offset >= end_offset {
15018                return Ok(());
15019            }
15020
15021            // Decode unknown envelopes for gaps in ordinals.
15022            while _next_ordinal_to_read < 1 {
15023                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15024                _next_ordinal_to_read += 1;
15025                next_offset += envelope_size;
15026            }
15027
15028            let next_out_of_line = decoder.next_out_of_line();
15029            let handles_before = decoder.remaining_handles();
15030            if let Some((inlined, num_bytes, num_handles)) =
15031                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15032            {
15033                let member_inline_size =
15034                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15035                if inlined != (member_inline_size <= 4) {
15036                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15037                }
15038                let inner_offset;
15039                let mut inner_depth = depth.clone();
15040                if inlined {
15041                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15042                    inner_offset = next_offset;
15043                } else {
15044                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15045                    inner_depth.increment()?;
15046                }
15047                let val_ref = self.bool_member.get_or_insert_with(|| {
15048                    fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect)
15049                });
15050                fidl::decode!(
15051                    bool,
15052                    fidl::encoding::DefaultFuchsiaResourceDialect,
15053                    val_ref,
15054                    decoder,
15055                    inner_offset,
15056                    inner_depth
15057                )?;
15058                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15059                {
15060                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15061                }
15062                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15063                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15064                }
15065            }
15066
15067            next_offset += envelope_size;
15068            _next_ordinal_to_read += 1;
15069            if next_offset >= end_offset {
15070                return Ok(());
15071            }
15072
15073            // Decode unknown envelopes for gaps in ordinals.
15074            while _next_ordinal_to_read < 2 {
15075                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15076                _next_ordinal_to_read += 1;
15077                next_offset += envelope_size;
15078            }
15079
15080            let next_out_of_line = decoder.next_out_of_line();
15081            let handles_before = decoder.remaining_handles();
15082            if let Some((inlined, num_bytes, num_handles)) =
15083                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15084            {
15085                let member_inline_size =
15086                    <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15087                if inlined != (member_inline_size <= 4) {
15088                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15089                }
15090                let inner_offset;
15091                let mut inner_depth = depth.clone();
15092                if inlined {
15093                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15094                    inner_offset = next_offset;
15095                } else {
15096                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15097                    inner_depth.increment()?;
15098                }
15099                let val_ref = self.int8_member.get_or_insert_with(|| {
15100                    fidl::new_empty!(i8, fidl::encoding::DefaultFuchsiaResourceDialect)
15101                });
15102                fidl::decode!(
15103                    i8,
15104                    fidl::encoding::DefaultFuchsiaResourceDialect,
15105                    val_ref,
15106                    decoder,
15107                    inner_offset,
15108                    inner_depth
15109                )?;
15110                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15111                {
15112                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15113                }
15114                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15115                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15116                }
15117            }
15118
15119            next_offset += envelope_size;
15120            _next_ordinal_to_read += 1;
15121            if next_offset >= end_offset {
15122                return Ok(());
15123            }
15124
15125            // Decode unknown envelopes for gaps in ordinals.
15126            while _next_ordinal_to_read < 3 {
15127                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15128                _next_ordinal_to_read += 1;
15129                next_offset += envelope_size;
15130            }
15131
15132            let next_out_of_line = decoder.next_out_of_line();
15133            let handles_before = decoder.remaining_handles();
15134            if let Some((inlined, num_bytes, num_handles)) =
15135                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15136            {
15137                let member_inline_size =
15138                    <i16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15139                if inlined != (member_inline_size <= 4) {
15140                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15141                }
15142                let inner_offset;
15143                let mut inner_depth = depth.clone();
15144                if inlined {
15145                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15146                    inner_offset = next_offset;
15147                } else {
15148                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15149                    inner_depth.increment()?;
15150                }
15151                let val_ref = self.int16_member.get_or_insert_with(|| {
15152                    fidl::new_empty!(i16, fidl::encoding::DefaultFuchsiaResourceDialect)
15153                });
15154                fidl::decode!(
15155                    i16,
15156                    fidl::encoding::DefaultFuchsiaResourceDialect,
15157                    val_ref,
15158                    decoder,
15159                    inner_offset,
15160                    inner_depth
15161                )?;
15162                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15163                {
15164                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15165                }
15166                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15167                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15168                }
15169            }
15170
15171            next_offset += envelope_size;
15172            _next_ordinal_to_read += 1;
15173            if next_offset >= end_offset {
15174                return Ok(());
15175            }
15176
15177            // Decode unknown envelopes for gaps in ordinals.
15178            while _next_ordinal_to_read < 4 {
15179                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15180                _next_ordinal_to_read += 1;
15181                next_offset += envelope_size;
15182            }
15183
15184            let next_out_of_line = decoder.next_out_of_line();
15185            let handles_before = decoder.remaining_handles();
15186            if let Some((inlined, num_bytes, num_handles)) =
15187                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15188            {
15189                let member_inline_size =
15190                    <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15191                if inlined != (member_inline_size <= 4) {
15192                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15193                }
15194                let inner_offset;
15195                let mut inner_depth = depth.clone();
15196                if inlined {
15197                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15198                    inner_offset = next_offset;
15199                } else {
15200                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15201                    inner_depth.increment()?;
15202                }
15203                let val_ref = self.int32_member.get_or_insert_with(|| {
15204                    fidl::new_empty!(i32, fidl::encoding::DefaultFuchsiaResourceDialect)
15205                });
15206                fidl::decode!(
15207                    i32,
15208                    fidl::encoding::DefaultFuchsiaResourceDialect,
15209                    val_ref,
15210                    decoder,
15211                    inner_offset,
15212                    inner_depth
15213                )?;
15214                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15215                {
15216                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15217                }
15218                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15219                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15220                }
15221            }
15222
15223            next_offset += envelope_size;
15224            _next_ordinal_to_read += 1;
15225            if next_offset >= end_offset {
15226                return Ok(());
15227            }
15228
15229            // Decode unknown envelopes for gaps in ordinals.
15230            while _next_ordinal_to_read < 5 {
15231                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15232                _next_ordinal_to_read += 1;
15233                next_offset += envelope_size;
15234            }
15235
15236            let next_out_of_line = decoder.next_out_of_line();
15237            let handles_before = decoder.remaining_handles();
15238            if let Some((inlined, num_bytes, num_handles)) =
15239                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15240            {
15241                let member_inline_size =
15242                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15243                if inlined != (member_inline_size <= 4) {
15244                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15245                }
15246                let inner_offset;
15247                let mut inner_depth = depth.clone();
15248                if inlined {
15249                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15250                    inner_offset = next_offset;
15251                } else {
15252                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15253                    inner_depth.increment()?;
15254                }
15255                let val_ref = self.int64_member.get_or_insert_with(|| {
15256                    fidl::new_empty!(i64, fidl::encoding::DefaultFuchsiaResourceDialect)
15257                });
15258                fidl::decode!(
15259                    i64,
15260                    fidl::encoding::DefaultFuchsiaResourceDialect,
15261                    val_ref,
15262                    decoder,
15263                    inner_offset,
15264                    inner_depth
15265                )?;
15266                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15267                {
15268                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15269                }
15270                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15271                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15272                }
15273            }
15274
15275            next_offset += envelope_size;
15276            _next_ordinal_to_read += 1;
15277            if next_offset >= end_offset {
15278                return Ok(());
15279            }
15280
15281            // Decode unknown envelopes for gaps in ordinals.
15282            while _next_ordinal_to_read < 6 {
15283                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15284                _next_ordinal_to_read += 1;
15285                next_offset += envelope_size;
15286            }
15287
15288            let next_out_of_line = decoder.next_out_of_line();
15289            let handles_before = decoder.remaining_handles();
15290            if let Some((inlined, num_bytes, num_handles)) =
15291                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15292            {
15293                let member_inline_size =
15294                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15295                if inlined != (member_inline_size <= 4) {
15296                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15297                }
15298                let inner_offset;
15299                let mut inner_depth = depth.clone();
15300                if inlined {
15301                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15302                    inner_offset = next_offset;
15303                } else {
15304                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15305                    inner_depth.increment()?;
15306                }
15307                let val_ref = self.uint8_member.get_or_insert_with(|| {
15308                    fidl::new_empty!(u8, fidl::encoding::DefaultFuchsiaResourceDialect)
15309                });
15310                fidl::decode!(
15311                    u8,
15312                    fidl::encoding::DefaultFuchsiaResourceDialect,
15313                    val_ref,
15314                    decoder,
15315                    inner_offset,
15316                    inner_depth
15317                )?;
15318                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15319                {
15320                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15321                }
15322                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15323                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15324                }
15325            }
15326
15327            next_offset += envelope_size;
15328            _next_ordinal_to_read += 1;
15329            if next_offset >= end_offset {
15330                return Ok(());
15331            }
15332
15333            // Decode unknown envelopes for gaps in ordinals.
15334            while _next_ordinal_to_read < 7 {
15335                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15336                _next_ordinal_to_read += 1;
15337                next_offset += envelope_size;
15338            }
15339
15340            let next_out_of_line = decoder.next_out_of_line();
15341            let handles_before = decoder.remaining_handles();
15342            if let Some((inlined, num_bytes, num_handles)) =
15343                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15344            {
15345                let member_inline_size =
15346                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15347                if inlined != (member_inline_size <= 4) {
15348                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15349                }
15350                let inner_offset;
15351                let mut inner_depth = depth.clone();
15352                if inlined {
15353                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15354                    inner_offset = next_offset;
15355                } else {
15356                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15357                    inner_depth.increment()?;
15358                }
15359                let val_ref = self.uint16_member.get_or_insert_with(|| {
15360                    fidl::new_empty!(u16, fidl::encoding::DefaultFuchsiaResourceDialect)
15361                });
15362                fidl::decode!(
15363                    u16,
15364                    fidl::encoding::DefaultFuchsiaResourceDialect,
15365                    val_ref,
15366                    decoder,
15367                    inner_offset,
15368                    inner_depth
15369                )?;
15370                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15371                {
15372                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15373                }
15374                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15375                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15376                }
15377            }
15378
15379            next_offset += envelope_size;
15380            _next_ordinal_to_read += 1;
15381            if next_offset >= end_offset {
15382                return Ok(());
15383            }
15384
15385            // Decode unknown envelopes for gaps in ordinals.
15386            while _next_ordinal_to_read < 8 {
15387                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15388                _next_ordinal_to_read += 1;
15389                next_offset += envelope_size;
15390            }
15391
15392            let next_out_of_line = decoder.next_out_of_line();
15393            let handles_before = decoder.remaining_handles();
15394            if let Some((inlined, num_bytes, num_handles)) =
15395                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15396            {
15397                let member_inline_size =
15398                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15399                if inlined != (member_inline_size <= 4) {
15400                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15401                }
15402                let inner_offset;
15403                let mut inner_depth = depth.clone();
15404                if inlined {
15405                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15406                    inner_offset = next_offset;
15407                } else {
15408                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15409                    inner_depth.increment()?;
15410                }
15411                let val_ref = self.uint32_member.get_or_insert_with(|| {
15412                    fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect)
15413                });
15414                fidl::decode!(
15415                    u32,
15416                    fidl::encoding::DefaultFuchsiaResourceDialect,
15417                    val_ref,
15418                    decoder,
15419                    inner_offset,
15420                    inner_depth
15421                )?;
15422                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15423                {
15424                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15425                }
15426                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15427                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15428                }
15429            }
15430
15431            next_offset += envelope_size;
15432            _next_ordinal_to_read += 1;
15433            if next_offset >= end_offset {
15434                return Ok(());
15435            }
15436
15437            // Decode unknown envelopes for gaps in ordinals.
15438            while _next_ordinal_to_read < 9 {
15439                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15440                _next_ordinal_to_read += 1;
15441                next_offset += envelope_size;
15442            }
15443
15444            let next_out_of_line = decoder.next_out_of_line();
15445            let handles_before = decoder.remaining_handles();
15446            if let Some((inlined, num_bytes, num_handles)) =
15447                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15448            {
15449                let member_inline_size =
15450                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15451                if inlined != (member_inline_size <= 4) {
15452                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15453                }
15454                let inner_offset;
15455                let mut inner_depth = depth.clone();
15456                if inlined {
15457                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15458                    inner_offset = next_offset;
15459                } else {
15460                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15461                    inner_depth.increment()?;
15462                }
15463                let val_ref = self.uint64_member.get_or_insert_with(|| {
15464                    fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect)
15465                });
15466                fidl::decode!(
15467                    u64,
15468                    fidl::encoding::DefaultFuchsiaResourceDialect,
15469                    val_ref,
15470                    decoder,
15471                    inner_offset,
15472                    inner_depth
15473                )?;
15474                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15475                {
15476                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15477                }
15478                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15479                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15480                }
15481            }
15482
15483            next_offset += envelope_size;
15484            _next_ordinal_to_read += 1;
15485            if next_offset >= end_offset {
15486                return Ok(());
15487            }
15488
15489            // Decode unknown envelopes for gaps in ordinals.
15490            while _next_ordinal_to_read < 10 {
15491                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15492                _next_ordinal_to_read += 1;
15493                next_offset += envelope_size;
15494            }
15495
15496            let next_out_of_line = decoder.next_out_of_line();
15497            let handles_before = decoder.remaining_handles();
15498            if let Some((inlined, num_bytes, num_handles)) =
15499                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15500            {
15501                let member_inline_size =
15502                    <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15503                if inlined != (member_inline_size <= 4) {
15504                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15505                }
15506                let inner_offset;
15507                let mut inner_depth = depth.clone();
15508                if inlined {
15509                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15510                    inner_offset = next_offset;
15511                } else {
15512                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15513                    inner_depth.increment()?;
15514                }
15515                let val_ref = self.float32_member.get_or_insert_with(|| {
15516                    fidl::new_empty!(f32, fidl::encoding::DefaultFuchsiaResourceDialect)
15517                });
15518                fidl::decode!(
15519                    f32,
15520                    fidl::encoding::DefaultFuchsiaResourceDialect,
15521                    val_ref,
15522                    decoder,
15523                    inner_offset,
15524                    inner_depth
15525                )?;
15526                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15527                {
15528                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15529                }
15530                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15531                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15532                }
15533            }
15534
15535            next_offset += envelope_size;
15536            _next_ordinal_to_read += 1;
15537            if next_offset >= end_offset {
15538                return Ok(());
15539            }
15540
15541            // Decode unknown envelopes for gaps in ordinals.
15542            while _next_ordinal_to_read < 11 {
15543                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15544                _next_ordinal_to_read += 1;
15545                next_offset += envelope_size;
15546            }
15547
15548            let next_out_of_line = decoder.next_out_of_line();
15549            let handles_before = decoder.remaining_handles();
15550            if let Some((inlined, num_bytes, num_handles)) =
15551                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15552            {
15553                let member_inline_size =
15554                    <f64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15555                if inlined != (member_inline_size <= 4) {
15556                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15557                }
15558                let inner_offset;
15559                let mut inner_depth = depth.clone();
15560                if inlined {
15561                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15562                    inner_offset = next_offset;
15563                } else {
15564                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15565                    inner_depth.increment()?;
15566                }
15567                let val_ref = self.float64_member.get_or_insert_with(|| {
15568                    fidl::new_empty!(f64, fidl::encoding::DefaultFuchsiaResourceDialect)
15569                });
15570                fidl::decode!(
15571                    f64,
15572                    fidl::encoding::DefaultFuchsiaResourceDialect,
15573                    val_ref,
15574                    decoder,
15575                    inner_offset,
15576                    inner_depth
15577                )?;
15578                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15579                {
15580                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15581                }
15582                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15583                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15584                }
15585            }
15586
15587            next_offset += envelope_size;
15588            _next_ordinal_to_read += 1;
15589            if next_offset >= end_offset {
15590                return Ok(());
15591            }
15592
15593            // Decode unknown envelopes for gaps in ordinals.
15594            while _next_ordinal_to_read < 12 {
15595                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15596                _next_ordinal_to_read += 1;
15597                next_offset += envelope_size;
15598            }
15599
15600            let next_out_of_line = decoder.next_out_of_line();
15601            let handles_before = decoder.remaining_handles();
15602            if let Some((inlined, num_bytes, num_handles)) =
15603                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15604            {
15605                let member_inline_size =
15606                    <DefaultEnum as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15607                if inlined != (member_inline_size <= 4) {
15608                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15609                }
15610                let inner_offset;
15611                let mut inner_depth = depth.clone();
15612                if inlined {
15613                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15614                    inner_offset = next_offset;
15615                } else {
15616                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15617                    inner_depth.increment()?;
15618                }
15619                let val_ref = self.enum_member.get_or_insert_with(|| {
15620                    fidl::new_empty!(DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect)
15621                });
15622                fidl::decode!(
15623                    DefaultEnum,
15624                    fidl::encoding::DefaultFuchsiaResourceDialect,
15625                    val_ref,
15626                    decoder,
15627                    inner_offset,
15628                    inner_depth
15629                )?;
15630                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15631                {
15632                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15633                }
15634                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15635                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15636                }
15637            }
15638
15639            next_offset += envelope_size;
15640            _next_ordinal_to_read += 1;
15641            if next_offset >= end_offset {
15642                return Ok(());
15643            }
15644
15645            // Decode unknown envelopes for gaps in ordinals.
15646            while _next_ordinal_to_read < 13 {
15647                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15648                _next_ordinal_to_read += 1;
15649                next_offset += envelope_size;
15650            }
15651
15652            let next_out_of_line = decoder.next_out_of_line();
15653            let handles_before = decoder.remaining_handles();
15654            if let Some((inlined, num_bytes, num_handles)) =
15655                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15656            {
15657                let member_inline_size =
15658                    <DefaultBits as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15659                if inlined != (member_inline_size <= 4) {
15660                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15661                }
15662                let inner_offset;
15663                let mut inner_depth = depth.clone();
15664                if inlined {
15665                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15666                    inner_offset = next_offset;
15667                } else {
15668                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15669                    inner_depth.increment()?;
15670                }
15671                let val_ref = self.bits_member.get_or_insert_with(|| {
15672                    fidl::new_empty!(DefaultBits, fidl::encoding::DefaultFuchsiaResourceDialect)
15673                });
15674                fidl::decode!(
15675                    DefaultBits,
15676                    fidl::encoding::DefaultFuchsiaResourceDialect,
15677                    val_ref,
15678                    decoder,
15679                    inner_offset,
15680                    inner_depth
15681                )?;
15682                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15683                {
15684                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15685                }
15686                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15687                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15688                }
15689            }
15690
15691            next_offset += envelope_size;
15692            _next_ordinal_to_read += 1;
15693            if next_offset >= end_offset {
15694                return Ok(());
15695            }
15696
15697            // Decode unknown envelopes for gaps in ordinals.
15698            while _next_ordinal_to_read < 14 {
15699                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15700                _next_ordinal_to_read += 1;
15701                next_offset += envelope_size;
15702            }
15703
15704            let next_out_of_line = decoder.next_out_of_line();
15705            let handles_before = decoder.remaining_handles();
15706            if let Some((inlined, num_bytes, num_handles)) =
15707                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15708            {
15709                let member_inline_size = <fidl::encoding::HandleType<
15710                    fidl::NullableHandle,
15711                    { fidl::ObjectType::NONE.into_raw() },
15712                    2147483648,
15713                > as fidl::encoding::TypeMarker>::inline_size(
15714                    decoder.context
15715                );
15716                if inlined != (member_inline_size <= 4) {
15717                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15718                }
15719                let inner_offset;
15720                let mut inner_depth = depth.clone();
15721                if inlined {
15722                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15723                    inner_offset = next_offset;
15724                } else {
15725                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15726                    inner_depth.increment()?;
15727                }
15728                let val_ref =
15729                self.handle_member.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
15730                fidl::decode!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
15731                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15732                {
15733                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15734                }
15735                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15736                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15737                }
15738            }
15739
15740            next_offset += envelope_size;
15741            _next_ordinal_to_read += 1;
15742            if next_offset >= end_offset {
15743                return Ok(());
15744            }
15745
15746            // Decode unknown envelopes for gaps in ordinals.
15747            while _next_ordinal_to_read < 15 {
15748                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15749                _next_ordinal_to_read += 1;
15750                next_offset += envelope_size;
15751            }
15752
15753            let next_out_of_line = decoder.next_out_of_line();
15754            let handles_before = decoder.remaining_handles();
15755            if let Some((inlined, num_bytes, num_handles)) =
15756                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15757            {
15758                let member_inline_size =
15759                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
15760                        decoder.context,
15761                    );
15762                if inlined != (member_inline_size <= 4) {
15763                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15764                }
15765                let inner_offset;
15766                let mut inner_depth = depth.clone();
15767                if inlined {
15768                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15769                    inner_offset = next_offset;
15770                } else {
15771                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15772                    inner_depth.increment()?;
15773                }
15774                let val_ref = self.string_member.get_or_insert_with(|| {
15775                    fidl::new_empty!(
15776                        fidl::encoding::UnboundedString,
15777                        fidl::encoding::DefaultFuchsiaResourceDialect
15778                    )
15779                });
15780                fidl::decode!(
15781                    fidl::encoding::UnboundedString,
15782                    fidl::encoding::DefaultFuchsiaResourceDialect,
15783                    val_ref,
15784                    decoder,
15785                    inner_offset,
15786                    inner_depth
15787                )?;
15788                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15789                {
15790                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15791                }
15792                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15793                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15794                }
15795            }
15796
15797            next_offset += envelope_size;
15798            _next_ordinal_to_read += 1;
15799            if next_offset >= end_offset {
15800                return Ok(());
15801            }
15802
15803            // Decode unknown envelopes for gaps in ordinals.
15804            while _next_ordinal_to_read < 16 {
15805                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15806                _next_ordinal_to_read += 1;
15807                next_offset += envelope_size;
15808            }
15809
15810            let next_out_of_line = decoder.next_out_of_line();
15811            let handles_before = decoder.remaining_handles();
15812            if let Some((inlined, num_bytes, num_handles)) =
15813                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15814            {
15815                let member_inline_size =
15816                    <ThisIsAStruct as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15817                if inlined != (member_inline_size <= 4) {
15818                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15819                }
15820                let inner_offset;
15821                let mut inner_depth = depth.clone();
15822                if inlined {
15823                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15824                    inner_offset = next_offset;
15825                } else {
15826                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15827                    inner_depth.increment()?;
15828                }
15829                let val_ref = self.struct_member.get_or_insert_with(|| {
15830                    fidl::new_empty!(ThisIsAStruct, fidl::encoding::DefaultFuchsiaResourceDialect)
15831                });
15832                fidl::decode!(
15833                    ThisIsAStruct,
15834                    fidl::encoding::DefaultFuchsiaResourceDialect,
15835                    val_ref,
15836                    decoder,
15837                    inner_offset,
15838                    inner_depth
15839                )?;
15840                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15841                {
15842                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15843                }
15844                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15845                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15846                }
15847            }
15848
15849            next_offset += envelope_size;
15850            _next_ordinal_to_read += 1;
15851            if next_offset >= end_offset {
15852                return Ok(());
15853            }
15854
15855            // Decode unknown envelopes for gaps in ordinals.
15856            while _next_ordinal_to_read < 17 {
15857                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15858                _next_ordinal_to_read += 1;
15859                next_offset += envelope_size;
15860            }
15861
15862            let next_out_of_line = decoder.next_out_of_line();
15863            let handles_before = decoder.remaining_handles();
15864            if let Some((inlined, num_bytes, num_handles)) =
15865                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15866            {
15867                let member_inline_size =
15868                    <ThisIsAUnion as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15869                if inlined != (member_inline_size <= 4) {
15870                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15871                }
15872                let inner_offset;
15873                let mut inner_depth = depth.clone();
15874                if inlined {
15875                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15876                    inner_offset = next_offset;
15877                } else {
15878                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15879                    inner_depth.increment()?;
15880                }
15881                let val_ref = self.union_member.get_or_insert_with(|| {
15882                    fidl::new_empty!(ThisIsAUnion, fidl::encoding::DefaultFuchsiaResourceDialect)
15883                });
15884                fidl::decode!(
15885                    ThisIsAUnion,
15886                    fidl::encoding::DefaultFuchsiaResourceDialect,
15887                    val_ref,
15888                    decoder,
15889                    inner_offset,
15890                    inner_depth
15891                )?;
15892                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15893                {
15894                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15895                }
15896                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15897                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15898                }
15899            }
15900
15901            next_offset += envelope_size;
15902            _next_ordinal_to_read += 1;
15903            if next_offset >= end_offset {
15904                return Ok(());
15905            }
15906
15907            // Decode unknown envelopes for gaps in ordinals.
15908            while _next_ordinal_to_read < 18 {
15909                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15910                _next_ordinal_to_read += 1;
15911                next_offset += envelope_size;
15912            }
15913
15914            let next_out_of_line = decoder.next_out_of_line();
15915            let handles_before = decoder.remaining_handles();
15916            if let Some((inlined, num_bytes, num_handles)) =
15917                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15918            {
15919                let member_inline_size =
15920                    <fidl::encoding::Array<u32, 3> as fidl::encoding::TypeMarker>::inline_size(
15921                        decoder.context,
15922                    );
15923                if inlined != (member_inline_size <= 4) {
15924                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15925                }
15926                let inner_offset;
15927                let mut inner_depth = depth.clone();
15928                if inlined {
15929                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15930                    inner_offset = next_offset;
15931                } else {
15932                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15933                    inner_depth.increment()?;
15934                }
15935                let val_ref =
15936                self.array_member.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect));
15937                fidl::decode!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
15938                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15939                {
15940                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15941                }
15942                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15943                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15944                }
15945            }
15946
15947            next_offset += envelope_size;
15948            _next_ordinal_to_read += 1;
15949            if next_offset >= end_offset {
15950                return Ok(());
15951            }
15952
15953            // Decode unknown envelopes for gaps in ordinals.
15954            while _next_ordinal_to_read < 19 {
15955                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15956                _next_ordinal_to_read += 1;
15957                next_offset += envelope_size;
15958            }
15959
15960            let next_out_of_line = decoder.next_out_of_line();
15961            let handles_before = decoder.remaining_handles();
15962            if let Some((inlined, num_bytes, num_handles)) =
15963                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15964            {
15965                let member_inline_size = <fidl::encoding::UnboundedVector<u32> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15966                if inlined != (member_inline_size <= 4) {
15967                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15968                }
15969                let inner_offset;
15970                let mut inner_depth = depth.clone();
15971                if inlined {
15972                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15973                    inner_offset = next_offset;
15974                } else {
15975                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15976                    inner_depth.increment()?;
15977                }
15978                let val_ref = self.vector_member.get_or_insert_with(|| {
15979                    fidl::new_empty!(
15980                        fidl::encoding::UnboundedVector<u32>,
15981                        fidl::encoding::DefaultFuchsiaResourceDialect
15982                    )
15983                });
15984                fidl::decode!(
15985                    fidl::encoding::UnboundedVector<u32>,
15986                    fidl::encoding::DefaultFuchsiaResourceDialect,
15987                    val_ref,
15988                    decoder,
15989                    inner_offset,
15990                    inner_depth
15991                )?;
15992                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15993                {
15994                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15995                }
15996                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15997                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15998                }
15999            }
16000
16001            next_offset += envelope_size;
16002            _next_ordinal_to_read += 1;
16003            if next_offset >= end_offset {
16004                return Ok(());
16005            }
16006
16007            // Decode unknown envelopes for gaps in ordinals.
16008            while _next_ordinal_to_read < 20 {
16009                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16010                _next_ordinal_to_read += 1;
16011                next_offset += envelope_size;
16012            }
16013
16014            let next_out_of_line = decoder.next_out_of_line();
16015            let handles_before = decoder.remaining_handles();
16016            if let Some((inlined, num_bytes, num_handles)) =
16017                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16018            {
16019                let member_inline_size =
16020                    <ThisIsATable as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16021                if inlined != (member_inline_size <= 4) {
16022                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16023                }
16024                let inner_offset;
16025                let mut inner_depth = depth.clone();
16026                if inlined {
16027                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16028                    inner_offset = next_offset;
16029                } else {
16030                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16031                    inner_depth.increment()?;
16032                }
16033                let val_ref = self.table_member.get_or_insert_with(|| {
16034                    fidl::new_empty!(ThisIsATable, fidl::encoding::DefaultFuchsiaResourceDialect)
16035                });
16036                fidl::decode!(
16037                    ThisIsATable,
16038                    fidl::encoding::DefaultFuchsiaResourceDialect,
16039                    val_ref,
16040                    decoder,
16041                    inner_offset,
16042                    inner_depth
16043                )?;
16044                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16045                {
16046                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16047                }
16048                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16049                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16050                }
16051            }
16052
16053            next_offset += envelope_size;
16054            _next_ordinal_to_read += 1;
16055            if next_offset >= end_offset {
16056                return Ok(());
16057            }
16058
16059            // Decode unknown envelopes for gaps in ordinals.
16060            while _next_ordinal_to_read < 21 {
16061                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16062                _next_ordinal_to_read += 1;
16063                next_offset += envelope_size;
16064            }
16065
16066            let next_out_of_line = decoder.next_out_of_line();
16067            let handles_before = decoder.remaining_handles();
16068            if let Some((inlined, num_bytes, num_handles)) =
16069                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16070            {
16071                let member_inline_size =
16072                    <ThisIsAXunion as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16073                if inlined != (member_inline_size <= 4) {
16074                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16075                }
16076                let inner_offset;
16077                let mut inner_depth = depth.clone();
16078                if inlined {
16079                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16080                    inner_offset = next_offset;
16081                } else {
16082                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16083                    inner_depth.increment()?;
16084                }
16085                let val_ref = self.xunion_member.get_or_insert_with(|| {
16086                    fidl::new_empty!(ThisIsAXunion, fidl::encoding::DefaultFuchsiaResourceDialect)
16087                });
16088                fidl::decode!(
16089                    ThisIsAXunion,
16090                    fidl::encoding::DefaultFuchsiaResourceDialect,
16091                    val_ref,
16092                    decoder,
16093                    inner_offset,
16094                    inner_depth
16095                )?;
16096                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16097                {
16098                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16099                }
16100                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16101                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16102                }
16103            }
16104
16105            next_offset += envelope_size;
16106
16107            // Decode the remaining unknown envelopes.
16108            while next_offset < end_offset {
16109                _next_ordinal_to_read += 1;
16110                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16111                next_offset += envelope_size;
16112            }
16113
16114            Ok(())
16115        }
16116    }
16117
16118    impl fidl::encoding::ResourceTypeMarker for AllTypesXunion {
16119        type Borrowed<'a> = &'a mut Self;
16120        fn take_or_borrow<'a>(
16121            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
16122        ) -> Self::Borrowed<'a> {
16123            value
16124        }
16125    }
16126
16127    unsafe impl fidl::encoding::TypeMarker for AllTypesXunion {
16128        type Owned = Self;
16129
16130        #[inline(always)]
16131        fn inline_align(_context: fidl::encoding::Context) -> usize {
16132            8
16133        }
16134
16135        #[inline(always)]
16136        fn inline_size(_context: fidl::encoding::Context) -> usize {
16137            16
16138        }
16139    }
16140
16141    unsafe impl
16142        fidl::encoding::Encode<AllTypesXunion, fidl::encoding::DefaultFuchsiaResourceDialect>
16143        for &mut AllTypesXunion
16144    {
16145        #[inline]
16146        unsafe fn encode(
16147            self,
16148            encoder: &mut fidl::encoding::Encoder<
16149                '_,
16150                fidl::encoding::DefaultFuchsiaResourceDialect,
16151            >,
16152            offset: usize,
16153            _depth: fidl::encoding::Depth,
16154        ) -> fidl::Result<()> {
16155            encoder.debug_check_bounds::<AllTypesXunion>(offset);
16156            encoder.write_num::<u64>(self.ordinal(), offset);
16157            match self {
16158            AllTypesXunion::BoolMember(ref val) => {
16159                fidl::encoding::encode_in_envelope::<bool, fidl::encoding::DefaultFuchsiaResourceDialect>(
16160                    <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
16161                    encoder, offset + 8, _depth
16162                )
16163            }
16164            AllTypesXunion::Int8Member(ref val) => {
16165                fidl::encoding::encode_in_envelope::<i8, fidl::encoding::DefaultFuchsiaResourceDialect>(
16166                    <i8 as fidl::encoding::ValueTypeMarker>::borrow(val),
16167                    encoder, offset + 8, _depth
16168                )
16169            }
16170            AllTypesXunion::Int16Member(ref val) => {
16171                fidl::encoding::encode_in_envelope::<i16, fidl::encoding::DefaultFuchsiaResourceDialect>(
16172                    <i16 as fidl::encoding::ValueTypeMarker>::borrow(val),
16173                    encoder, offset + 8, _depth
16174                )
16175            }
16176            AllTypesXunion::Int32Member(ref val) => {
16177                fidl::encoding::encode_in_envelope::<i32, fidl::encoding::DefaultFuchsiaResourceDialect>(
16178                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(val),
16179                    encoder, offset + 8, _depth
16180                )
16181            }
16182            AllTypesXunion::Int64Member(ref val) => {
16183                fidl::encoding::encode_in_envelope::<i64, fidl::encoding::DefaultFuchsiaResourceDialect>(
16184                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(val),
16185                    encoder, offset + 8, _depth
16186                )
16187            }
16188            AllTypesXunion::Uint8Member(ref val) => {
16189                fidl::encoding::encode_in_envelope::<u8, fidl::encoding::DefaultFuchsiaResourceDialect>(
16190                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(val),
16191                    encoder, offset + 8, _depth
16192                )
16193            }
16194            AllTypesXunion::Uint16Member(ref val) => {
16195                fidl::encoding::encode_in_envelope::<u16, fidl::encoding::DefaultFuchsiaResourceDialect>(
16196                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(val),
16197                    encoder, offset + 8, _depth
16198                )
16199            }
16200            AllTypesXunion::Uint32Member(ref val) => {
16201                fidl::encoding::encode_in_envelope::<u32, fidl::encoding::DefaultFuchsiaResourceDialect>(
16202                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
16203                    encoder, offset + 8, _depth
16204                )
16205            }
16206            AllTypesXunion::Uint64Member(ref val) => {
16207                fidl::encoding::encode_in_envelope::<u64, fidl::encoding::DefaultFuchsiaResourceDialect>(
16208                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(val),
16209                    encoder, offset + 8, _depth
16210                )
16211            }
16212            AllTypesXunion::Float32Member(ref val) => {
16213                fidl::encoding::encode_in_envelope::<f32, fidl::encoding::DefaultFuchsiaResourceDialect>(
16214                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(val),
16215                    encoder, offset + 8, _depth
16216                )
16217            }
16218            AllTypesXunion::Float64Member(ref val) => {
16219                fidl::encoding::encode_in_envelope::<f64, fidl::encoding::DefaultFuchsiaResourceDialect>(
16220                    <f64 as fidl::encoding::ValueTypeMarker>::borrow(val),
16221                    encoder, offset + 8, _depth
16222                )
16223            }
16224            AllTypesXunion::EnumMember(ref val) => {
16225                fidl::encoding::encode_in_envelope::<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>(
16226                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(val),
16227                    encoder, offset + 8, _depth
16228                )
16229            }
16230            AllTypesXunion::BitsMember(ref val) => {
16231                fidl::encoding::encode_in_envelope::<DefaultBits, fidl::encoding::DefaultFuchsiaResourceDialect>(
16232                    <DefaultBits as fidl::encoding::ValueTypeMarker>::borrow(val),
16233                    encoder, offset + 8, _depth
16234                )
16235            }
16236            AllTypesXunion::HandleMember(ref mut val) => {
16237                fidl::encoding::encode_in_envelope::<fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect>(
16238                    <fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
16239                    encoder, offset + 8, _depth
16240                )
16241            }
16242            AllTypesXunion::StringMember(ref val) => {
16243                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedString, fidl::encoding::DefaultFuchsiaResourceDialect>(
16244                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(val),
16245                    encoder, offset + 8, _depth
16246                )
16247            }
16248            AllTypesXunion::StructMember(ref val) => {
16249                fidl::encoding::encode_in_envelope::<ThisIsAStruct, fidl::encoding::DefaultFuchsiaResourceDialect>(
16250                    <ThisIsAStruct as fidl::encoding::ValueTypeMarker>::borrow(val),
16251                    encoder, offset + 8, _depth
16252                )
16253            }
16254            AllTypesXunion::UnionMember(ref val) => {
16255                fidl::encoding::encode_in_envelope::<ThisIsAUnion, fidl::encoding::DefaultFuchsiaResourceDialect>(
16256                    <ThisIsAUnion as fidl::encoding::ValueTypeMarker>::borrow(val),
16257                    encoder, offset + 8, _depth
16258                )
16259            }
16260            AllTypesXunion::ArrayMember(ref val) => {
16261                fidl::encoding::encode_in_envelope::<fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect>(
16262                    <fidl::encoding::Array<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow(val),
16263                    encoder, offset + 8, _depth
16264                )
16265            }
16266            AllTypesXunion::VectorMember(ref val) => {
16267                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<u32>, fidl::encoding::DefaultFuchsiaResourceDialect>(
16268                    <fidl::encoding::UnboundedVector<u32> as fidl::encoding::ValueTypeMarker>::borrow(val),
16269                    encoder, offset + 8, _depth
16270                )
16271            }
16272            AllTypesXunion::TableMember(ref val) => {
16273                fidl::encoding::encode_in_envelope::<ThisIsATable, fidl::encoding::DefaultFuchsiaResourceDialect>(
16274                    <ThisIsATable as fidl::encoding::ValueTypeMarker>::borrow(val),
16275                    encoder, offset + 8, _depth
16276                )
16277            }
16278            AllTypesXunion::XunionMember(ref val) => {
16279                fidl::encoding::encode_in_envelope::<ThisIsAXunion, fidl::encoding::DefaultFuchsiaResourceDialect>(
16280                    <ThisIsAXunion as fidl::encoding::ValueTypeMarker>::borrow(val),
16281                    encoder, offset + 8, _depth
16282                )
16283            }
16284            AllTypesXunion::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
16285        }
16286        }
16287    }
16288
16289    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
16290        for AllTypesXunion
16291    {
16292        #[inline(always)]
16293        fn new_empty() -> Self {
16294            Self::__SourceBreaking { unknown_ordinal: 0 }
16295        }
16296
16297        #[inline]
16298        unsafe fn decode(
16299            &mut self,
16300            decoder: &mut fidl::encoding::Decoder<
16301                '_,
16302                fidl::encoding::DefaultFuchsiaResourceDialect,
16303            >,
16304            offset: usize,
16305            mut depth: fidl::encoding::Depth,
16306        ) -> fidl::Result<()> {
16307            decoder.debug_check_bounds::<Self>(offset);
16308            #[allow(unused_variables)]
16309            let next_out_of_line = decoder.next_out_of_line();
16310            let handles_before = decoder.remaining_handles();
16311            let (ordinal, inlined, num_bytes, num_handles) =
16312                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
16313
16314            let member_inline_size = match ordinal {
16315            1 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16316            2 => <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16317            3 => <i16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16318            4 => <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16319            5 => <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16320            6 => <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16321            7 => <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16322            8 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16323            9 => <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16324            10 => <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16325            11 => <f64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16326            12 => <DefaultEnum as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16327            13 => <DefaultBits as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16328            14 => <fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16329            15 => <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16330            16 => <ThisIsAStruct as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16331            17 => <ThisIsAUnion as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16332            18 => <fidl::encoding::Array<u32, 3> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16333            19 => <fidl::encoding::UnboundedVector<u32> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16334            20 => <ThisIsATable as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16335            21 => <ThisIsAXunion as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16336            0 => return Err(fidl::Error::UnknownUnionTag),
16337            _ => num_bytes as usize,
16338        };
16339
16340            if inlined != (member_inline_size <= 4) {
16341                return Err(fidl::Error::InvalidInlineBitInEnvelope);
16342            }
16343            let _inner_offset;
16344            if inlined {
16345                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
16346                _inner_offset = offset + 8;
16347            } else {
16348                depth.increment()?;
16349                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16350            }
16351            match ordinal {
16352                1 => {
16353                    #[allow(irrefutable_let_patterns)]
16354                    if let AllTypesXunion::BoolMember(_) = self {
16355                        // Do nothing, read the value into the object
16356                    } else {
16357                        // Initialize `self` to the right variant
16358                        *self = AllTypesXunion::BoolMember(fidl::new_empty!(
16359                            bool,
16360                            fidl::encoding::DefaultFuchsiaResourceDialect
16361                        ));
16362                    }
16363                    #[allow(irrefutable_let_patterns)]
16364                    if let AllTypesXunion::BoolMember(ref mut val) = self {
16365                        fidl::decode!(
16366                            bool,
16367                            fidl::encoding::DefaultFuchsiaResourceDialect,
16368                            val,
16369                            decoder,
16370                            _inner_offset,
16371                            depth
16372                        )?;
16373                    } else {
16374                        unreachable!()
16375                    }
16376                }
16377                2 => {
16378                    #[allow(irrefutable_let_patterns)]
16379                    if let AllTypesXunion::Int8Member(_) = self {
16380                        // Do nothing, read the value into the object
16381                    } else {
16382                        // Initialize `self` to the right variant
16383                        *self = AllTypesXunion::Int8Member(fidl::new_empty!(
16384                            i8,
16385                            fidl::encoding::DefaultFuchsiaResourceDialect
16386                        ));
16387                    }
16388                    #[allow(irrefutable_let_patterns)]
16389                    if let AllTypesXunion::Int8Member(ref mut val) = self {
16390                        fidl::decode!(
16391                            i8,
16392                            fidl::encoding::DefaultFuchsiaResourceDialect,
16393                            val,
16394                            decoder,
16395                            _inner_offset,
16396                            depth
16397                        )?;
16398                    } else {
16399                        unreachable!()
16400                    }
16401                }
16402                3 => {
16403                    #[allow(irrefutable_let_patterns)]
16404                    if let AllTypesXunion::Int16Member(_) = self {
16405                        // Do nothing, read the value into the object
16406                    } else {
16407                        // Initialize `self` to the right variant
16408                        *self = AllTypesXunion::Int16Member(fidl::new_empty!(
16409                            i16,
16410                            fidl::encoding::DefaultFuchsiaResourceDialect
16411                        ));
16412                    }
16413                    #[allow(irrefutable_let_patterns)]
16414                    if let AllTypesXunion::Int16Member(ref mut val) = self {
16415                        fidl::decode!(
16416                            i16,
16417                            fidl::encoding::DefaultFuchsiaResourceDialect,
16418                            val,
16419                            decoder,
16420                            _inner_offset,
16421                            depth
16422                        )?;
16423                    } else {
16424                        unreachable!()
16425                    }
16426                }
16427                4 => {
16428                    #[allow(irrefutable_let_patterns)]
16429                    if let AllTypesXunion::Int32Member(_) = self {
16430                        // Do nothing, read the value into the object
16431                    } else {
16432                        // Initialize `self` to the right variant
16433                        *self = AllTypesXunion::Int32Member(fidl::new_empty!(
16434                            i32,
16435                            fidl::encoding::DefaultFuchsiaResourceDialect
16436                        ));
16437                    }
16438                    #[allow(irrefutable_let_patterns)]
16439                    if let AllTypesXunion::Int32Member(ref mut val) = self {
16440                        fidl::decode!(
16441                            i32,
16442                            fidl::encoding::DefaultFuchsiaResourceDialect,
16443                            val,
16444                            decoder,
16445                            _inner_offset,
16446                            depth
16447                        )?;
16448                    } else {
16449                        unreachable!()
16450                    }
16451                }
16452                5 => {
16453                    #[allow(irrefutable_let_patterns)]
16454                    if let AllTypesXunion::Int64Member(_) = self {
16455                        // Do nothing, read the value into the object
16456                    } else {
16457                        // Initialize `self` to the right variant
16458                        *self = AllTypesXunion::Int64Member(fidl::new_empty!(
16459                            i64,
16460                            fidl::encoding::DefaultFuchsiaResourceDialect
16461                        ));
16462                    }
16463                    #[allow(irrefutable_let_patterns)]
16464                    if let AllTypesXunion::Int64Member(ref mut val) = self {
16465                        fidl::decode!(
16466                            i64,
16467                            fidl::encoding::DefaultFuchsiaResourceDialect,
16468                            val,
16469                            decoder,
16470                            _inner_offset,
16471                            depth
16472                        )?;
16473                    } else {
16474                        unreachable!()
16475                    }
16476                }
16477                6 => {
16478                    #[allow(irrefutable_let_patterns)]
16479                    if let AllTypesXunion::Uint8Member(_) = self {
16480                        // Do nothing, read the value into the object
16481                    } else {
16482                        // Initialize `self` to the right variant
16483                        *self = AllTypesXunion::Uint8Member(fidl::new_empty!(
16484                            u8,
16485                            fidl::encoding::DefaultFuchsiaResourceDialect
16486                        ));
16487                    }
16488                    #[allow(irrefutable_let_patterns)]
16489                    if let AllTypesXunion::Uint8Member(ref mut val) = self {
16490                        fidl::decode!(
16491                            u8,
16492                            fidl::encoding::DefaultFuchsiaResourceDialect,
16493                            val,
16494                            decoder,
16495                            _inner_offset,
16496                            depth
16497                        )?;
16498                    } else {
16499                        unreachable!()
16500                    }
16501                }
16502                7 => {
16503                    #[allow(irrefutable_let_patterns)]
16504                    if let AllTypesXunion::Uint16Member(_) = self {
16505                        // Do nothing, read the value into the object
16506                    } else {
16507                        // Initialize `self` to the right variant
16508                        *self = AllTypesXunion::Uint16Member(fidl::new_empty!(
16509                            u16,
16510                            fidl::encoding::DefaultFuchsiaResourceDialect
16511                        ));
16512                    }
16513                    #[allow(irrefutable_let_patterns)]
16514                    if let AllTypesXunion::Uint16Member(ref mut val) = self {
16515                        fidl::decode!(
16516                            u16,
16517                            fidl::encoding::DefaultFuchsiaResourceDialect,
16518                            val,
16519                            decoder,
16520                            _inner_offset,
16521                            depth
16522                        )?;
16523                    } else {
16524                        unreachable!()
16525                    }
16526                }
16527                8 => {
16528                    #[allow(irrefutable_let_patterns)]
16529                    if let AllTypesXunion::Uint32Member(_) = self {
16530                        // Do nothing, read the value into the object
16531                    } else {
16532                        // Initialize `self` to the right variant
16533                        *self = AllTypesXunion::Uint32Member(fidl::new_empty!(
16534                            u32,
16535                            fidl::encoding::DefaultFuchsiaResourceDialect
16536                        ));
16537                    }
16538                    #[allow(irrefutable_let_patterns)]
16539                    if let AllTypesXunion::Uint32Member(ref mut val) = self {
16540                        fidl::decode!(
16541                            u32,
16542                            fidl::encoding::DefaultFuchsiaResourceDialect,
16543                            val,
16544                            decoder,
16545                            _inner_offset,
16546                            depth
16547                        )?;
16548                    } else {
16549                        unreachable!()
16550                    }
16551                }
16552                9 => {
16553                    #[allow(irrefutable_let_patterns)]
16554                    if let AllTypesXunion::Uint64Member(_) = self {
16555                        // Do nothing, read the value into the object
16556                    } else {
16557                        // Initialize `self` to the right variant
16558                        *self = AllTypesXunion::Uint64Member(fidl::new_empty!(
16559                            u64,
16560                            fidl::encoding::DefaultFuchsiaResourceDialect
16561                        ));
16562                    }
16563                    #[allow(irrefutable_let_patterns)]
16564                    if let AllTypesXunion::Uint64Member(ref mut val) = self {
16565                        fidl::decode!(
16566                            u64,
16567                            fidl::encoding::DefaultFuchsiaResourceDialect,
16568                            val,
16569                            decoder,
16570                            _inner_offset,
16571                            depth
16572                        )?;
16573                    } else {
16574                        unreachable!()
16575                    }
16576                }
16577                10 => {
16578                    #[allow(irrefutable_let_patterns)]
16579                    if let AllTypesXunion::Float32Member(_) = self {
16580                        // Do nothing, read the value into the object
16581                    } else {
16582                        // Initialize `self` to the right variant
16583                        *self = AllTypesXunion::Float32Member(fidl::new_empty!(
16584                            f32,
16585                            fidl::encoding::DefaultFuchsiaResourceDialect
16586                        ));
16587                    }
16588                    #[allow(irrefutable_let_patterns)]
16589                    if let AllTypesXunion::Float32Member(ref mut val) = self {
16590                        fidl::decode!(
16591                            f32,
16592                            fidl::encoding::DefaultFuchsiaResourceDialect,
16593                            val,
16594                            decoder,
16595                            _inner_offset,
16596                            depth
16597                        )?;
16598                    } else {
16599                        unreachable!()
16600                    }
16601                }
16602                11 => {
16603                    #[allow(irrefutable_let_patterns)]
16604                    if let AllTypesXunion::Float64Member(_) = self {
16605                        // Do nothing, read the value into the object
16606                    } else {
16607                        // Initialize `self` to the right variant
16608                        *self = AllTypesXunion::Float64Member(fidl::new_empty!(
16609                            f64,
16610                            fidl::encoding::DefaultFuchsiaResourceDialect
16611                        ));
16612                    }
16613                    #[allow(irrefutable_let_patterns)]
16614                    if let AllTypesXunion::Float64Member(ref mut val) = self {
16615                        fidl::decode!(
16616                            f64,
16617                            fidl::encoding::DefaultFuchsiaResourceDialect,
16618                            val,
16619                            decoder,
16620                            _inner_offset,
16621                            depth
16622                        )?;
16623                    } else {
16624                        unreachable!()
16625                    }
16626                }
16627                12 => {
16628                    #[allow(irrefutable_let_patterns)]
16629                    if let AllTypesXunion::EnumMember(_) = self {
16630                        // Do nothing, read the value into the object
16631                    } else {
16632                        // Initialize `self` to the right variant
16633                        *self = AllTypesXunion::EnumMember(fidl::new_empty!(
16634                            DefaultEnum,
16635                            fidl::encoding::DefaultFuchsiaResourceDialect
16636                        ));
16637                    }
16638                    #[allow(irrefutable_let_patterns)]
16639                    if let AllTypesXunion::EnumMember(ref mut val) = self {
16640                        fidl::decode!(
16641                            DefaultEnum,
16642                            fidl::encoding::DefaultFuchsiaResourceDialect,
16643                            val,
16644                            decoder,
16645                            _inner_offset,
16646                            depth
16647                        )?;
16648                    } else {
16649                        unreachable!()
16650                    }
16651                }
16652                13 => {
16653                    #[allow(irrefutable_let_patterns)]
16654                    if let AllTypesXunion::BitsMember(_) = self {
16655                        // Do nothing, read the value into the object
16656                    } else {
16657                        // Initialize `self` to the right variant
16658                        *self = AllTypesXunion::BitsMember(fidl::new_empty!(
16659                            DefaultBits,
16660                            fidl::encoding::DefaultFuchsiaResourceDialect
16661                        ));
16662                    }
16663                    #[allow(irrefutable_let_patterns)]
16664                    if let AllTypesXunion::BitsMember(ref mut val) = self {
16665                        fidl::decode!(
16666                            DefaultBits,
16667                            fidl::encoding::DefaultFuchsiaResourceDialect,
16668                            val,
16669                            decoder,
16670                            _inner_offset,
16671                            depth
16672                        )?;
16673                    } else {
16674                        unreachable!()
16675                    }
16676                }
16677                14 => {
16678                    #[allow(irrefutable_let_patterns)]
16679                    if let AllTypesXunion::HandleMember(_) = self {
16680                        // Do nothing, read the value into the object
16681                    } else {
16682                        // Initialize `self` to the right variant
16683                        *self = AllTypesXunion::HandleMember(
16684                            fidl::new_empty!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
16685                        );
16686                    }
16687                    #[allow(irrefutable_let_patterns)]
16688                    if let AllTypesXunion::HandleMember(ref mut val) = self {
16689                        fidl::decode!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val, decoder, _inner_offset, depth)?;
16690                    } else {
16691                        unreachable!()
16692                    }
16693                }
16694                15 => {
16695                    #[allow(irrefutable_let_patterns)]
16696                    if let AllTypesXunion::StringMember(_) = self {
16697                        // Do nothing, read the value into the object
16698                    } else {
16699                        // Initialize `self` to the right variant
16700                        *self = AllTypesXunion::StringMember(fidl::new_empty!(
16701                            fidl::encoding::UnboundedString,
16702                            fidl::encoding::DefaultFuchsiaResourceDialect
16703                        ));
16704                    }
16705                    #[allow(irrefutable_let_patterns)]
16706                    if let AllTypesXunion::StringMember(ref mut val) = self {
16707                        fidl::decode!(
16708                            fidl::encoding::UnboundedString,
16709                            fidl::encoding::DefaultFuchsiaResourceDialect,
16710                            val,
16711                            decoder,
16712                            _inner_offset,
16713                            depth
16714                        )?;
16715                    } else {
16716                        unreachable!()
16717                    }
16718                }
16719                16 => {
16720                    #[allow(irrefutable_let_patterns)]
16721                    if let AllTypesXunion::StructMember(_) = self {
16722                        // Do nothing, read the value into the object
16723                    } else {
16724                        // Initialize `self` to the right variant
16725                        *self = AllTypesXunion::StructMember(fidl::new_empty!(
16726                            ThisIsAStruct,
16727                            fidl::encoding::DefaultFuchsiaResourceDialect
16728                        ));
16729                    }
16730                    #[allow(irrefutable_let_patterns)]
16731                    if let AllTypesXunion::StructMember(ref mut val) = self {
16732                        fidl::decode!(
16733                            ThisIsAStruct,
16734                            fidl::encoding::DefaultFuchsiaResourceDialect,
16735                            val,
16736                            decoder,
16737                            _inner_offset,
16738                            depth
16739                        )?;
16740                    } else {
16741                        unreachable!()
16742                    }
16743                }
16744                17 => {
16745                    #[allow(irrefutable_let_patterns)]
16746                    if let AllTypesXunion::UnionMember(_) = self {
16747                        // Do nothing, read the value into the object
16748                    } else {
16749                        // Initialize `self` to the right variant
16750                        *self = AllTypesXunion::UnionMember(fidl::new_empty!(
16751                            ThisIsAUnion,
16752                            fidl::encoding::DefaultFuchsiaResourceDialect
16753                        ));
16754                    }
16755                    #[allow(irrefutable_let_patterns)]
16756                    if let AllTypesXunion::UnionMember(ref mut val) = self {
16757                        fidl::decode!(
16758                            ThisIsAUnion,
16759                            fidl::encoding::DefaultFuchsiaResourceDialect,
16760                            val,
16761                            decoder,
16762                            _inner_offset,
16763                            depth
16764                        )?;
16765                    } else {
16766                        unreachable!()
16767                    }
16768                }
16769                18 => {
16770                    #[allow(irrefutable_let_patterns)]
16771                    if let AllTypesXunion::ArrayMember(_) = self {
16772                        // Do nothing, read the value into the object
16773                    } else {
16774                        // Initialize `self` to the right variant
16775                        *self = AllTypesXunion::ArrayMember(
16776                            fidl::new_empty!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
16777                        );
16778                    }
16779                    #[allow(irrefutable_let_patterns)]
16780                    if let AllTypesXunion::ArrayMember(ref mut val) = self {
16781                        fidl::decode!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, val, decoder, _inner_offset, depth)?;
16782                    } else {
16783                        unreachable!()
16784                    }
16785                }
16786                19 => {
16787                    #[allow(irrefutable_let_patterns)]
16788                    if let AllTypesXunion::VectorMember(_) = self {
16789                        // Do nothing, read the value into the object
16790                    } else {
16791                        // Initialize `self` to the right variant
16792                        *self = AllTypesXunion::VectorMember(fidl::new_empty!(
16793                            fidl::encoding::UnboundedVector<u32>,
16794                            fidl::encoding::DefaultFuchsiaResourceDialect
16795                        ));
16796                    }
16797                    #[allow(irrefutable_let_patterns)]
16798                    if let AllTypesXunion::VectorMember(ref mut val) = self {
16799                        fidl::decode!(
16800                            fidl::encoding::UnboundedVector<u32>,
16801                            fidl::encoding::DefaultFuchsiaResourceDialect,
16802                            val,
16803                            decoder,
16804                            _inner_offset,
16805                            depth
16806                        )?;
16807                    } else {
16808                        unreachable!()
16809                    }
16810                }
16811                20 => {
16812                    #[allow(irrefutable_let_patterns)]
16813                    if let AllTypesXunion::TableMember(_) = self {
16814                        // Do nothing, read the value into the object
16815                    } else {
16816                        // Initialize `self` to the right variant
16817                        *self = AllTypesXunion::TableMember(fidl::new_empty!(
16818                            ThisIsATable,
16819                            fidl::encoding::DefaultFuchsiaResourceDialect
16820                        ));
16821                    }
16822                    #[allow(irrefutable_let_patterns)]
16823                    if let AllTypesXunion::TableMember(ref mut val) = self {
16824                        fidl::decode!(
16825                            ThisIsATable,
16826                            fidl::encoding::DefaultFuchsiaResourceDialect,
16827                            val,
16828                            decoder,
16829                            _inner_offset,
16830                            depth
16831                        )?;
16832                    } else {
16833                        unreachable!()
16834                    }
16835                }
16836                21 => {
16837                    #[allow(irrefutable_let_patterns)]
16838                    if let AllTypesXunion::XunionMember(_) = self {
16839                        // Do nothing, read the value into the object
16840                    } else {
16841                        // Initialize `self` to the right variant
16842                        *self = AllTypesXunion::XunionMember(fidl::new_empty!(
16843                            ThisIsAXunion,
16844                            fidl::encoding::DefaultFuchsiaResourceDialect
16845                        ));
16846                    }
16847                    #[allow(irrefutable_let_patterns)]
16848                    if let AllTypesXunion::XunionMember(ref mut val) = self {
16849                        fidl::decode!(
16850                            ThisIsAXunion,
16851                            fidl::encoding::DefaultFuchsiaResourceDialect,
16852                            val,
16853                            decoder,
16854                            _inner_offset,
16855                            depth
16856                        )?;
16857                    } else {
16858                        unreachable!()
16859                    }
16860                }
16861                #[allow(deprecated)]
16862                ordinal => {
16863                    for _ in 0..num_handles {
16864                        decoder.drop_next_handle()?;
16865                    }
16866                    *self = AllTypesXunion::__SourceBreaking { unknown_ordinal: ordinal };
16867                }
16868            }
16869            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
16870                return Err(fidl::Error::InvalidNumBytesInEnvelope);
16871            }
16872            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16873                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16874            }
16875            Ok(())
16876        }
16877    }
16878}
fidl_fidl_test_compatibility/fidl_fidl_test_compatibility.rs

fidl_fidl_test_compatibility/
fidl_fidl_test_compatibility.rs
