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 ConfigControlHandle {
1009    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
1010        self.inner.shutdown_with_epitaph(status.into())
1011    }
1012}
1013
1014impl fidl::endpoints::ControlHandle for ConfigControlHandle {
1015    fn shutdown(&self) {
1016        self.inner.shutdown()
1017    }
1018
1019    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
1020        self.inner.shutdown_with_epitaph(status)
1021    }
1022
1023    fn is_closed(&self) -> bool {
1024        self.inner.channel().is_closed()
1025    }
1026    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1027        self.inner.channel().on_closed()
1028    }
1029
1030    #[cfg(target_os = "fuchsia")]
1031    fn signal_peer(
1032        &self,
1033        clear_mask: zx::Signals,
1034        set_mask: zx::Signals,
1035    ) -> Result<(), zx_status::Status> {
1036        use fidl::Peered;
1037        self.inner.channel().signal_peer(clear_mask, set_mask)
1038    }
1039}
1040
1041impl ConfigControlHandle {}
1042
1043#[must_use = "FIDL methods require a response to be sent"]
1044#[derive(Debug)]
1045pub struct ConfigGetImplsResponder {
1046    control_handle: std::mem::ManuallyDrop<ConfigControlHandle>,
1047    tx_id: u32,
1048}
1049
1050/// Set the the channel to be shutdown (see [`ConfigControlHandle::shutdown`])
1051/// if the responder is dropped without sending a response, so that the client
1052/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1053impl std::ops::Drop for ConfigGetImplsResponder {
1054    fn drop(&mut self) {
1055        self.control_handle.shutdown();
1056        // Safety: drops once, never accessed again
1057        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1058    }
1059}
1060
1061impl fidl::endpoints::Responder for ConfigGetImplsResponder {
1062    type ControlHandle = ConfigControlHandle;
1063
1064    fn control_handle(&self) -> &ConfigControlHandle {
1065        &self.control_handle
1066    }
1067
1068    fn drop_without_shutdown(mut self) {
1069        // Safety: drops once, never accessed again due to mem::forget
1070        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1071        // Prevent Drop from running (which would shut down the channel)
1072        std::mem::forget(self);
1073    }
1074}
1075
1076impl ConfigGetImplsResponder {
1077    /// Sends a response to the FIDL transaction.
1078    ///
1079    /// Sets the channel to shutdown if an error occurs.
1080    pub fn send(self, mut impls: &[String]) -> Result<(), fidl::Error> {
1081        let _result = self.send_raw(impls);
1082        if _result.is_err() {
1083            self.control_handle.shutdown();
1084        }
1085        self.drop_without_shutdown();
1086        _result
1087    }
1088
1089    /// Similar to "send" but does not shutdown the channel if an error occurs.
1090    pub fn send_no_shutdown_on_err(self, mut impls: &[String]) -> Result<(), fidl::Error> {
1091        let _result = self.send_raw(impls);
1092        self.drop_without_shutdown();
1093        _result
1094    }
1095
1096    fn send_raw(&self, mut impls: &[String]) -> Result<(), fidl::Error> {
1097        self.control_handle.inner.send::<ConfigGetImplsResponse>(
1098            (impls,),
1099            self.tx_id,
1100            0x3b360c86a6dbdfe0,
1101            fidl::encoding::DynamicFlags::empty(),
1102        )
1103    }
1104}
1105
1106#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
1107pub struct EchoMarker;
1108
1109impl fidl::endpoints::ProtocolMarker for EchoMarker {
1110    type Proxy = EchoProxy;
1111    type RequestStream = EchoRequestStream;
1112    #[cfg(target_os = "fuchsia")]
1113    type SynchronousProxy = EchoSynchronousProxy;
1114
1115    const DEBUG_NAME: &'static str = "fidl.test.compatibility.Echo";
1116}
1117impl fidl::endpoints::DiscoverableProtocolMarker for EchoMarker {}
1118pub type EchoEchoMinimalWithErrorResult = Result<(), u32>;
1119pub type EchoEchoStructWithErrorResult = Result<Struct, DefaultEnum>;
1120pub type EchoEchoArraysWithErrorResult = Result<ArraysStruct, DefaultEnum>;
1121pub type EchoEchoVectorsWithErrorResult = Result<VectorsStruct, DefaultEnum>;
1122pub type EchoEchoTableWithErrorResult = Result<AllTypesTable, DefaultEnum>;
1123pub type EchoEchoXunionsWithErrorResult = Result<Vec<AllTypesXunion>, DefaultEnum>;
1124pub type EchoEchoNamedStructWithErrorResult = Result<fidl_fidl_test_imported::SimpleStruct, u32>;
1125pub type EchoEchoTablePayloadWithErrorResult = Result<ResponseTable, DefaultEnum>;
1126pub type EchoEchoUnionPayloadWithErrorResult = Result<ResponseUnion, DefaultEnum>;
1127
1128pub trait EchoProxyInterface: Send + Sync {
1129    type EchoTableRequestComposedResponseFut: std::future::Future<Output = Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error>>
1130        + Send;
1131    fn r#echo_table_request_composed(
1132        &self,
1133        payload: &fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
1134    ) -> Self::EchoTableRequestComposedResponseFut;
1135    type EchoUnionResponseWithErrorComposedResponseFut: std::future::Future<
1136            Output = Result<
1137                fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
1138                fidl::Error,
1139            >,
1140        > + Send;
1141    fn r#echo_union_response_with_error_composed(
1142        &self,
1143        value: i64,
1144        want_absolute_value: bool,
1145        forward_to_server: &str,
1146        result_err: u32,
1147        result_variant: fidl_fidl_test_imported::WantResponse,
1148    ) -> Self::EchoUnionResponseWithErrorComposedResponseFut;
1149    type EchoMinimalResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
1150    fn r#echo_minimal(&self, forward_to_server: &str) -> Self::EchoMinimalResponseFut;
1151    type EchoMinimalWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoMinimalWithErrorResult, fidl::Error>>
1152        + Send;
1153    fn r#echo_minimal_with_error(
1154        &self,
1155        forward_to_server: &str,
1156        result_variant: RespondWith,
1157    ) -> Self::EchoMinimalWithErrorResponseFut;
1158    fn r#echo_minimal_no_ret_val(&self, forward_to_server: &str) -> Result<(), fidl::Error>;
1159    type EchoStructResponseFut: std::future::Future<Output = Result<Struct, fidl::Error>> + Send;
1160    fn r#echo_struct(&self, value: Struct, forward_to_server: &str) -> Self::EchoStructResponseFut;
1161    type EchoStructWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoStructWithErrorResult, fidl::Error>>
1162        + Send;
1163    fn r#echo_struct_with_error(
1164        &self,
1165        value: Struct,
1166        result_err: DefaultEnum,
1167        forward_to_server: &str,
1168        result_variant: RespondWith,
1169    ) -> Self::EchoStructWithErrorResponseFut;
1170    fn r#echo_struct_no_ret_val(
1171        &self,
1172        value: Struct,
1173        forward_to_server: &str,
1174    ) -> Result<(), fidl::Error>;
1175    type EchoArraysResponseFut: std::future::Future<Output = Result<ArraysStruct, fidl::Error>>
1176        + Send;
1177    fn r#echo_arrays(
1178        &self,
1179        value: ArraysStruct,
1180        forward_to_server: &str,
1181    ) -> Self::EchoArraysResponseFut;
1182    type EchoArraysWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoArraysWithErrorResult, fidl::Error>>
1183        + Send;
1184    fn r#echo_arrays_with_error(
1185        &self,
1186        value: ArraysStruct,
1187        result_err: DefaultEnum,
1188        forward_to_server: &str,
1189        result_variant: RespondWith,
1190    ) -> Self::EchoArraysWithErrorResponseFut;
1191    type EchoVectorsResponseFut: std::future::Future<Output = Result<VectorsStruct, fidl::Error>>
1192        + Send;
1193    fn r#echo_vectors(
1194        &self,
1195        value: VectorsStruct,
1196        forward_to_server: &str,
1197    ) -> Self::EchoVectorsResponseFut;
1198    type EchoVectorsWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoVectorsWithErrorResult, fidl::Error>>
1199        + Send;
1200    fn r#echo_vectors_with_error(
1201        &self,
1202        value: VectorsStruct,
1203        result_err: DefaultEnum,
1204        forward_to_server: &str,
1205        result_variant: RespondWith,
1206    ) -> Self::EchoVectorsWithErrorResponseFut;
1207    type EchoTableResponseFut: std::future::Future<Output = Result<AllTypesTable, fidl::Error>>
1208        + Send;
1209    fn r#echo_table(
1210        &self,
1211        value: AllTypesTable,
1212        forward_to_server: &str,
1213    ) -> Self::EchoTableResponseFut;
1214    type EchoTableWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoTableWithErrorResult, fidl::Error>>
1215        + Send;
1216    fn r#echo_table_with_error(
1217        &self,
1218        value: AllTypesTable,
1219        result_err: DefaultEnum,
1220        forward_to_server: &str,
1221        result_variant: RespondWith,
1222    ) -> Self::EchoTableWithErrorResponseFut;
1223    type EchoXunionsResponseFut: std::future::Future<Output = Result<Vec<AllTypesXunion>, fidl::Error>>
1224        + Send;
1225    fn r#echo_xunions(
1226        &self,
1227        value: Vec<AllTypesXunion>,
1228        forward_to_server: &str,
1229    ) -> Self::EchoXunionsResponseFut;
1230    type EchoXunionsWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoXunionsWithErrorResult, fidl::Error>>
1231        + Send;
1232    fn r#echo_xunions_with_error(
1233        &self,
1234        value: Vec<AllTypesXunion>,
1235        result_err: DefaultEnum,
1236        forward_to_server: &str,
1237        result_variant: RespondWith,
1238    ) -> Self::EchoXunionsWithErrorResponseFut;
1239    type EchoNamedStructResponseFut: std::future::Future<Output = Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error>>
1240        + Send;
1241    fn r#echo_named_struct(
1242        &self,
1243        value: &fidl_fidl_test_imported::SimpleStruct,
1244        forward_to_server: &str,
1245    ) -> Self::EchoNamedStructResponseFut;
1246    type EchoNamedStructWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoNamedStructWithErrorResult, fidl::Error>>
1247        + Send;
1248    fn r#echo_named_struct_with_error(
1249        &self,
1250        value: &fidl_fidl_test_imported::SimpleStruct,
1251        result_err: u32,
1252        forward_to_server: &str,
1253        result_variant: fidl_fidl_test_imported::WantResponse,
1254    ) -> Self::EchoNamedStructWithErrorResponseFut;
1255    fn r#echo_named_struct_no_ret_val(
1256        &self,
1257        value: &fidl_fidl_test_imported::SimpleStruct,
1258        forward_to_server: &str,
1259    ) -> Result<(), fidl::Error>;
1260    type EchoTablePayloadResponseFut: std::future::Future<Output = Result<ResponseTable, fidl::Error>>
1261        + Send;
1262    fn r#echo_table_payload(&self, payload: &RequestTable) -> Self::EchoTablePayloadResponseFut;
1263    type EchoTablePayloadWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoTablePayloadWithErrorResult, fidl::Error>>
1264        + Send;
1265    fn r#echo_table_payload_with_error(
1266        &self,
1267        payload: &EchoEchoTablePayloadWithErrorRequest,
1268    ) -> Self::EchoTablePayloadWithErrorResponseFut;
1269    fn r#echo_table_payload_no_ret_val(&self, payload: &RequestTable) -> Result<(), fidl::Error>;
1270    type EchoUnionPayloadResponseFut: std::future::Future<Output = Result<ResponseUnion, fidl::Error>>
1271        + Send;
1272    fn r#echo_union_payload(&self, payload: &RequestUnion) -> Self::EchoUnionPayloadResponseFut;
1273    type EchoUnionPayloadWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoUnionPayloadWithErrorResult, fidl::Error>>
1274        + Send;
1275    fn r#echo_union_payload_with_error(
1276        &self,
1277        payload: &EchoEchoUnionPayloadWithErrorRequest,
1278    ) -> Self::EchoUnionPayloadWithErrorResponseFut;
1279    fn r#echo_union_payload_no_ret_val(&self, payload: &RequestUnion) -> Result<(), fidl::Error>;
1280}
1281#[derive(Debug)]
1282#[cfg(target_os = "fuchsia")]
1283pub struct EchoSynchronousProxy {
1284    client: fidl::client::sync::Client,
1285}
1286
1287#[cfg(target_os = "fuchsia")]
1288impl fidl::endpoints::SynchronousProxy for EchoSynchronousProxy {
1289    type Proxy = EchoProxy;
1290    type Protocol = EchoMarker;
1291
1292    fn from_channel(inner: fidl::Channel) -> Self {
1293        Self::new(inner)
1294    }
1295
1296    fn into_channel(self) -> fidl::Channel {
1297        self.client.into_channel()
1298    }
1299
1300    fn as_channel(&self) -> &fidl::Channel {
1301        self.client.as_channel()
1302    }
1303}
1304
1305#[cfg(target_os = "fuchsia")]
1306impl EchoSynchronousProxy {
1307    pub fn new(channel: fidl::Channel) -> Self {
1308        Self { client: fidl::client::sync::Client::new(channel) }
1309    }
1310
1311    pub fn into_channel(self) -> fidl::Channel {
1312        self.client.into_channel()
1313    }
1314
1315    /// Waits until an event arrives and returns it. It is safe for other
1316    /// threads to make concurrent requests while waiting for an event.
1317    pub fn wait_for_event(&self, deadline: zx::MonotonicInstant) -> Result<EchoEvent, fidl::Error> {
1318        EchoEvent::decode(self.client.wait_for_event::<EchoMarker>(deadline)?)
1319    }
1320
1321    pub fn r#echo_table_request_composed(
1322        &self,
1323        mut payload: &fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
1324        ___deadline: zx::MonotonicInstant,
1325    ) -> Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error> {
1326        let _response = self.client.send_query::<
1327            fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
1328            fidl_fidl_test_imported::ResponseStruct,
1329            EchoMarker,
1330        >(
1331            payload,
1332            0x1d545c738c7a8ee,
1333            fidl::encoding::DynamicFlags::empty(),
1334            ___deadline,
1335        )?;
1336        Ok(_response.value)
1337    }
1338
1339    pub fn r#echo_union_response_with_error_composed(
1340        &self,
1341        mut value: i64,
1342        mut want_absolute_value: bool,
1343        mut forward_to_server: &str,
1344        mut result_err: u32,
1345        mut result_variant: fidl_fidl_test_imported::WantResponse,
1346        ___deadline: zx::MonotonicInstant,
1347    ) -> Result<
1348        fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
1349        fidl::Error,
1350    > {
1351        let _response = self.client.send_query::<
1352            fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedRequest,
1353            fidl::encoding::ResultType<fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse, u32>,
1354            EchoMarker,
1355        >(
1356            (value, want_absolute_value, forward_to_server, result_err, result_variant,),
1357            0x38a67e88d6106443,
1358            fidl::encoding::DynamicFlags::empty(),
1359            ___deadline,
1360        )?;
1361        Ok(_response.map(|x| x))
1362    }
1363
1364    pub fn r#echo_minimal(
1365        &self,
1366        mut forward_to_server: &str,
1367        ___deadline: zx::MonotonicInstant,
1368    ) -> Result<(), fidl::Error> {
1369        let _response = self
1370            .client
1371            .send_query::<EchoEchoMinimalRequest, fidl::encoding::EmptyPayload, EchoMarker>(
1372                (forward_to_server,),
1373                0x39edd68c837482ec,
1374                fidl::encoding::DynamicFlags::empty(),
1375                ___deadline,
1376            )?;
1377        Ok(_response)
1378    }
1379
1380    pub fn r#echo_minimal_with_error(
1381        &self,
1382        mut forward_to_server: &str,
1383        mut result_variant: RespondWith,
1384        ___deadline: zx::MonotonicInstant,
1385    ) -> Result<EchoEchoMinimalWithErrorResult, fidl::Error> {
1386        let _response = self.client.send_query::<
1387            EchoEchoMinimalWithErrorRequest,
1388            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, u32>,
1389            EchoMarker,
1390        >(
1391            (forward_to_server, result_variant,),
1392            0x36f4695996e35acc,
1393            fidl::encoding::DynamicFlags::empty(),
1394            ___deadline,
1395        )?;
1396        Ok(_response.map(|x| x))
1397    }
1398
1399    pub fn r#echo_minimal_no_ret_val(
1400        &self,
1401        mut forward_to_server: &str,
1402    ) -> Result<(), fidl::Error> {
1403        self.client.send::<EchoEchoMinimalNoRetValRequest>(
1404            (forward_to_server,),
1405            0x42693c143e2c3694,
1406            fidl::encoding::DynamicFlags::empty(),
1407        )
1408    }
1409
1410    pub fn r#echo_struct(
1411        &self,
1412        mut value: Struct,
1413        mut forward_to_server: &str,
1414        ___deadline: zx::MonotonicInstant,
1415    ) -> Result<Struct, fidl::Error> {
1416        let _response =
1417            self.client.send_query::<EchoEchoStructRequest, EchoEchoStructResponse, EchoMarker>(
1418                (&mut value, forward_to_server),
1419                0x4c2f85818cc53f37,
1420                fidl::encoding::DynamicFlags::empty(),
1421                ___deadline,
1422            )?;
1423        Ok(_response.value)
1424    }
1425
1426    pub fn r#echo_struct_with_error(
1427        &self,
1428        mut value: Struct,
1429        mut result_err: DefaultEnum,
1430        mut forward_to_server: &str,
1431        mut result_variant: RespondWith,
1432        ___deadline: zx::MonotonicInstant,
1433    ) -> Result<EchoEchoStructWithErrorResult, fidl::Error> {
1434        let _response = self.client.send_query::<
1435            EchoEchoStructWithErrorRequest,
1436            fidl::encoding::ResultType<EchoEchoStructWithErrorResponse, DefaultEnum>,
1437            EchoMarker,
1438        >(
1439            (&mut value, result_err, forward_to_server, result_variant,),
1440            0x46cb32652c4c0899,
1441            fidl::encoding::DynamicFlags::empty(),
1442            ___deadline,
1443        )?;
1444        Ok(_response.map(|x| x.value))
1445    }
1446
1447    pub fn r#echo_struct_no_ret_val(
1448        &self,
1449        mut value: Struct,
1450        mut forward_to_server: &str,
1451    ) -> Result<(), fidl::Error> {
1452        self.client.send::<EchoEchoStructNoRetValRequest>(
1453            (&mut value, forward_to_server),
1454            0x1f763e602cf5892a,
1455            fidl::encoding::DynamicFlags::empty(),
1456        )
1457    }
1458
1459    pub fn r#echo_arrays(
1460        &self,
1461        mut value: ArraysStruct,
1462        mut forward_to_server: &str,
1463        ___deadline: zx::MonotonicInstant,
1464    ) -> Result<ArraysStruct, fidl::Error> {
1465        let _response =
1466            self.client.send_query::<EchoEchoArraysRequest, EchoEchoArraysResponse, EchoMarker>(
1467                (&mut value, forward_to_server),
1468                0x1b6019d5611f2470,
1469                fidl::encoding::DynamicFlags::empty(),
1470                ___deadline,
1471            )?;
1472        Ok(_response.value)
1473    }
1474
1475    pub fn r#echo_arrays_with_error(
1476        &self,
1477        mut value: ArraysStruct,
1478        mut result_err: DefaultEnum,
1479        mut forward_to_server: &str,
1480        mut result_variant: RespondWith,
1481        ___deadline: zx::MonotonicInstant,
1482    ) -> Result<EchoEchoArraysWithErrorResult, fidl::Error> {
1483        let _response = self.client.send_query::<
1484            EchoEchoArraysWithErrorRequest,
1485            fidl::encoding::ResultType<EchoEchoArraysWithErrorResponse, DefaultEnum>,
1486            EchoMarker,
1487        >(
1488            (&mut value, result_err, forward_to_server, result_variant,),
1489            0x6dbf26e67e253afa,
1490            fidl::encoding::DynamicFlags::empty(),
1491            ___deadline,
1492        )?;
1493        Ok(_response.map(|x| x.value))
1494    }
1495
1496    pub fn r#echo_vectors(
1497        &self,
1498        mut value: VectorsStruct,
1499        mut forward_to_server: &str,
1500        ___deadline: zx::MonotonicInstant,
1501    ) -> Result<VectorsStruct, fidl::Error> {
1502        let _response =
1503            self.client.send_query::<EchoEchoVectorsRequest, EchoEchoVectorsResponse, EchoMarker>(
1504                (&mut value, forward_to_server),
1505                0x1582623f0d9f6e5e,
1506                fidl::encoding::DynamicFlags::empty(),
1507                ___deadline,
1508            )?;
1509        Ok(_response.value)
1510    }
1511
1512    pub fn r#echo_vectors_with_error(
1513        &self,
1514        mut value: VectorsStruct,
1515        mut result_err: DefaultEnum,
1516        mut forward_to_server: &str,
1517        mut result_variant: RespondWith,
1518        ___deadline: zx::MonotonicInstant,
1519    ) -> Result<EchoEchoVectorsWithErrorResult, fidl::Error> {
1520        let _response = self.client.send_query::<
1521            EchoEchoVectorsWithErrorRequest,
1522            fidl::encoding::ResultType<EchoEchoVectorsWithErrorResponse, DefaultEnum>,
1523            EchoMarker,
1524        >(
1525            (&mut value, result_err, forward_to_server, result_variant,),
1526            0x730f163401e2b3e5,
1527            fidl::encoding::DynamicFlags::empty(),
1528            ___deadline,
1529        )?;
1530        Ok(_response.map(|x| x.value))
1531    }
1532
1533    pub fn r#echo_table(
1534        &self,
1535        mut value: AllTypesTable,
1536        mut forward_to_server: &str,
1537        ___deadline: zx::MonotonicInstant,
1538    ) -> Result<AllTypesTable, fidl::Error> {
1539        let _response =
1540            self.client.send_query::<EchoEchoTableRequest, EchoEchoTableResponse, EchoMarker>(
1541                (&mut value, forward_to_server),
1542                0x4f1fb0a512f47c4b,
1543                fidl::encoding::DynamicFlags::empty(),
1544                ___deadline,
1545            )?;
1546        Ok(_response.value)
1547    }
1548
1549    pub fn r#echo_table_with_error(
1550        &self,
1551        mut value: AllTypesTable,
1552        mut result_err: DefaultEnum,
1553        mut forward_to_server: &str,
1554        mut result_variant: RespondWith,
1555        ___deadline: zx::MonotonicInstant,
1556    ) -> Result<EchoEchoTableWithErrorResult, fidl::Error> {
1557        let _response = self.client.send_query::<
1558            EchoEchoTableWithErrorRequest,
1559            fidl::encoding::ResultType<EchoEchoTableWithErrorResponse, DefaultEnum>,
1560            EchoMarker,
1561        >(
1562            (&mut value, result_err, forward_to_server, result_variant,),
1563            0x44e835cb1eb9a931,
1564            fidl::encoding::DynamicFlags::empty(),
1565            ___deadline,
1566        )?;
1567        Ok(_response.map(|x| x.value))
1568    }
1569
1570    pub fn r#echo_xunions(
1571        &self,
1572        mut value: Vec<AllTypesXunion>,
1573        mut forward_to_server: &str,
1574        ___deadline: zx::MonotonicInstant,
1575    ) -> Result<Vec<AllTypesXunion>, fidl::Error> {
1576        let _response =
1577            self.client.send_query::<EchoEchoXunionsRequest, EchoEchoXunionsResponse, EchoMarker>(
1578                (value.as_mut(), forward_to_server),
1579                0x3dc181909041a583,
1580                fidl::encoding::DynamicFlags::empty(),
1581                ___deadline,
1582            )?;
1583        Ok(_response.value)
1584    }
1585
1586    pub fn r#echo_xunions_with_error(
1587        &self,
1588        mut value: Vec<AllTypesXunion>,
1589        mut result_err: DefaultEnum,
1590        mut forward_to_server: &str,
1591        mut result_variant: RespondWith,
1592        ___deadline: zx::MonotonicInstant,
1593    ) -> Result<EchoEchoXunionsWithErrorResult, fidl::Error> {
1594        let _response = self.client.send_query::<
1595            EchoEchoXunionsWithErrorRequest,
1596            fidl::encoding::ResultType<EchoEchoXunionsWithErrorResponse, DefaultEnum>,
1597            EchoMarker,
1598        >(
1599            (value.as_mut(), result_err, forward_to_server, result_variant,),
1600            0x75184102667fa766,
1601            fidl::encoding::DynamicFlags::empty(),
1602            ___deadline,
1603        )?;
1604        Ok(_response.map(|x| x.value))
1605    }
1606
1607    pub fn r#echo_named_struct(
1608        &self,
1609        mut value: &fidl_fidl_test_imported::SimpleStruct,
1610        mut forward_to_server: &str,
1611        ___deadline: zx::MonotonicInstant,
1612    ) -> Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error> {
1613        let _response = self.client.send_query::<
1614            fidl_fidl_test_imported::RequestStruct,
1615            fidl_fidl_test_imported::ResponseStruct,
1616            EchoMarker,
1617        >(
1618            (value, forward_to_server,),
1619            0xf2d4aa9e65f7111,
1620            fidl::encoding::DynamicFlags::empty(),
1621            ___deadline,
1622        )?;
1623        Ok(_response.value)
1624    }
1625
1626    pub fn r#echo_named_struct_with_error(
1627        &self,
1628        mut value: &fidl_fidl_test_imported::SimpleStruct,
1629        mut result_err: u32,
1630        mut forward_to_server: &str,
1631        mut result_variant: fidl_fidl_test_imported::WantResponse,
1632        ___deadline: zx::MonotonicInstant,
1633    ) -> Result<EchoEchoNamedStructWithErrorResult, fidl::Error> {
1634        let _response = self.client.send_query::<
1635            fidl_fidl_test_imported::ErrorableRequestStruct,
1636            fidl::encoding::ResultType<fidl_fidl_test_imported::ResponseStruct, u32>,
1637            EchoMarker,
1638        >(
1639            (value, result_err, forward_to_server, result_variant,),
1640            0x5766fee9e74442e8,
1641            fidl::encoding::DynamicFlags::empty(),
1642            ___deadline,
1643        )?;
1644        Ok(_response.map(|x| x.value))
1645    }
1646
1647    pub fn r#echo_named_struct_no_ret_val(
1648        &self,
1649        mut value: &fidl_fidl_test_imported::SimpleStruct,
1650        mut forward_to_server: &str,
1651    ) -> Result<(), fidl::Error> {
1652        self.client.send::<fidl_fidl_test_imported::EventTriggeringRequestStruct>(
1653            (value, forward_to_server),
1654            0x3a50bbf7d2113ad7,
1655            fidl::encoding::DynamicFlags::empty(),
1656        )
1657    }
1658
1659    pub fn r#echo_table_payload(
1660        &self,
1661        mut payload: &RequestTable,
1662        ___deadline: zx::MonotonicInstant,
1663    ) -> Result<ResponseTable, fidl::Error> {
1664        let _response = self.client.send_query::<RequestTable, ResponseTable, EchoMarker>(
1665            payload,
1666            0x641d98087378c003,
1667            fidl::encoding::DynamicFlags::empty(),
1668            ___deadline,
1669        )?;
1670        Ok(_response)
1671    }
1672
1673    pub fn r#echo_table_payload_with_error(
1674        &self,
1675        mut payload: &EchoEchoTablePayloadWithErrorRequest,
1676        ___deadline: zx::MonotonicInstant,
1677    ) -> Result<EchoEchoTablePayloadWithErrorResult, fidl::Error> {
1678        let _response = self.client.send_query::<
1679            EchoEchoTablePayloadWithErrorRequest,
1680            fidl::encoding::ResultType<ResponseTable, DefaultEnum>,
1681            EchoMarker,
1682        >(
1683            payload,
1684            0x636ed243761ab66d,
1685            fidl::encoding::DynamicFlags::empty(),
1686            ___deadline,
1687        )?;
1688        Ok(_response.map(|x| x))
1689    }
1690
1691    pub fn r#echo_table_payload_no_ret_val(
1692        &self,
1693        mut payload: &RequestTable,
1694    ) -> Result<(), fidl::Error> {
1695        self.client.send::<RequestTable>(
1696            payload,
1697            0x32961f7d718569f8,
1698            fidl::encoding::DynamicFlags::empty(),
1699        )
1700    }
1701
1702    pub fn r#echo_union_payload(
1703        &self,
1704        mut payload: &RequestUnion,
1705        ___deadline: zx::MonotonicInstant,
1706    ) -> Result<ResponseUnion, fidl::Error> {
1707        let _response = self.client.send_query::<RequestUnion, ResponseUnion, EchoMarker>(
1708            payload,
1709            0x66def9e793f10c55,
1710            fidl::encoding::DynamicFlags::empty(),
1711            ___deadline,
1712        )?;
1713        Ok(_response)
1714    }
1715
1716    pub fn r#echo_union_payload_with_error(
1717        &self,
1718        mut payload: &EchoEchoUnionPayloadWithErrorRequest,
1719        ___deadline: zx::MonotonicInstant,
1720    ) -> Result<EchoEchoUnionPayloadWithErrorResult, fidl::Error> {
1721        let _response = self.client.send_query::<
1722            EchoEchoUnionPayloadWithErrorRequest,
1723            fidl::encoding::ResultType<ResponseUnion, DefaultEnum>,
1724            EchoMarker,
1725        >(
1726            payload,
1727            0x1be890d6e68ef063,
1728            fidl::encoding::DynamicFlags::empty(),
1729            ___deadline,
1730        )?;
1731        Ok(_response.map(|x| x))
1732    }
1733
1734    pub fn r#echo_union_payload_no_ret_val(
1735        &self,
1736        mut payload: &RequestUnion,
1737    ) -> Result<(), fidl::Error> {
1738        self.client.send::<RequestUnion>(
1739            payload,
1740            0x11518bf346430040,
1741            fidl::encoding::DynamicFlags::empty(),
1742        )
1743    }
1744}
1745
1746#[cfg(target_os = "fuchsia")]
1747impl From<EchoSynchronousProxy> for zx::NullableHandle {
1748    fn from(value: EchoSynchronousProxy) -> Self {
1749        value.into_channel().into()
1750    }
1751}
1752
1753#[cfg(target_os = "fuchsia")]
1754impl From<fidl::Channel> for EchoSynchronousProxy {
1755    fn from(value: fidl::Channel) -> Self {
1756        Self::new(value)
1757    }
1758}
1759
1760#[cfg(target_os = "fuchsia")]
1761impl fidl::endpoints::FromClient for EchoSynchronousProxy {
1762    type Protocol = EchoMarker;
1763
1764    fn from_client(value: fidl::endpoints::ClientEnd<EchoMarker>) -> Self {
1765        Self::new(value.into_channel())
1766    }
1767}
1768
1769#[derive(Debug, Clone)]
1770pub struct EchoProxy {
1771    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
1772}
1773
1774impl fidl::endpoints::Proxy for EchoProxy {
1775    type Protocol = EchoMarker;
1776
1777    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
1778        Self::new(inner)
1779    }
1780
1781    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
1782        self.client.into_channel().map_err(|client| Self { client })
1783    }
1784
1785    fn as_channel(&self) -> &::fidl::AsyncChannel {
1786        self.client.as_channel()
1787    }
1788}
1789
1790impl EchoProxy {
1791    /// Create a new Proxy for fidl.test.compatibility/Echo.
1792    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
1793        let protocol_name = <EchoMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1794        Self { client: fidl::client::Client::new(channel, protocol_name) }
1795    }
1796
1797    /// Get a Stream of events from the remote end of the protocol.
1798    ///
1799    /// # Panics
1800    ///
1801    /// Panics if the event stream was already taken.
1802    pub fn take_event_stream(&self) -> EchoEventStream {
1803        EchoEventStream { event_receiver: self.client.take_event_receiver() }
1804    }
1805
1806    pub fn r#echo_table_request_composed(
1807        &self,
1808        mut payload: &fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
1809    ) -> fidl::client::QueryResponseFut<
1810        fidl_fidl_test_imported::SimpleStruct,
1811        fidl::encoding::DefaultFuchsiaResourceDialect,
1812    > {
1813        EchoProxyInterface::r#echo_table_request_composed(self, payload)
1814    }
1815
1816    pub fn r#echo_union_response_with_error_composed(
1817        &self,
1818        mut value: i64,
1819        mut want_absolute_value: bool,
1820        mut forward_to_server: &str,
1821        mut result_err: u32,
1822        mut result_variant: fidl_fidl_test_imported::WantResponse,
1823    ) -> fidl::client::QueryResponseFut<
1824        fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
1825        fidl::encoding::DefaultFuchsiaResourceDialect,
1826    > {
1827        EchoProxyInterface::r#echo_union_response_with_error_composed(
1828            self,
1829            value,
1830            want_absolute_value,
1831            forward_to_server,
1832            result_err,
1833            result_variant,
1834        )
1835    }
1836
1837    pub fn r#echo_minimal(
1838        &self,
1839        mut forward_to_server: &str,
1840    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
1841        EchoProxyInterface::r#echo_minimal(self, forward_to_server)
1842    }
1843
1844    pub fn r#echo_minimal_with_error(
1845        &self,
1846        mut forward_to_server: &str,
1847        mut result_variant: RespondWith,
1848    ) -> fidl::client::QueryResponseFut<
1849        EchoEchoMinimalWithErrorResult,
1850        fidl::encoding::DefaultFuchsiaResourceDialect,
1851    > {
1852        EchoProxyInterface::r#echo_minimal_with_error(self, forward_to_server, result_variant)
1853    }
1854
1855    pub fn r#echo_minimal_no_ret_val(
1856        &self,
1857        mut forward_to_server: &str,
1858    ) -> Result<(), fidl::Error> {
1859        EchoProxyInterface::r#echo_minimal_no_ret_val(self, forward_to_server)
1860    }
1861
1862    pub fn r#echo_struct(
1863        &self,
1864        mut value: Struct,
1865        mut forward_to_server: &str,
1866    ) -> fidl::client::QueryResponseFut<Struct, fidl::encoding::DefaultFuchsiaResourceDialect> {
1867        EchoProxyInterface::r#echo_struct(self, value, forward_to_server)
1868    }
1869
1870    pub fn r#echo_struct_with_error(
1871        &self,
1872        mut value: Struct,
1873        mut result_err: DefaultEnum,
1874        mut forward_to_server: &str,
1875        mut result_variant: RespondWith,
1876    ) -> fidl::client::QueryResponseFut<
1877        EchoEchoStructWithErrorResult,
1878        fidl::encoding::DefaultFuchsiaResourceDialect,
1879    > {
1880        EchoProxyInterface::r#echo_struct_with_error(
1881            self,
1882            value,
1883            result_err,
1884            forward_to_server,
1885            result_variant,
1886        )
1887    }
1888
1889    pub fn r#echo_struct_no_ret_val(
1890        &self,
1891        mut value: Struct,
1892        mut forward_to_server: &str,
1893    ) -> Result<(), fidl::Error> {
1894        EchoProxyInterface::r#echo_struct_no_ret_val(self, value, forward_to_server)
1895    }
1896
1897    pub fn r#echo_arrays(
1898        &self,
1899        mut value: ArraysStruct,
1900        mut forward_to_server: &str,
1901    ) -> fidl::client::QueryResponseFut<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
1902    {
1903        EchoProxyInterface::r#echo_arrays(self, value, forward_to_server)
1904    }
1905
1906    pub fn r#echo_arrays_with_error(
1907        &self,
1908        mut value: ArraysStruct,
1909        mut result_err: DefaultEnum,
1910        mut forward_to_server: &str,
1911        mut result_variant: RespondWith,
1912    ) -> fidl::client::QueryResponseFut<
1913        EchoEchoArraysWithErrorResult,
1914        fidl::encoding::DefaultFuchsiaResourceDialect,
1915    > {
1916        EchoProxyInterface::r#echo_arrays_with_error(
1917            self,
1918            value,
1919            result_err,
1920            forward_to_server,
1921            result_variant,
1922        )
1923    }
1924
1925    pub fn r#echo_vectors(
1926        &self,
1927        mut value: VectorsStruct,
1928        mut forward_to_server: &str,
1929    ) -> fidl::client::QueryResponseFut<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
1930    {
1931        EchoProxyInterface::r#echo_vectors(self, value, forward_to_server)
1932    }
1933
1934    pub fn r#echo_vectors_with_error(
1935        &self,
1936        mut value: VectorsStruct,
1937        mut result_err: DefaultEnum,
1938        mut forward_to_server: &str,
1939        mut result_variant: RespondWith,
1940    ) -> fidl::client::QueryResponseFut<
1941        EchoEchoVectorsWithErrorResult,
1942        fidl::encoding::DefaultFuchsiaResourceDialect,
1943    > {
1944        EchoProxyInterface::r#echo_vectors_with_error(
1945            self,
1946            value,
1947            result_err,
1948            forward_to_server,
1949            result_variant,
1950        )
1951    }
1952
1953    pub fn r#echo_table(
1954        &self,
1955        mut value: AllTypesTable,
1956        mut forward_to_server: &str,
1957    ) -> fidl::client::QueryResponseFut<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>
1958    {
1959        EchoProxyInterface::r#echo_table(self, value, forward_to_server)
1960    }
1961
1962    pub fn r#echo_table_with_error(
1963        &self,
1964        mut value: AllTypesTable,
1965        mut result_err: DefaultEnum,
1966        mut forward_to_server: &str,
1967        mut result_variant: RespondWith,
1968    ) -> fidl::client::QueryResponseFut<
1969        EchoEchoTableWithErrorResult,
1970        fidl::encoding::DefaultFuchsiaResourceDialect,
1971    > {
1972        EchoProxyInterface::r#echo_table_with_error(
1973            self,
1974            value,
1975            result_err,
1976            forward_to_server,
1977            result_variant,
1978        )
1979    }
1980
1981    pub fn r#echo_xunions(
1982        &self,
1983        mut value: Vec<AllTypesXunion>,
1984        mut forward_to_server: &str,
1985    ) -> fidl::client::QueryResponseFut<
1986        Vec<AllTypesXunion>,
1987        fidl::encoding::DefaultFuchsiaResourceDialect,
1988    > {
1989        EchoProxyInterface::r#echo_xunions(self, value, forward_to_server)
1990    }
1991
1992    pub fn r#echo_xunions_with_error(
1993        &self,
1994        mut value: Vec<AllTypesXunion>,
1995        mut result_err: DefaultEnum,
1996        mut forward_to_server: &str,
1997        mut result_variant: RespondWith,
1998    ) -> fidl::client::QueryResponseFut<
1999        EchoEchoXunionsWithErrorResult,
2000        fidl::encoding::DefaultFuchsiaResourceDialect,
2001    > {
2002        EchoProxyInterface::r#echo_xunions_with_error(
2003            self,
2004            value,
2005            result_err,
2006            forward_to_server,
2007            result_variant,
2008        )
2009    }
2010
2011    pub fn r#echo_named_struct(
2012        &self,
2013        mut value: &fidl_fidl_test_imported::SimpleStruct,
2014        mut forward_to_server: &str,
2015    ) -> fidl::client::QueryResponseFut<
2016        fidl_fidl_test_imported::SimpleStruct,
2017        fidl::encoding::DefaultFuchsiaResourceDialect,
2018    > {
2019        EchoProxyInterface::r#echo_named_struct(self, value, forward_to_server)
2020    }
2021
2022    pub fn r#echo_named_struct_with_error(
2023        &self,
2024        mut value: &fidl_fidl_test_imported::SimpleStruct,
2025        mut result_err: u32,
2026        mut forward_to_server: &str,
2027        mut result_variant: fidl_fidl_test_imported::WantResponse,
2028    ) -> fidl::client::QueryResponseFut<
2029        EchoEchoNamedStructWithErrorResult,
2030        fidl::encoding::DefaultFuchsiaResourceDialect,
2031    > {
2032        EchoProxyInterface::r#echo_named_struct_with_error(
2033            self,
2034            value,
2035            result_err,
2036            forward_to_server,
2037            result_variant,
2038        )
2039    }
2040
2041    pub fn r#echo_named_struct_no_ret_val(
2042        &self,
2043        mut value: &fidl_fidl_test_imported::SimpleStruct,
2044        mut forward_to_server: &str,
2045    ) -> Result<(), fidl::Error> {
2046        EchoProxyInterface::r#echo_named_struct_no_ret_val(self, value, forward_to_server)
2047    }
2048
2049    pub fn r#echo_table_payload(
2050        &self,
2051        mut payload: &RequestTable,
2052    ) -> fidl::client::QueryResponseFut<ResponseTable, fidl::encoding::DefaultFuchsiaResourceDialect>
2053    {
2054        EchoProxyInterface::r#echo_table_payload(self, payload)
2055    }
2056
2057    pub fn r#echo_table_payload_with_error(
2058        &self,
2059        mut payload: &EchoEchoTablePayloadWithErrorRequest,
2060    ) -> fidl::client::QueryResponseFut<
2061        EchoEchoTablePayloadWithErrorResult,
2062        fidl::encoding::DefaultFuchsiaResourceDialect,
2063    > {
2064        EchoProxyInterface::r#echo_table_payload_with_error(self, payload)
2065    }
2066
2067    pub fn r#echo_table_payload_no_ret_val(
2068        &self,
2069        mut payload: &RequestTable,
2070    ) -> Result<(), fidl::Error> {
2071        EchoProxyInterface::r#echo_table_payload_no_ret_val(self, payload)
2072    }
2073
2074    pub fn r#echo_union_payload(
2075        &self,
2076        mut payload: &RequestUnion,
2077    ) -> fidl::client::QueryResponseFut<ResponseUnion, fidl::encoding::DefaultFuchsiaResourceDialect>
2078    {
2079        EchoProxyInterface::r#echo_union_payload(self, payload)
2080    }
2081
2082    pub fn r#echo_union_payload_with_error(
2083        &self,
2084        mut payload: &EchoEchoUnionPayloadWithErrorRequest,
2085    ) -> fidl::client::QueryResponseFut<
2086        EchoEchoUnionPayloadWithErrorResult,
2087        fidl::encoding::DefaultFuchsiaResourceDialect,
2088    > {
2089        EchoProxyInterface::r#echo_union_payload_with_error(self, payload)
2090    }
2091
2092    pub fn r#echo_union_payload_no_ret_val(
2093        &self,
2094        mut payload: &RequestUnion,
2095    ) -> Result<(), fidl::Error> {
2096        EchoProxyInterface::r#echo_union_payload_no_ret_val(self, payload)
2097    }
2098}
2099
2100impl EchoProxyInterface for EchoProxy {
2101    type EchoTableRequestComposedResponseFut = fidl::client::QueryResponseFut<
2102        fidl_fidl_test_imported::SimpleStruct,
2103        fidl::encoding::DefaultFuchsiaResourceDialect,
2104    >;
2105    fn r#echo_table_request_composed(
2106        &self,
2107        mut payload: &fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
2108    ) -> Self::EchoTableRequestComposedResponseFut {
2109        fn _decode(
2110            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2111        ) -> Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error> {
2112            let _response = fidl::client::decode_transaction_body::<
2113                fidl_fidl_test_imported::ResponseStruct,
2114                fidl::encoding::DefaultFuchsiaResourceDialect,
2115                0x1d545c738c7a8ee,
2116            >(_buf?)?;
2117            Ok(_response.value)
2118        }
2119        self.client.send_query_and_decode::<
2120            fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
2121            fidl_fidl_test_imported::SimpleStruct,
2122        >(
2123            payload,
2124            0x1d545c738c7a8ee,
2125            fidl::encoding::DynamicFlags::empty(),
2126            _decode,
2127        )
2128    }
2129
2130    type EchoUnionResponseWithErrorComposedResponseFut = fidl::client::QueryResponseFut<
2131        fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
2132        fidl::encoding::DefaultFuchsiaResourceDialect,
2133    >;
2134    fn r#echo_union_response_with_error_composed(
2135        &self,
2136        mut value: i64,
2137        mut want_absolute_value: bool,
2138        mut forward_to_server: &str,
2139        mut result_err: u32,
2140        mut result_variant: fidl_fidl_test_imported::WantResponse,
2141    ) -> Self::EchoUnionResponseWithErrorComposedResponseFut {
2142        fn _decode(
2143            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2144        ) -> Result<
2145            fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
2146            fidl::Error,
2147        > {
2148            let _response = fidl::client::decode_transaction_body::<
2149                fidl::encoding::ResultType<
2150                    fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse,
2151                    u32,
2152                >,
2153                fidl::encoding::DefaultFuchsiaResourceDialect,
2154                0x38a67e88d6106443,
2155            >(_buf?)?;
2156            Ok(_response.map(|x| x))
2157        }
2158        self.client.send_query_and_decode::<
2159            fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedRequest,
2160            fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
2161        >(
2162            (value, want_absolute_value, forward_to_server, result_err, result_variant,),
2163            0x38a67e88d6106443,
2164            fidl::encoding::DynamicFlags::empty(),
2165            _decode,
2166        )
2167    }
2168
2169    type EchoMinimalResponseFut =
2170        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
2171    fn r#echo_minimal(&self, mut forward_to_server: &str) -> Self::EchoMinimalResponseFut {
2172        fn _decode(
2173            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2174        ) -> Result<(), fidl::Error> {
2175            let _response = fidl::client::decode_transaction_body::<
2176                fidl::encoding::EmptyPayload,
2177                fidl::encoding::DefaultFuchsiaResourceDialect,
2178                0x39edd68c837482ec,
2179            >(_buf?)?;
2180            Ok(_response)
2181        }
2182        self.client.send_query_and_decode::<EchoEchoMinimalRequest, ()>(
2183            (forward_to_server,),
2184            0x39edd68c837482ec,
2185            fidl::encoding::DynamicFlags::empty(),
2186            _decode,
2187        )
2188    }
2189
2190    type EchoMinimalWithErrorResponseFut = fidl::client::QueryResponseFut<
2191        EchoEchoMinimalWithErrorResult,
2192        fidl::encoding::DefaultFuchsiaResourceDialect,
2193    >;
2194    fn r#echo_minimal_with_error(
2195        &self,
2196        mut forward_to_server: &str,
2197        mut result_variant: RespondWith,
2198    ) -> Self::EchoMinimalWithErrorResponseFut {
2199        fn _decode(
2200            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2201        ) -> Result<EchoEchoMinimalWithErrorResult, fidl::Error> {
2202            let _response = fidl::client::decode_transaction_body::<
2203                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, u32>,
2204                fidl::encoding::DefaultFuchsiaResourceDialect,
2205                0x36f4695996e35acc,
2206            >(_buf?)?;
2207            Ok(_response.map(|x| x))
2208        }
2209        self.client.send_query_and_decode::<
2210            EchoEchoMinimalWithErrorRequest,
2211            EchoEchoMinimalWithErrorResult,
2212        >(
2213            (forward_to_server, result_variant,),
2214            0x36f4695996e35acc,
2215            fidl::encoding::DynamicFlags::empty(),
2216            _decode,
2217        )
2218    }
2219
2220    fn r#echo_minimal_no_ret_val(&self, mut forward_to_server: &str) -> Result<(), fidl::Error> {
2221        self.client.send::<EchoEchoMinimalNoRetValRequest>(
2222            (forward_to_server,),
2223            0x42693c143e2c3694,
2224            fidl::encoding::DynamicFlags::empty(),
2225        )
2226    }
2227
2228    type EchoStructResponseFut =
2229        fidl::client::QueryResponseFut<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>;
2230    fn r#echo_struct(
2231        &self,
2232        mut value: Struct,
2233        mut forward_to_server: &str,
2234    ) -> Self::EchoStructResponseFut {
2235        fn _decode(
2236            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2237        ) -> Result<Struct, fidl::Error> {
2238            let _response = fidl::client::decode_transaction_body::<
2239                EchoEchoStructResponse,
2240                fidl::encoding::DefaultFuchsiaResourceDialect,
2241                0x4c2f85818cc53f37,
2242            >(_buf?)?;
2243            Ok(_response.value)
2244        }
2245        self.client.send_query_and_decode::<EchoEchoStructRequest, Struct>(
2246            (&mut value, forward_to_server),
2247            0x4c2f85818cc53f37,
2248            fidl::encoding::DynamicFlags::empty(),
2249            _decode,
2250        )
2251    }
2252
2253    type EchoStructWithErrorResponseFut = fidl::client::QueryResponseFut<
2254        EchoEchoStructWithErrorResult,
2255        fidl::encoding::DefaultFuchsiaResourceDialect,
2256    >;
2257    fn r#echo_struct_with_error(
2258        &self,
2259        mut value: Struct,
2260        mut result_err: DefaultEnum,
2261        mut forward_to_server: &str,
2262        mut result_variant: RespondWith,
2263    ) -> Self::EchoStructWithErrorResponseFut {
2264        fn _decode(
2265            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2266        ) -> Result<EchoEchoStructWithErrorResult, fidl::Error> {
2267            let _response = fidl::client::decode_transaction_body::<
2268                fidl::encoding::ResultType<EchoEchoStructWithErrorResponse, DefaultEnum>,
2269                fidl::encoding::DefaultFuchsiaResourceDialect,
2270                0x46cb32652c4c0899,
2271            >(_buf?)?;
2272            Ok(_response.map(|x| x.value))
2273        }
2274        self.client
2275            .send_query_and_decode::<EchoEchoStructWithErrorRequest, EchoEchoStructWithErrorResult>(
2276                (&mut value, result_err, forward_to_server, result_variant),
2277                0x46cb32652c4c0899,
2278                fidl::encoding::DynamicFlags::empty(),
2279                _decode,
2280            )
2281    }
2282
2283    fn r#echo_struct_no_ret_val(
2284        &self,
2285        mut value: Struct,
2286        mut forward_to_server: &str,
2287    ) -> Result<(), fidl::Error> {
2288        self.client.send::<EchoEchoStructNoRetValRequest>(
2289            (&mut value, forward_to_server),
2290            0x1f763e602cf5892a,
2291            fidl::encoding::DynamicFlags::empty(),
2292        )
2293    }
2294
2295    type EchoArraysResponseFut =
2296        fidl::client::QueryResponseFut<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>;
2297    fn r#echo_arrays(
2298        &self,
2299        mut value: ArraysStruct,
2300        mut forward_to_server: &str,
2301    ) -> Self::EchoArraysResponseFut {
2302        fn _decode(
2303            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2304        ) -> Result<ArraysStruct, fidl::Error> {
2305            let _response = fidl::client::decode_transaction_body::<
2306                EchoEchoArraysResponse,
2307                fidl::encoding::DefaultFuchsiaResourceDialect,
2308                0x1b6019d5611f2470,
2309            >(_buf?)?;
2310            Ok(_response.value)
2311        }
2312        self.client.send_query_and_decode::<EchoEchoArraysRequest, ArraysStruct>(
2313            (&mut value, forward_to_server),
2314            0x1b6019d5611f2470,
2315            fidl::encoding::DynamicFlags::empty(),
2316            _decode,
2317        )
2318    }
2319
2320    type EchoArraysWithErrorResponseFut = fidl::client::QueryResponseFut<
2321        EchoEchoArraysWithErrorResult,
2322        fidl::encoding::DefaultFuchsiaResourceDialect,
2323    >;
2324    fn r#echo_arrays_with_error(
2325        &self,
2326        mut value: ArraysStruct,
2327        mut result_err: DefaultEnum,
2328        mut forward_to_server: &str,
2329        mut result_variant: RespondWith,
2330    ) -> Self::EchoArraysWithErrorResponseFut {
2331        fn _decode(
2332            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2333        ) -> Result<EchoEchoArraysWithErrorResult, fidl::Error> {
2334            let _response = fidl::client::decode_transaction_body::<
2335                fidl::encoding::ResultType<EchoEchoArraysWithErrorResponse, DefaultEnum>,
2336                fidl::encoding::DefaultFuchsiaResourceDialect,
2337                0x6dbf26e67e253afa,
2338            >(_buf?)?;
2339            Ok(_response.map(|x| x.value))
2340        }
2341        self.client
2342            .send_query_and_decode::<EchoEchoArraysWithErrorRequest, EchoEchoArraysWithErrorResult>(
2343                (&mut value, result_err, forward_to_server, result_variant),
2344                0x6dbf26e67e253afa,
2345                fidl::encoding::DynamicFlags::empty(),
2346                _decode,
2347            )
2348    }
2349
2350    type EchoVectorsResponseFut = fidl::client::QueryResponseFut<
2351        VectorsStruct,
2352        fidl::encoding::DefaultFuchsiaResourceDialect,
2353    >;
2354    fn r#echo_vectors(
2355        &self,
2356        mut value: VectorsStruct,
2357        mut forward_to_server: &str,
2358    ) -> Self::EchoVectorsResponseFut {
2359        fn _decode(
2360            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2361        ) -> Result<VectorsStruct, fidl::Error> {
2362            let _response = fidl::client::decode_transaction_body::<
2363                EchoEchoVectorsResponse,
2364                fidl::encoding::DefaultFuchsiaResourceDialect,
2365                0x1582623f0d9f6e5e,
2366            >(_buf?)?;
2367            Ok(_response.value)
2368        }
2369        self.client.send_query_and_decode::<EchoEchoVectorsRequest, VectorsStruct>(
2370            (&mut value, forward_to_server),
2371            0x1582623f0d9f6e5e,
2372            fidl::encoding::DynamicFlags::empty(),
2373            _decode,
2374        )
2375    }
2376
2377    type EchoVectorsWithErrorResponseFut = fidl::client::QueryResponseFut<
2378        EchoEchoVectorsWithErrorResult,
2379        fidl::encoding::DefaultFuchsiaResourceDialect,
2380    >;
2381    fn r#echo_vectors_with_error(
2382        &self,
2383        mut value: VectorsStruct,
2384        mut result_err: DefaultEnum,
2385        mut forward_to_server: &str,
2386        mut result_variant: RespondWith,
2387    ) -> Self::EchoVectorsWithErrorResponseFut {
2388        fn _decode(
2389            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2390        ) -> Result<EchoEchoVectorsWithErrorResult, fidl::Error> {
2391            let _response = fidl::client::decode_transaction_body::<
2392                fidl::encoding::ResultType<EchoEchoVectorsWithErrorResponse, DefaultEnum>,
2393                fidl::encoding::DefaultFuchsiaResourceDialect,
2394                0x730f163401e2b3e5,
2395            >(_buf?)?;
2396            Ok(_response.map(|x| x.value))
2397        }
2398        self.client.send_query_and_decode::<
2399            EchoEchoVectorsWithErrorRequest,
2400            EchoEchoVectorsWithErrorResult,
2401        >(
2402            (&mut value, result_err, forward_to_server, result_variant,),
2403            0x730f163401e2b3e5,
2404            fidl::encoding::DynamicFlags::empty(),
2405            _decode,
2406        )
2407    }
2408
2409    type EchoTableResponseFut = fidl::client::QueryResponseFut<
2410        AllTypesTable,
2411        fidl::encoding::DefaultFuchsiaResourceDialect,
2412    >;
2413    fn r#echo_table(
2414        &self,
2415        mut value: AllTypesTable,
2416        mut forward_to_server: &str,
2417    ) -> Self::EchoTableResponseFut {
2418        fn _decode(
2419            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2420        ) -> Result<AllTypesTable, fidl::Error> {
2421            let _response = fidl::client::decode_transaction_body::<
2422                EchoEchoTableResponse,
2423                fidl::encoding::DefaultFuchsiaResourceDialect,
2424                0x4f1fb0a512f47c4b,
2425            >(_buf?)?;
2426            Ok(_response.value)
2427        }
2428        self.client.send_query_and_decode::<EchoEchoTableRequest, AllTypesTable>(
2429            (&mut value, forward_to_server),
2430            0x4f1fb0a512f47c4b,
2431            fidl::encoding::DynamicFlags::empty(),
2432            _decode,
2433        )
2434    }
2435
2436    type EchoTableWithErrorResponseFut = fidl::client::QueryResponseFut<
2437        EchoEchoTableWithErrorResult,
2438        fidl::encoding::DefaultFuchsiaResourceDialect,
2439    >;
2440    fn r#echo_table_with_error(
2441        &self,
2442        mut value: AllTypesTable,
2443        mut result_err: DefaultEnum,
2444        mut forward_to_server: &str,
2445        mut result_variant: RespondWith,
2446    ) -> Self::EchoTableWithErrorResponseFut {
2447        fn _decode(
2448            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2449        ) -> Result<EchoEchoTableWithErrorResult, fidl::Error> {
2450            let _response = fidl::client::decode_transaction_body::<
2451                fidl::encoding::ResultType<EchoEchoTableWithErrorResponse, DefaultEnum>,
2452                fidl::encoding::DefaultFuchsiaResourceDialect,
2453                0x44e835cb1eb9a931,
2454            >(_buf?)?;
2455            Ok(_response.map(|x| x.value))
2456        }
2457        self.client
2458            .send_query_and_decode::<EchoEchoTableWithErrorRequest, EchoEchoTableWithErrorResult>(
2459                (&mut value, result_err, forward_to_server, result_variant),
2460                0x44e835cb1eb9a931,
2461                fidl::encoding::DynamicFlags::empty(),
2462                _decode,
2463            )
2464    }
2465
2466    type EchoXunionsResponseFut = fidl::client::QueryResponseFut<
2467        Vec<AllTypesXunion>,
2468        fidl::encoding::DefaultFuchsiaResourceDialect,
2469    >;
2470    fn r#echo_xunions(
2471        &self,
2472        mut value: Vec<AllTypesXunion>,
2473        mut forward_to_server: &str,
2474    ) -> Self::EchoXunionsResponseFut {
2475        fn _decode(
2476            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2477        ) -> Result<Vec<AllTypesXunion>, fidl::Error> {
2478            let _response = fidl::client::decode_transaction_body::<
2479                EchoEchoXunionsResponse,
2480                fidl::encoding::DefaultFuchsiaResourceDialect,
2481                0x3dc181909041a583,
2482            >(_buf?)?;
2483            Ok(_response.value)
2484        }
2485        self.client.send_query_and_decode::<EchoEchoXunionsRequest, Vec<AllTypesXunion>>(
2486            (value.as_mut(), forward_to_server),
2487            0x3dc181909041a583,
2488            fidl::encoding::DynamicFlags::empty(),
2489            _decode,
2490        )
2491    }
2492
2493    type EchoXunionsWithErrorResponseFut = fidl::client::QueryResponseFut<
2494        EchoEchoXunionsWithErrorResult,
2495        fidl::encoding::DefaultFuchsiaResourceDialect,
2496    >;
2497    fn r#echo_xunions_with_error(
2498        &self,
2499        mut value: Vec<AllTypesXunion>,
2500        mut result_err: DefaultEnum,
2501        mut forward_to_server: &str,
2502        mut result_variant: RespondWith,
2503    ) -> Self::EchoXunionsWithErrorResponseFut {
2504        fn _decode(
2505            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2506        ) -> Result<EchoEchoXunionsWithErrorResult, fidl::Error> {
2507            let _response = fidl::client::decode_transaction_body::<
2508                fidl::encoding::ResultType<EchoEchoXunionsWithErrorResponse, DefaultEnum>,
2509                fidl::encoding::DefaultFuchsiaResourceDialect,
2510                0x75184102667fa766,
2511            >(_buf?)?;
2512            Ok(_response.map(|x| x.value))
2513        }
2514        self.client.send_query_and_decode::<
2515            EchoEchoXunionsWithErrorRequest,
2516            EchoEchoXunionsWithErrorResult,
2517        >(
2518            (value.as_mut(), result_err, forward_to_server, result_variant,),
2519            0x75184102667fa766,
2520            fidl::encoding::DynamicFlags::empty(),
2521            _decode,
2522        )
2523    }
2524
2525    type EchoNamedStructResponseFut = fidl::client::QueryResponseFut<
2526        fidl_fidl_test_imported::SimpleStruct,
2527        fidl::encoding::DefaultFuchsiaResourceDialect,
2528    >;
2529    fn r#echo_named_struct(
2530        &self,
2531        mut value: &fidl_fidl_test_imported::SimpleStruct,
2532        mut forward_to_server: &str,
2533    ) -> Self::EchoNamedStructResponseFut {
2534        fn _decode(
2535            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2536        ) -> Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error> {
2537            let _response = fidl::client::decode_transaction_body::<
2538                fidl_fidl_test_imported::ResponseStruct,
2539                fidl::encoding::DefaultFuchsiaResourceDialect,
2540                0xf2d4aa9e65f7111,
2541            >(_buf?)?;
2542            Ok(_response.value)
2543        }
2544        self.client.send_query_and_decode::<
2545            fidl_fidl_test_imported::RequestStruct,
2546            fidl_fidl_test_imported::SimpleStruct,
2547        >(
2548            (value, forward_to_server,),
2549            0xf2d4aa9e65f7111,
2550            fidl::encoding::DynamicFlags::empty(),
2551            _decode,
2552        )
2553    }
2554
2555    type EchoNamedStructWithErrorResponseFut = fidl::client::QueryResponseFut<
2556        EchoEchoNamedStructWithErrorResult,
2557        fidl::encoding::DefaultFuchsiaResourceDialect,
2558    >;
2559    fn r#echo_named_struct_with_error(
2560        &self,
2561        mut value: &fidl_fidl_test_imported::SimpleStruct,
2562        mut result_err: u32,
2563        mut forward_to_server: &str,
2564        mut result_variant: fidl_fidl_test_imported::WantResponse,
2565    ) -> Self::EchoNamedStructWithErrorResponseFut {
2566        fn _decode(
2567            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2568        ) -> Result<EchoEchoNamedStructWithErrorResult, fidl::Error> {
2569            let _response = fidl::client::decode_transaction_body::<
2570                fidl::encoding::ResultType<fidl_fidl_test_imported::ResponseStruct, u32>,
2571                fidl::encoding::DefaultFuchsiaResourceDialect,
2572                0x5766fee9e74442e8,
2573            >(_buf?)?;
2574            Ok(_response.map(|x| x.value))
2575        }
2576        self.client.send_query_and_decode::<
2577            fidl_fidl_test_imported::ErrorableRequestStruct,
2578            EchoEchoNamedStructWithErrorResult,
2579        >(
2580            (value, result_err, forward_to_server, result_variant,),
2581            0x5766fee9e74442e8,
2582            fidl::encoding::DynamicFlags::empty(),
2583            _decode,
2584        )
2585    }
2586
2587    fn r#echo_named_struct_no_ret_val(
2588        &self,
2589        mut value: &fidl_fidl_test_imported::SimpleStruct,
2590        mut forward_to_server: &str,
2591    ) -> Result<(), fidl::Error> {
2592        self.client.send::<fidl_fidl_test_imported::EventTriggeringRequestStruct>(
2593            (value, forward_to_server),
2594            0x3a50bbf7d2113ad7,
2595            fidl::encoding::DynamicFlags::empty(),
2596        )
2597    }
2598
2599    type EchoTablePayloadResponseFut = fidl::client::QueryResponseFut<
2600        ResponseTable,
2601        fidl::encoding::DefaultFuchsiaResourceDialect,
2602    >;
2603    fn r#echo_table_payload(
2604        &self,
2605        mut payload: &RequestTable,
2606    ) -> Self::EchoTablePayloadResponseFut {
2607        fn _decode(
2608            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2609        ) -> Result<ResponseTable, fidl::Error> {
2610            let _response = fidl::client::decode_transaction_body::<
2611                ResponseTable,
2612                fidl::encoding::DefaultFuchsiaResourceDialect,
2613                0x641d98087378c003,
2614            >(_buf?)?;
2615            Ok(_response)
2616        }
2617        self.client.send_query_and_decode::<RequestTable, ResponseTable>(
2618            payload,
2619            0x641d98087378c003,
2620            fidl::encoding::DynamicFlags::empty(),
2621            _decode,
2622        )
2623    }
2624
2625    type EchoTablePayloadWithErrorResponseFut = fidl::client::QueryResponseFut<
2626        EchoEchoTablePayloadWithErrorResult,
2627        fidl::encoding::DefaultFuchsiaResourceDialect,
2628    >;
2629    fn r#echo_table_payload_with_error(
2630        &self,
2631        mut payload: &EchoEchoTablePayloadWithErrorRequest,
2632    ) -> Self::EchoTablePayloadWithErrorResponseFut {
2633        fn _decode(
2634            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2635        ) -> Result<EchoEchoTablePayloadWithErrorResult, fidl::Error> {
2636            let _response = fidl::client::decode_transaction_body::<
2637                fidl::encoding::ResultType<ResponseTable, DefaultEnum>,
2638                fidl::encoding::DefaultFuchsiaResourceDialect,
2639                0x636ed243761ab66d,
2640            >(_buf?)?;
2641            Ok(_response.map(|x| x))
2642        }
2643        self.client.send_query_and_decode::<
2644            EchoEchoTablePayloadWithErrorRequest,
2645            EchoEchoTablePayloadWithErrorResult,
2646        >(
2647            payload,
2648            0x636ed243761ab66d,
2649            fidl::encoding::DynamicFlags::empty(),
2650            _decode,
2651        )
2652    }
2653
2654    fn r#echo_table_payload_no_ret_val(
2655        &self,
2656        mut payload: &RequestTable,
2657    ) -> Result<(), fidl::Error> {
2658        self.client.send::<RequestTable>(
2659            payload,
2660            0x32961f7d718569f8,
2661            fidl::encoding::DynamicFlags::empty(),
2662        )
2663    }
2664
2665    type EchoUnionPayloadResponseFut = fidl::client::QueryResponseFut<
2666        ResponseUnion,
2667        fidl::encoding::DefaultFuchsiaResourceDialect,
2668    >;
2669    fn r#echo_union_payload(
2670        &self,
2671        mut payload: &RequestUnion,
2672    ) -> Self::EchoUnionPayloadResponseFut {
2673        fn _decode(
2674            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2675        ) -> Result<ResponseUnion, fidl::Error> {
2676            let _response = fidl::client::decode_transaction_body::<
2677                ResponseUnion,
2678                fidl::encoding::DefaultFuchsiaResourceDialect,
2679                0x66def9e793f10c55,
2680            >(_buf?)?;
2681            Ok(_response)
2682        }
2683        self.client.send_query_and_decode::<RequestUnion, ResponseUnion>(
2684            payload,
2685            0x66def9e793f10c55,
2686            fidl::encoding::DynamicFlags::empty(),
2687            _decode,
2688        )
2689    }
2690
2691    type EchoUnionPayloadWithErrorResponseFut = fidl::client::QueryResponseFut<
2692        EchoEchoUnionPayloadWithErrorResult,
2693        fidl::encoding::DefaultFuchsiaResourceDialect,
2694    >;
2695    fn r#echo_union_payload_with_error(
2696        &self,
2697        mut payload: &EchoEchoUnionPayloadWithErrorRequest,
2698    ) -> Self::EchoUnionPayloadWithErrorResponseFut {
2699        fn _decode(
2700            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2701        ) -> Result<EchoEchoUnionPayloadWithErrorResult, fidl::Error> {
2702            let _response = fidl::client::decode_transaction_body::<
2703                fidl::encoding::ResultType<ResponseUnion, DefaultEnum>,
2704                fidl::encoding::DefaultFuchsiaResourceDialect,
2705                0x1be890d6e68ef063,
2706            >(_buf?)?;
2707            Ok(_response.map(|x| x))
2708        }
2709        self.client.send_query_and_decode::<
2710            EchoEchoUnionPayloadWithErrorRequest,
2711            EchoEchoUnionPayloadWithErrorResult,
2712        >(
2713            payload,
2714            0x1be890d6e68ef063,
2715            fidl::encoding::DynamicFlags::empty(),
2716            _decode,
2717        )
2718    }
2719
2720    fn r#echo_union_payload_no_ret_val(
2721        &self,
2722        mut payload: &RequestUnion,
2723    ) -> Result<(), fidl::Error> {
2724        self.client.send::<RequestUnion>(
2725            payload,
2726            0x11518bf346430040,
2727            fidl::encoding::DynamicFlags::empty(),
2728        )
2729    }
2730}
2731
2732pub struct EchoEventStream {
2733    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
2734}
2735
2736impl std::marker::Unpin for EchoEventStream {}
2737
2738impl futures::stream::FusedStream for EchoEventStream {
2739    fn is_terminated(&self) -> bool {
2740        self.event_receiver.is_terminated()
2741    }
2742}
2743
2744impl futures::Stream for EchoEventStream {
2745    type Item = Result<EchoEvent, fidl::Error>;
2746
2747    fn poll_next(
2748        mut self: std::pin::Pin<&mut Self>,
2749        cx: &mut std::task::Context<'_>,
2750    ) -> std::task::Poll<Option<Self::Item>> {
2751        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
2752            &mut self.event_receiver,
2753            cx
2754        )?) {
2755            Some(buf) => std::task::Poll::Ready(Some(EchoEvent::decode(buf))),
2756            None => std::task::Poll::Ready(None),
2757        }
2758    }
2759}
2760
2761#[derive(Debug)]
2762pub enum EchoEvent {
2763    EchoMinimalEvent {},
2764    EchoEvent { value: Struct },
2765    OnEchoNamedEvent { value: fidl_fidl_test_imported::SimpleStruct },
2766    OnEchoTablePayloadEvent { payload: ResponseTable },
2767    OnEchoUnionPayloadEvent { payload: ResponseUnion },
2768}
2769
2770impl EchoEvent {
2771    #[allow(irrefutable_let_patterns)]
2772    pub fn into_echo_minimal_event(self) -> Option<()> {
2773        if let EchoEvent::EchoMinimalEvent {} = self { Some(()) } else { None }
2774    }
2775    #[allow(irrefutable_let_patterns)]
2776    pub fn into_echo_event(self) -> Option<Struct> {
2777        if let EchoEvent::EchoEvent { value } = self { Some((value)) } else { None }
2778    }
2779    #[allow(irrefutable_let_patterns)]
2780    pub fn into_on_echo_named_event(self) -> Option<fidl_fidl_test_imported::SimpleStruct> {
2781        if let EchoEvent::OnEchoNamedEvent { value } = self { Some((value)) } else { None }
2782    }
2783    #[allow(irrefutable_let_patterns)]
2784    pub fn into_on_echo_table_payload_event(self) -> Option<ResponseTable> {
2785        if let EchoEvent::OnEchoTablePayloadEvent { payload } = self {
2786            Some((payload))
2787        } else {
2788            None
2789        }
2790    }
2791    #[allow(irrefutable_let_patterns)]
2792    pub fn into_on_echo_union_payload_event(self) -> Option<ResponseUnion> {
2793        if let EchoEvent::OnEchoUnionPayloadEvent { payload } = self {
2794            Some((payload))
2795        } else {
2796            None
2797        }
2798    }
2799
2800    /// Decodes a message buffer as a [`EchoEvent`].
2801    fn decode(
2802        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
2803    ) -> Result<EchoEvent, fidl::Error> {
2804        let (bytes, _handles) = buf.split_mut();
2805        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
2806        debug_assert_eq!(tx_header.tx_id, 0);
2807        match tx_header.ordinal {
2808            0x273b2029f1a0aee2 => {
2809                let mut out = fidl::new_empty!(
2810                    fidl::encoding::EmptyPayload,
2811                    fidl::encoding::DefaultFuchsiaResourceDialect
2812                );
2813                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&tx_header, _body_bytes, _handles, &mut out)?;
2814                Ok((EchoEvent::EchoMinimalEvent {}))
2815            }
2816            0x1219e12e0450024 => {
2817                let mut out = fidl::new_empty!(
2818                    EchoEchoEventRequest,
2819                    fidl::encoding::DefaultFuchsiaResourceDialect
2820                );
2821                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoEventRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
2822                Ok((EchoEvent::EchoEvent { value: out.value }))
2823            }
2824            0x749ebde83348a374 => {
2825                let mut out = fidl::new_empty!(
2826                    fidl_fidl_test_imported::ResponseStruct,
2827                    fidl::encoding::DefaultFuchsiaResourceDialect
2828                );
2829                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::ResponseStruct>(&tx_header, _body_bytes, _handles, &mut out)?;
2830                Ok((EchoEvent::OnEchoNamedEvent { value: out.value }))
2831            }
2832            0x708dddea1cb98430 => {
2833                let mut out =
2834                    fidl::new_empty!(ResponseTable, fidl::encoding::DefaultFuchsiaResourceDialect);
2835                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ResponseTable>(&tx_header, _body_bytes, _handles, &mut out)?;
2836                Ok((EchoEvent::OnEchoTablePayloadEvent { payload: out }))
2837            }
2838            0x642f4c265a05f4c0 => {
2839                let mut out =
2840                    fidl::new_empty!(ResponseUnion, fidl::encoding::DefaultFuchsiaResourceDialect);
2841                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ResponseUnion>(&tx_header, _body_bytes, _handles, &mut out)?;
2842                Ok((EchoEvent::OnEchoUnionPayloadEvent { payload: out }))
2843            }
2844            _ => Err(fidl::Error::UnknownOrdinal {
2845                ordinal: tx_header.ordinal,
2846                protocol_name: <EchoMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
2847            }),
2848        }
2849    }
2850}
2851
2852/// A Stream of incoming requests for fidl.test.compatibility/Echo.
2853pub struct EchoRequestStream {
2854    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
2855    is_terminated: bool,
2856}
2857
2858impl std::marker::Unpin for EchoRequestStream {}
2859
2860impl futures::stream::FusedStream for EchoRequestStream {
2861    fn is_terminated(&self) -> bool {
2862        self.is_terminated
2863    }
2864}
2865
2866impl fidl::endpoints::RequestStream for EchoRequestStream {
2867    type Protocol = EchoMarker;
2868    type ControlHandle = EchoControlHandle;
2869
2870    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
2871        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
2872    }
2873
2874    fn control_handle(&self) -> Self::ControlHandle {
2875        EchoControlHandle { inner: self.inner.clone() }
2876    }
2877
2878    fn into_inner(
2879        self,
2880    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
2881    {
2882        (self.inner, self.is_terminated)
2883    }
2884
2885    fn from_inner(
2886        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
2887        is_terminated: bool,
2888    ) -> Self {
2889        Self { inner, is_terminated }
2890    }
2891}
2892
2893impl futures::Stream for EchoRequestStream {
2894    type Item = Result<EchoRequest, fidl::Error>;
2895
2896    fn poll_next(
2897        mut self: std::pin::Pin<&mut Self>,
2898        cx: &mut std::task::Context<'_>,
2899    ) -> std::task::Poll<Option<Self::Item>> {
2900        let this = &mut *self;
2901        if this.inner.check_shutdown(cx) {
2902            this.is_terminated = true;
2903            return std::task::Poll::Ready(None);
2904        }
2905        if this.is_terminated {
2906            panic!("polled EchoRequestStream after completion");
2907        }
2908        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
2909            |bytes, handles| {
2910                match this.inner.channel().read_etc(cx, bytes, handles) {
2911                    std::task::Poll::Ready(Ok(())) => {}
2912                    std::task::Poll::Pending => return std::task::Poll::Pending,
2913                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
2914                        this.is_terminated = true;
2915                        return std::task::Poll::Ready(None);
2916                    }
2917                    std::task::Poll::Ready(Err(e)) => {
2918                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
2919                            e.into(),
2920                        ))));
2921                    }
2922                }
2923
2924                // A message has been received from the channel
2925                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
2926
2927                std::task::Poll::Ready(Some(match header.ordinal {
2928                    0x1d545c738c7a8ee => {
2929                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2930                        let mut req = fidl::new_empty!(
2931                            fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
2932                            fidl::encoding::DefaultFuchsiaResourceDialect
2933                        );
2934                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest>(&header, _body_bytes, handles, &mut req)?;
2935                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
2936                        Ok(EchoRequest::EchoTableRequestComposed {
2937                            payload: req,
2938                            responder: EchoEchoTableRequestComposedResponder {
2939                                control_handle: std::mem::ManuallyDrop::new(control_handle),
2940                                tx_id: header.tx_id,
2941                            },
2942                        })
2943                    }
2944                    0x38a67e88d6106443 => {
2945                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2946                        let mut req = fidl::new_empty!(fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
2947                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedRequest>(&header, _body_bytes, handles, &mut req)?;
2948                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
2949                        Ok(EchoRequest::EchoUnionResponseWithErrorComposed {
2950                            value: req.value,
2951                            want_absolute_value: req.want_absolute_value,
2952                            forward_to_server: req.forward_to_server,
2953                            result_err: req.result_err,
2954                            result_variant: req.result_variant,
2955
2956                            responder: EchoEchoUnionResponseWithErrorComposedResponder {
2957                                control_handle: std::mem::ManuallyDrop::new(control_handle),
2958                                tx_id: header.tx_id,
2959                            },
2960                        })
2961                    }
2962                    0x39edd68c837482ec => {
2963                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2964                        let mut req = fidl::new_empty!(
2965                            EchoEchoMinimalRequest,
2966                            fidl::encoding::DefaultFuchsiaResourceDialect
2967                        );
2968                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoMinimalRequest>(&header, _body_bytes, handles, &mut req)?;
2969                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
2970                        Ok(EchoRequest::EchoMinimal {
2971                            forward_to_server: req.forward_to_server,
2972
2973                            responder: EchoEchoMinimalResponder {
2974                                control_handle: std::mem::ManuallyDrop::new(control_handle),
2975                                tx_id: header.tx_id,
2976                            },
2977                        })
2978                    }
2979                    0x36f4695996e35acc => {
2980                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2981                        let mut req = fidl::new_empty!(
2982                            EchoEchoMinimalWithErrorRequest,
2983                            fidl::encoding::DefaultFuchsiaResourceDialect
2984                        );
2985                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoMinimalWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
2986                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
2987                        Ok(EchoRequest::EchoMinimalWithError {
2988                            forward_to_server: req.forward_to_server,
2989                            result_variant: req.result_variant,
2990
2991                            responder: EchoEchoMinimalWithErrorResponder {
2992                                control_handle: std::mem::ManuallyDrop::new(control_handle),
2993                                tx_id: header.tx_id,
2994                            },
2995                        })
2996                    }
2997                    0x42693c143e2c3694 => {
2998                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
2999                        let mut req = fidl::new_empty!(
3000                            EchoEchoMinimalNoRetValRequest,
3001                            fidl::encoding::DefaultFuchsiaResourceDialect
3002                        );
3003                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoMinimalNoRetValRequest>(&header, _body_bytes, handles, &mut req)?;
3004                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3005                        Ok(EchoRequest::EchoMinimalNoRetVal {
3006                            forward_to_server: req.forward_to_server,
3007
3008                            control_handle,
3009                        })
3010                    }
3011                    0x4c2f85818cc53f37 => {
3012                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3013                        let mut req = fidl::new_empty!(
3014                            EchoEchoStructRequest,
3015                            fidl::encoding::DefaultFuchsiaResourceDialect
3016                        );
3017                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoStructRequest>(&header, _body_bytes, handles, &mut req)?;
3018                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3019                        Ok(EchoRequest::EchoStruct {
3020                            value: req.value,
3021                            forward_to_server: req.forward_to_server,
3022
3023                            responder: EchoEchoStructResponder {
3024                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3025                                tx_id: header.tx_id,
3026                            },
3027                        })
3028                    }
3029                    0x46cb32652c4c0899 => {
3030                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3031                        let mut req = fidl::new_empty!(
3032                            EchoEchoStructWithErrorRequest,
3033                            fidl::encoding::DefaultFuchsiaResourceDialect
3034                        );
3035                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoStructWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3036                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3037                        Ok(EchoRequest::EchoStructWithError {
3038                            value: req.value,
3039                            result_err: req.result_err,
3040                            forward_to_server: req.forward_to_server,
3041                            result_variant: req.result_variant,
3042
3043                            responder: EchoEchoStructWithErrorResponder {
3044                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3045                                tx_id: header.tx_id,
3046                            },
3047                        })
3048                    }
3049                    0x1f763e602cf5892a => {
3050                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
3051                        let mut req = fidl::new_empty!(
3052                            EchoEchoStructNoRetValRequest,
3053                            fidl::encoding::DefaultFuchsiaResourceDialect
3054                        );
3055                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoStructNoRetValRequest>(&header, _body_bytes, handles, &mut req)?;
3056                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3057                        Ok(EchoRequest::EchoStructNoRetVal {
3058                            value: req.value,
3059                            forward_to_server: req.forward_to_server,
3060
3061                            control_handle,
3062                        })
3063                    }
3064                    0x1b6019d5611f2470 => {
3065                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3066                        let mut req = fidl::new_empty!(
3067                            EchoEchoArraysRequest,
3068                            fidl::encoding::DefaultFuchsiaResourceDialect
3069                        );
3070                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoArraysRequest>(&header, _body_bytes, handles, &mut req)?;
3071                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3072                        Ok(EchoRequest::EchoArrays {
3073                            value: req.value,
3074                            forward_to_server: req.forward_to_server,
3075
3076                            responder: EchoEchoArraysResponder {
3077                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3078                                tx_id: header.tx_id,
3079                            },
3080                        })
3081                    }
3082                    0x6dbf26e67e253afa => {
3083                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3084                        let mut req = fidl::new_empty!(
3085                            EchoEchoArraysWithErrorRequest,
3086                            fidl::encoding::DefaultFuchsiaResourceDialect
3087                        );
3088                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoArraysWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3089                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3090                        Ok(EchoRequest::EchoArraysWithError {
3091                            value: req.value,
3092                            result_err: req.result_err,
3093                            forward_to_server: req.forward_to_server,
3094                            result_variant: req.result_variant,
3095
3096                            responder: EchoEchoArraysWithErrorResponder {
3097                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3098                                tx_id: header.tx_id,
3099                            },
3100                        })
3101                    }
3102                    0x1582623f0d9f6e5e => {
3103                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3104                        let mut req = fidl::new_empty!(
3105                            EchoEchoVectorsRequest,
3106                            fidl::encoding::DefaultFuchsiaResourceDialect
3107                        );
3108                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoVectorsRequest>(&header, _body_bytes, handles, &mut req)?;
3109                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3110                        Ok(EchoRequest::EchoVectors {
3111                            value: req.value,
3112                            forward_to_server: req.forward_to_server,
3113
3114                            responder: EchoEchoVectorsResponder {
3115                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3116                                tx_id: header.tx_id,
3117                            },
3118                        })
3119                    }
3120                    0x730f163401e2b3e5 => {
3121                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3122                        let mut req = fidl::new_empty!(
3123                            EchoEchoVectorsWithErrorRequest,
3124                            fidl::encoding::DefaultFuchsiaResourceDialect
3125                        );
3126                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoVectorsWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3127                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3128                        Ok(EchoRequest::EchoVectorsWithError {
3129                            value: req.value,
3130                            result_err: req.result_err,
3131                            forward_to_server: req.forward_to_server,
3132                            result_variant: req.result_variant,
3133
3134                            responder: EchoEchoVectorsWithErrorResponder {
3135                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3136                                tx_id: header.tx_id,
3137                            },
3138                        })
3139                    }
3140                    0x4f1fb0a512f47c4b => {
3141                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3142                        let mut req = fidl::new_empty!(
3143                            EchoEchoTableRequest,
3144                            fidl::encoding::DefaultFuchsiaResourceDialect
3145                        );
3146                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoTableRequest>(&header, _body_bytes, handles, &mut req)?;
3147                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3148                        Ok(EchoRequest::EchoTable {
3149                            value: req.value,
3150                            forward_to_server: req.forward_to_server,
3151
3152                            responder: EchoEchoTableResponder {
3153                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3154                                tx_id: header.tx_id,
3155                            },
3156                        })
3157                    }
3158                    0x44e835cb1eb9a931 => {
3159                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3160                        let mut req = fidl::new_empty!(
3161                            EchoEchoTableWithErrorRequest,
3162                            fidl::encoding::DefaultFuchsiaResourceDialect
3163                        );
3164                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoTableWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3165                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3166                        Ok(EchoRequest::EchoTableWithError {
3167                            value: req.value,
3168                            result_err: req.result_err,
3169                            forward_to_server: req.forward_to_server,
3170                            result_variant: req.result_variant,
3171
3172                            responder: EchoEchoTableWithErrorResponder {
3173                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3174                                tx_id: header.tx_id,
3175                            },
3176                        })
3177                    }
3178                    0x3dc181909041a583 => {
3179                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3180                        let mut req = fidl::new_empty!(
3181                            EchoEchoXunionsRequest,
3182                            fidl::encoding::DefaultFuchsiaResourceDialect
3183                        );
3184                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoXunionsRequest>(&header, _body_bytes, handles, &mut req)?;
3185                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3186                        Ok(EchoRequest::EchoXunions {
3187                            value: req.value,
3188                            forward_to_server: req.forward_to_server,
3189
3190                            responder: EchoEchoXunionsResponder {
3191                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3192                                tx_id: header.tx_id,
3193                            },
3194                        })
3195                    }
3196                    0x75184102667fa766 => {
3197                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3198                        let mut req = fidl::new_empty!(
3199                            EchoEchoXunionsWithErrorRequest,
3200                            fidl::encoding::DefaultFuchsiaResourceDialect
3201                        );
3202                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoXunionsWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3203                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3204                        Ok(EchoRequest::EchoXunionsWithError {
3205                            value: req.value,
3206                            result_err: req.result_err,
3207                            forward_to_server: req.forward_to_server,
3208                            result_variant: req.result_variant,
3209
3210                            responder: EchoEchoXunionsWithErrorResponder {
3211                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3212                                tx_id: header.tx_id,
3213                            },
3214                        })
3215                    }
3216                    0xf2d4aa9e65f7111 => {
3217                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3218                        let mut req = fidl::new_empty!(
3219                            fidl_fidl_test_imported::RequestStruct,
3220                            fidl::encoding::DefaultFuchsiaResourceDialect
3221                        );
3222                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::RequestStruct>(&header, _body_bytes, handles, &mut req)?;
3223                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3224                        Ok(EchoRequest::EchoNamedStruct {
3225                            value: req.value,
3226                            forward_to_server: req.forward_to_server,
3227
3228                            responder: EchoEchoNamedStructResponder {
3229                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3230                                tx_id: header.tx_id,
3231                            },
3232                        })
3233                    }
3234                    0x5766fee9e74442e8 => {
3235                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3236                        let mut req = fidl::new_empty!(
3237                            fidl_fidl_test_imported::ErrorableRequestStruct,
3238                            fidl::encoding::DefaultFuchsiaResourceDialect
3239                        );
3240                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::ErrorableRequestStruct>(&header, _body_bytes, handles, &mut req)?;
3241                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3242                        Ok(EchoRequest::EchoNamedStructWithError {
3243                            value: req.value,
3244                            result_err: req.result_err,
3245                            forward_to_server: req.forward_to_server,
3246                            result_variant: req.result_variant,
3247
3248                            responder: EchoEchoNamedStructWithErrorResponder {
3249                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3250                                tx_id: header.tx_id,
3251                            },
3252                        })
3253                    }
3254                    0x3a50bbf7d2113ad7 => {
3255                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
3256                        let mut req = fidl::new_empty!(
3257                            fidl_fidl_test_imported::EventTriggeringRequestStruct,
3258                            fidl::encoding::DefaultFuchsiaResourceDialect
3259                        );
3260                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::EventTriggeringRequestStruct>(&header, _body_bytes, handles, &mut req)?;
3261                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3262                        Ok(EchoRequest::EchoNamedStructNoRetVal {
3263                            value: req.value,
3264                            forward_to_server: req.forward_to_server,
3265
3266                            control_handle,
3267                        })
3268                    }
3269                    0x641d98087378c003 => {
3270                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3271                        let mut req = fidl::new_empty!(
3272                            RequestTable,
3273                            fidl::encoding::DefaultFuchsiaResourceDialect
3274                        );
3275                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RequestTable>(&header, _body_bytes, handles, &mut req)?;
3276                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3277                        Ok(EchoRequest::EchoTablePayload {
3278                            payload: req,
3279                            responder: EchoEchoTablePayloadResponder {
3280                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3281                                tx_id: header.tx_id,
3282                            },
3283                        })
3284                    }
3285                    0x636ed243761ab66d => {
3286                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3287                        let mut req = fidl::new_empty!(
3288                            EchoEchoTablePayloadWithErrorRequest,
3289                            fidl::encoding::DefaultFuchsiaResourceDialect
3290                        );
3291                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoTablePayloadWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3292                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3293                        Ok(EchoRequest::EchoTablePayloadWithError {
3294                            payload: req,
3295                            responder: EchoEchoTablePayloadWithErrorResponder {
3296                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3297                                tx_id: header.tx_id,
3298                            },
3299                        })
3300                    }
3301                    0x32961f7d718569f8 => {
3302                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
3303                        let mut req = fidl::new_empty!(
3304                            RequestTable,
3305                            fidl::encoding::DefaultFuchsiaResourceDialect
3306                        );
3307                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RequestTable>(&header, _body_bytes, handles, &mut req)?;
3308                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3309                        Ok(EchoRequest::EchoTablePayloadNoRetVal { payload: req, control_handle })
3310                    }
3311                    0x66def9e793f10c55 => {
3312                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3313                        let mut req = fidl::new_empty!(
3314                            RequestUnion,
3315                            fidl::encoding::DefaultFuchsiaResourceDialect
3316                        );
3317                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RequestUnion>(&header, _body_bytes, handles, &mut req)?;
3318                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3319                        Ok(EchoRequest::EchoUnionPayload {
3320                            payload: req,
3321                            responder: EchoEchoUnionPayloadResponder {
3322                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3323                                tx_id: header.tx_id,
3324                            },
3325                        })
3326                    }
3327                    0x1be890d6e68ef063 => {
3328                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3329                        let mut req = fidl::new_empty!(
3330                            EchoEchoUnionPayloadWithErrorRequest,
3331                            fidl::encoding::DefaultFuchsiaResourceDialect
3332                        );
3333                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoUnionPayloadWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3334                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3335                        Ok(EchoRequest::EchoUnionPayloadWithError {
3336                            payload: req,
3337                            responder: EchoEchoUnionPayloadWithErrorResponder {
3338                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3339                                tx_id: header.tx_id,
3340                            },
3341                        })
3342                    }
3343                    0x11518bf346430040 => {
3344                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
3345                        let mut req = fidl::new_empty!(
3346                            RequestUnion,
3347                            fidl::encoding::DefaultFuchsiaResourceDialect
3348                        );
3349                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RequestUnion>(&header, _body_bytes, handles, &mut req)?;
3350                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3351                        Ok(EchoRequest::EchoUnionPayloadNoRetVal { payload: req, control_handle })
3352                    }
3353                    _ => Err(fidl::Error::UnknownOrdinal {
3354                        ordinal: header.ordinal,
3355                        protocol_name: <EchoMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
3356                    }),
3357                }))
3358            },
3359        )
3360    }
3361}
3362
3363#[derive(Debug)]
3364pub enum EchoRequest {
3365    EchoTableRequestComposed {
3366        payload: fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
3367        responder: EchoEchoTableRequestComposedResponder,
3368    },
3369    EchoUnionResponseWithErrorComposed {
3370        value: i64,
3371        want_absolute_value: bool,
3372        forward_to_server: String,
3373        result_err: u32,
3374        result_variant: fidl_fidl_test_imported::WantResponse,
3375        responder: EchoEchoUnionResponseWithErrorComposedResponder,
3376    },
3377    EchoMinimal {
3378        forward_to_server: String,
3379        responder: EchoEchoMinimalResponder,
3380    },
3381    EchoMinimalWithError {
3382        forward_to_server: String,
3383        result_variant: RespondWith,
3384        responder: EchoEchoMinimalWithErrorResponder,
3385    },
3386    EchoMinimalNoRetVal {
3387        forward_to_server: String,
3388        control_handle: EchoControlHandle,
3389    },
3390    EchoStruct {
3391        value: Struct,
3392        forward_to_server: String,
3393        responder: EchoEchoStructResponder,
3394    },
3395    EchoStructWithError {
3396        value: Struct,
3397        result_err: DefaultEnum,
3398        forward_to_server: String,
3399        result_variant: RespondWith,
3400        responder: EchoEchoStructWithErrorResponder,
3401    },
3402    EchoStructNoRetVal {
3403        value: Struct,
3404        forward_to_server: String,
3405        control_handle: EchoControlHandle,
3406    },
3407    EchoArrays {
3408        value: ArraysStruct,
3409        forward_to_server: String,
3410        responder: EchoEchoArraysResponder,
3411    },
3412    EchoArraysWithError {
3413        value: ArraysStruct,
3414        result_err: DefaultEnum,
3415        forward_to_server: String,
3416        result_variant: RespondWith,
3417        responder: EchoEchoArraysWithErrorResponder,
3418    },
3419    EchoVectors {
3420        value: VectorsStruct,
3421        forward_to_server: String,
3422        responder: EchoEchoVectorsResponder,
3423    },
3424    EchoVectorsWithError {
3425        value: VectorsStruct,
3426        result_err: DefaultEnum,
3427        forward_to_server: String,
3428        result_variant: RespondWith,
3429        responder: EchoEchoVectorsWithErrorResponder,
3430    },
3431    EchoTable {
3432        value: AllTypesTable,
3433        forward_to_server: String,
3434        responder: EchoEchoTableResponder,
3435    },
3436    EchoTableWithError {
3437        value: AllTypesTable,
3438        result_err: DefaultEnum,
3439        forward_to_server: String,
3440        result_variant: RespondWith,
3441        responder: EchoEchoTableWithErrorResponder,
3442    },
3443    EchoXunions {
3444        value: Vec<AllTypesXunion>,
3445        forward_to_server: String,
3446        responder: EchoEchoXunionsResponder,
3447    },
3448    EchoXunionsWithError {
3449        value: Vec<AllTypesXunion>,
3450        result_err: DefaultEnum,
3451        forward_to_server: String,
3452        result_variant: RespondWith,
3453        responder: EchoEchoXunionsWithErrorResponder,
3454    },
3455    EchoNamedStruct {
3456        value: fidl_fidl_test_imported::SimpleStruct,
3457        forward_to_server: String,
3458        responder: EchoEchoNamedStructResponder,
3459    },
3460    EchoNamedStructWithError {
3461        value: fidl_fidl_test_imported::SimpleStruct,
3462        result_err: u32,
3463        forward_to_server: String,
3464        result_variant: fidl_fidl_test_imported::WantResponse,
3465        responder: EchoEchoNamedStructWithErrorResponder,
3466    },
3467    EchoNamedStructNoRetVal {
3468        value: fidl_fidl_test_imported::SimpleStruct,
3469        forward_to_server: String,
3470        control_handle: EchoControlHandle,
3471    },
3472    EchoTablePayload {
3473        payload: RequestTable,
3474        responder: EchoEchoTablePayloadResponder,
3475    },
3476    EchoTablePayloadWithError {
3477        payload: EchoEchoTablePayloadWithErrorRequest,
3478        responder: EchoEchoTablePayloadWithErrorResponder,
3479    },
3480    EchoTablePayloadNoRetVal {
3481        payload: RequestTable,
3482        control_handle: EchoControlHandle,
3483    },
3484    EchoUnionPayload {
3485        payload: RequestUnion,
3486        responder: EchoEchoUnionPayloadResponder,
3487    },
3488    EchoUnionPayloadWithError {
3489        payload: EchoEchoUnionPayloadWithErrorRequest,
3490        responder: EchoEchoUnionPayloadWithErrorResponder,
3491    },
3492    EchoUnionPayloadNoRetVal {
3493        payload: RequestUnion,
3494        control_handle: EchoControlHandle,
3495    },
3496}
3497
3498impl EchoRequest {
3499    #[allow(irrefutable_let_patterns)]
3500    pub fn into_echo_table_request_composed(
3501        self,
3502    ) -> Option<(
3503        fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
3504        EchoEchoTableRequestComposedResponder,
3505    )> {
3506        if let EchoRequest::EchoTableRequestComposed { payload, responder } = self {
3507            Some((payload, responder))
3508        } else {
3509            None
3510        }
3511    }
3512
3513    #[allow(irrefutable_let_patterns)]
3514    pub fn into_echo_union_response_with_error_composed(
3515        self,
3516    ) -> Option<(
3517        i64,
3518        bool,
3519        String,
3520        u32,
3521        fidl_fidl_test_imported::WantResponse,
3522        EchoEchoUnionResponseWithErrorComposedResponder,
3523    )> {
3524        if let EchoRequest::EchoUnionResponseWithErrorComposed {
3525            value,
3526            want_absolute_value,
3527            forward_to_server,
3528            result_err,
3529            result_variant,
3530            responder,
3531        } = self
3532        {
3533            Some((
3534                value,
3535                want_absolute_value,
3536                forward_to_server,
3537                result_err,
3538                result_variant,
3539                responder,
3540            ))
3541        } else {
3542            None
3543        }
3544    }
3545
3546    #[allow(irrefutable_let_patterns)]
3547    pub fn into_echo_minimal(self) -> Option<(String, EchoEchoMinimalResponder)> {
3548        if let EchoRequest::EchoMinimal { forward_to_server, responder } = self {
3549            Some((forward_to_server, responder))
3550        } else {
3551            None
3552        }
3553    }
3554
3555    #[allow(irrefutable_let_patterns)]
3556    pub fn into_echo_minimal_with_error(
3557        self,
3558    ) -> Option<(String, RespondWith, EchoEchoMinimalWithErrorResponder)> {
3559        if let EchoRequest::EchoMinimalWithError { forward_to_server, result_variant, responder } =
3560            self
3561        {
3562            Some((forward_to_server, result_variant, responder))
3563        } else {
3564            None
3565        }
3566    }
3567
3568    #[allow(irrefutable_let_patterns)]
3569    pub fn into_echo_minimal_no_ret_val(self) -> Option<(String, EchoControlHandle)> {
3570        if let EchoRequest::EchoMinimalNoRetVal { forward_to_server, control_handle } = self {
3571            Some((forward_to_server, control_handle))
3572        } else {
3573            None
3574        }
3575    }
3576
3577    #[allow(irrefutable_let_patterns)]
3578    pub fn into_echo_struct(self) -> Option<(Struct, String, EchoEchoStructResponder)> {
3579        if let EchoRequest::EchoStruct { value, forward_to_server, responder } = self {
3580            Some((value, forward_to_server, responder))
3581        } else {
3582            None
3583        }
3584    }
3585
3586    #[allow(irrefutable_let_patterns)]
3587    pub fn into_echo_struct_with_error(
3588        self,
3589    ) -> Option<(Struct, DefaultEnum, String, RespondWith, EchoEchoStructWithErrorResponder)> {
3590        if let EchoRequest::EchoStructWithError {
3591            value,
3592            result_err,
3593            forward_to_server,
3594            result_variant,
3595            responder,
3596        } = self
3597        {
3598            Some((value, result_err, forward_to_server, result_variant, responder))
3599        } else {
3600            None
3601        }
3602    }
3603
3604    #[allow(irrefutable_let_patterns)]
3605    pub fn into_echo_struct_no_ret_val(self) -> Option<(Struct, String, EchoControlHandle)> {
3606        if let EchoRequest::EchoStructNoRetVal { value, forward_to_server, control_handle } = self {
3607            Some((value, forward_to_server, control_handle))
3608        } else {
3609            None
3610        }
3611    }
3612
3613    #[allow(irrefutable_let_patterns)]
3614    pub fn into_echo_arrays(self) -> Option<(ArraysStruct, String, EchoEchoArraysResponder)> {
3615        if let EchoRequest::EchoArrays { value, forward_to_server, responder } = self {
3616            Some((value, forward_to_server, responder))
3617        } else {
3618            None
3619        }
3620    }
3621
3622    #[allow(irrefutable_let_patterns)]
3623    pub fn into_echo_arrays_with_error(
3624        self,
3625    ) -> Option<(ArraysStruct, DefaultEnum, String, RespondWith, EchoEchoArraysWithErrorResponder)>
3626    {
3627        if let EchoRequest::EchoArraysWithError {
3628            value,
3629            result_err,
3630            forward_to_server,
3631            result_variant,
3632            responder,
3633        } = self
3634        {
3635            Some((value, result_err, forward_to_server, result_variant, responder))
3636        } else {
3637            None
3638        }
3639    }
3640
3641    #[allow(irrefutable_let_patterns)]
3642    pub fn into_echo_vectors(self) -> Option<(VectorsStruct, String, EchoEchoVectorsResponder)> {
3643        if let EchoRequest::EchoVectors { value, forward_to_server, responder } = self {
3644            Some((value, forward_to_server, responder))
3645        } else {
3646            None
3647        }
3648    }
3649
3650    #[allow(irrefutable_let_patterns)]
3651    pub fn into_echo_vectors_with_error(
3652        self,
3653    ) -> Option<(VectorsStruct, DefaultEnum, String, RespondWith, EchoEchoVectorsWithErrorResponder)>
3654    {
3655        if let EchoRequest::EchoVectorsWithError {
3656            value,
3657            result_err,
3658            forward_to_server,
3659            result_variant,
3660            responder,
3661        } = self
3662        {
3663            Some((value, result_err, forward_to_server, result_variant, responder))
3664        } else {
3665            None
3666        }
3667    }
3668
3669    #[allow(irrefutable_let_patterns)]
3670    pub fn into_echo_table(self) -> Option<(AllTypesTable, String, EchoEchoTableResponder)> {
3671        if let EchoRequest::EchoTable { value, forward_to_server, responder } = self {
3672            Some((value, forward_to_server, responder))
3673        } else {
3674            None
3675        }
3676    }
3677
3678    #[allow(irrefutable_let_patterns)]
3679    pub fn into_echo_table_with_error(
3680        self,
3681    ) -> Option<(AllTypesTable, DefaultEnum, String, RespondWith, EchoEchoTableWithErrorResponder)>
3682    {
3683        if let EchoRequest::EchoTableWithError {
3684            value,
3685            result_err,
3686            forward_to_server,
3687            result_variant,
3688            responder,
3689        } = self
3690        {
3691            Some((value, result_err, forward_to_server, result_variant, responder))
3692        } else {
3693            None
3694        }
3695    }
3696
3697    #[allow(irrefutable_let_patterns)]
3698    pub fn into_echo_xunions(
3699        self,
3700    ) -> Option<(Vec<AllTypesXunion>, String, EchoEchoXunionsResponder)> {
3701        if let EchoRequest::EchoXunions { value, forward_to_server, responder } = self {
3702            Some((value, forward_to_server, responder))
3703        } else {
3704            None
3705        }
3706    }
3707
3708    #[allow(irrefutable_let_patterns)]
3709    pub fn into_echo_xunions_with_error(
3710        self,
3711    ) -> Option<(
3712        Vec<AllTypesXunion>,
3713        DefaultEnum,
3714        String,
3715        RespondWith,
3716        EchoEchoXunionsWithErrorResponder,
3717    )> {
3718        if let EchoRequest::EchoXunionsWithError {
3719            value,
3720            result_err,
3721            forward_to_server,
3722            result_variant,
3723            responder,
3724        } = self
3725        {
3726            Some((value, result_err, forward_to_server, result_variant, responder))
3727        } else {
3728            None
3729        }
3730    }
3731
3732    #[allow(irrefutable_let_patterns)]
3733    pub fn into_echo_named_struct(
3734        self,
3735    ) -> Option<(fidl_fidl_test_imported::SimpleStruct, String, EchoEchoNamedStructResponder)> {
3736        if let EchoRequest::EchoNamedStruct { value, forward_to_server, responder } = self {
3737            Some((value, forward_to_server, responder))
3738        } else {
3739            None
3740        }
3741    }
3742
3743    #[allow(irrefutable_let_patterns)]
3744    pub fn into_echo_named_struct_with_error(
3745        self,
3746    ) -> Option<(
3747        fidl_fidl_test_imported::SimpleStruct,
3748        u32,
3749        String,
3750        fidl_fidl_test_imported::WantResponse,
3751        EchoEchoNamedStructWithErrorResponder,
3752    )> {
3753        if let EchoRequest::EchoNamedStructWithError {
3754            value,
3755            result_err,
3756            forward_to_server,
3757            result_variant,
3758            responder,
3759        } = self
3760        {
3761            Some((value, result_err, forward_to_server, result_variant, responder))
3762        } else {
3763            None
3764        }
3765    }
3766
3767    #[allow(irrefutable_let_patterns)]
3768    pub fn into_echo_named_struct_no_ret_val(
3769        self,
3770    ) -> Option<(fidl_fidl_test_imported::SimpleStruct, String, EchoControlHandle)> {
3771        if let EchoRequest::EchoNamedStructNoRetVal { value, forward_to_server, control_handle } =
3772            self
3773        {
3774            Some((value, forward_to_server, control_handle))
3775        } else {
3776            None
3777        }
3778    }
3779
3780    #[allow(irrefutable_let_patterns)]
3781    pub fn into_echo_table_payload(self) -> Option<(RequestTable, EchoEchoTablePayloadResponder)> {
3782        if let EchoRequest::EchoTablePayload { payload, responder } = self {
3783            Some((payload, responder))
3784        } else {
3785            None
3786        }
3787    }
3788
3789    #[allow(irrefutable_let_patterns)]
3790    pub fn into_echo_table_payload_with_error(
3791        self,
3792    ) -> Option<(EchoEchoTablePayloadWithErrorRequest, EchoEchoTablePayloadWithErrorResponder)>
3793    {
3794        if let EchoRequest::EchoTablePayloadWithError { payload, responder } = self {
3795            Some((payload, responder))
3796        } else {
3797            None
3798        }
3799    }
3800
3801    #[allow(irrefutable_let_patterns)]
3802    pub fn into_echo_table_payload_no_ret_val(self) -> Option<(RequestTable, EchoControlHandle)> {
3803        if let EchoRequest::EchoTablePayloadNoRetVal { payload, control_handle } = self {
3804            Some((payload, control_handle))
3805        } else {
3806            None
3807        }
3808    }
3809
3810    #[allow(irrefutable_let_patterns)]
3811    pub fn into_echo_union_payload(self) -> Option<(RequestUnion, EchoEchoUnionPayloadResponder)> {
3812        if let EchoRequest::EchoUnionPayload { payload, responder } = self {
3813            Some((payload, responder))
3814        } else {
3815            None
3816        }
3817    }
3818
3819    #[allow(irrefutable_let_patterns)]
3820    pub fn into_echo_union_payload_with_error(
3821        self,
3822    ) -> Option<(EchoEchoUnionPayloadWithErrorRequest, EchoEchoUnionPayloadWithErrorResponder)>
3823    {
3824        if let EchoRequest::EchoUnionPayloadWithError { payload, responder } = self {
3825            Some((payload, responder))
3826        } else {
3827            None
3828        }
3829    }
3830
3831    #[allow(irrefutable_let_patterns)]
3832    pub fn into_echo_union_payload_no_ret_val(self) -> Option<(RequestUnion, EchoControlHandle)> {
3833        if let EchoRequest::EchoUnionPayloadNoRetVal { payload, control_handle } = self {
3834            Some((payload, control_handle))
3835        } else {
3836            None
3837        }
3838    }
3839
3840    /// Name of the method defined in FIDL
3841    pub fn method_name(&self) -> &'static str {
3842        match *self {
3843            EchoRequest::EchoTableRequestComposed { .. } => "echo_table_request_composed",
3844            EchoRequest::EchoUnionResponseWithErrorComposed { .. } => {
3845                "echo_union_response_with_error_composed"
3846            }
3847            EchoRequest::EchoMinimal { .. } => "echo_minimal",
3848            EchoRequest::EchoMinimalWithError { .. } => "echo_minimal_with_error",
3849            EchoRequest::EchoMinimalNoRetVal { .. } => "echo_minimal_no_ret_val",
3850            EchoRequest::EchoStruct { .. } => "echo_struct",
3851            EchoRequest::EchoStructWithError { .. } => "echo_struct_with_error",
3852            EchoRequest::EchoStructNoRetVal { .. } => "echo_struct_no_ret_val",
3853            EchoRequest::EchoArrays { .. } => "echo_arrays",
3854            EchoRequest::EchoArraysWithError { .. } => "echo_arrays_with_error",
3855            EchoRequest::EchoVectors { .. } => "echo_vectors",
3856            EchoRequest::EchoVectorsWithError { .. } => "echo_vectors_with_error",
3857            EchoRequest::EchoTable { .. } => "echo_table",
3858            EchoRequest::EchoTableWithError { .. } => "echo_table_with_error",
3859            EchoRequest::EchoXunions { .. } => "echo_xunions",
3860            EchoRequest::EchoXunionsWithError { .. } => "echo_xunions_with_error",
3861            EchoRequest::EchoNamedStruct { .. } => "echo_named_struct",
3862            EchoRequest::EchoNamedStructWithError { .. } => "echo_named_struct_with_error",
3863            EchoRequest::EchoNamedStructNoRetVal { .. } => "echo_named_struct_no_ret_val",
3864            EchoRequest::EchoTablePayload { .. } => "echo_table_payload",
3865            EchoRequest::EchoTablePayloadWithError { .. } => "echo_table_payload_with_error",
3866            EchoRequest::EchoTablePayloadNoRetVal { .. } => "echo_table_payload_no_ret_val",
3867            EchoRequest::EchoUnionPayload { .. } => "echo_union_payload",
3868            EchoRequest::EchoUnionPayloadWithError { .. } => "echo_union_payload_with_error",
3869            EchoRequest::EchoUnionPayloadNoRetVal { .. } => "echo_union_payload_no_ret_val",
3870        }
3871    }
3872}
3873
3874#[derive(Debug, Clone)]
3875pub struct EchoControlHandle {
3876    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
3877}
3878
3879impl EchoControlHandle {
3880    pub fn shutdown_with_epitaph(&self, status: impl Into<fidl::Epitaph>) {
3881        self.inner.shutdown_with_epitaph(status.into())
3882    }
3883}
3884
3885impl fidl::endpoints::ControlHandle for EchoControlHandle {
3886    fn shutdown(&self) {
3887        self.inner.shutdown()
3888    }
3889
3890    fn shutdown_with_epitaph(&self, status: fidl::Epitaph) {
3891        self.inner.shutdown_with_epitaph(status)
3892    }
3893
3894    fn is_closed(&self) -> bool {
3895        self.inner.channel().is_closed()
3896    }
3897    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
3898        self.inner.channel().on_closed()
3899    }
3900
3901    #[cfg(target_os = "fuchsia")]
3902    fn signal_peer(
3903        &self,
3904        clear_mask: zx::Signals,
3905        set_mask: zx::Signals,
3906    ) -> Result<(), zx_status::Status> {
3907        use fidl::Peered;
3908        self.inner.channel().signal_peer(clear_mask, set_mask)
3909    }
3910}
3911
3912impl EchoControlHandle {
3913    pub fn send_echo_minimal_event(&self) -> Result<(), fidl::Error> {
3914        self.inner.send::<fidl::encoding::EmptyPayload>(
3915            (),
3916            0,
3917            0x273b2029f1a0aee2,
3918            fidl::encoding::DynamicFlags::empty(),
3919        )
3920    }
3921
3922    pub fn send_echo_event(&self, mut value: Struct) -> Result<(), fidl::Error> {
3923        self.inner.send::<EchoEchoEventRequest>(
3924            (&mut value,),
3925            0,
3926            0x1219e12e0450024,
3927            fidl::encoding::DynamicFlags::empty(),
3928        )
3929    }
3930
3931    pub fn send_on_echo_named_event(
3932        &self,
3933        mut value: &fidl_fidl_test_imported::SimpleStruct,
3934    ) -> Result<(), fidl::Error> {
3935        self.inner.send::<fidl_fidl_test_imported::ResponseStruct>(
3936            (value,),
3937            0,
3938            0x749ebde83348a374,
3939            fidl::encoding::DynamicFlags::empty(),
3940        )
3941    }
3942
3943    pub fn send_on_echo_table_payload_event(
3944        &self,
3945        mut payload: &ResponseTable,
3946    ) -> Result<(), fidl::Error> {
3947        self.inner.send::<ResponseTable>(
3948            payload,
3949            0,
3950            0x708dddea1cb98430,
3951            fidl::encoding::DynamicFlags::empty(),
3952        )
3953    }
3954
3955    pub fn send_on_echo_union_payload_event(
3956        &self,
3957        mut payload: &ResponseUnion,
3958    ) -> Result<(), fidl::Error> {
3959        self.inner.send::<ResponseUnion>(
3960            payload,
3961            0,
3962            0x642f4c265a05f4c0,
3963            fidl::encoding::DynamicFlags::empty(),
3964        )
3965    }
3966}
3967
3968#[must_use = "FIDL methods require a response to be sent"]
3969#[derive(Debug)]
3970pub struct EchoEchoTableRequestComposedResponder {
3971    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
3972    tx_id: u32,
3973}
3974
3975/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
3976/// if the responder is dropped without sending a response, so that the client
3977/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
3978impl std::ops::Drop for EchoEchoTableRequestComposedResponder {
3979    fn drop(&mut self) {
3980        self.control_handle.shutdown();
3981        // Safety: drops once, never accessed again
3982        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3983    }
3984}
3985
3986impl fidl::endpoints::Responder for EchoEchoTableRequestComposedResponder {
3987    type ControlHandle = EchoControlHandle;
3988
3989    fn control_handle(&self) -> &EchoControlHandle {
3990        &self.control_handle
3991    }
3992
3993    fn drop_without_shutdown(mut self) {
3994        // Safety: drops once, never accessed again due to mem::forget
3995        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3996        // Prevent Drop from running (which would shut down the channel)
3997        std::mem::forget(self);
3998    }
3999}
4000
4001impl EchoEchoTableRequestComposedResponder {
4002    /// Sends a response to the FIDL transaction.
4003    ///
4004    /// Sets the channel to shutdown if an error occurs.
4005    pub fn send(
4006        self,
4007        mut value: &fidl_fidl_test_imported::SimpleStruct,
4008    ) -> Result<(), fidl::Error> {
4009        let _result = self.send_raw(value);
4010        if _result.is_err() {
4011            self.control_handle.shutdown();
4012        }
4013        self.drop_without_shutdown();
4014        _result
4015    }
4016
4017    /// Similar to "send" but does not shutdown the channel if an error occurs.
4018    pub fn send_no_shutdown_on_err(
4019        self,
4020        mut value: &fidl_fidl_test_imported::SimpleStruct,
4021    ) -> Result<(), fidl::Error> {
4022        let _result = self.send_raw(value);
4023        self.drop_without_shutdown();
4024        _result
4025    }
4026
4027    fn send_raw(
4028        &self,
4029        mut value: &fidl_fidl_test_imported::SimpleStruct,
4030    ) -> Result<(), fidl::Error> {
4031        self.control_handle.inner.send::<fidl_fidl_test_imported::ResponseStruct>(
4032            (value,),
4033            self.tx_id,
4034            0x1d545c738c7a8ee,
4035            fidl::encoding::DynamicFlags::empty(),
4036        )
4037    }
4038}
4039
4040#[must_use = "FIDL methods require a response to be sent"]
4041#[derive(Debug)]
4042pub struct EchoEchoUnionResponseWithErrorComposedResponder {
4043    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4044    tx_id: u32,
4045}
4046
4047/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4048/// if the responder is dropped without sending a response, so that the client
4049/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4050impl std::ops::Drop for EchoEchoUnionResponseWithErrorComposedResponder {
4051    fn drop(&mut self) {
4052        self.control_handle.shutdown();
4053        // Safety: drops once, never accessed again
4054        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4055    }
4056}
4057
4058impl fidl::endpoints::Responder for EchoEchoUnionResponseWithErrorComposedResponder {
4059    type ControlHandle = EchoControlHandle;
4060
4061    fn control_handle(&self) -> &EchoControlHandle {
4062        &self.control_handle
4063    }
4064
4065    fn drop_without_shutdown(mut self) {
4066        // Safety: drops once, never accessed again due to mem::forget
4067        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4068        // Prevent Drop from running (which would shut down the channel)
4069        std::mem::forget(self);
4070    }
4071}
4072
4073impl EchoEchoUnionResponseWithErrorComposedResponder {
4074    /// Sends a response to the FIDL transaction.
4075    ///
4076    /// Sets the channel to shutdown if an error occurs.
4077    pub fn send(
4078        self,
4079        mut result: Result<
4080            &fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse,
4081            u32,
4082        >,
4083    ) -> Result<(), fidl::Error> {
4084        let _result = self.send_raw(result);
4085        if _result.is_err() {
4086            self.control_handle.shutdown();
4087        }
4088        self.drop_without_shutdown();
4089        _result
4090    }
4091
4092    /// Similar to "send" but does not shutdown the channel if an error occurs.
4093    pub fn send_no_shutdown_on_err(
4094        self,
4095        mut result: Result<
4096            &fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse,
4097            u32,
4098        >,
4099    ) -> Result<(), fidl::Error> {
4100        let _result = self.send_raw(result);
4101        self.drop_without_shutdown();
4102        _result
4103    }
4104
4105    fn send_raw(
4106        &self,
4107        mut result: Result<
4108            &fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse,
4109            u32,
4110        >,
4111    ) -> Result<(), fidl::Error> {
4112        self.control_handle.inner.send::<fidl::encoding::ResultType<
4113            fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse,
4114            u32,
4115        >>(
4116            result,
4117            self.tx_id,
4118            0x38a67e88d6106443,
4119            fidl::encoding::DynamicFlags::empty(),
4120        )
4121    }
4122}
4123
4124#[must_use = "FIDL methods require a response to be sent"]
4125#[derive(Debug)]
4126pub struct EchoEchoMinimalResponder {
4127    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4128    tx_id: u32,
4129}
4130
4131/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4132/// if the responder is dropped without sending a response, so that the client
4133/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4134impl std::ops::Drop for EchoEchoMinimalResponder {
4135    fn drop(&mut self) {
4136        self.control_handle.shutdown();
4137        // Safety: drops once, never accessed again
4138        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4139    }
4140}
4141
4142impl fidl::endpoints::Responder for EchoEchoMinimalResponder {
4143    type ControlHandle = EchoControlHandle;
4144
4145    fn control_handle(&self) -> &EchoControlHandle {
4146        &self.control_handle
4147    }
4148
4149    fn drop_without_shutdown(mut self) {
4150        // Safety: drops once, never accessed again due to mem::forget
4151        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4152        // Prevent Drop from running (which would shut down the channel)
4153        std::mem::forget(self);
4154    }
4155}
4156
4157impl EchoEchoMinimalResponder {
4158    /// Sends a response to the FIDL transaction.
4159    ///
4160    /// Sets the channel to shutdown if an error occurs.
4161    pub fn send(self) -> Result<(), fidl::Error> {
4162        let _result = self.send_raw();
4163        if _result.is_err() {
4164            self.control_handle.shutdown();
4165        }
4166        self.drop_without_shutdown();
4167        _result
4168    }
4169
4170    /// Similar to "send" but does not shutdown the channel if an error occurs.
4171    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
4172        let _result = self.send_raw();
4173        self.drop_without_shutdown();
4174        _result
4175    }
4176
4177    fn send_raw(&self) -> Result<(), fidl::Error> {
4178        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
4179            (),
4180            self.tx_id,
4181            0x39edd68c837482ec,
4182            fidl::encoding::DynamicFlags::empty(),
4183        )
4184    }
4185}
4186
4187#[must_use = "FIDL methods require a response to be sent"]
4188#[derive(Debug)]
4189pub struct EchoEchoMinimalWithErrorResponder {
4190    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4191    tx_id: u32,
4192}
4193
4194/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4195/// if the responder is dropped without sending a response, so that the client
4196/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4197impl std::ops::Drop for EchoEchoMinimalWithErrorResponder {
4198    fn drop(&mut self) {
4199        self.control_handle.shutdown();
4200        // Safety: drops once, never accessed again
4201        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4202    }
4203}
4204
4205impl fidl::endpoints::Responder for EchoEchoMinimalWithErrorResponder {
4206    type ControlHandle = EchoControlHandle;
4207
4208    fn control_handle(&self) -> &EchoControlHandle {
4209        &self.control_handle
4210    }
4211
4212    fn drop_without_shutdown(mut self) {
4213        // Safety: drops once, never accessed again due to mem::forget
4214        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4215        // Prevent Drop from running (which would shut down the channel)
4216        std::mem::forget(self);
4217    }
4218}
4219
4220impl EchoEchoMinimalWithErrorResponder {
4221    /// Sends a response to the FIDL transaction.
4222    ///
4223    /// Sets the channel to shutdown if an error occurs.
4224    pub fn send(self, mut result: Result<(), u32>) -> Result<(), fidl::Error> {
4225        let _result = self.send_raw(result);
4226        if _result.is_err() {
4227            self.control_handle.shutdown();
4228        }
4229        self.drop_without_shutdown();
4230        _result
4231    }
4232
4233    /// Similar to "send" but does not shutdown the channel if an error occurs.
4234    pub fn send_no_shutdown_on_err(self, mut result: Result<(), u32>) -> Result<(), fidl::Error> {
4235        let _result = self.send_raw(result);
4236        self.drop_without_shutdown();
4237        _result
4238    }
4239
4240    fn send_raw(&self, mut result: Result<(), u32>) -> Result<(), fidl::Error> {
4241        self.control_handle
4242            .inner
4243            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, u32>>(
4244                result,
4245                self.tx_id,
4246                0x36f4695996e35acc,
4247                fidl::encoding::DynamicFlags::empty(),
4248            )
4249    }
4250}
4251
4252#[must_use = "FIDL methods require a response to be sent"]
4253#[derive(Debug)]
4254pub struct EchoEchoStructResponder {
4255    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4256    tx_id: u32,
4257}
4258
4259/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4260/// if the responder is dropped without sending a response, so that the client
4261/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4262impl std::ops::Drop for EchoEchoStructResponder {
4263    fn drop(&mut self) {
4264        self.control_handle.shutdown();
4265        // Safety: drops once, never accessed again
4266        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4267    }
4268}
4269
4270impl fidl::endpoints::Responder for EchoEchoStructResponder {
4271    type ControlHandle = EchoControlHandle;
4272
4273    fn control_handle(&self) -> &EchoControlHandle {
4274        &self.control_handle
4275    }
4276
4277    fn drop_without_shutdown(mut self) {
4278        // Safety: drops once, never accessed again due to mem::forget
4279        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4280        // Prevent Drop from running (which would shut down the channel)
4281        std::mem::forget(self);
4282    }
4283}
4284
4285impl EchoEchoStructResponder {
4286    /// Sends a response to the FIDL transaction.
4287    ///
4288    /// Sets the channel to shutdown if an error occurs.
4289    pub fn send(self, mut value: Struct) -> Result<(), fidl::Error> {
4290        let _result = self.send_raw(value);
4291        if _result.is_err() {
4292            self.control_handle.shutdown();
4293        }
4294        self.drop_without_shutdown();
4295        _result
4296    }
4297
4298    /// Similar to "send" but does not shutdown the channel if an error occurs.
4299    pub fn send_no_shutdown_on_err(self, mut value: Struct) -> Result<(), fidl::Error> {
4300        let _result = self.send_raw(value);
4301        self.drop_without_shutdown();
4302        _result
4303    }
4304
4305    fn send_raw(&self, mut value: Struct) -> Result<(), fidl::Error> {
4306        self.control_handle.inner.send::<EchoEchoStructResponse>(
4307            (&mut value,),
4308            self.tx_id,
4309            0x4c2f85818cc53f37,
4310            fidl::encoding::DynamicFlags::empty(),
4311        )
4312    }
4313}
4314
4315#[must_use = "FIDL methods require a response to be sent"]
4316#[derive(Debug)]
4317pub struct EchoEchoStructWithErrorResponder {
4318    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4319    tx_id: u32,
4320}
4321
4322/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4323/// if the responder is dropped without sending a response, so that the client
4324/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4325impl std::ops::Drop for EchoEchoStructWithErrorResponder {
4326    fn drop(&mut self) {
4327        self.control_handle.shutdown();
4328        // Safety: drops once, never accessed again
4329        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4330    }
4331}
4332
4333impl fidl::endpoints::Responder for EchoEchoStructWithErrorResponder {
4334    type ControlHandle = EchoControlHandle;
4335
4336    fn control_handle(&self) -> &EchoControlHandle {
4337        &self.control_handle
4338    }
4339
4340    fn drop_without_shutdown(mut self) {
4341        // Safety: drops once, never accessed again due to mem::forget
4342        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4343        // Prevent Drop from running (which would shut down the channel)
4344        std::mem::forget(self);
4345    }
4346}
4347
4348impl EchoEchoStructWithErrorResponder {
4349    /// Sends a response to the FIDL transaction.
4350    ///
4351    /// Sets the channel to shutdown if an error occurs.
4352    pub fn send(self, mut result: Result<Struct, DefaultEnum>) -> Result<(), fidl::Error> {
4353        let _result = self.send_raw(result);
4354        if _result.is_err() {
4355            self.control_handle.shutdown();
4356        }
4357        self.drop_without_shutdown();
4358        _result
4359    }
4360
4361    /// Similar to "send" but does not shutdown the channel if an error occurs.
4362    pub fn send_no_shutdown_on_err(
4363        self,
4364        mut result: Result<Struct, DefaultEnum>,
4365    ) -> Result<(), fidl::Error> {
4366        let _result = self.send_raw(result);
4367        self.drop_without_shutdown();
4368        _result
4369    }
4370
4371    fn send_raw(&self, mut result: Result<Struct, DefaultEnum>) -> Result<(), fidl::Error> {
4372        self.control_handle.inner.send::<fidl::encoding::ResultType<
4373            EchoEchoStructWithErrorResponse,
4374            DefaultEnum,
4375        >>(
4376            result.as_mut().map_err(|e| *e).map(|value| (value,)),
4377            self.tx_id,
4378            0x46cb32652c4c0899,
4379            fidl::encoding::DynamicFlags::empty(),
4380        )
4381    }
4382}
4383
4384#[must_use = "FIDL methods require a response to be sent"]
4385#[derive(Debug)]
4386pub struct EchoEchoArraysResponder {
4387    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4388    tx_id: u32,
4389}
4390
4391/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4392/// if the responder is dropped without sending a response, so that the client
4393/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4394impl std::ops::Drop for EchoEchoArraysResponder {
4395    fn drop(&mut self) {
4396        self.control_handle.shutdown();
4397        // Safety: drops once, never accessed again
4398        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4399    }
4400}
4401
4402impl fidl::endpoints::Responder for EchoEchoArraysResponder {
4403    type ControlHandle = EchoControlHandle;
4404
4405    fn control_handle(&self) -> &EchoControlHandle {
4406        &self.control_handle
4407    }
4408
4409    fn drop_without_shutdown(mut self) {
4410        // Safety: drops once, never accessed again due to mem::forget
4411        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4412        // Prevent Drop from running (which would shut down the channel)
4413        std::mem::forget(self);
4414    }
4415}
4416
4417impl EchoEchoArraysResponder {
4418    /// Sends a response to the FIDL transaction.
4419    ///
4420    /// Sets the channel to shutdown if an error occurs.
4421    pub fn send(self, mut value: ArraysStruct) -> Result<(), fidl::Error> {
4422        let _result = self.send_raw(value);
4423        if _result.is_err() {
4424            self.control_handle.shutdown();
4425        }
4426        self.drop_without_shutdown();
4427        _result
4428    }
4429
4430    /// Similar to "send" but does not shutdown the channel if an error occurs.
4431    pub fn send_no_shutdown_on_err(self, mut value: ArraysStruct) -> Result<(), fidl::Error> {
4432        let _result = self.send_raw(value);
4433        self.drop_without_shutdown();
4434        _result
4435    }
4436
4437    fn send_raw(&self, mut value: ArraysStruct) -> Result<(), fidl::Error> {
4438        self.control_handle.inner.send::<EchoEchoArraysResponse>(
4439            (&mut value,),
4440            self.tx_id,
4441            0x1b6019d5611f2470,
4442            fidl::encoding::DynamicFlags::empty(),
4443        )
4444    }
4445}
4446
4447#[must_use = "FIDL methods require a response to be sent"]
4448#[derive(Debug)]
4449pub struct EchoEchoArraysWithErrorResponder {
4450    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4451    tx_id: u32,
4452}
4453
4454/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4455/// if the responder is dropped without sending a response, so that the client
4456/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4457impl std::ops::Drop for EchoEchoArraysWithErrorResponder {
4458    fn drop(&mut self) {
4459        self.control_handle.shutdown();
4460        // Safety: drops once, never accessed again
4461        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4462    }
4463}
4464
4465impl fidl::endpoints::Responder for EchoEchoArraysWithErrorResponder {
4466    type ControlHandle = EchoControlHandle;
4467
4468    fn control_handle(&self) -> &EchoControlHandle {
4469        &self.control_handle
4470    }
4471
4472    fn drop_without_shutdown(mut self) {
4473        // Safety: drops once, never accessed again due to mem::forget
4474        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4475        // Prevent Drop from running (which would shut down the channel)
4476        std::mem::forget(self);
4477    }
4478}
4479
4480impl EchoEchoArraysWithErrorResponder {
4481    /// Sends a response to the FIDL transaction.
4482    ///
4483    /// Sets the channel to shutdown if an error occurs.
4484    pub fn send(self, mut result: Result<ArraysStruct, DefaultEnum>) -> Result<(), fidl::Error> {
4485        let _result = self.send_raw(result);
4486        if _result.is_err() {
4487            self.control_handle.shutdown();
4488        }
4489        self.drop_without_shutdown();
4490        _result
4491    }
4492
4493    /// Similar to "send" but does not shutdown the channel if an error occurs.
4494    pub fn send_no_shutdown_on_err(
4495        self,
4496        mut result: Result<ArraysStruct, DefaultEnum>,
4497    ) -> Result<(), fidl::Error> {
4498        let _result = self.send_raw(result);
4499        self.drop_without_shutdown();
4500        _result
4501    }
4502
4503    fn send_raw(&self, mut result: Result<ArraysStruct, DefaultEnum>) -> Result<(), fidl::Error> {
4504        self.control_handle.inner.send::<fidl::encoding::ResultType<
4505            EchoEchoArraysWithErrorResponse,
4506            DefaultEnum,
4507        >>(
4508            result.as_mut().map_err(|e| *e).map(|value| (value,)),
4509            self.tx_id,
4510            0x6dbf26e67e253afa,
4511            fidl::encoding::DynamicFlags::empty(),
4512        )
4513    }
4514}
4515
4516#[must_use = "FIDL methods require a response to be sent"]
4517#[derive(Debug)]
4518pub struct EchoEchoVectorsResponder {
4519    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4520    tx_id: u32,
4521}
4522
4523/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4524/// if the responder is dropped without sending a response, so that the client
4525/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4526impl std::ops::Drop for EchoEchoVectorsResponder {
4527    fn drop(&mut self) {
4528        self.control_handle.shutdown();
4529        // Safety: drops once, never accessed again
4530        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4531    }
4532}
4533
4534impl fidl::endpoints::Responder for EchoEchoVectorsResponder {
4535    type ControlHandle = EchoControlHandle;
4536
4537    fn control_handle(&self) -> &EchoControlHandle {
4538        &self.control_handle
4539    }
4540
4541    fn drop_without_shutdown(mut self) {
4542        // Safety: drops once, never accessed again due to mem::forget
4543        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4544        // Prevent Drop from running (which would shut down the channel)
4545        std::mem::forget(self);
4546    }
4547}
4548
4549impl EchoEchoVectorsResponder {
4550    /// Sends a response to the FIDL transaction.
4551    ///
4552    /// Sets the channel to shutdown if an error occurs.
4553    pub fn send(self, mut value: VectorsStruct) -> Result<(), fidl::Error> {
4554        let _result = self.send_raw(value);
4555        if _result.is_err() {
4556            self.control_handle.shutdown();
4557        }
4558        self.drop_without_shutdown();
4559        _result
4560    }
4561
4562    /// Similar to "send" but does not shutdown the channel if an error occurs.
4563    pub fn send_no_shutdown_on_err(self, mut value: VectorsStruct) -> Result<(), fidl::Error> {
4564        let _result = self.send_raw(value);
4565        self.drop_without_shutdown();
4566        _result
4567    }
4568
4569    fn send_raw(&self, mut value: VectorsStruct) -> Result<(), fidl::Error> {
4570        self.control_handle.inner.send::<EchoEchoVectorsResponse>(
4571            (&mut value,),
4572            self.tx_id,
4573            0x1582623f0d9f6e5e,
4574            fidl::encoding::DynamicFlags::empty(),
4575        )
4576    }
4577}
4578
4579#[must_use = "FIDL methods require a response to be sent"]
4580#[derive(Debug)]
4581pub struct EchoEchoVectorsWithErrorResponder {
4582    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4583    tx_id: u32,
4584}
4585
4586/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4587/// if the responder is dropped without sending a response, so that the client
4588/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4589impl std::ops::Drop for EchoEchoVectorsWithErrorResponder {
4590    fn drop(&mut self) {
4591        self.control_handle.shutdown();
4592        // Safety: drops once, never accessed again
4593        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4594    }
4595}
4596
4597impl fidl::endpoints::Responder for EchoEchoVectorsWithErrorResponder {
4598    type ControlHandle = EchoControlHandle;
4599
4600    fn control_handle(&self) -> &EchoControlHandle {
4601        &self.control_handle
4602    }
4603
4604    fn drop_without_shutdown(mut self) {
4605        // Safety: drops once, never accessed again due to mem::forget
4606        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4607        // Prevent Drop from running (which would shut down the channel)
4608        std::mem::forget(self);
4609    }
4610}
4611
4612impl EchoEchoVectorsWithErrorResponder {
4613    /// Sends a response to the FIDL transaction.
4614    ///
4615    /// Sets the channel to shutdown if an error occurs.
4616    pub fn send(self, mut result: Result<VectorsStruct, DefaultEnum>) -> Result<(), fidl::Error> {
4617        let _result = self.send_raw(result);
4618        if _result.is_err() {
4619            self.control_handle.shutdown();
4620        }
4621        self.drop_without_shutdown();
4622        _result
4623    }
4624
4625    /// Similar to "send" but does not shutdown the channel if an error occurs.
4626    pub fn send_no_shutdown_on_err(
4627        self,
4628        mut result: Result<VectorsStruct, DefaultEnum>,
4629    ) -> Result<(), fidl::Error> {
4630        let _result = self.send_raw(result);
4631        self.drop_without_shutdown();
4632        _result
4633    }
4634
4635    fn send_raw(&self, mut result: Result<VectorsStruct, DefaultEnum>) -> Result<(), fidl::Error> {
4636        self.control_handle.inner.send::<fidl::encoding::ResultType<
4637            EchoEchoVectorsWithErrorResponse,
4638            DefaultEnum,
4639        >>(
4640            result.as_mut().map_err(|e| *e).map(|value| (value,)),
4641            self.tx_id,
4642            0x730f163401e2b3e5,
4643            fidl::encoding::DynamicFlags::empty(),
4644        )
4645    }
4646}
4647
4648#[must_use = "FIDL methods require a response to be sent"]
4649#[derive(Debug)]
4650pub struct EchoEchoTableResponder {
4651    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4652    tx_id: u32,
4653}
4654
4655/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4656/// if the responder is dropped without sending a response, so that the client
4657/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4658impl std::ops::Drop for EchoEchoTableResponder {
4659    fn drop(&mut self) {
4660        self.control_handle.shutdown();
4661        // Safety: drops once, never accessed again
4662        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4663    }
4664}
4665
4666impl fidl::endpoints::Responder for EchoEchoTableResponder {
4667    type ControlHandle = EchoControlHandle;
4668
4669    fn control_handle(&self) -> &EchoControlHandle {
4670        &self.control_handle
4671    }
4672
4673    fn drop_without_shutdown(mut self) {
4674        // Safety: drops once, never accessed again due to mem::forget
4675        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4676        // Prevent Drop from running (which would shut down the channel)
4677        std::mem::forget(self);
4678    }
4679}
4680
4681impl EchoEchoTableResponder {
4682    /// Sends a response to the FIDL transaction.
4683    ///
4684    /// Sets the channel to shutdown if an error occurs.
4685    pub fn send(self, mut value: AllTypesTable) -> Result<(), fidl::Error> {
4686        let _result = self.send_raw(value);
4687        if _result.is_err() {
4688            self.control_handle.shutdown();
4689        }
4690        self.drop_without_shutdown();
4691        _result
4692    }
4693
4694    /// Similar to "send" but does not shutdown the channel if an error occurs.
4695    pub fn send_no_shutdown_on_err(self, mut value: AllTypesTable) -> Result<(), fidl::Error> {
4696        let _result = self.send_raw(value);
4697        self.drop_without_shutdown();
4698        _result
4699    }
4700
4701    fn send_raw(&self, mut value: AllTypesTable) -> Result<(), fidl::Error> {
4702        self.control_handle.inner.send::<EchoEchoTableResponse>(
4703            (&mut value,),
4704            self.tx_id,
4705            0x4f1fb0a512f47c4b,
4706            fidl::encoding::DynamicFlags::empty(),
4707        )
4708    }
4709}
4710
4711#[must_use = "FIDL methods require a response to be sent"]
4712#[derive(Debug)]
4713pub struct EchoEchoTableWithErrorResponder {
4714    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4715    tx_id: u32,
4716}
4717
4718/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4719/// if the responder is dropped without sending a response, so that the client
4720/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4721impl std::ops::Drop for EchoEchoTableWithErrorResponder {
4722    fn drop(&mut self) {
4723        self.control_handle.shutdown();
4724        // Safety: drops once, never accessed again
4725        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4726    }
4727}
4728
4729impl fidl::endpoints::Responder for EchoEchoTableWithErrorResponder {
4730    type ControlHandle = EchoControlHandle;
4731
4732    fn control_handle(&self) -> &EchoControlHandle {
4733        &self.control_handle
4734    }
4735
4736    fn drop_without_shutdown(mut self) {
4737        // Safety: drops once, never accessed again due to mem::forget
4738        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4739        // Prevent Drop from running (which would shut down the channel)
4740        std::mem::forget(self);
4741    }
4742}
4743
4744impl EchoEchoTableWithErrorResponder {
4745    /// Sends a response to the FIDL transaction.
4746    ///
4747    /// Sets the channel to shutdown if an error occurs.
4748    pub fn send(self, mut result: Result<AllTypesTable, DefaultEnum>) -> Result<(), fidl::Error> {
4749        let _result = self.send_raw(result);
4750        if _result.is_err() {
4751            self.control_handle.shutdown();
4752        }
4753        self.drop_without_shutdown();
4754        _result
4755    }
4756
4757    /// Similar to "send" but does not shutdown the channel if an error occurs.
4758    pub fn send_no_shutdown_on_err(
4759        self,
4760        mut result: Result<AllTypesTable, DefaultEnum>,
4761    ) -> Result<(), fidl::Error> {
4762        let _result = self.send_raw(result);
4763        self.drop_without_shutdown();
4764        _result
4765    }
4766
4767    fn send_raw(&self, mut result: Result<AllTypesTable, DefaultEnum>) -> Result<(), fidl::Error> {
4768        self.control_handle.inner.send::<fidl::encoding::ResultType<
4769            EchoEchoTableWithErrorResponse,
4770            DefaultEnum,
4771        >>(
4772            result.as_mut().map_err(|e| *e).map(|value| (value,)),
4773            self.tx_id,
4774            0x44e835cb1eb9a931,
4775            fidl::encoding::DynamicFlags::empty(),
4776        )
4777    }
4778}
4779
4780#[must_use = "FIDL methods require a response to be sent"]
4781#[derive(Debug)]
4782pub struct EchoEchoXunionsResponder {
4783    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4784    tx_id: u32,
4785}
4786
4787/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4788/// if the responder is dropped without sending a response, so that the client
4789/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4790impl std::ops::Drop for EchoEchoXunionsResponder {
4791    fn drop(&mut self) {
4792        self.control_handle.shutdown();
4793        // Safety: drops once, never accessed again
4794        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4795    }
4796}
4797
4798impl fidl::endpoints::Responder for EchoEchoXunionsResponder {
4799    type ControlHandle = EchoControlHandle;
4800
4801    fn control_handle(&self) -> &EchoControlHandle {
4802        &self.control_handle
4803    }
4804
4805    fn drop_without_shutdown(mut self) {
4806        // Safety: drops once, never accessed again due to mem::forget
4807        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4808        // Prevent Drop from running (which would shut down the channel)
4809        std::mem::forget(self);
4810    }
4811}
4812
4813impl EchoEchoXunionsResponder {
4814    /// Sends a response to the FIDL transaction.
4815    ///
4816    /// Sets the channel to shutdown if an error occurs.
4817    pub fn send(self, mut value: Vec<AllTypesXunion>) -> Result<(), fidl::Error> {
4818        let _result = self.send_raw(value);
4819        if _result.is_err() {
4820            self.control_handle.shutdown();
4821        }
4822        self.drop_without_shutdown();
4823        _result
4824    }
4825
4826    /// Similar to "send" but does not shutdown the channel if an error occurs.
4827    pub fn send_no_shutdown_on_err(
4828        self,
4829        mut value: Vec<AllTypesXunion>,
4830    ) -> Result<(), fidl::Error> {
4831        let _result = self.send_raw(value);
4832        self.drop_without_shutdown();
4833        _result
4834    }
4835
4836    fn send_raw(&self, mut value: Vec<AllTypesXunion>) -> Result<(), fidl::Error> {
4837        self.control_handle.inner.send::<EchoEchoXunionsResponse>(
4838            (value.as_mut(),),
4839            self.tx_id,
4840            0x3dc181909041a583,
4841            fidl::encoding::DynamicFlags::empty(),
4842        )
4843    }
4844}
4845
4846#[must_use = "FIDL methods require a response to be sent"]
4847#[derive(Debug)]
4848pub struct EchoEchoXunionsWithErrorResponder {
4849    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4850    tx_id: u32,
4851}
4852
4853/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4854/// if the responder is dropped without sending a response, so that the client
4855/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4856impl std::ops::Drop for EchoEchoXunionsWithErrorResponder {
4857    fn drop(&mut self) {
4858        self.control_handle.shutdown();
4859        // Safety: drops once, never accessed again
4860        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4861    }
4862}
4863
4864impl fidl::endpoints::Responder for EchoEchoXunionsWithErrorResponder {
4865    type ControlHandle = EchoControlHandle;
4866
4867    fn control_handle(&self) -> &EchoControlHandle {
4868        &self.control_handle
4869    }
4870
4871    fn drop_without_shutdown(mut self) {
4872        // Safety: drops once, never accessed again due to mem::forget
4873        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4874        // Prevent Drop from running (which would shut down the channel)
4875        std::mem::forget(self);
4876    }
4877}
4878
4879impl EchoEchoXunionsWithErrorResponder {
4880    /// Sends a response to the FIDL transaction.
4881    ///
4882    /// Sets the channel to shutdown if an error occurs.
4883    pub fn send(
4884        self,
4885        mut result: Result<Vec<AllTypesXunion>, DefaultEnum>,
4886    ) -> Result<(), fidl::Error> {
4887        let _result = self.send_raw(result);
4888        if _result.is_err() {
4889            self.control_handle.shutdown();
4890        }
4891        self.drop_without_shutdown();
4892        _result
4893    }
4894
4895    /// Similar to "send" but does not shutdown the channel if an error occurs.
4896    pub fn send_no_shutdown_on_err(
4897        self,
4898        mut result: Result<Vec<AllTypesXunion>, DefaultEnum>,
4899    ) -> Result<(), fidl::Error> {
4900        let _result = self.send_raw(result);
4901        self.drop_without_shutdown();
4902        _result
4903    }
4904
4905    fn send_raw(
4906        &self,
4907        mut result: Result<Vec<AllTypesXunion>, DefaultEnum>,
4908    ) -> Result<(), fidl::Error> {
4909        self.control_handle.inner.send::<fidl::encoding::ResultType<
4910            EchoEchoXunionsWithErrorResponse,
4911            DefaultEnum,
4912        >>(
4913            result.as_mut().map_err(|e| *e).map(|value| (value.as_mut_slice(),)),
4914            self.tx_id,
4915            0x75184102667fa766,
4916            fidl::encoding::DynamicFlags::empty(),
4917        )
4918    }
4919}
4920
4921#[must_use = "FIDL methods require a response to be sent"]
4922#[derive(Debug)]
4923pub struct EchoEchoNamedStructResponder {
4924    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4925    tx_id: u32,
4926}
4927
4928/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4929/// if the responder is dropped without sending a response, so that the client
4930/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4931impl std::ops::Drop for EchoEchoNamedStructResponder {
4932    fn drop(&mut self) {
4933        self.control_handle.shutdown();
4934        // Safety: drops once, never accessed again
4935        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4936    }
4937}
4938
4939impl fidl::endpoints::Responder for EchoEchoNamedStructResponder {
4940    type ControlHandle = EchoControlHandle;
4941
4942    fn control_handle(&self) -> &EchoControlHandle {
4943        &self.control_handle
4944    }
4945
4946    fn drop_without_shutdown(mut self) {
4947        // Safety: drops once, never accessed again due to mem::forget
4948        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4949        // Prevent Drop from running (which would shut down the channel)
4950        std::mem::forget(self);
4951    }
4952}
4953
4954impl EchoEchoNamedStructResponder {
4955    /// Sends a response to the FIDL transaction.
4956    ///
4957    /// Sets the channel to shutdown if an error occurs.
4958    pub fn send(
4959        self,
4960        mut value: &fidl_fidl_test_imported::SimpleStruct,
4961    ) -> Result<(), fidl::Error> {
4962        let _result = self.send_raw(value);
4963        if _result.is_err() {
4964            self.control_handle.shutdown();
4965        }
4966        self.drop_without_shutdown();
4967        _result
4968    }
4969
4970    /// Similar to "send" but does not shutdown the channel if an error occurs.
4971    pub fn send_no_shutdown_on_err(
4972        self,
4973        mut value: &fidl_fidl_test_imported::SimpleStruct,
4974    ) -> Result<(), fidl::Error> {
4975        let _result = self.send_raw(value);
4976        self.drop_without_shutdown();
4977        _result
4978    }
4979
4980    fn send_raw(
4981        &self,
4982        mut value: &fidl_fidl_test_imported::SimpleStruct,
4983    ) -> Result<(), fidl::Error> {
4984        self.control_handle.inner.send::<fidl_fidl_test_imported::ResponseStruct>(
4985            (value,),
4986            self.tx_id,
4987            0xf2d4aa9e65f7111,
4988            fidl::encoding::DynamicFlags::empty(),
4989        )
4990    }
4991}
4992
4993#[must_use = "FIDL methods require a response to be sent"]
4994#[derive(Debug)]
4995pub struct EchoEchoNamedStructWithErrorResponder {
4996    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4997    tx_id: u32,
4998}
4999
5000/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
5001/// if the responder is dropped without sending a response, so that the client
5002/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
5003impl std::ops::Drop for EchoEchoNamedStructWithErrorResponder {
5004    fn drop(&mut self) {
5005        self.control_handle.shutdown();
5006        // Safety: drops once, never accessed again
5007        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5008    }
5009}
5010
5011impl fidl::endpoints::Responder for EchoEchoNamedStructWithErrorResponder {
5012    type ControlHandle = EchoControlHandle;
5013
5014    fn control_handle(&self) -> &EchoControlHandle {
5015        &self.control_handle
5016    }
5017
5018    fn drop_without_shutdown(mut self) {
5019        // Safety: drops once, never accessed again due to mem::forget
5020        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5021        // Prevent Drop from running (which would shut down the channel)
5022        std::mem::forget(self);
5023    }
5024}
5025
5026impl EchoEchoNamedStructWithErrorResponder {
5027    /// Sends a response to the FIDL transaction.
5028    ///
5029    /// Sets the channel to shutdown if an error occurs.
5030    pub fn send(
5031        self,
5032        mut result: Result<&fidl_fidl_test_imported::SimpleStruct, u32>,
5033    ) -> Result<(), fidl::Error> {
5034        let _result = self.send_raw(result);
5035        if _result.is_err() {
5036            self.control_handle.shutdown();
5037        }
5038        self.drop_without_shutdown();
5039        _result
5040    }
5041
5042    /// Similar to "send" but does not shutdown the channel if an error occurs.
5043    pub fn send_no_shutdown_on_err(
5044        self,
5045        mut result: Result<&fidl_fidl_test_imported::SimpleStruct, u32>,
5046    ) -> Result<(), fidl::Error> {
5047        let _result = self.send_raw(result);
5048        self.drop_without_shutdown();
5049        _result
5050    }
5051
5052    fn send_raw(
5053        &self,
5054        mut result: Result<&fidl_fidl_test_imported::SimpleStruct, u32>,
5055    ) -> Result<(), fidl::Error> {
5056        self.control_handle.inner.send::<fidl::encoding::ResultType<
5057            fidl_fidl_test_imported::ResponseStruct,
5058            u32,
5059        >>(
5060            result.map(|value| (value,)),
5061            self.tx_id,
5062            0x5766fee9e74442e8,
5063            fidl::encoding::DynamicFlags::empty(),
5064        )
5065    }
5066}
5067
5068#[must_use = "FIDL methods require a response to be sent"]
5069#[derive(Debug)]
5070pub struct EchoEchoTablePayloadResponder {
5071    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
5072    tx_id: u32,
5073}
5074
5075/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
5076/// if the responder is dropped without sending a response, so that the client
5077/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
5078impl std::ops::Drop for EchoEchoTablePayloadResponder {
5079    fn drop(&mut self) {
5080        self.control_handle.shutdown();
5081        // Safety: drops once, never accessed again
5082        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5083    }
5084}
5085
5086impl fidl::endpoints::Responder for EchoEchoTablePayloadResponder {
5087    type ControlHandle = EchoControlHandle;
5088
5089    fn control_handle(&self) -> &EchoControlHandle {
5090        &self.control_handle
5091    }
5092
5093    fn drop_without_shutdown(mut self) {
5094        // Safety: drops once, never accessed again due to mem::forget
5095        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5096        // Prevent Drop from running (which would shut down the channel)
5097        std::mem::forget(self);
5098    }
5099}
5100
5101impl EchoEchoTablePayloadResponder {
5102    /// Sends a response to the FIDL transaction.
5103    ///
5104    /// Sets the channel to shutdown if an error occurs.
5105    pub fn send(self, mut payload: &ResponseTable) -> Result<(), fidl::Error> {
5106        let _result = self.send_raw(payload);
5107        if _result.is_err() {
5108            self.control_handle.shutdown();
5109        }
5110        self.drop_without_shutdown();
5111        _result
5112    }
5113
5114    /// Similar to "send" but does not shutdown the channel if an error occurs.
5115    pub fn send_no_shutdown_on_err(self, mut payload: &ResponseTable) -> Result<(), fidl::Error> {
5116        let _result = self.send_raw(payload);
5117        self.drop_without_shutdown();
5118        _result
5119    }
5120
5121    fn send_raw(&self, mut payload: &ResponseTable) -> Result<(), fidl::Error> {
5122        self.control_handle.inner.send::<ResponseTable>(
5123            payload,
5124            self.tx_id,
5125            0x641d98087378c003,
5126            fidl::encoding::DynamicFlags::empty(),
5127        )
5128    }
5129}
5130
5131#[must_use = "FIDL methods require a response to be sent"]
5132#[derive(Debug)]
5133pub struct EchoEchoTablePayloadWithErrorResponder {
5134    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
5135    tx_id: u32,
5136}
5137
5138/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
5139/// if the responder is dropped without sending a response, so that the client
5140/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
5141impl std::ops::Drop for EchoEchoTablePayloadWithErrorResponder {
5142    fn drop(&mut self) {
5143        self.control_handle.shutdown();
5144        // Safety: drops once, never accessed again
5145        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5146    }
5147}
5148
5149impl fidl::endpoints::Responder for EchoEchoTablePayloadWithErrorResponder {
5150    type ControlHandle = EchoControlHandle;
5151
5152    fn control_handle(&self) -> &EchoControlHandle {
5153        &self.control_handle
5154    }
5155
5156    fn drop_without_shutdown(mut self) {
5157        // Safety: drops once, never accessed again due to mem::forget
5158        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5159        // Prevent Drop from running (which would shut down the channel)
5160        std::mem::forget(self);
5161    }
5162}
5163
5164impl EchoEchoTablePayloadWithErrorResponder {
5165    /// Sends a response to the FIDL transaction.
5166    ///
5167    /// Sets the channel to shutdown if an error occurs.
5168    pub fn send(self, mut result: Result<&ResponseTable, DefaultEnum>) -> Result<(), fidl::Error> {
5169        let _result = self.send_raw(result);
5170        if _result.is_err() {
5171            self.control_handle.shutdown();
5172        }
5173        self.drop_without_shutdown();
5174        _result
5175    }
5176
5177    /// Similar to "send" but does not shutdown the channel if an error occurs.
5178    pub fn send_no_shutdown_on_err(
5179        self,
5180        mut result: Result<&ResponseTable, DefaultEnum>,
5181    ) -> Result<(), fidl::Error> {
5182        let _result = self.send_raw(result);
5183        self.drop_without_shutdown();
5184        _result
5185    }
5186
5187    fn send_raw(&self, mut result: Result<&ResponseTable, DefaultEnum>) -> Result<(), fidl::Error> {
5188        self.control_handle.inner.send::<fidl::encoding::ResultType<ResponseTable, DefaultEnum>>(
5189            result,
5190            self.tx_id,
5191            0x636ed243761ab66d,
5192            fidl::encoding::DynamicFlags::empty(),
5193        )
5194    }
5195}
5196
5197#[must_use = "FIDL methods require a response to be sent"]
5198#[derive(Debug)]
5199pub struct EchoEchoUnionPayloadResponder {
5200    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
5201    tx_id: u32,
5202}
5203
5204/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
5205/// if the responder is dropped without sending a response, so that the client
5206/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
5207impl std::ops::Drop for EchoEchoUnionPayloadResponder {
5208    fn drop(&mut self) {
5209        self.control_handle.shutdown();
5210        // Safety: drops once, never accessed again
5211        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5212    }
5213}
5214
5215impl fidl::endpoints::Responder for EchoEchoUnionPayloadResponder {
5216    type ControlHandle = EchoControlHandle;
5217
5218    fn control_handle(&self) -> &EchoControlHandle {
5219        &self.control_handle
5220    }
5221
5222    fn drop_without_shutdown(mut self) {
5223        // Safety: drops once, never accessed again due to mem::forget
5224        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5225        // Prevent Drop from running (which would shut down the channel)
5226        std::mem::forget(self);
5227    }
5228}
5229
5230impl EchoEchoUnionPayloadResponder {
5231    /// Sends a response to the FIDL transaction.
5232    ///
5233    /// Sets the channel to shutdown if an error occurs.
5234    pub fn send(self, mut payload: &ResponseUnion) -> Result<(), fidl::Error> {
5235        let _result = self.send_raw(payload);
5236        if _result.is_err() {
5237            self.control_handle.shutdown();
5238        }
5239        self.drop_without_shutdown();
5240        _result
5241    }
5242
5243    /// Similar to "send" but does not shutdown the channel if an error occurs.
5244    pub fn send_no_shutdown_on_err(self, mut payload: &ResponseUnion) -> Result<(), fidl::Error> {
5245        let _result = self.send_raw(payload);
5246        self.drop_without_shutdown();
5247        _result
5248    }
5249
5250    fn send_raw(&self, mut payload: &ResponseUnion) -> Result<(), fidl::Error> {
5251        self.control_handle.inner.send::<ResponseUnion>(
5252            payload,
5253            self.tx_id,
5254            0x66def9e793f10c55,
5255            fidl::encoding::DynamicFlags::empty(),
5256        )
5257    }
5258}
5259
5260#[must_use = "FIDL methods require a response to be sent"]
5261#[derive(Debug)]
5262pub struct EchoEchoUnionPayloadWithErrorResponder {
5263    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
5264    tx_id: u32,
5265}
5266
5267/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
5268/// if the responder is dropped without sending a response, so that the client
5269/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
5270impl std::ops::Drop for EchoEchoUnionPayloadWithErrorResponder {
5271    fn drop(&mut self) {
5272        self.control_handle.shutdown();
5273        // Safety: drops once, never accessed again
5274        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5275    }
5276}
5277
5278impl fidl::endpoints::Responder for EchoEchoUnionPayloadWithErrorResponder {
5279    type ControlHandle = EchoControlHandle;
5280
5281    fn control_handle(&self) -> &EchoControlHandle {
5282        &self.control_handle
5283    }
5284
5285    fn drop_without_shutdown(mut self) {
5286        // Safety: drops once, never accessed again due to mem::forget
5287        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5288        // Prevent Drop from running (which would shut down the channel)
5289        std::mem::forget(self);
5290    }
5291}
5292
5293impl EchoEchoUnionPayloadWithErrorResponder {
5294    /// Sends a response to the FIDL transaction.
5295    ///
5296    /// Sets the channel to shutdown if an error occurs.
5297    pub fn send(self, mut result: Result<&ResponseUnion, DefaultEnum>) -> Result<(), fidl::Error> {
5298        let _result = self.send_raw(result);
5299        if _result.is_err() {
5300            self.control_handle.shutdown();
5301        }
5302        self.drop_without_shutdown();
5303        _result
5304    }
5305
5306    /// Similar to "send" but does not shutdown the channel if an error occurs.
5307    pub fn send_no_shutdown_on_err(
5308        self,
5309        mut result: Result<&ResponseUnion, DefaultEnum>,
5310    ) -> Result<(), fidl::Error> {
5311        let _result = self.send_raw(result);
5312        self.drop_without_shutdown();
5313        _result
5314    }
5315
5316    fn send_raw(&self, mut result: Result<&ResponseUnion, DefaultEnum>) -> Result<(), fidl::Error> {
5317        self.control_handle.inner.send::<fidl::encoding::ResultType<ResponseUnion, DefaultEnum>>(
5318            result,
5319            self.tx_id,
5320            0x1be890d6e68ef063,
5321            fidl::encoding::DynamicFlags::empty(),
5322        )
5323    }
5324}
5325
5326mod internal {
5327    use super::*;
5328
5329    impl fidl::encoding::ResourceTypeMarker for ArraysStruct {
5330        type Borrowed<'a> = &'a mut Self;
5331        fn take_or_borrow<'a>(
5332            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
5333        ) -> Self::Borrowed<'a> {
5334            value
5335        }
5336    }
5337
5338    unsafe impl fidl::encoding::TypeMarker for ArraysStruct {
5339        type Owned = Self;
5340
5341        #[inline(always)]
5342        fn inline_align(_context: fidl::encoding::Context) -> usize {
5343            8
5344        }
5345
5346        #[inline(always)]
5347        fn inline_size(_context: fidl::encoding::Context) -> usize {
5348            680
5349        }
5350    }
5351
5352    unsafe impl fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
5353        for &mut ArraysStruct
5354    {
5355        #[inline]
5356        unsafe fn encode(
5357            self,
5358            encoder: &mut fidl::encoding::Encoder<
5359                '_,
5360                fidl::encoding::DefaultFuchsiaResourceDialect,
5361            >,
5362            offset: usize,
5363            _depth: fidl::encoding::Depth,
5364        ) -> fidl::Result<()> {
5365            encoder.debug_check_bounds::<ArraysStruct>(offset);
5366            // Delegate to tuple encoding.
5367            fidl::encoding::Encode::<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
5368                (
5369                    <fidl::encoding::Array<bool, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.bools),
5370                    <fidl::encoding::Array<i8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int8s),
5371                    <fidl::encoding::Array<i16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int16s),
5372                    <fidl::encoding::Array<i32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int32s),
5373                    <fidl::encoding::Array<i64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int64s),
5374                    <fidl::encoding::Array<u8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint8s),
5375                    <fidl::encoding::Array<u16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint16s),
5376                    <fidl::encoding::Array<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint32s),
5377                    <fidl::encoding::Array<u64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint64s),
5378                    <fidl::encoding::Array<f32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.float32s),
5379                    <fidl::encoding::Array<f64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.float64s),
5380                    <fidl::encoding::Array<DefaultEnum, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.enums),
5381                    <fidl::encoding::Array<DefaultBits, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.bits),
5382                    <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),
5383                    <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),
5384                    <fidl::encoding::Array<fidl::encoding::UnboundedString, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.strings),
5385                    <fidl::encoding::Array<fidl::encoding::Optional<fidl::encoding::UnboundedString>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_strings),
5386                    <fidl::encoding::Array<ThisIsAStruct, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.structs),
5387                    <fidl::encoding::Array<fidl::encoding::Boxed<ThisIsAStruct>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_structs),
5388                    <fidl::encoding::Array<ThisIsAUnion, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.unions),
5389                    <fidl::encoding::Array<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_unions),
5390                    <fidl::encoding::Array<fidl::encoding::Array<u32, 3>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.arrays),
5391                    <fidl::encoding::Array<fidl::encoding::UnboundedVector<u32>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.vectors),
5392                    <fidl::encoding::Array<fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_vectors),
5393                    <fidl::encoding::Array<ThisIsATable, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.tables),
5394                    <fidl::encoding::Array<ThisIsAXunion, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.xunions),
5395                ),
5396                encoder, offset, _depth
5397            )
5398        }
5399    }
5400    unsafe impl<
5401        T0: fidl::encoding::Encode<
5402                fidl::encoding::Array<bool, 3>,
5403                fidl::encoding::DefaultFuchsiaResourceDialect,
5404            >,
5405        T1: fidl::encoding::Encode<
5406                fidl::encoding::Array<i8, 3>,
5407                fidl::encoding::DefaultFuchsiaResourceDialect,
5408            >,
5409        T2: fidl::encoding::Encode<
5410                fidl::encoding::Array<i16, 3>,
5411                fidl::encoding::DefaultFuchsiaResourceDialect,
5412            >,
5413        T3: fidl::encoding::Encode<
5414                fidl::encoding::Array<i32, 3>,
5415                fidl::encoding::DefaultFuchsiaResourceDialect,
5416            >,
5417        T4: fidl::encoding::Encode<
5418                fidl::encoding::Array<i64, 3>,
5419                fidl::encoding::DefaultFuchsiaResourceDialect,
5420            >,
5421        T5: fidl::encoding::Encode<
5422                fidl::encoding::Array<u8, 3>,
5423                fidl::encoding::DefaultFuchsiaResourceDialect,
5424            >,
5425        T6: fidl::encoding::Encode<
5426                fidl::encoding::Array<u16, 3>,
5427                fidl::encoding::DefaultFuchsiaResourceDialect,
5428            >,
5429        T7: fidl::encoding::Encode<
5430                fidl::encoding::Array<u32, 3>,
5431                fidl::encoding::DefaultFuchsiaResourceDialect,
5432            >,
5433        T8: fidl::encoding::Encode<
5434                fidl::encoding::Array<u64, 3>,
5435                fidl::encoding::DefaultFuchsiaResourceDialect,
5436            >,
5437        T9: fidl::encoding::Encode<
5438                fidl::encoding::Array<f32, 3>,
5439                fidl::encoding::DefaultFuchsiaResourceDialect,
5440            >,
5441        T10: fidl::encoding::Encode<
5442                fidl::encoding::Array<f64, 3>,
5443                fidl::encoding::DefaultFuchsiaResourceDialect,
5444            >,
5445        T11: fidl::encoding::Encode<
5446                fidl::encoding::Array<DefaultEnum, 3>,
5447                fidl::encoding::DefaultFuchsiaResourceDialect,
5448            >,
5449        T12: fidl::encoding::Encode<
5450                fidl::encoding::Array<DefaultBits, 3>,
5451                fidl::encoding::DefaultFuchsiaResourceDialect,
5452            >,
5453        T13: fidl::encoding::Encode<
5454                fidl::encoding::Array<
5455                    fidl::encoding::HandleType<
5456                        fidl::NullableHandle,
5457                        { fidl::ObjectType::NONE.into_raw() },
5458                        2147483648,
5459                    >,
5460                    3,
5461                >,
5462                fidl::encoding::DefaultFuchsiaResourceDialect,
5463            >,
5464        T14: fidl::encoding::Encode<
5465                fidl::encoding::Array<
5466                    fidl::encoding::Optional<
5467                        fidl::encoding::HandleType<
5468                            fidl::NullableHandle,
5469                            { fidl::ObjectType::NONE.into_raw() },
5470                            2147483648,
5471                        >,
5472                    >,
5473                    3,
5474                >,
5475                fidl::encoding::DefaultFuchsiaResourceDialect,
5476            >,
5477        T15: fidl::encoding::Encode<
5478                fidl::encoding::Array<fidl::encoding::UnboundedString, 3>,
5479                fidl::encoding::DefaultFuchsiaResourceDialect,
5480            >,
5481        T16: fidl::encoding::Encode<
5482                fidl::encoding::Array<fidl::encoding::Optional<fidl::encoding::UnboundedString>, 3>,
5483                fidl::encoding::DefaultFuchsiaResourceDialect,
5484            >,
5485        T17: fidl::encoding::Encode<
5486                fidl::encoding::Array<ThisIsAStruct, 3>,
5487                fidl::encoding::DefaultFuchsiaResourceDialect,
5488            >,
5489        T18: fidl::encoding::Encode<
5490                fidl::encoding::Array<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
5491                fidl::encoding::DefaultFuchsiaResourceDialect,
5492            >,
5493        T19: fidl::encoding::Encode<
5494                fidl::encoding::Array<ThisIsAUnion, 3>,
5495                fidl::encoding::DefaultFuchsiaResourceDialect,
5496            >,
5497        T20: fidl::encoding::Encode<
5498                fidl::encoding::Array<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
5499                fidl::encoding::DefaultFuchsiaResourceDialect,
5500            >,
5501        T21: fidl::encoding::Encode<
5502                fidl::encoding::Array<fidl::encoding::Array<u32, 3>, 3>,
5503                fidl::encoding::DefaultFuchsiaResourceDialect,
5504            >,
5505        T22: fidl::encoding::Encode<
5506                fidl::encoding::Array<fidl::encoding::UnboundedVector<u32>, 3>,
5507                fidl::encoding::DefaultFuchsiaResourceDialect,
5508            >,
5509        T23: fidl::encoding::Encode<
5510                fidl::encoding::Array<
5511                    fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
5512                    3,
5513                >,
5514                fidl::encoding::DefaultFuchsiaResourceDialect,
5515            >,
5516        T24: fidl::encoding::Encode<
5517                fidl::encoding::Array<ThisIsATable, 3>,
5518                fidl::encoding::DefaultFuchsiaResourceDialect,
5519            >,
5520        T25: fidl::encoding::Encode<
5521                fidl::encoding::Array<ThisIsAXunion, 3>,
5522                fidl::encoding::DefaultFuchsiaResourceDialect,
5523            >,
5524    > fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
5525        for (
5526            T0,
5527            T1,
5528            T2,
5529            T3,
5530            T4,
5531            T5,
5532            T6,
5533            T7,
5534            T8,
5535            T9,
5536            T10,
5537            T11,
5538            T12,
5539            T13,
5540            T14,
5541            T15,
5542            T16,
5543            T17,
5544            T18,
5545            T19,
5546            T20,
5547            T21,
5548            T22,
5549            T23,
5550            T24,
5551            T25,
5552        )
5553    {
5554        #[inline]
5555        unsafe fn encode(
5556            self,
5557            encoder: &mut fidl::encoding::Encoder<
5558                '_,
5559                fidl::encoding::DefaultFuchsiaResourceDialect,
5560            >,
5561            offset: usize,
5562            depth: fidl::encoding::Depth,
5563        ) -> fidl::Result<()> {
5564            encoder.debug_check_bounds::<ArraysStruct>(offset);
5565            // Zero out padding regions. There's no need to apply masks
5566            // because the unmasked parts will be overwritten by fields.
5567            unsafe {
5568                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(48);
5569                (ptr as *mut u64).write_unaligned(0);
5570            }
5571            unsafe {
5572                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(56);
5573                (ptr as *mut u64).write_unaligned(0);
5574            }
5575            unsafe {
5576                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(104);
5577                (ptr as *mut u64).write_unaligned(0);
5578            }
5579            unsafe {
5580                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(480);
5581                (ptr as *mut u64).write_unaligned(0);
5582            }
5583            // Write the fields.
5584            self.0.encode(encoder, offset + 0, depth)?;
5585            self.1.encode(encoder, offset + 3, depth)?;
5586            self.2.encode(encoder, offset + 6, depth)?;
5587            self.3.encode(encoder, offset + 12, depth)?;
5588            self.4.encode(encoder, offset + 24, depth)?;
5589            self.5.encode(encoder, offset + 48, depth)?;
5590            self.6.encode(encoder, offset + 52, depth)?;
5591            self.7.encode(encoder, offset + 60, depth)?;
5592            self.8.encode(encoder, offset + 72, depth)?;
5593            self.9.encode(encoder, offset + 96, depth)?;
5594            self.10.encode(encoder, offset + 112, depth)?;
5595            self.11.encode(encoder, offset + 136, depth)?;
5596            self.12.encode(encoder, offset + 148, depth)?;
5597            self.13.encode(encoder, offset + 160, depth)?;
5598            self.14.encode(encoder, offset + 172, depth)?;
5599            self.15.encode(encoder, offset + 184, depth)?;
5600            self.16.encode(encoder, offset + 232, depth)?;
5601            self.17.encode(encoder, offset + 280, depth)?;
5602            self.18.encode(encoder, offset + 328, depth)?;
5603            self.19.encode(encoder, offset + 352, depth)?;
5604            self.20.encode(encoder, offset + 400, depth)?;
5605            self.21.encode(encoder, offset + 448, depth)?;
5606            self.22.encode(encoder, offset + 488, depth)?;
5607            self.23.encode(encoder, offset + 536, depth)?;
5608            self.24.encode(encoder, offset + 584, depth)?;
5609            self.25.encode(encoder, offset + 632, depth)?;
5610            Ok(())
5611        }
5612    }
5613
5614    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for ArraysStruct {
5615        #[inline(always)]
5616        fn new_empty() -> Self {
5617            Self {
5618                bools: fidl::new_empty!(fidl::encoding::Array<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5619                int8s: fidl::new_empty!(fidl::encoding::Array<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5620                int16s: fidl::new_empty!(fidl::encoding::Array<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5621                int32s: fidl::new_empty!(fidl::encoding::Array<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5622                int64s: fidl::new_empty!(fidl::encoding::Array<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5623                uint8s: fidl::new_empty!(fidl::encoding::Array<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5624                uint16s: fidl::new_empty!(fidl::encoding::Array<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5625                uint32s: fidl::new_empty!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5626                uint64s: fidl::new_empty!(fidl::encoding::Array<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5627                float32s: fidl::new_empty!(fidl::encoding::Array<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5628                float64s: fidl::new_empty!(fidl::encoding::Array<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5629                enums: fidl::new_empty!(fidl::encoding::Array<DefaultEnum, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5630                bits: fidl::new_empty!(fidl::encoding::Array<DefaultBits, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5631                handles: fidl::new_empty!(
5632                    fidl::encoding::Array<
5633                        fidl::encoding::HandleType<
5634                            fidl::NullableHandle,
5635                            { fidl::ObjectType::NONE.into_raw() },
5636                            2147483648,
5637                        >,
5638                        3,
5639                    >,
5640                    fidl::encoding::DefaultFuchsiaResourceDialect
5641                ),
5642                nullable_handles: fidl::new_empty!(
5643                    fidl::encoding::Array<
5644                        fidl::encoding::Optional<
5645                            fidl::encoding::HandleType<
5646                                fidl::NullableHandle,
5647                                { fidl::ObjectType::NONE.into_raw() },
5648                                2147483648,
5649                            >,
5650                        >,
5651                        3,
5652                    >,
5653                    fidl::encoding::DefaultFuchsiaResourceDialect
5654                ),
5655                strings: fidl::new_empty!(fidl::encoding::Array<fidl::encoding::UnboundedString, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5656                nullable_strings: fidl::new_empty!(
5657                    fidl::encoding::Array<
5658                        fidl::encoding::Optional<fidl::encoding::UnboundedString>,
5659                        3,
5660                    >,
5661                    fidl::encoding::DefaultFuchsiaResourceDialect
5662                ),
5663                structs: fidl::new_empty!(fidl::encoding::Array<ThisIsAStruct, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5664                nullable_structs: fidl::new_empty!(
5665                    fidl::encoding::Array<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
5666                    fidl::encoding::DefaultFuchsiaResourceDialect
5667                ),
5668                unions: fidl::new_empty!(fidl::encoding::Array<ThisIsAUnion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5669                nullable_unions: fidl::new_empty!(
5670                    fidl::encoding::Array<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
5671                    fidl::encoding::DefaultFuchsiaResourceDialect
5672                ),
5673                arrays: fidl::new_empty!(
5674                    fidl::encoding::Array<fidl::encoding::Array<u32, 3>, 3>,
5675                    fidl::encoding::DefaultFuchsiaResourceDialect
5676                ),
5677                vectors: fidl::new_empty!(
5678                    fidl::encoding::Array<fidl::encoding::UnboundedVector<u32>, 3>,
5679                    fidl::encoding::DefaultFuchsiaResourceDialect
5680                ),
5681                nullable_vectors: fidl::new_empty!(
5682                    fidl::encoding::Array<
5683                        fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
5684                        3,
5685                    >,
5686                    fidl::encoding::DefaultFuchsiaResourceDialect
5687                ),
5688                tables: fidl::new_empty!(fidl::encoding::Array<ThisIsATable, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5689                xunions: fidl::new_empty!(fidl::encoding::Array<ThisIsAXunion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5690            }
5691        }
5692
5693        #[inline]
5694        unsafe fn decode(
5695            &mut self,
5696            decoder: &mut fidl::encoding::Decoder<
5697                '_,
5698                fidl::encoding::DefaultFuchsiaResourceDialect,
5699            >,
5700            offset: usize,
5701            _depth: fidl::encoding::Depth,
5702        ) -> fidl::Result<()> {
5703            decoder.debug_check_bounds::<Self>(offset);
5704            // Verify that padding bytes are zero.
5705            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(48) };
5706            let padval = unsafe { (ptr as *const u64).read_unaligned() };
5707            let mask = 0xff000000u64;
5708            let maskedval = padval & mask;
5709            if maskedval != 0 {
5710                return Err(fidl::Error::NonZeroPadding {
5711                    padding_start: offset + 48 + ((mask as u64).trailing_zeros() / 8) as usize,
5712                });
5713            }
5714            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(56) };
5715            let padval = unsafe { (ptr as *const u64).read_unaligned() };
5716            let mask = 0xffff0000u64;
5717            let maskedval = padval & mask;
5718            if maskedval != 0 {
5719                return Err(fidl::Error::NonZeroPadding {
5720                    padding_start: offset + 56 + ((mask as u64).trailing_zeros() / 8) as usize,
5721                });
5722            }
5723            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(104) };
5724            let padval = unsafe { (ptr as *const u64).read_unaligned() };
5725            let mask = 0xffffffff00000000u64;
5726            let maskedval = padval & mask;
5727            if maskedval != 0 {
5728                return Err(fidl::Error::NonZeroPadding {
5729                    padding_start: offset + 104 + ((mask as u64).trailing_zeros() / 8) as usize,
5730                });
5731            }
5732            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(480) };
5733            let padval = unsafe { (ptr as *const u64).read_unaligned() };
5734            let mask = 0xffffffff00000000u64;
5735            let maskedval = padval & mask;
5736            if maskedval != 0 {
5737                return Err(fidl::Error::NonZeroPadding {
5738                    padding_start: offset + 480 + ((mask as u64).trailing_zeros() / 8) as usize,
5739                });
5740            }
5741            fidl::decode!(fidl::encoding::Array<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.bools, decoder, offset + 0, _depth)?;
5742            fidl::decode!(fidl::encoding::Array<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int8s, decoder, offset + 3, _depth)?;
5743            fidl::decode!(fidl::encoding::Array<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int16s, decoder, offset + 6, _depth)?;
5744            fidl::decode!(fidl::encoding::Array<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int32s, decoder, offset + 12, _depth)?;
5745            fidl::decode!(fidl::encoding::Array<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int64s, decoder, offset + 24, _depth)?;
5746            fidl::decode!(fidl::encoding::Array<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint8s, decoder, offset + 48, _depth)?;
5747            fidl::decode!(fidl::encoding::Array<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint16s, decoder, offset + 52, _depth)?;
5748            fidl::decode!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint32s, decoder, offset + 60, _depth)?;
5749            fidl::decode!(fidl::encoding::Array<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint64s, decoder, offset + 72, _depth)?;
5750            fidl::decode!(fidl::encoding::Array<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.float32s, decoder, offset + 96, _depth)?;
5751            fidl::decode!(fidl::encoding::Array<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.float64s, decoder, offset + 112, _depth)?;
5752            fidl::decode!(fidl::encoding::Array<DefaultEnum, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.enums, decoder, offset + 136, _depth)?;
5753            fidl::decode!(fidl::encoding::Array<DefaultBits, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.bits, decoder, offset + 148, _depth)?;
5754            fidl::decode!(
5755                fidl::encoding::Array<
5756                    fidl::encoding::HandleType<
5757                        fidl::NullableHandle,
5758                        { fidl::ObjectType::NONE.into_raw() },
5759                        2147483648,
5760                    >,
5761                    3,
5762                >,
5763                fidl::encoding::DefaultFuchsiaResourceDialect,
5764                &mut self.handles,
5765                decoder,
5766                offset + 160,
5767                _depth
5768            )?;
5769            fidl::decode!(
5770                fidl::encoding::Array<
5771                    fidl::encoding::Optional<
5772                        fidl::encoding::HandleType<
5773                            fidl::NullableHandle,
5774                            { fidl::ObjectType::NONE.into_raw() },
5775                            2147483648,
5776                        >,
5777                    >,
5778                    3,
5779                >,
5780                fidl::encoding::DefaultFuchsiaResourceDialect,
5781                &mut self.nullable_handles,
5782                decoder,
5783                offset + 172,
5784                _depth
5785            )?;
5786            fidl::decode!(fidl::encoding::Array<fidl::encoding::UnboundedString, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.strings, decoder, offset + 184, _depth)?;
5787            fidl::decode!(
5788                fidl::encoding::Array<fidl::encoding::Optional<fidl::encoding::UnboundedString>, 3>,
5789                fidl::encoding::DefaultFuchsiaResourceDialect,
5790                &mut self.nullable_strings,
5791                decoder,
5792                offset + 232,
5793                _depth
5794            )?;
5795            fidl::decode!(fidl::encoding::Array<ThisIsAStruct, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.structs, decoder, offset + 280, _depth)?;
5796            fidl::decode!(
5797                fidl::encoding::Array<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
5798                fidl::encoding::DefaultFuchsiaResourceDialect,
5799                &mut self.nullable_structs,
5800                decoder,
5801                offset + 328,
5802                _depth
5803            )?;
5804            fidl::decode!(fidl::encoding::Array<ThisIsAUnion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.unions, decoder, offset + 352, _depth)?;
5805            fidl::decode!(
5806                fidl::encoding::Array<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
5807                fidl::encoding::DefaultFuchsiaResourceDialect,
5808                &mut self.nullable_unions,
5809                decoder,
5810                offset + 400,
5811                _depth
5812            )?;
5813            fidl::decode!(
5814                fidl::encoding::Array<fidl::encoding::Array<u32, 3>, 3>,
5815                fidl::encoding::DefaultFuchsiaResourceDialect,
5816                &mut self.arrays,
5817                decoder,
5818                offset + 448,
5819                _depth
5820            )?;
5821            fidl::decode!(
5822                fidl::encoding::Array<fidl::encoding::UnboundedVector<u32>, 3>,
5823                fidl::encoding::DefaultFuchsiaResourceDialect,
5824                &mut self.vectors,
5825                decoder,
5826                offset + 488,
5827                _depth
5828            )?;
5829            fidl::decode!(
5830                fidl::encoding::Array<
5831                    fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
5832                    3,
5833                >,
5834                fidl::encoding::DefaultFuchsiaResourceDialect,
5835                &mut self.nullable_vectors,
5836                decoder,
5837                offset + 536,
5838                _depth
5839            )?;
5840            fidl::decode!(fidl::encoding::Array<ThisIsATable, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.tables, decoder, offset + 584, _depth)?;
5841            fidl::decode!(fidl::encoding::Array<ThisIsAXunion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.xunions, decoder, offset + 632, _depth)?;
5842            Ok(())
5843        }
5844    }
5845
5846    impl fidl::encoding::ResourceTypeMarker for EchoEchoArraysRequest {
5847        type Borrowed<'a> = &'a mut Self;
5848        fn take_or_borrow<'a>(
5849            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
5850        ) -> Self::Borrowed<'a> {
5851            value
5852        }
5853    }
5854
5855    unsafe impl fidl::encoding::TypeMarker for EchoEchoArraysRequest {
5856        type Owned = Self;
5857
5858        #[inline(always)]
5859        fn inline_align(_context: fidl::encoding::Context) -> usize {
5860            8
5861        }
5862
5863        #[inline(always)]
5864        fn inline_size(_context: fidl::encoding::Context) -> usize {
5865            696
5866        }
5867    }
5868
5869    unsafe impl
5870        fidl::encoding::Encode<EchoEchoArraysRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
5871        for &mut EchoEchoArraysRequest
5872    {
5873        #[inline]
5874        unsafe fn encode(
5875            self,
5876            encoder: &mut fidl::encoding::Encoder<
5877                '_,
5878                fidl::encoding::DefaultFuchsiaResourceDialect,
5879            >,
5880            offset: usize,
5881            _depth: fidl::encoding::Depth,
5882        ) -> fidl::Result<()> {
5883            encoder.debug_check_bounds::<EchoEchoArraysRequest>(offset);
5884            // Delegate to tuple encoding.
5885            fidl::encoding::Encode::<
5886                EchoEchoArraysRequest,
5887                fidl::encoding::DefaultFuchsiaResourceDialect,
5888            >::encode(
5889                (
5890                    <ArraysStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
5891                        &mut self.value,
5892                    ),
5893                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
5894                        &self.forward_to_server,
5895                    ),
5896                ),
5897                encoder,
5898                offset,
5899                _depth,
5900            )
5901        }
5902    }
5903    unsafe impl<
5904        T0: fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
5905        T1: fidl::encoding::Encode<
5906                fidl::encoding::UnboundedString,
5907                fidl::encoding::DefaultFuchsiaResourceDialect,
5908            >,
5909    >
5910        fidl::encoding::Encode<EchoEchoArraysRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
5911        for (T0, T1)
5912    {
5913        #[inline]
5914        unsafe fn encode(
5915            self,
5916            encoder: &mut fidl::encoding::Encoder<
5917                '_,
5918                fidl::encoding::DefaultFuchsiaResourceDialect,
5919            >,
5920            offset: usize,
5921            depth: fidl::encoding::Depth,
5922        ) -> fidl::Result<()> {
5923            encoder.debug_check_bounds::<EchoEchoArraysRequest>(offset);
5924            // Zero out padding regions. There's no need to apply masks
5925            // because the unmasked parts will be overwritten by fields.
5926            // Write the fields.
5927            self.0.encode(encoder, offset + 0, depth)?;
5928            self.1.encode(encoder, offset + 680, depth)?;
5929            Ok(())
5930        }
5931    }
5932
5933    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
5934        for EchoEchoArraysRequest
5935    {
5936        #[inline(always)]
5937        fn new_empty() -> Self {
5938            Self {
5939                value: fidl::new_empty!(
5940                    ArraysStruct,
5941                    fidl::encoding::DefaultFuchsiaResourceDialect
5942                ),
5943                forward_to_server: fidl::new_empty!(
5944                    fidl::encoding::UnboundedString,
5945                    fidl::encoding::DefaultFuchsiaResourceDialect
5946                ),
5947            }
5948        }
5949
5950        #[inline]
5951        unsafe fn decode(
5952            &mut self,
5953            decoder: &mut fidl::encoding::Decoder<
5954                '_,
5955                fidl::encoding::DefaultFuchsiaResourceDialect,
5956            >,
5957            offset: usize,
5958            _depth: fidl::encoding::Depth,
5959        ) -> fidl::Result<()> {
5960            decoder.debug_check_bounds::<Self>(offset);
5961            // Verify that padding bytes are zero.
5962            fidl::decode!(
5963                ArraysStruct,
5964                fidl::encoding::DefaultFuchsiaResourceDialect,
5965                &mut self.value,
5966                decoder,
5967                offset + 0,
5968                _depth
5969            )?;
5970            fidl::decode!(
5971                fidl::encoding::UnboundedString,
5972                fidl::encoding::DefaultFuchsiaResourceDialect,
5973                &mut self.forward_to_server,
5974                decoder,
5975                offset + 680,
5976                _depth
5977            )?;
5978            Ok(())
5979        }
5980    }
5981
5982    impl fidl::encoding::ResourceTypeMarker for EchoEchoArraysResponse {
5983        type Borrowed<'a> = &'a mut Self;
5984        fn take_or_borrow<'a>(
5985            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
5986        ) -> Self::Borrowed<'a> {
5987            value
5988        }
5989    }
5990
5991    unsafe impl fidl::encoding::TypeMarker for EchoEchoArraysResponse {
5992        type Owned = Self;
5993
5994        #[inline(always)]
5995        fn inline_align(_context: fidl::encoding::Context) -> usize {
5996            8
5997        }
5998
5999        #[inline(always)]
6000        fn inline_size(_context: fidl::encoding::Context) -> usize {
6001            680
6002        }
6003    }
6004
6005    unsafe impl
6006        fidl::encoding::Encode<
6007            EchoEchoArraysResponse,
6008            fidl::encoding::DefaultFuchsiaResourceDialect,
6009        > for &mut EchoEchoArraysResponse
6010    {
6011        #[inline]
6012        unsafe fn encode(
6013            self,
6014            encoder: &mut fidl::encoding::Encoder<
6015                '_,
6016                fidl::encoding::DefaultFuchsiaResourceDialect,
6017            >,
6018            offset: usize,
6019            _depth: fidl::encoding::Depth,
6020        ) -> fidl::Result<()> {
6021            encoder.debug_check_bounds::<EchoEchoArraysResponse>(offset);
6022            // Delegate to tuple encoding.
6023            fidl::encoding::Encode::<
6024                EchoEchoArraysResponse,
6025                fidl::encoding::DefaultFuchsiaResourceDialect,
6026            >::encode(
6027                (<ArraysStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
6028                    &mut self.value,
6029                ),),
6030                encoder,
6031                offset,
6032                _depth,
6033            )
6034        }
6035    }
6036    unsafe impl<
6037        T0: fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
6038    >
6039        fidl::encoding::Encode<
6040            EchoEchoArraysResponse,
6041            fidl::encoding::DefaultFuchsiaResourceDialect,
6042        > for (T0,)
6043    {
6044        #[inline]
6045        unsafe fn encode(
6046            self,
6047            encoder: &mut fidl::encoding::Encoder<
6048                '_,
6049                fidl::encoding::DefaultFuchsiaResourceDialect,
6050            >,
6051            offset: usize,
6052            depth: fidl::encoding::Depth,
6053        ) -> fidl::Result<()> {
6054            encoder.debug_check_bounds::<EchoEchoArraysResponse>(offset);
6055            // Zero out padding regions. There's no need to apply masks
6056            // because the unmasked parts will be overwritten by fields.
6057            // Write the fields.
6058            self.0.encode(encoder, offset + 0, depth)?;
6059            Ok(())
6060        }
6061    }
6062
6063    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6064        for EchoEchoArraysResponse
6065    {
6066        #[inline(always)]
6067        fn new_empty() -> Self {
6068            Self {
6069                value: fidl::new_empty!(
6070                    ArraysStruct,
6071                    fidl::encoding::DefaultFuchsiaResourceDialect
6072                ),
6073            }
6074        }
6075
6076        #[inline]
6077        unsafe fn decode(
6078            &mut self,
6079            decoder: &mut fidl::encoding::Decoder<
6080                '_,
6081                fidl::encoding::DefaultFuchsiaResourceDialect,
6082            >,
6083            offset: usize,
6084            _depth: fidl::encoding::Depth,
6085        ) -> fidl::Result<()> {
6086            decoder.debug_check_bounds::<Self>(offset);
6087            // Verify that padding bytes are zero.
6088            fidl::decode!(
6089                ArraysStruct,
6090                fidl::encoding::DefaultFuchsiaResourceDialect,
6091                &mut self.value,
6092                decoder,
6093                offset + 0,
6094                _depth
6095            )?;
6096            Ok(())
6097        }
6098    }
6099
6100    impl fidl::encoding::ResourceTypeMarker for EchoEchoArraysWithErrorRequest {
6101        type Borrowed<'a> = &'a mut Self;
6102        fn take_or_borrow<'a>(
6103            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6104        ) -> Self::Borrowed<'a> {
6105            value
6106        }
6107    }
6108
6109    unsafe impl fidl::encoding::TypeMarker for EchoEchoArraysWithErrorRequest {
6110        type Owned = Self;
6111
6112        #[inline(always)]
6113        fn inline_align(_context: fidl::encoding::Context) -> usize {
6114            8
6115        }
6116
6117        #[inline(always)]
6118        fn inline_size(_context: fidl::encoding::Context) -> usize {
6119            712
6120        }
6121    }
6122
6123    unsafe impl
6124        fidl::encoding::Encode<
6125            EchoEchoArraysWithErrorRequest,
6126            fidl::encoding::DefaultFuchsiaResourceDialect,
6127        > for &mut EchoEchoArraysWithErrorRequest
6128    {
6129        #[inline]
6130        unsafe fn encode(
6131            self,
6132            encoder: &mut fidl::encoding::Encoder<
6133                '_,
6134                fidl::encoding::DefaultFuchsiaResourceDialect,
6135            >,
6136            offset: usize,
6137            _depth: fidl::encoding::Depth,
6138        ) -> fidl::Result<()> {
6139            encoder.debug_check_bounds::<EchoEchoArraysWithErrorRequest>(offset);
6140            // Delegate to tuple encoding.
6141            fidl::encoding::Encode::<
6142                EchoEchoArraysWithErrorRequest,
6143                fidl::encoding::DefaultFuchsiaResourceDialect,
6144            >::encode(
6145                (
6146                    <ArraysStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
6147                        &mut self.value,
6148                    ),
6149                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
6150                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
6151                        &self.forward_to_server,
6152                    ),
6153                    <RespondWith as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
6154                ),
6155                encoder,
6156                offset,
6157                _depth,
6158            )
6159        }
6160    }
6161    unsafe impl<
6162        T0: fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
6163        T1: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
6164        T2: fidl::encoding::Encode<
6165                fidl::encoding::UnboundedString,
6166                fidl::encoding::DefaultFuchsiaResourceDialect,
6167            >,
6168        T3: fidl::encoding::Encode<RespondWith, fidl::encoding::DefaultFuchsiaResourceDialect>,
6169    >
6170        fidl::encoding::Encode<
6171            EchoEchoArraysWithErrorRequest,
6172            fidl::encoding::DefaultFuchsiaResourceDialect,
6173        > for (T0, T1, T2, T3)
6174    {
6175        #[inline]
6176        unsafe fn encode(
6177            self,
6178            encoder: &mut fidl::encoding::Encoder<
6179                '_,
6180                fidl::encoding::DefaultFuchsiaResourceDialect,
6181            >,
6182            offset: usize,
6183            depth: fidl::encoding::Depth,
6184        ) -> fidl::Result<()> {
6185            encoder.debug_check_bounds::<EchoEchoArraysWithErrorRequest>(offset);
6186            // Zero out padding regions. There's no need to apply masks
6187            // because the unmasked parts will be overwritten by fields.
6188            unsafe {
6189                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(680);
6190                (ptr as *mut u64).write_unaligned(0);
6191            }
6192            unsafe {
6193                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(704);
6194                (ptr as *mut u64).write_unaligned(0);
6195            }
6196            // Write the fields.
6197            self.0.encode(encoder, offset + 0, depth)?;
6198            self.1.encode(encoder, offset + 680, depth)?;
6199            self.2.encode(encoder, offset + 688, depth)?;
6200            self.3.encode(encoder, offset + 704, depth)?;
6201            Ok(())
6202        }
6203    }
6204
6205    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6206        for EchoEchoArraysWithErrorRequest
6207    {
6208        #[inline(always)]
6209        fn new_empty() -> Self {
6210            Self {
6211                value: fidl::new_empty!(
6212                    ArraysStruct,
6213                    fidl::encoding::DefaultFuchsiaResourceDialect
6214                ),
6215                result_err: fidl::new_empty!(
6216                    DefaultEnum,
6217                    fidl::encoding::DefaultFuchsiaResourceDialect
6218                ),
6219                forward_to_server: fidl::new_empty!(
6220                    fidl::encoding::UnboundedString,
6221                    fidl::encoding::DefaultFuchsiaResourceDialect
6222                ),
6223                result_variant: fidl::new_empty!(
6224                    RespondWith,
6225                    fidl::encoding::DefaultFuchsiaResourceDialect
6226                ),
6227            }
6228        }
6229
6230        #[inline]
6231        unsafe fn decode(
6232            &mut self,
6233            decoder: &mut fidl::encoding::Decoder<
6234                '_,
6235                fidl::encoding::DefaultFuchsiaResourceDialect,
6236            >,
6237            offset: usize,
6238            _depth: fidl::encoding::Depth,
6239        ) -> fidl::Result<()> {
6240            decoder.debug_check_bounds::<Self>(offset);
6241            // Verify that padding bytes are zero.
6242            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(680) };
6243            let padval = unsafe { (ptr as *const u64).read_unaligned() };
6244            let mask = 0xffffffff00000000u64;
6245            let maskedval = padval & mask;
6246            if maskedval != 0 {
6247                return Err(fidl::Error::NonZeroPadding {
6248                    padding_start: offset + 680 + ((mask as u64).trailing_zeros() / 8) as usize,
6249                });
6250            }
6251            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(704) };
6252            let padval = unsafe { (ptr as *const u64).read_unaligned() };
6253            let mask = 0xffffffff00000000u64;
6254            let maskedval = padval & mask;
6255            if maskedval != 0 {
6256                return Err(fidl::Error::NonZeroPadding {
6257                    padding_start: offset + 704 + ((mask as u64).trailing_zeros() / 8) as usize,
6258                });
6259            }
6260            fidl::decode!(
6261                ArraysStruct,
6262                fidl::encoding::DefaultFuchsiaResourceDialect,
6263                &mut self.value,
6264                decoder,
6265                offset + 0,
6266                _depth
6267            )?;
6268            fidl::decode!(
6269                DefaultEnum,
6270                fidl::encoding::DefaultFuchsiaResourceDialect,
6271                &mut self.result_err,
6272                decoder,
6273                offset + 680,
6274                _depth
6275            )?;
6276            fidl::decode!(
6277                fidl::encoding::UnboundedString,
6278                fidl::encoding::DefaultFuchsiaResourceDialect,
6279                &mut self.forward_to_server,
6280                decoder,
6281                offset + 688,
6282                _depth
6283            )?;
6284            fidl::decode!(
6285                RespondWith,
6286                fidl::encoding::DefaultFuchsiaResourceDialect,
6287                &mut self.result_variant,
6288                decoder,
6289                offset + 704,
6290                _depth
6291            )?;
6292            Ok(())
6293        }
6294    }
6295
6296    impl fidl::encoding::ResourceTypeMarker for EchoEchoEventRequest {
6297        type Borrowed<'a> = &'a mut Self;
6298        fn take_or_borrow<'a>(
6299            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6300        ) -> Self::Borrowed<'a> {
6301            value
6302        }
6303    }
6304
6305    unsafe impl fidl::encoding::TypeMarker for EchoEchoEventRequest {
6306        type Owned = Self;
6307
6308        #[inline(always)]
6309        fn inline_align(_context: fidl::encoding::Context) -> usize {
6310            8
6311        }
6312
6313        #[inline(always)]
6314        fn inline_size(_context: fidl::encoding::Context) -> usize {
6315            2912
6316        }
6317    }
6318
6319    unsafe impl
6320        fidl::encoding::Encode<EchoEchoEventRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
6321        for &mut EchoEchoEventRequest
6322    {
6323        #[inline]
6324        unsafe fn encode(
6325            self,
6326            encoder: &mut fidl::encoding::Encoder<
6327                '_,
6328                fidl::encoding::DefaultFuchsiaResourceDialect,
6329            >,
6330            offset: usize,
6331            _depth: fidl::encoding::Depth,
6332        ) -> fidl::Result<()> {
6333            encoder.debug_check_bounds::<EchoEchoEventRequest>(offset);
6334            // Delegate to tuple encoding.
6335            fidl::encoding::Encode::<
6336                EchoEchoEventRequest,
6337                fidl::encoding::DefaultFuchsiaResourceDialect,
6338            >::encode(
6339                (<Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),),
6340                encoder,
6341                offset,
6342                _depth,
6343            )
6344        }
6345    }
6346    unsafe impl<T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>>
6347        fidl::encoding::Encode<EchoEchoEventRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
6348        for (T0,)
6349    {
6350        #[inline]
6351        unsafe fn encode(
6352            self,
6353            encoder: &mut fidl::encoding::Encoder<
6354                '_,
6355                fidl::encoding::DefaultFuchsiaResourceDialect,
6356            >,
6357            offset: usize,
6358            depth: fidl::encoding::Depth,
6359        ) -> fidl::Result<()> {
6360            encoder.debug_check_bounds::<EchoEchoEventRequest>(offset);
6361            // Zero out padding regions. There's no need to apply masks
6362            // because the unmasked parts will be overwritten by fields.
6363            // Write the fields.
6364            self.0.encode(encoder, offset + 0, depth)?;
6365            Ok(())
6366        }
6367    }
6368
6369    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6370        for EchoEchoEventRequest
6371    {
6372        #[inline(always)]
6373        fn new_empty() -> Self {
6374            Self { value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect) }
6375        }
6376
6377        #[inline]
6378        unsafe fn decode(
6379            &mut self,
6380            decoder: &mut fidl::encoding::Decoder<
6381                '_,
6382                fidl::encoding::DefaultFuchsiaResourceDialect,
6383            >,
6384            offset: usize,
6385            _depth: fidl::encoding::Depth,
6386        ) -> fidl::Result<()> {
6387            decoder.debug_check_bounds::<Self>(offset);
6388            // Verify that padding bytes are zero.
6389            fidl::decode!(
6390                Struct,
6391                fidl::encoding::DefaultFuchsiaResourceDialect,
6392                &mut self.value,
6393                decoder,
6394                offset + 0,
6395                _depth
6396            )?;
6397            Ok(())
6398        }
6399    }
6400
6401    impl fidl::encoding::ResourceTypeMarker for EchoEchoStructNoRetValRequest {
6402        type Borrowed<'a> = &'a mut Self;
6403        fn take_or_borrow<'a>(
6404            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6405        ) -> Self::Borrowed<'a> {
6406            value
6407        }
6408    }
6409
6410    unsafe impl fidl::encoding::TypeMarker for EchoEchoStructNoRetValRequest {
6411        type Owned = Self;
6412
6413        #[inline(always)]
6414        fn inline_align(_context: fidl::encoding::Context) -> usize {
6415            8
6416        }
6417
6418        #[inline(always)]
6419        fn inline_size(_context: fidl::encoding::Context) -> usize {
6420            2928
6421        }
6422    }
6423
6424    unsafe impl
6425        fidl::encoding::Encode<
6426            EchoEchoStructNoRetValRequest,
6427            fidl::encoding::DefaultFuchsiaResourceDialect,
6428        > for &mut EchoEchoStructNoRetValRequest
6429    {
6430        #[inline]
6431        unsafe fn encode(
6432            self,
6433            encoder: &mut fidl::encoding::Encoder<
6434                '_,
6435                fidl::encoding::DefaultFuchsiaResourceDialect,
6436            >,
6437            offset: usize,
6438            _depth: fidl::encoding::Depth,
6439        ) -> fidl::Result<()> {
6440            encoder.debug_check_bounds::<EchoEchoStructNoRetValRequest>(offset);
6441            // Delegate to tuple encoding.
6442            fidl::encoding::Encode::<
6443                EchoEchoStructNoRetValRequest,
6444                fidl::encoding::DefaultFuchsiaResourceDialect,
6445            >::encode(
6446                (
6447                    <Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
6448                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
6449                        &self.forward_to_server,
6450                    ),
6451                ),
6452                encoder,
6453                offset,
6454                _depth,
6455            )
6456        }
6457    }
6458    unsafe impl<
6459        T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>,
6460        T1: fidl::encoding::Encode<
6461                fidl::encoding::UnboundedString,
6462                fidl::encoding::DefaultFuchsiaResourceDialect,
6463            >,
6464    >
6465        fidl::encoding::Encode<
6466            EchoEchoStructNoRetValRequest,
6467            fidl::encoding::DefaultFuchsiaResourceDialect,
6468        > for (T0, T1)
6469    {
6470        #[inline]
6471        unsafe fn encode(
6472            self,
6473            encoder: &mut fidl::encoding::Encoder<
6474                '_,
6475                fidl::encoding::DefaultFuchsiaResourceDialect,
6476            >,
6477            offset: usize,
6478            depth: fidl::encoding::Depth,
6479        ) -> fidl::Result<()> {
6480            encoder.debug_check_bounds::<EchoEchoStructNoRetValRequest>(offset);
6481            // Zero out padding regions. There's no need to apply masks
6482            // because the unmasked parts will be overwritten by fields.
6483            // Write the fields.
6484            self.0.encode(encoder, offset + 0, depth)?;
6485            self.1.encode(encoder, offset + 2912, depth)?;
6486            Ok(())
6487        }
6488    }
6489
6490    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6491        for EchoEchoStructNoRetValRequest
6492    {
6493        #[inline(always)]
6494        fn new_empty() -> Self {
6495            Self {
6496                value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect),
6497                forward_to_server: fidl::new_empty!(
6498                    fidl::encoding::UnboundedString,
6499                    fidl::encoding::DefaultFuchsiaResourceDialect
6500                ),
6501            }
6502        }
6503
6504        #[inline]
6505        unsafe fn decode(
6506            &mut self,
6507            decoder: &mut fidl::encoding::Decoder<
6508                '_,
6509                fidl::encoding::DefaultFuchsiaResourceDialect,
6510            >,
6511            offset: usize,
6512            _depth: fidl::encoding::Depth,
6513        ) -> fidl::Result<()> {
6514            decoder.debug_check_bounds::<Self>(offset);
6515            // Verify that padding bytes are zero.
6516            fidl::decode!(
6517                Struct,
6518                fidl::encoding::DefaultFuchsiaResourceDialect,
6519                &mut self.value,
6520                decoder,
6521                offset + 0,
6522                _depth
6523            )?;
6524            fidl::decode!(
6525                fidl::encoding::UnboundedString,
6526                fidl::encoding::DefaultFuchsiaResourceDialect,
6527                &mut self.forward_to_server,
6528                decoder,
6529                offset + 2912,
6530                _depth
6531            )?;
6532            Ok(())
6533        }
6534    }
6535
6536    impl fidl::encoding::ResourceTypeMarker for EchoEchoStructRequest {
6537        type Borrowed<'a> = &'a mut Self;
6538        fn take_or_borrow<'a>(
6539            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6540        ) -> Self::Borrowed<'a> {
6541            value
6542        }
6543    }
6544
6545    unsafe impl fidl::encoding::TypeMarker for EchoEchoStructRequest {
6546        type Owned = Self;
6547
6548        #[inline(always)]
6549        fn inline_align(_context: fidl::encoding::Context) -> usize {
6550            8
6551        }
6552
6553        #[inline(always)]
6554        fn inline_size(_context: fidl::encoding::Context) -> usize {
6555            2928
6556        }
6557    }
6558
6559    unsafe impl
6560        fidl::encoding::Encode<EchoEchoStructRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
6561        for &mut EchoEchoStructRequest
6562    {
6563        #[inline]
6564        unsafe fn encode(
6565            self,
6566            encoder: &mut fidl::encoding::Encoder<
6567                '_,
6568                fidl::encoding::DefaultFuchsiaResourceDialect,
6569            >,
6570            offset: usize,
6571            _depth: fidl::encoding::Depth,
6572        ) -> fidl::Result<()> {
6573            encoder.debug_check_bounds::<EchoEchoStructRequest>(offset);
6574            // Delegate to tuple encoding.
6575            fidl::encoding::Encode::<
6576                EchoEchoStructRequest,
6577                fidl::encoding::DefaultFuchsiaResourceDialect,
6578            >::encode(
6579                (
6580                    <Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
6581                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
6582                        &self.forward_to_server,
6583                    ),
6584                ),
6585                encoder,
6586                offset,
6587                _depth,
6588            )
6589        }
6590    }
6591    unsafe impl<
6592        T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>,
6593        T1: fidl::encoding::Encode<
6594                fidl::encoding::UnboundedString,
6595                fidl::encoding::DefaultFuchsiaResourceDialect,
6596            >,
6597    >
6598        fidl::encoding::Encode<EchoEchoStructRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
6599        for (T0, T1)
6600    {
6601        #[inline]
6602        unsafe fn encode(
6603            self,
6604            encoder: &mut fidl::encoding::Encoder<
6605                '_,
6606                fidl::encoding::DefaultFuchsiaResourceDialect,
6607            >,
6608            offset: usize,
6609            depth: fidl::encoding::Depth,
6610        ) -> fidl::Result<()> {
6611            encoder.debug_check_bounds::<EchoEchoStructRequest>(offset);
6612            // Zero out padding regions. There's no need to apply masks
6613            // because the unmasked parts will be overwritten by fields.
6614            // Write the fields.
6615            self.0.encode(encoder, offset + 0, depth)?;
6616            self.1.encode(encoder, offset + 2912, depth)?;
6617            Ok(())
6618        }
6619    }
6620
6621    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6622        for EchoEchoStructRequest
6623    {
6624        #[inline(always)]
6625        fn new_empty() -> Self {
6626            Self {
6627                value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect),
6628                forward_to_server: fidl::new_empty!(
6629                    fidl::encoding::UnboundedString,
6630                    fidl::encoding::DefaultFuchsiaResourceDialect
6631                ),
6632            }
6633        }
6634
6635        #[inline]
6636        unsafe fn decode(
6637            &mut self,
6638            decoder: &mut fidl::encoding::Decoder<
6639                '_,
6640                fidl::encoding::DefaultFuchsiaResourceDialect,
6641            >,
6642            offset: usize,
6643            _depth: fidl::encoding::Depth,
6644        ) -> fidl::Result<()> {
6645            decoder.debug_check_bounds::<Self>(offset);
6646            // Verify that padding bytes are zero.
6647            fidl::decode!(
6648                Struct,
6649                fidl::encoding::DefaultFuchsiaResourceDialect,
6650                &mut self.value,
6651                decoder,
6652                offset + 0,
6653                _depth
6654            )?;
6655            fidl::decode!(
6656                fidl::encoding::UnboundedString,
6657                fidl::encoding::DefaultFuchsiaResourceDialect,
6658                &mut self.forward_to_server,
6659                decoder,
6660                offset + 2912,
6661                _depth
6662            )?;
6663            Ok(())
6664        }
6665    }
6666
6667    impl fidl::encoding::ResourceTypeMarker for EchoEchoStructResponse {
6668        type Borrowed<'a> = &'a mut Self;
6669        fn take_or_borrow<'a>(
6670            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6671        ) -> Self::Borrowed<'a> {
6672            value
6673        }
6674    }
6675
6676    unsafe impl fidl::encoding::TypeMarker for EchoEchoStructResponse {
6677        type Owned = Self;
6678
6679        #[inline(always)]
6680        fn inline_align(_context: fidl::encoding::Context) -> usize {
6681            8
6682        }
6683
6684        #[inline(always)]
6685        fn inline_size(_context: fidl::encoding::Context) -> usize {
6686            2912
6687        }
6688    }
6689
6690    unsafe impl
6691        fidl::encoding::Encode<
6692            EchoEchoStructResponse,
6693            fidl::encoding::DefaultFuchsiaResourceDialect,
6694        > for &mut EchoEchoStructResponse
6695    {
6696        #[inline]
6697        unsafe fn encode(
6698            self,
6699            encoder: &mut fidl::encoding::Encoder<
6700                '_,
6701                fidl::encoding::DefaultFuchsiaResourceDialect,
6702            >,
6703            offset: usize,
6704            _depth: fidl::encoding::Depth,
6705        ) -> fidl::Result<()> {
6706            encoder.debug_check_bounds::<EchoEchoStructResponse>(offset);
6707            // Delegate to tuple encoding.
6708            fidl::encoding::Encode::<
6709                EchoEchoStructResponse,
6710                fidl::encoding::DefaultFuchsiaResourceDialect,
6711            >::encode(
6712                (<Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),),
6713                encoder,
6714                offset,
6715                _depth,
6716            )
6717        }
6718    }
6719    unsafe impl<T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>>
6720        fidl::encoding::Encode<
6721            EchoEchoStructResponse,
6722            fidl::encoding::DefaultFuchsiaResourceDialect,
6723        > for (T0,)
6724    {
6725        #[inline]
6726        unsafe fn encode(
6727            self,
6728            encoder: &mut fidl::encoding::Encoder<
6729                '_,
6730                fidl::encoding::DefaultFuchsiaResourceDialect,
6731            >,
6732            offset: usize,
6733            depth: fidl::encoding::Depth,
6734        ) -> fidl::Result<()> {
6735            encoder.debug_check_bounds::<EchoEchoStructResponse>(offset);
6736            // Zero out padding regions. There's no need to apply masks
6737            // because the unmasked parts will be overwritten by fields.
6738            // Write the fields.
6739            self.0.encode(encoder, offset + 0, depth)?;
6740            Ok(())
6741        }
6742    }
6743
6744    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6745        for EchoEchoStructResponse
6746    {
6747        #[inline(always)]
6748        fn new_empty() -> Self {
6749            Self { value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect) }
6750        }
6751
6752        #[inline]
6753        unsafe fn decode(
6754            &mut self,
6755            decoder: &mut fidl::encoding::Decoder<
6756                '_,
6757                fidl::encoding::DefaultFuchsiaResourceDialect,
6758            >,
6759            offset: usize,
6760            _depth: fidl::encoding::Depth,
6761        ) -> fidl::Result<()> {
6762            decoder.debug_check_bounds::<Self>(offset);
6763            // Verify that padding bytes are zero.
6764            fidl::decode!(
6765                Struct,
6766                fidl::encoding::DefaultFuchsiaResourceDialect,
6767                &mut self.value,
6768                decoder,
6769                offset + 0,
6770                _depth
6771            )?;
6772            Ok(())
6773        }
6774    }
6775
6776    impl fidl::encoding::ResourceTypeMarker for EchoEchoStructWithErrorRequest {
6777        type Borrowed<'a> = &'a mut Self;
6778        fn take_or_borrow<'a>(
6779            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6780        ) -> Self::Borrowed<'a> {
6781            value
6782        }
6783    }
6784
6785    unsafe impl fidl::encoding::TypeMarker for EchoEchoStructWithErrorRequest {
6786        type Owned = Self;
6787
6788        #[inline(always)]
6789        fn inline_align(_context: fidl::encoding::Context) -> usize {
6790            8
6791        }
6792
6793        #[inline(always)]
6794        fn inline_size(_context: fidl::encoding::Context) -> usize {
6795            2944
6796        }
6797    }
6798
6799    unsafe impl
6800        fidl::encoding::Encode<
6801            EchoEchoStructWithErrorRequest,
6802            fidl::encoding::DefaultFuchsiaResourceDialect,
6803        > for &mut EchoEchoStructWithErrorRequest
6804    {
6805        #[inline]
6806        unsafe fn encode(
6807            self,
6808            encoder: &mut fidl::encoding::Encoder<
6809                '_,
6810                fidl::encoding::DefaultFuchsiaResourceDialect,
6811            >,
6812            offset: usize,
6813            _depth: fidl::encoding::Depth,
6814        ) -> fidl::Result<()> {
6815            encoder.debug_check_bounds::<EchoEchoStructWithErrorRequest>(offset);
6816            // Delegate to tuple encoding.
6817            fidl::encoding::Encode::<
6818                EchoEchoStructWithErrorRequest,
6819                fidl::encoding::DefaultFuchsiaResourceDialect,
6820            >::encode(
6821                (
6822                    <Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
6823                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
6824                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
6825                        &self.forward_to_server,
6826                    ),
6827                    <RespondWith as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
6828                ),
6829                encoder,
6830                offset,
6831                _depth,
6832            )
6833        }
6834    }
6835    unsafe impl<
6836        T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>,
6837        T1: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
6838        T2: fidl::encoding::Encode<
6839                fidl::encoding::UnboundedString,
6840                fidl::encoding::DefaultFuchsiaResourceDialect,
6841            >,
6842        T3: fidl::encoding::Encode<RespondWith, fidl::encoding::DefaultFuchsiaResourceDialect>,
6843    >
6844        fidl::encoding::Encode<
6845            EchoEchoStructWithErrorRequest,
6846            fidl::encoding::DefaultFuchsiaResourceDialect,
6847        > for (T0, T1, T2, T3)
6848    {
6849        #[inline]
6850        unsafe fn encode(
6851            self,
6852            encoder: &mut fidl::encoding::Encoder<
6853                '_,
6854                fidl::encoding::DefaultFuchsiaResourceDialect,
6855            >,
6856            offset: usize,
6857            depth: fidl::encoding::Depth,
6858        ) -> fidl::Result<()> {
6859            encoder.debug_check_bounds::<EchoEchoStructWithErrorRequest>(offset);
6860            // Zero out padding regions. There's no need to apply masks
6861            // because the unmasked parts will be overwritten by fields.
6862            unsafe {
6863                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2912);
6864                (ptr as *mut u64).write_unaligned(0);
6865            }
6866            unsafe {
6867                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2936);
6868                (ptr as *mut u64).write_unaligned(0);
6869            }
6870            // Write the fields.
6871            self.0.encode(encoder, offset + 0, depth)?;
6872            self.1.encode(encoder, offset + 2912, depth)?;
6873            self.2.encode(encoder, offset + 2920, depth)?;
6874            self.3.encode(encoder, offset + 2936, depth)?;
6875            Ok(())
6876        }
6877    }
6878
6879    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6880        for EchoEchoStructWithErrorRequest
6881    {
6882        #[inline(always)]
6883        fn new_empty() -> Self {
6884            Self {
6885                value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect),
6886                result_err: fidl::new_empty!(
6887                    DefaultEnum,
6888                    fidl::encoding::DefaultFuchsiaResourceDialect
6889                ),
6890                forward_to_server: fidl::new_empty!(
6891                    fidl::encoding::UnboundedString,
6892                    fidl::encoding::DefaultFuchsiaResourceDialect
6893                ),
6894                result_variant: fidl::new_empty!(
6895                    RespondWith,
6896                    fidl::encoding::DefaultFuchsiaResourceDialect
6897                ),
6898            }
6899        }
6900
6901        #[inline]
6902        unsafe fn decode(
6903            &mut self,
6904            decoder: &mut fidl::encoding::Decoder<
6905                '_,
6906                fidl::encoding::DefaultFuchsiaResourceDialect,
6907            >,
6908            offset: usize,
6909            _depth: fidl::encoding::Depth,
6910        ) -> fidl::Result<()> {
6911            decoder.debug_check_bounds::<Self>(offset);
6912            // Verify that padding bytes are zero.
6913            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2912) };
6914            let padval = unsafe { (ptr as *const u64).read_unaligned() };
6915            let mask = 0xffffffff00000000u64;
6916            let maskedval = padval & mask;
6917            if maskedval != 0 {
6918                return Err(fidl::Error::NonZeroPadding {
6919                    padding_start: offset + 2912 + ((mask as u64).trailing_zeros() / 8) as usize,
6920                });
6921            }
6922            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2936) };
6923            let padval = unsafe { (ptr as *const u64).read_unaligned() };
6924            let mask = 0xffffffff00000000u64;
6925            let maskedval = padval & mask;
6926            if maskedval != 0 {
6927                return Err(fidl::Error::NonZeroPadding {
6928                    padding_start: offset + 2936 + ((mask as u64).trailing_zeros() / 8) as usize,
6929                });
6930            }
6931            fidl::decode!(
6932                Struct,
6933                fidl::encoding::DefaultFuchsiaResourceDialect,
6934                &mut self.value,
6935                decoder,
6936                offset + 0,
6937                _depth
6938            )?;
6939            fidl::decode!(
6940                DefaultEnum,
6941                fidl::encoding::DefaultFuchsiaResourceDialect,
6942                &mut self.result_err,
6943                decoder,
6944                offset + 2912,
6945                _depth
6946            )?;
6947            fidl::decode!(
6948                fidl::encoding::UnboundedString,
6949                fidl::encoding::DefaultFuchsiaResourceDialect,
6950                &mut self.forward_to_server,
6951                decoder,
6952                offset + 2920,
6953                _depth
6954            )?;
6955            fidl::decode!(
6956                RespondWith,
6957                fidl::encoding::DefaultFuchsiaResourceDialect,
6958                &mut self.result_variant,
6959                decoder,
6960                offset + 2936,
6961                _depth
6962            )?;
6963            Ok(())
6964        }
6965    }
6966
6967    impl fidl::encoding::ResourceTypeMarker for EchoEchoTableRequest {
6968        type Borrowed<'a> = &'a mut Self;
6969        fn take_or_borrow<'a>(
6970            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6971        ) -> Self::Borrowed<'a> {
6972            value
6973        }
6974    }
6975
6976    unsafe impl fidl::encoding::TypeMarker for EchoEchoTableRequest {
6977        type Owned = Self;
6978
6979        #[inline(always)]
6980        fn inline_align(_context: fidl::encoding::Context) -> usize {
6981            8
6982        }
6983
6984        #[inline(always)]
6985        fn inline_size(_context: fidl::encoding::Context) -> usize {
6986            32
6987        }
6988    }
6989
6990    unsafe impl
6991        fidl::encoding::Encode<EchoEchoTableRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
6992        for &mut EchoEchoTableRequest
6993    {
6994        #[inline]
6995        unsafe fn encode(
6996            self,
6997            encoder: &mut fidl::encoding::Encoder<
6998                '_,
6999                fidl::encoding::DefaultFuchsiaResourceDialect,
7000            >,
7001            offset: usize,
7002            _depth: fidl::encoding::Depth,
7003        ) -> fidl::Result<()> {
7004            encoder.debug_check_bounds::<EchoEchoTableRequest>(offset);
7005            // Delegate to tuple encoding.
7006            fidl::encoding::Encode::<
7007                EchoEchoTableRequest,
7008                fidl::encoding::DefaultFuchsiaResourceDialect,
7009            >::encode(
7010                (
7011                    <AllTypesTable as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7012                        &mut self.value,
7013                    ),
7014                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
7015                        &self.forward_to_server,
7016                    ),
7017                ),
7018                encoder,
7019                offset,
7020                _depth,
7021            )
7022        }
7023    }
7024    unsafe impl<
7025        T0: fidl::encoding::Encode<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>,
7026        T1: fidl::encoding::Encode<
7027                fidl::encoding::UnboundedString,
7028                fidl::encoding::DefaultFuchsiaResourceDialect,
7029            >,
7030    >
7031        fidl::encoding::Encode<EchoEchoTableRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
7032        for (T0, T1)
7033    {
7034        #[inline]
7035        unsafe fn encode(
7036            self,
7037            encoder: &mut fidl::encoding::Encoder<
7038                '_,
7039                fidl::encoding::DefaultFuchsiaResourceDialect,
7040            >,
7041            offset: usize,
7042            depth: fidl::encoding::Depth,
7043        ) -> fidl::Result<()> {
7044            encoder.debug_check_bounds::<EchoEchoTableRequest>(offset);
7045            // Zero out padding regions. There's no need to apply masks
7046            // because the unmasked parts will be overwritten by fields.
7047            // Write the fields.
7048            self.0.encode(encoder, offset + 0, depth)?;
7049            self.1.encode(encoder, offset + 16, depth)?;
7050            Ok(())
7051        }
7052    }
7053
7054    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7055        for EchoEchoTableRequest
7056    {
7057        #[inline(always)]
7058        fn new_empty() -> Self {
7059            Self {
7060                value: fidl::new_empty!(
7061                    AllTypesTable,
7062                    fidl::encoding::DefaultFuchsiaResourceDialect
7063                ),
7064                forward_to_server: fidl::new_empty!(
7065                    fidl::encoding::UnboundedString,
7066                    fidl::encoding::DefaultFuchsiaResourceDialect
7067                ),
7068            }
7069        }
7070
7071        #[inline]
7072        unsafe fn decode(
7073            &mut self,
7074            decoder: &mut fidl::encoding::Decoder<
7075                '_,
7076                fidl::encoding::DefaultFuchsiaResourceDialect,
7077            >,
7078            offset: usize,
7079            _depth: fidl::encoding::Depth,
7080        ) -> fidl::Result<()> {
7081            decoder.debug_check_bounds::<Self>(offset);
7082            // Verify that padding bytes are zero.
7083            fidl::decode!(
7084                AllTypesTable,
7085                fidl::encoding::DefaultFuchsiaResourceDialect,
7086                &mut self.value,
7087                decoder,
7088                offset + 0,
7089                _depth
7090            )?;
7091            fidl::decode!(
7092                fidl::encoding::UnboundedString,
7093                fidl::encoding::DefaultFuchsiaResourceDialect,
7094                &mut self.forward_to_server,
7095                decoder,
7096                offset + 16,
7097                _depth
7098            )?;
7099            Ok(())
7100        }
7101    }
7102
7103    impl fidl::encoding::ResourceTypeMarker for EchoEchoTableResponse {
7104        type Borrowed<'a> = &'a mut Self;
7105        fn take_or_borrow<'a>(
7106            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7107        ) -> Self::Borrowed<'a> {
7108            value
7109        }
7110    }
7111
7112    unsafe impl fidl::encoding::TypeMarker for EchoEchoTableResponse {
7113        type Owned = Self;
7114
7115        #[inline(always)]
7116        fn inline_align(_context: fidl::encoding::Context) -> usize {
7117            8
7118        }
7119
7120        #[inline(always)]
7121        fn inline_size(_context: fidl::encoding::Context) -> usize {
7122            16
7123        }
7124    }
7125
7126    unsafe impl
7127        fidl::encoding::Encode<EchoEchoTableResponse, fidl::encoding::DefaultFuchsiaResourceDialect>
7128        for &mut EchoEchoTableResponse
7129    {
7130        #[inline]
7131        unsafe fn encode(
7132            self,
7133            encoder: &mut fidl::encoding::Encoder<
7134                '_,
7135                fidl::encoding::DefaultFuchsiaResourceDialect,
7136            >,
7137            offset: usize,
7138            _depth: fidl::encoding::Depth,
7139        ) -> fidl::Result<()> {
7140            encoder.debug_check_bounds::<EchoEchoTableResponse>(offset);
7141            // Delegate to tuple encoding.
7142            fidl::encoding::Encode::<
7143                EchoEchoTableResponse,
7144                fidl::encoding::DefaultFuchsiaResourceDialect,
7145            >::encode(
7146                (<AllTypesTable as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7147                    &mut self.value,
7148                ),),
7149                encoder,
7150                offset,
7151                _depth,
7152            )
7153        }
7154    }
7155    unsafe impl<
7156        T0: fidl::encoding::Encode<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>,
7157    >
7158        fidl::encoding::Encode<EchoEchoTableResponse, fidl::encoding::DefaultFuchsiaResourceDialect>
7159        for (T0,)
7160    {
7161        #[inline]
7162        unsafe fn encode(
7163            self,
7164            encoder: &mut fidl::encoding::Encoder<
7165                '_,
7166                fidl::encoding::DefaultFuchsiaResourceDialect,
7167            >,
7168            offset: usize,
7169            depth: fidl::encoding::Depth,
7170        ) -> fidl::Result<()> {
7171            encoder.debug_check_bounds::<EchoEchoTableResponse>(offset);
7172            // Zero out padding regions. There's no need to apply masks
7173            // because the unmasked parts will be overwritten by fields.
7174            // Write the fields.
7175            self.0.encode(encoder, offset + 0, depth)?;
7176            Ok(())
7177        }
7178    }
7179
7180    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7181        for EchoEchoTableResponse
7182    {
7183        #[inline(always)]
7184        fn new_empty() -> Self {
7185            Self {
7186                value: fidl::new_empty!(
7187                    AllTypesTable,
7188                    fidl::encoding::DefaultFuchsiaResourceDialect
7189                ),
7190            }
7191        }
7192
7193        #[inline]
7194        unsafe fn decode(
7195            &mut self,
7196            decoder: &mut fidl::encoding::Decoder<
7197                '_,
7198                fidl::encoding::DefaultFuchsiaResourceDialect,
7199            >,
7200            offset: usize,
7201            _depth: fidl::encoding::Depth,
7202        ) -> fidl::Result<()> {
7203            decoder.debug_check_bounds::<Self>(offset);
7204            // Verify that padding bytes are zero.
7205            fidl::decode!(
7206                AllTypesTable,
7207                fidl::encoding::DefaultFuchsiaResourceDialect,
7208                &mut self.value,
7209                decoder,
7210                offset + 0,
7211                _depth
7212            )?;
7213            Ok(())
7214        }
7215    }
7216
7217    impl fidl::encoding::ResourceTypeMarker for EchoEchoTableWithErrorRequest {
7218        type Borrowed<'a> = &'a mut Self;
7219        fn take_or_borrow<'a>(
7220            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7221        ) -> Self::Borrowed<'a> {
7222            value
7223        }
7224    }
7225
7226    unsafe impl fidl::encoding::TypeMarker for EchoEchoTableWithErrorRequest {
7227        type Owned = Self;
7228
7229        #[inline(always)]
7230        fn inline_align(_context: fidl::encoding::Context) -> usize {
7231            8
7232        }
7233
7234        #[inline(always)]
7235        fn inline_size(_context: fidl::encoding::Context) -> usize {
7236            48
7237        }
7238    }
7239
7240    unsafe impl
7241        fidl::encoding::Encode<
7242            EchoEchoTableWithErrorRequest,
7243            fidl::encoding::DefaultFuchsiaResourceDialect,
7244        > for &mut EchoEchoTableWithErrorRequest
7245    {
7246        #[inline]
7247        unsafe fn encode(
7248            self,
7249            encoder: &mut fidl::encoding::Encoder<
7250                '_,
7251                fidl::encoding::DefaultFuchsiaResourceDialect,
7252            >,
7253            offset: usize,
7254            _depth: fidl::encoding::Depth,
7255        ) -> fidl::Result<()> {
7256            encoder.debug_check_bounds::<EchoEchoTableWithErrorRequest>(offset);
7257            // Delegate to tuple encoding.
7258            fidl::encoding::Encode::<
7259                EchoEchoTableWithErrorRequest,
7260                fidl::encoding::DefaultFuchsiaResourceDialect,
7261            >::encode(
7262                (
7263                    <AllTypesTable as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7264                        &mut self.value,
7265                    ),
7266                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
7267                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
7268                        &self.forward_to_server,
7269                    ),
7270                    <RespondWith as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
7271                ),
7272                encoder,
7273                offset,
7274                _depth,
7275            )
7276        }
7277    }
7278    unsafe impl<
7279        T0: fidl::encoding::Encode<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>,
7280        T1: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
7281        T2: fidl::encoding::Encode<
7282                fidl::encoding::UnboundedString,
7283                fidl::encoding::DefaultFuchsiaResourceDialect,
7284            >,
7285        T3: fidl::encoding::Encode<RespondWith, fidl::encoding::DefaultFuchsiaResourceDialect>,
7286    >
7287        fidl::encoding::Encode<
7288            EchoEchoTableWithErrorRequest,
7289            fidl::encoding::DefaultFuchsiaResourceDialect,
7290        > for (T0, T1, T2, T3)
7291    {
7292        #[inline]
7293        unsafe fn encode(
7294            self,
7295            encoder: &mut fidl::encoding::Encoder<
7296                '_,
7297                fidl::encoding::DefaultFuchsiaResourceDialect,
7298            >,
7299            offset: usize,
7300            depth: fidl::encoding::Depth,
7301        ) -> fidl::Result<()> {
7302            encoder.debug_check_bounds::<EchoEchoTableWithErrorRequest>(offset);
7303            // Zero out padding regions. There's no need to apply masks
7304            // because the unmasked parts will be overwritten by fields.
7305            unsafe {
7306                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
7307                (ptr as *mut u64).write_unaligned(0);
7308            }
7309            unsafe {
7310                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
7311                (ptr as *mut u64).write_unaligned(0);
7312            }
7313            // Write the fields.
7314            self.0.encode(encoder, offset + 0, depth)?;
7315            self.1.encode(encoder, offset + 16, depth)?;
7316            self.2.encode(encoder, offset + 24, depth)?;
7317            self.3.encode(encoder, offset + 40, depth)?;
7318            Ok(())
7319        }
7320    }
7321
7322    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7323        for EchoEchoTableWithErrorRequest
7324    {
7325        #[inline(always)]
7326        fn new_empty() -> Self {
7327            Self {
7328                value: fidl::new_empty!(
7329                    AllTypesTable,
7330                    fidl::encoding::DefaultFuchsiaResourceDialect
7331                ),
7332                result_err: fidl::new_empty!(
7333                    DefaultEnum,
7334                    fidl::encoding::DefaultFuchsiaResourceDialect
7335                ),
7336                forward_to_server: fidl::new_empty!(
7337                    fidl::encoding::UnboundedString,
7338                    fidl::encoding::DefaultFuchsiaResourceDialect
7339                ),
7340                result_variant: fidl::new_empty!(
7341                    RespondWith,
7342                    fidl::encoding::DefaultFuchsiaResourceDialect
7343                ),
7344            }
7345        }
7346
7347        #[inline]
7348        unsafe fn decode(
7349            &mut self,
7350            decoder: &mut fidl::encoding::Decoder<
7351                '_,
7352                fidl::encoding::DefaultFuchsiaResourceDialect,
7353            >,
7354            offset: usize,
7355            _depth: fidl::encoding::Depth,
7356        ) -> fidl::Result<()> {
7357            decoder.debug_check_bounds::<Self>(offset);
7358            // Verify that padding bytes are zero.
7359            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
7360            let padval = unsafe { (ptr as *const u64).read_unaligned() };
7361            let mask = 0xffffffff00000000u64;
7362            let maskedval = padval & mask;
7363            if maskedval != 0 {
7364                return Err(fidl::Error::NonZeroPadding {
7365                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
7366                });
7367            }
7368            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
7369            let padval = unsafe { (ptr as *const u64).read_unaligned() };
7370            let mask = 0xffffffff00000000u64;
7371            let maskedval = padval & mask;
7372            if maskedval != 0 {
7373                return Err(fidl::Error::NonZeroPadding {
7374                    padding_start: offset + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
7375                });
7376            }
7377            fidl::decode!(
7378                AllTypesTable,
7379                fidl::encoding::DefaultFuchsiaResourceDialect,
7380                &mut self.value,
7381                decoder,
7382                offset + 0,
7383                _depth
7384            )?;
7385            fidl::decode!(
7386                DefaultEnum,
7387                fidl::encoding::DefaultFuchsiaResourceDialect,
7388                &mut self.result_err,
7389                decoder,
7390                offset + 16,
7391                _depth
7392            )?;
7393            fidl::decode!(
7394                fidl::encoding::UnboundedString,
7395                fidl::encoding::DefaultFuchsiaResourceDialect,
7396                &mut self.forward_to_server,
7397                decoder,
7398                offset + 24,
7399                _depth
7400            )?;
7401            fidl::decode!(
7402                RespondWith,
7403                fidl::encoding::DefaultFuchsiaResourceDialect,
7404                &mut self.result_variant,
7405                decoder,
7406                offset + 40,
7407                _depth
7408            )?;
7409            Ok(())
7410        }
7411    }
7412
7413    impl fidl::encoding::ResourceTypeMarker for EchoEchoVectorsRequest {
7414        type Borrowed<'a> = &'a mut Self;
7415        fn take_or_borrow<'a>(
7416            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7417        ) -> Self::Borrowed<'a> {
7418            value
7419        }
7420    }
7421
7422    unsafe impl fidl::encoding::TypeMarker for EchoEchoVectorsRequest {
7423        type Owned = Self;
7424
7425        #[inline(always)]
7426        fn inline_align(_context: fidl::encoding::Context) -> usize {
7427            8
7428        }
7429
7430        #[inline(always)]
7431        fn inline_size(_context: fidl::encoding::Context) -> usize {
7432            432
7433        }
7434    }
7435
7436    unsafe impl
7437        fidl::encoding::Encode<
7438            EchoEchoVectorsRequest,
7439            fidl::encoding::DefaultFuchsiaResourceDialect,
7440        > for &mut EchoEchoVectorsRequest
7441    {
7442        #[inline]
7443        unsafe fn encode(
7444            self,
7445            encoder: &mut fidl::encoding::Encoder<
7446                '_,
7447                fidl::encoding::DefaultFuchsiaResourceDialect,
7448            >,
7449            offset: usize,
7450            _depth: fidl::encoding::Depth,
7451        ) -> fidl::Result<()> {
7452            encoder.debug_check_bounds::<EchoEchoVectorsRequest>(offset);
7453            // Delegate to tuple encoding.
7454            fidl::encoding::Encode::<
7455                EchoEchoVectorsRequest,
7456                fidl::encoding::DefaultFuchsiaResourceDialect,
7457            >::encode(
7458                (
7459                    <VectorsStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7460                        &mut self.value,
7461                    ),
7462                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
7463                        &self.forward_to_server,
7464                    ),
7465                ),
7466                encoder,
7467                offset,
7468                _depth,
7469            )
7470        }
7471    }
7472    unsafe impl<
7473        T0: fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
7474        T1: fidl::encoding::Encode<
7475                fidl::encoding::UnboundedString,
7476                fidl::encoding::DefaultFuchsiaResourceDialect,
7477            >,
7478    >
7479        fidl::encoding::Encode<
7480            EchoEchoVectorsRequest,
7481            fidl::encoding::DefaultFuchsiaResourceDialect,
7482        > for (T0, T1)
7483    {
7484        #[inline]
7485        unsafe fn encode(
7486            self,
7487            encoder: &mut fidl::encoding::Encoder<
7488                '_,
7489                fidl::encoding::DefaultFuchsiaResourceDialect,
7490            >,
7491            offset: usize,
7492            depth: fidl::encoding::Depth,
7493        ) -> fidl::Result<()> {
7494            encoder.debug_check_bounds::<EchoEchoVectorsRequest>(offset);
7495            // Zero out padding regions. There's no need to apply masks
7496            // because the unmasked parts will be overwritten by fields.
7497            // Write the fields.
7498            self.0.encode(encoder, offset + 0, depth)?;
7499            self.1.encode(encoder, offset + 416, depth)?;
7500            Ok(())
7501        }
7502    }
7503
7504    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7505        for EchoEchoVectorsRequest
7506    {
7507        #[inline(always)]
7508        fn new_empty() -> Self {
7509            Self {
7510                value: fidl::new_empty!(
7511                    VectorsStruct,
7512                    fidl::encoding::DefaultFuchsiaResourceDialect
7513                ),
7514                forward_to_server: fidl::new_empty!(
7515                    fidl::encoding::UnboundedString,
7516                    fidl::encoding::DefaultFuchsiaResourceDialect
7517                ),
7518            }
7519        }
7520
7521        #[inline]
7522        unsafe fn decode(
7523            &mut self,
7524            decoder: &mut fidl::encoding::Decoder<
7525                '_,
7526                fidl::encoding::DefaultFuchsiaResourceDialect,
7527            >,
7528            offset: usize,
7529            _depth: fidl::encoding::Depth,
7530        ) -> fidl::Result<()> {
7531            decoder.debug_check_bounds::<Self>(offset);
7532            // Verify that padding bytes are zero.
7533            fidl::decode!(
7534                VectorsStruct,
7535                fidl::encoding::DefaultFuchsiaResourceDialect,
7536                &mut self.value,
7537                decoder,
7538                offset + 0,
7539                _depth
7540            )?;
7541            fidl::decode!(
7542                fidl::encoding::UnboundedString,
7543                fidl::encoding::DefaultFuchsiaResourceDialect,
7544                &mut self.forward_to_server,
7545                decoder,
7546                offset + 416,
7547                _depth
7548            )?;
7549            Ok(())
7550        }
7551    }
7552
7553    impl fidl::encoding::ResourceTypeMarker for EchoEchoVectorsResponse {
7554        type Borrowed<'a> = &'a mut Self;
7555        fn take_or_borrow<'a>(
7556            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7557        ) -> Self::Borrowed<'a> {
7558            value
7559        }
7560    }
7561
7562    unsafe impl fidl::encoding::TypeMarker for EchoEchoVectorsResponse {
7563        type Owned = Self;
7564
7565        #[inline(always)]
7566        fn inline_align(_context: fidl::encoding::Context) -> usize {
7567            8
7568        }
7569
7570        #[inline(always)]
7571        fn inline_size(_context: fidl::encoding::Context) -> usize {
7572            416
7573        }
7574    }
7575
7576    unsafe impl
7577        fidl::encoding::Encode<
7578            EchoEchoVectorsResponse,
7579            fidl::encoding::DefaultFuchsiaResourceDialect,
7580        > for &mut EchoEchoVectorsResponse
7581    {
7582        #[inline]
7583        unsafe fn encode(
7584            self,
7585            encoder: &mut fidl::encoding::Encoder<
7586                '_,
7587                fidl::encoding::DefaultFuchsiaResourceDialect,
7588            >,
7589            offset: usize,
7590            _depth: fidl::encoding::Depth,
7591        ) -> fidl::Result<()> {
7592            encoder.debug_check_bounds::<EchoEchoVectorsResponse>(offset);
7593            // Delegate to tuple encoding.
7594            fidl::encoding::Encode::<
7595                EchoEchoVectorsResponse,
7596                fidl::encoding::DefaultFuchsiaResourceDialect,
7597            >::encode(
7598                (<VectorsStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7599                    &mut self.value,
7600                ),),
7601                encoder,
7602                offset,
7603                _depth,
7604            )
7605        }
7606    }
7607    unsafe impl<
7608        T0: fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
7609    >
7610        fidl::encoding::Encode<
7611            EchoEchoVectorsResponse,
7612            fidl::encoding::DefaultFuchsiaResourceDialect,
7613        > for (T0,)
7614    {
7615        #[inline]
7616        unsafe fn encode(
7617            self,
7618            encoder: &mut fidl::encoding::Encoder<
7619                '_,
7620                fidl::encoding::DefaultFuchsiaResourceDialect,
7621            >,
7622            offset: usize,
7623            depth: fidl::encoding::Depth,
7624        ) -> fidl::Result<()> {
7625            encoder.debug_check_bounds::<EchoEchoVectorsResponse>(offset);
7626            // Zero out padding regions. There's no need to apply masks
7627            // because the unmasked parts will be overwritten by fields.
7628            // Write the fields.
7629            self.0.encode(encoder, offset + 0, depth)?;
7630            Ok(())
7631        }
7632    }
7633
7634    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7635        for EchoEchoVectorsResponse
7636    {
7637        #[inline(always)]
7638        fn new_empty() -> Self {
7639            Self {
7640                value: fidl::new_empty!(
7641                    VectorsStruct,
7642                    fidl::encoding::DefaultFuchsiaResourceDialect
7643                ),
7644            }
7645        }
7646
7647        #[inline]
7648        unsafe fn decode(
7649            &mut self,
7650            decoder: &mut fidl::encoding::Decoder<
7651                '_,
7652                fidl::encoding::DefaultFuchsiaResourceDialect,
7653            >,
7654            offset: usize,
7655            _depth: fidl::encoding::Depth,
7656        ) -> fidl::Result<()> {
7657            decoder.debug_check_bounds::<Self>(offset);
7658            // Verify that padding bytes are zero.
7659            fidl::decode!(
7660                VectorsStruct,
7661                fidl::encoding::DefaultFuchsiaResourceDialect,
7662                &mut self.value,
7663                decoder,
7664                offset + 0,
7665                _depth
7666            )?;
7667            Ok(())
7668        }
7669    }
7670
7671    impl fidl::encoding::ResourceTypeMarker for EchoEchoVectorsWithErrorRequest {
7672        type Borrowed<'a> = &'a mut Self;
7673        fn take_or_borrow<'a>(
7674            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7675        ) -> Self::Borrowed<'a> {
7676            value
7677        }
7678    }
7679
7680    unsafe impl fidl::encoding::TypeMarker for EchoEchoVectorsWithErrorRequest {
7681        type Owned = Self;
7682
7683        #[inline(always)]
7684        fn inline_align(_context: fidl::encoding::Context) -> usize {
7685            8
7686        }
7687
7688        #[inline(always)]
7689        fn inline_size(_context: fidl::encoding::Context) -> usize {
7690            448
7691        }
7692    }
7693
7694    unsafe impl
7695        fidl::encoding::Encode<
7696            EchoEchoVectorsWithErrorRequest,
7697            fidl::encoding::DefaultFuchsiaResourceDialect,
7698        > for &mut EchoEchoVectorsWithErrorRequest
7699    {
7700        #[inline]
7701        unsafe fn encode(
7702            self,
7703            encoder: &mut fidl::encoding::Encoder<
7704                '_,
7705                fidl::encoding::DefaultFuchsiaResourceDialect,
7706            >,
7707            offset: usize,
7708            _depth: fidl::encoding::Depth,
7709        ) -> fidl::Result<()> {
7710            encoder.debug_check_bounds::<EchoEchoVectorsWithErrorRequest>(offset);
7711            // Delegate to tuple encoding.
7712            fidl::encoding::Encode::<
7713                EchoEchoVectorsWithErrorRequest,
7714                fidl::encoding::DefaultFuchsiaResourceDialect,
7715            >::encode(
7716                (
7717                    <VectorsStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7718                        &mut self.value,
7719                    ),
7720                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
7721                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
7722                        &self.forward_to_server,
7723                    ),
7724                    <RespondWith as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
7725                ),
7726                encoder,
7727                offset,
7728                _depth,
7729            )
7730        }
7731    }
7732    unsafe impl<
7733        T0: fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
7734        T1: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
7735        T2: fidl::encoding::Encode<
7736                fidl::encoding::UnboundedString,
7737                fidl::encoding::DefaultFuchsiaResourceDialect,
7738            >,
7739        T3: fidl::encoding::Encode<RespondWith, fidl::encoding::DefaultFuchsiaResourceDialect>,
7740    >
7741        fidl::encoding::Encode<
7742            EchoEchoVectorsWithErrorRequest,
7743            fidl::encoding::DefaultFuchsiaResourceDialect,
7744        > for (T0, T1, T2, T3)
7745    {
7746        #[inline]
7747        unsafe fn encode(
7748            self,
7749            encoder: &mut fidl::encoding::Encoder<
7750                '_,
7751                fidl::encoding::DefaultFuchsiaResourceDialect,
7752            >,
7753            offset: usize,
7754            depth: fidl::encoding::Depth,
7755        ) -> fidl::Result<()> {
7756            encoder.debug_check_bounds::<EchoEchoVectorsWithErrorRequest>(offset);
7757            // Zero out padding regions. There's no need to apply masks
7758            // because the unmasked parts will be overwritten by fields.
7759            unsafe {
7760                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(416);
7761                (ptr as *mut u64).write_unaligned(0);
7762            }
7763            unsafe {
7764                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(440);
7765                (ptr as *mut u64).write_unaligned(0);
7766            }
7767            // Write the fields.
7768            self.0.encode(encoder, offset + 0, depth)?;
7769            self.1.encode(encoder, offset + 416, depth)?;
7770            self.2.encode(encoder, offset + 424, depth)?;
7771            self.3.encode(encoder, offset + 440, depth)?;
7772            Ok(())
7773        }
7774    }
7775
7776    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7777        for EchoEchoVectorsWithErrorRequest
7778    {
7779        #[inline(always)]
7780        fn new_empty() -> Self {
7781            Self {
7782                value: fidl::new_empty!(
7783                    VectorsStruct,
7784                    fidl::encoding::DefaultFuchsiaResourceDialect
7785                ),
7786                result_err: fidl::new_empty!(
7787                    DefaultEnum,
7788                    fidl::encoding::DefaultFuchsiaResourceDialect
7789                ),
7790                forward_to_server: fidl::new_empty!(
7791                    fidl::encoding::UnboundedString,
7792                    fidl::encoding::DefaultFuchsiaResourceDialect
7793                ),
7794                result_variant: fidl::new_empty!(
7795                    RespondWith,
7796                    fidl::encoding::DefaultFuchsiaResourceDialect
7797                ),
7798            }
7799        }
7800
7801        #[inline]
7802        unsafe fn decode(
7803            &mut self,
7804            decoder: &mut fidl::encoding::Decoder<
7805                '_,
7806                fidl::encoding::DefaultFuchsiaResourceDialect,
7807            >,
7808            offset: usize,
7809            _depth: fidl::encoding::Depth,
7810        ) -> fidl::Result<()> {
7811            decoder.debug_check_bounds::<Self>(offset);
7812            // Verify that padding bytes are zero.
7813            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(416) };
7814            let padval = unsafe { (ptr as *const u64).read_unaligned() };
7815            let mask = 0xffffffff00000000u64;
7816            let maskedval = padval & mask;
7817            if maskedval != 0 {
7818                return Err(fidl::Error::NonZeroPadding {
7819                    padding_start: offset + 416 + ((mask as u64).trailing_zeros() / 8) as usize,
7820                });
7821            }
7822            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(440) };
7823            let padval = unsafe { (ptr as *const u64).read_unaligned() };
7824            let mask = 0xffffffff00000000u64;
7825            let maskedval = padval & mask;
7826            if maskedval != 0 {
7827                return Err(fidl::Error::NonZeroPadding {
7828                    padding_start: offset + 440 + ((mask as u64).trailing_zeros() / 8) as usize,
7829                });
7830            }
7831            fidl::decode!(
7832                VectorsStruct,
7833                fidl::encoding::DefaultFuchsiaResourceDialect,
7834                &mut self.value,
7835                decoder,
7836                offset + 0,
7837                _depth
7838            )?;
7839            fidl::decode!(
7840                DefaultEnum,
7841                fidl::encoding::DefaultFuchsiaResourceDialect,
7842                &mut self.result_err,
7843                decoder,
7844                offset + 416,
7845                _depth
7846            )?;
7847            fidl::decode!(
7848                fidl::encoding::UnboundedString,
7849                fidl::encoding::DefaultFuchsiaResourceDialect,
7850                &mut self.forward_to_server,
7851                decoder,
7852                offset + 424,
7853                _depth
7854            )?;
7855            fidl::decode!(
7856                RespondWith,
7857                fidl::encoding::DefaultFuchsiaResourceDialect,
7858                &mut self.result_variant,
7859                decoder,
7860                offset + 440,
7861                _depth
7862            )?;
7863            Ok(())
7864        }
7865    }
7866
7867    impl fidl::encoding::ResourceTypeMarker for EchoEchoXunionsRequest {
7868        type Borrowed<'a> = &'a mut Self;
7869        fn take_or_borrow<'a>(
7870            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7871        ) -> Self::Borrowed<'a> {
7872            value
7873        }
7874    }
7875
7876    unsafe impl fidl::encoding::TypeMarker for EchoEchoXunionsRequest {
7877        type Owned = Self;
7878
7879        #[inline(always)]
7880        fn inline_align(_context: fidl::encoding::Context) -> usize {
7881            8
7882        }
7883
7884        #[inline(always)]
7885        fn inline_size(_context: fidl::encoding::Context) -> usize {
7886            32
7887        }
7888    }
7889
7890    unsafe impl
7891        fidl::encoding::Encode<
7892            EchoEchoXunionsRequest,
7893            fidl::encoding::DefaultFuchsiaResourceDialect,
7894        > for &mut EchoEchoXunionsRequest
7895    {
7896        #[inline]
7897        unsafe fn encode(
7898            self,
7899            encoder: &mut fidl::encoding::Encoder<
7900                '_,
7901                fidl::encoding::DefaultFuchsiaResourceDialect,
7902            >,
7903            offset: usize,
7904            _depth: fidl::encoding::Depth,
7905        ) -> fidl::Result<()> {
7906            encoder.debug_check_bounds::<EchoEchoXunionsRequest>(offset);
7907            // Delegate to tuple encoding.
7908            fidl::encoding::Encode::<EchoEchoXunionsRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
7909                (
7910                    <fidl::encoding::UnboundedVector<AllTypesXunion> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
7911                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(&self.forward_to_server),
7912                ),
7913                encoder, offset, _depth
7914            )
7915        }
7916    }
7917    unsafe impl<
7918        T0: fidl::encoding::Encode<
7919                fidl::encoding::UnboundedVector<AllTypesXunion>,
7920                fidl::encoding::DefaultFuchsiaResourceDialect,
7921            >,
7922        T1: fidl::encoding::Encode<
7923                fidl::encoding::UnboundedString,
7924                fidl::encoding::DefaultFuchsiaResourceDialect,
7925            >,
7926    >
7927        fidl::encoding::Encode<
7928            EchoEchoXunionsRequest,
7929            fidl::encoding::DefaultFuchsiaResourceDialect,
7930        > for (T0, T1)
7931    {
7932        #[inline]
7933        unsafe fn encode(
7934            self,
7935            encoder: &mut fidl::encoding::Encoder<
7936                '_,
7937                fidl::encoding::DefaultFuchsiaResourceDialect,
7938            >,
7939            offset: usize,
7940            depth: fidl::encoding::Depth,
7941        ) -> fidl::Result<()> {
7942            encoder.debug_check_bounds::<EchoEchoXunionsRequest>(offset);
7943            // Zero out padding regions. There's no need to apply masks
7944            // because the unmasked parts will be overwritten by fields.
7945            // Write the fields.
7946            self.0.encode(encoder, offset + 0, depth)?;
7947            self.1.encode(encoder, offset + 16, depth)?;
7948            Ok(())
7949        }
7950    }
7951
7952    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7953        for EchoEchoXunionsRequest
7954    {
7955        #[inline(always)]
7956        fn new_empty() -> Self {
7957            Self {
7958                value: fidl::new_empty!(
7959                    fidl::encoding::UnboundedVector<AllTypesXunion>,
7960                    fidl::encoding::DefaultFuchsiaResourceDialect
7961                ),
7962                forward_to_server: fidl::new_empty!(
7963                    fidl::encoding::UnboundedString,
7964                    fidl::encoding::DefaultFuchsiaResourceDialect
7965                ),
7966            }
7967        }
7968
7969        #[inline]
7970        unsafe fn decode(
7971            &mut self,
7972            decoder: &mut fidl::encoding::Decoder<
7973                '_,
7974                fidl::encoding::DefaultFuchsiaResourceDialect,
7975            >,
7976            offset: usize,
7977            _depth: fidl::encoding::Depth,
7978        ) -> fidl::Result<()> {
7979            decoder.debug_check_bounds::<Self>(offset);
7980            // Verify that padding bytes are zero.
7981            fidl::decode!(
7982                fidl::encoding::UnboundedVector<AllTypesXunion>,
7983                fidl::encoding::DefaultFuchsiaResourceDialect,
7984                &mut self.value,
7985                decoder,
7986                offset + 0,
7987                _depth
7988            )?;
7989            fidl::decode!(
7990                fidl::encoding::UnboundedString,
7991                fidl::encoding::DefaultFuchsiaResourceDialect,
7992                &mut self.forward_to_server,
7993                decoder,
7994                offset + 16,
7995                _depth
7996            )?;
7997            Ok(())
7998        }
7999    }
8000
8001    impl fidl::encoding::ResourceTypeMarker for EchoEchoXunionsResponse {
8002        type Borrowed<'a> = &'a mut Self;
8003        fn take_or_borrow<'a>(
8004            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8005        ) -> Self::Borrowed<'a> {
8006            value
8007        }
8008    }
8009
8010    unsafe impl fidl::encoding::TypeMarker for EchoEchoXunionsResponse {
8011        type Owned = Self;
8012
8013        #[inline(always)]
8014        fn inline_align(_context: fidl::encoding::Context) -> usize {
8015            8
8016        }
8017
8018        #[inline(always)]
8019        fn inline_size(_context: fidl::encoding::Context) -> usize {
8020            16
8021        }
8022    }
8023
8024    unsafe impl
8025        fidl::encoding::Encode<
8026            EchoEchoXunionsResponse,
8027            fidl::encoding::DefaultFuchsiaResourceDialect,
8028        > for &mut EchoEchoXunionsResponse
8029    {
8030        #[inline]
8031        unsafe fn encode(
8032            self,
8033            encoder: &mut fidl::encoding::Encoder<
8034                '_,
8035                fidl::encoding::DefaultFuchsiaResourceDialect,
8036            >,
8037            offset: usize,
8038            _depth: fidl::encoding::Depth,
8039        ) -> fidl::Result<()> {
8040            encoder.debug_check_bounds::<EchoEchoXunionsResponse>(offset);
8041            // Delegate to tuple encoding.
8042            fidl::encoding::Encode::<EchoEchoXunionsResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
8043                (
8044                    <fidl::encoding::UnboundedVector<AllTypesXunion> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
8045                ),
8046                encoder, offset, _depth
8047            )
8048        }
8049    }
8050    unsafe impl<
8051        T0: fidl::encoding::Encode<
8052                fidl::encoding::UnboundedVector<AllTypesXunion>,
8053                fidl::encoding::DefaultFuchsiaResourceDialect,
8054            >,
8055    >
8056        fidl::encoding::Encode<
8057            EchoEchoXunionsResponse,
8058            fidl::encoding::DefaultFuchsiaResourceDialect,
8059        > for (T0,)
8060    {
8061        #[inline]
8062        unsafe fn encode(
8063            self,
8064            encoder: &mut fidl::encoding::Encoder<
8065                '_,
8066                fidl::encoding::DefaultFuchsiaResourceDialect,
8067            >,
8068            offset: usize,
8069            depth: fidl::encoding::Depth,
8070        ) -> fidl::Result<()> {
8071            encoder.debug_check_bounds::<EchoEchoXunionsResponse>(offset);
8072            // Zero out padding regions. There's no need to apply masks
8073            // because the unmasked parts will be overwritten by fields.
8074            // Write the fields.
8075            self.0.encode(encoder, offset + 0, depth)?;
8076            Ok(())
8077        }
8078    }
8079
8080    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8081        for EchoEchoXunionsResponse
8082    {
8083        #[inline(always)]
8084        fn new_empty() -> Self {
8085            Self {
8086                value: fidl::new_empty!(
8087                    fidl::encoding::UnboundedVector<AllTypesXunion>,
8088                    fidl::encoding::DefaultFuchsiaResourceDialect
8089                ),
8090            }
8091        }
8092
8093        #[inline]
8094        unsafe fn decode(
8095            &mut self,
8096            decoder: &mut fidl::encoding::Decoder<
8097                '_,
8098                fidl::encoding::DefaultFuchsiaResourceDialect,
8099            >,
8100            offset: usize,
8101            _depth: fidl::encoding::Depth,
8102        ) -> fidl::Result<()> {
8103            decoder.debug_check_bounds::<Self>(offset);
8104            // Verify that padding bytes are zero.
8105            fidl::decode!(
8106                fidl::encoding::UnboundedVector<AllTypesXunion>,
8107                fidl::encoding::DefaultFuchsiaResourceDialect,
8108                &mut self.value,
8109                decoder,
8110                offset + 0,
8111                _depth
8112            )?;
8113            Ok(())
8114        }
8115    }
8116
8117    impl fidl::encoding::ResourceTypeMarker for EchoEchoXunionsWithErrorRequest {
8118        type Borrowed<'a> = &'a mut Self;
8119        fn take_or_borrow<'a>(
8120            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8121        ) -> Self::Borrowed<'a> {
8122            value
8123        }
8124    }
8125
8126    unsafe impl fidl::encoding::TypeMarker for EchoEchoXunionsWithErrorRequest {
8127        type Owned = Self;
8128
8129        #[inline(always)]
8130        fn inline_align(_context: fidl::encoding::Context) -> usize {
8131            8
8132        }
8133
8134        #[inline(always)]
8135        fn inline_size(_context: fidl::encoding::Context) -> usize {
8136            48
8137        }
8138    }
8139
8140    unsafe impl
8141        fidl::encoding::Encode<
8142            EchoEchoXunionsWithErrorRequest,
8143            fidl::encoding::DefaultFuchsiaResourceDialect,
8144        > for &mut EchoEchoXunionsWithErrorRequest
8145    {
8146        #[inline]
8147        unsafe fn encode(
8148            self,
8149            encoder: &mut fidl::encoding::Encoder<
8150                '_,
8151                fidl::encoding::DefaultFuchsiaResourceDialect,
8152            >,
8153            offset: usize,
8154            _depth: fidl::encoding::Depth,
8155        ) -> fidl::Result<()> {
8156            encoder.debug_check_bounds::<EchoEchoXunionsWithErrorRequest>(offset);
8157            // Delegate to tuple encoding.
8158            fidl::encoding::Encode::<EchoEchoXunionsWithErrorRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
8159                (
8160                    <fidl::encoding::UnboundedVector<AllTypesXunion> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
8161                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
8162                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(&self.forward_to_server),
8163                    <RespondWith as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
8164                ),
8165                encoder, offset, _depth
8166            )
8167        }
8168    }
8169    unsafe impl<
8170        T0: fidl::encoding::Encode<
8171                fidl::encoding::UnboundedVector<AllTypesXunion>,
8172                fidl::encoding::DefaultFuchsiaResourceDialect,
8173            >,
8174        T1: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8175        T2: fidl::encoding::Encode<
8176                fidl::encoding::UnboundedString,
8177                fidl::encoding::DefaultFuchsiaResourceDialect,
8178            >,
8179        T3: fidl::encoding::Encode<RespondWith, fidl::encoding::DefaultFuchsiaResourceDialect>,
8180    >
8181        fidl::encoding::Encode<
8182            EchoEchoXunionsWithErrorRequest,
8183            fidl::encoding::DefaultFuchsiaResourceDialect,
8184        > for (T0, T1, T2, T3)
8185    {
8186        #[inline]
8187        unsafe fn encode(
8188            self,
8189            encoder: &mut fidl::encoding::Encoder<
8190                '_,
8191                fidl::encoding::DefaultFuchsiaResourceDialect,
8192            >,
8193            offset: usize,
8194            depth: fidl::encoding::Depth,
8195        ) -> fidl::Result<()> {
8196            encoder.debug_check_bounds::<EchoEchoXunionsWithErrorRequest>(offset);
8197            // Zero out padding regions. There's no need to apply masks
8198            // because the unmasked parts will be overwritten by fields.
8199            unsafe {
8200                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
8201                (ptr as *mut u64).write_unaligned(0);
8202            }
8203            unsafe {
8204                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
8205                (ptr as *mut u64).write_unaligned(0);
8206            }
8207            // Write the fields.
8208            self.0.encode(encoder, offset + 0, depth)?;
8209            self.1.encode(encoder, offset + 16, depth)?;
8210            self.2.encode(encoder, offset + 24, depth)?;
8211            self.3.encode(encoder, offset + 40, depth)?;
8212            Ok(())
8213        }
8214    }
8215
8216    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8217        for EchoEchoXunionsWithErrorRequest
8218    {
8219        #[inline(always)]
8220        fn new_empty() -> Self {
8221            Self {
8222                value: fidl::new_empty!(
8223                    fidl::encoding::UnboundedVector<AllTypesXunion>,
8224                    fidl::encoding::DefaultFuchsiaResourceDialect
8225                ),
8226                result_err: fidl::new_empty!(
8227                    DefaultEnum,
8228                    fidl::encoding::DefaultFuchsiaResourceDialect
8229                ),
8230                forward_to_server: fidl::new_empty!(
8231                    fidl::encoding::UnboundedString,
8232                    fidl::encoding::DefaultFuchsiaResourceDialect
8233                ),
8234                result_variant: fidl::new_empty!(
8235                    RespondWith,
8236                    fidl::encoding::DefaultFuchsiaResourceDialect
8237                ),
8238            }
8239        }
8240
8241        #[inline]
8242        unsafe fn decode(
8243            &mut self,
8244            decoder: &mut fidl::encoding::Decoder<
8245                '_,
8246                fidl::encoding::DefaultFuchsiaResourceDialect,
8247            >,
8248            offset: usize,
8249            _depth: fidl::encoding::Depth,
8250        ) -> fidl::Result<()> {
8251            decoder.debug_check_bounds::<Self>(offset);
8252            // Verify that padding bytes are zero.
8253            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
8254            let padval = unsafe { (ptr as *const u64).read_unaligned() };
8255            let mask = 0xffffffff00000000u64;
8256            let maskedval = padval & mask;
8257            if maskedval != 0 {
8258                return Err(fidl::Error::NonZeroPadding {
8259                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
8260                });
8261            }
8262            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
8263            let padval = unsafe { (ptr as *const u64).read_unaligned() };
8264            let mask = 0xffffffff00000000u64;
8265            let maskedval = padval & mask;
8266            if maskedval != 0 {
8267                return Err(fidl::Error::NonZeroPadding {
8268                    padding_start: offset + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
8269                });
8270            }
8271            fidl::decode!(
8272                fidl::encoding::UnboundedVector<AllTypesXunion>,
8273                fidl::encoding::DefaultFuchsiaResourceDialect,
8274                &mut self.value,
8275                decoder,
8276                offset + 0,
8277                _depth
8278            )?;
8279            fidl::decode!(
8280                DefaultEnum,
8281                fidl::encoding::DefaultFuchsiaResourceDialect,
8282                &mut self.result_err,
8283                decoder,
8284                offset + 16,
8285                _depth
8286            )?;
8287            fidl::decode!(
8288                fidl::encoding::UnboundedString,
8289                fidl::encoding::DefaultFuchsiaResourceDialect,
8290                &mut self.forward_to_server,
8291                decoder,
8292                offset + 24,
8293                _depth
8294            )?;
8295            fidl::decode!(
8296                RespondWith,
8297                fidl::encoding::DefaultFuchsiaResourceDialect,
8298                &mut self.result_variant,
8299                decoder,
8300                offset + 40,
8301                _depth
8302            )?;
8303            Ok(())
8304        }
8305    }
8306
8307    impl fidl::encoding::ResourceTypeMarker for EchoEchoArraysWithErrorResponse {
8308        type Borrowed<'a> = &'a mut Self;
8309        fn take_or_borrow<'a>(
8310            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8311        ) -> Self::Borrowed<'a> {
8312            value
8313        }
8314    }
8315
8316    unsafe impl fidl::encoding::TypeMarker for EchoEchoArraysWithErrorResponse {
8317        type Owned = Self;
8318
8319        #[inline(always)]
8320        fn inline_align(_context: fidl::encoding::Context) -> usize {
8321            8
8322        }
8323
8324        #[inline(always)]
8325        fn inline_size(_context: fidl::encoding::Context) -> usize {
8326            680
8327        }
8328    }
8329
8330    unsafe impl
8331        fidl::encoding::Encode<
8332            EchoEchoArraysWithErrorResponse,
8333            fidl::encoding::DefaultFuchsiaResourceDialect,
8334        > for &mut EchoEchoArraysWithErrorResponse
8335    {
8336        #[inline]
8337        unsafe fn encode(
8338            self,
8339            encoder: &mut fidl::encoding::Encoder<
8340                '_,
8341                fidl::encoding::DefaultFuchsiaResourceDialect,
8342            >,
8343            offset: usize,
8344            _depth: fidl::encoding::Depth,
8345        ) -> fidl::Result<()> {
8346            encoder.debug_check_bounds::<EchoEchoArraysWithErrorResponse>(offset);
8347            // Delegate to tuple encoding.
8348            fidl::encoding::Encode::<
8349                EchoEchoArraysWithErrorResponse,
8350                fidl::encoding::DefaultFuchsiaResourceDialect,
8351            >::encode(
8352                (<ArraysStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8353                    &mut self.value,
8354                ),),
8355                encoder,
8356                offset,
8357                _depth,
8358            )
8359        }
8360    }
8361    unsafe impl<
8362        T0: fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
8363    >
8364        fidl::encoding::Encode<
8365            EchoEchoArraysWithErrorResponse,
8366            fidl::encoding::DefaultFuchsiaResourceDialect,
8367        > for (T0,)
8368    {
8369        #[inline]
8370        unsafe fn encode(
8371            self,
8372            encoder: &mut fidl::encoding::Encoder<
8373                '_,
8374                fidl::encoding::DefaultFuchsiaResourceDialect,
8375            >,
8376            offset: usize,
8377            depth: fidl::encoding::Depth,
8378        ) -> fidl::Result<()> {
8379            encoder.debug_check_bounds::<EchoEchoArraysWithErrorResponse>(offset);
8380            // Zero out padding regions. There's no need to apply masks
8381            // because the unmasked parts will be overwritten by fields.
8382            // Write the fields.
8383            self.0.encode(encoder, offset + 0, depth)?;
8384            Ok(())
8385        }
8386    }
8387
8388    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8389        for EchoEchoArraysWithErrorResponse
8390    {
8391        #[inline(always)]
8392        fn new_empty() -> Self {
8393            Self {
8394                value: fidl::new_empty!(
8395                    ArraysStruct,
8396                    fidl::encoding::DefaultFuchsiaResourceDialect
8397                ),
8398            }
8399        }
8400
8401        #[inline]
8402        unsafe fn decode(
8403            &mut self,
8404            decoder: &mut fidl::encoding::Decoder<
8405                '_,
8406                fidl::encoding::DefaultFuchsiaResourceDialect,
8407            >,
8408            offset: usize,
8409            _depth: fidl::encoding::Depth,
8410        ) -> fidl::Result<()> {
8411            decoder.debug_check_bounds::<Self>(offset);
8412            // Verify that padding bytes are zero.
8413            fidl::decode!(
8414                ArraysStruct,
8415                fidl::encoding::DefaultFuchsiaResourceDialect,
8416                &mut self.value,
8417                decoder,
8418                offset + 0,
8419                _depth
8420            )?;
8421            Ok(())
8422        }
8423    }
8424
8425    impl fidl::encoding::ResourceTypeMarker for EchoEchoStructWithErrorResponse {
8426        type Borrowed<'a> = &'a mut Self;
8427        fn take_or_borrow<'a>(
8428            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8429        ) -> Self::Borrowed<'a> {
8430            value
8431        }
8432    }
8433
8434    unsafe impl fidl::encoding::TypeMarker for EchoEchoStructWithErrorResponse {
8435        type Owned = Self;
8436
8437        #[inline(always)]
8438        fn inline_align(_context: fidl::encoding::Context) -> usize {
8439            8
8440        }
8441
8442        #[inline(always)]
8443        fn inline_size(_context: fidl::encoding::Context) -> usize {
8444            2912
8445        }
8446    }
8447
8448    unsafe impl
8449        fidl::encoding::Encode<
8450            EchoEchoStructWithErrorResponse,
8451            fidl::encoding::DefaultFuchsiaResourceDialect,
8452        > for &mut EchoEchoStructWithErrorResponse
8453    {
8454        #[inline]
8455        unsafe fn encode(
8456            self,
8457            encoder: &mut fidl::encoding::Encoder<
8458                '_,
8459                fidl::encoding::DefaultFuchsiaResourceDialect,
8460            >,
8461            offset: usize,
8462            _depth: fidl::encoding::Depth,
8463        ) -> fidl::Result<()> {
8464            encoder.debug_check_bounds::<EchoEchoStructWithErrorResponse>(offset);
8465            // Delegate to tuple encoding.
8466            fidl::encoding::Encode::<
8467                EchoEchoStructWithErrorResponse,
8468                fidl::encoding::DefaultFuchsiaResourceDialect,
8469            >::encode(
8470                (<Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),),
8471                encoder,
8472                offset,
8473                _depth,
8474            )
8475        }
8476    }
8477    unsafe impl<T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>>
8478        fidl::encoding::Encode<
8479            EchoEchoStructWithErrorResponse,
8480            fidl::encoding::DefaultFuchsiaResourceDialect,
8481        > for (T0,)
8482    {
8483        #[inline]
8484        unsafe fn encode(
8485            self,
8486            encoder: &mut fidl::encoding::Encoder<
8487                '_,
8488                fidl::encoding::DefaultFuchsiaResourceDialect,
8489            >,
8490            offset: usize,
8491            depth: fidl::encoding::Depth,
8492        ) -> fidl::Result<()> {
8493            encoder.debug_check_bounds::<EchoEchoStructWithErrorResponse>(offset);
8494            // Zero out padding regions. There's no need to apply masks
8495            // because the unmasked parts will be overwritten by fields.
8496            // Write the fields.
8497            self.0.encode(encoder, offset + 0, depth)?;
8498            Ok(())
8499        }
8500    }
8501
8502    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8503        for EchoEchoStructWithErrorResponse
8504    {
8505        #[inline(always)]
8506        fn new_empty() -> Self {
8507            Self { value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect) }
8508        }
8509
8510        #[inline]
8511        unsafe fn decode(
8512            &mut self,
8513            decoder: &mut fidl::encoding::Decoder<
8514                '_,
8515                fidl::encoding::DefaultFuchsiaResourceDialect,
8516            >,
8517            offset: usize,
8518            _depth: fidl::encoding::Depth,
8519        ) -> fidl::Result<()> {
8520            decoder.debug_check_bounds::<Self>(offset);
8521            // Verify that padding bytes are zero.
8522            fidl::decode!(
8523                Struct,
8524                fidl::encoding::DefaultFuchsiaResourceDialect,
8525                &mut self.value,
8526                decoder,
8527                offset + 0,
8528                _depth
8529            )?;
8530            Ok(())
8531        }
8532    }
8533
8534    impl fidl::encoding::ResourceTypeMarker for EchoEchoTableWithErrorResponse {
8535        type Borrowed<'a> = &'a mut Self;
8536        fn take_or_borrow<'a>(
8537            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8538        ) -> Self::Borrowed<'a> {
8539            value
8540        }
8541    }
8542
8543    unsafe impl fidl::encoding::TypeMarker for EchoEchoTableWithErrorResponse {
8544        type Owned = Self;
8545
8546        #[inline(always)]
8547        fn inline_align(_context: fidl::encoding::Context) -> usize {
8548            8
8549        }
8550
8551        #[inline(always)]
8552        fn inline_size(_context: fidl::encoding::Context) -> usize {
8553            16
8554        }
8555    }
8556
8557    unsafe impl
8558        fidl::encoding::Encode<
8559            EchoEchoTableWithErrorResponse,
8560            fidl::encoding::DefaultFuchsiaResourceDialect,
8561        > for &mut EchoEchoTableWithErrorResponse
8562    {
8563        #[inline]
8564        unsafe fn encode(
8565            self,
8566            encoder: &mut fidl::encoding::Encoder<
8567                '_,
8568                fidl::encoding::DefaultFuchsiaResourceDialect,
8569            >,
8570            offset: usize,
8571            _depth: fidl::encoding::Depth,
8572        ) -> fidl::Result<()> {
8573            encoder.debug_check_bounds::<EchoEchoTableWithErrorResponse>(offset);
8574            // Delegate to tuple encoding.
8575            fidl::encoding::Encode::<
8576                EchoEchoTableWithErrorResponse,
8577                fidl::encoding::DefaultFuchsiaResourceDialect,
8578            >::encode(
8579                (<AllTypesTable as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8580                    &mut self.value,
8581                ),),
8582                encoder,
8583                offset,
8584                _depth,
8585            )
8586        }
8587    }
8588    unsafe impl<
8589        T0: fidl::encoding::Encode<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>,
8590    >
8591        fidl::encoding::Encode<
8592            EchoEchoTableWithErrorResponse,
8593            fidl::encoding::DefaultFuchsiaResourceDialect,
8594        > for (T0,)
8595    {
8596        #[inline]
8597        unsafe fn encode(
8598            self,
8599            encoder: &mut fidl::encoding::Encoder<
8600                '_,
8601                fidl::encoding::DefaultFuchsiaResourceDialect,
8602            >,
8603            offset: usize,
8604            depth: fidl::encoding::Depth,
8605        ) -> fidl::Result<()> {
8606            encoder.debug_check_bounds::<EchoEchoTableWithErrorResponse>(offset);
8607            // Zero out padding regions. There's no need to apply masks
8608            // because the unmasked parts will be overwritten by fields.
8609            // Write the fields.
8610            self.0.encode(encoder, offset + 0, depth)?;
8611            Ok(())
8612        }
8613    }
8614
8615    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8616        for EchoEchoTableWithErrorResponse
8617    {
8618        #[inline(always)]
8619        fn new_empty() -> Self {
8620            Self {
8621                value: fidl::new_empty!(
8622                    AllTypesTable,
8623                    fidl::encoding::DefaultFuchsiaResourceDialect
8624                ),
8625            }
8626        }
8627
8628        #[inline]
8629        unsafe fn decode(
8630            &mut self,
8631            decoder: &mut fidl::encoding::Decoder<
8632                '_,
8633                fidl::encoding::DefaultFuchsiaResourceDialect,
8634            >,
8635            offset: usize,
8636            _depth: fidl::encoding::Depth,
8637        ) -> fidl::Result<()> {
8638            decoder.debug_check_bounds::<Self>(offset);
8639            // Verify that padding bytes are zero.
8640            fidl::decode!(
8641                AllTypesTable,
8642                fidl::encoding::DefaultFuchsiaResourceDialect,
8643                &mut self.value,
8644                decoder,
8645                offset + 0,
8646                _depth
8647            )?;
8648            Ok(())
8649        }
8650    }
8651
8652    impl fidl::encoding::ResourceTypeMarker for EchoEchoVectorsWithErrorResponse {
8653        type Borrowed<'a> = &'a mut Self;
8654        fn take_or_borrow<'a>(
8655            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8656        ) -> Self::Borrowed<'a> {
8657            value
8658        }
8659    }
8660
8661    unsafe impl fidl::encoding::TypeMarker for EchoEchoVectorsWithErrorResponse {
8662        type Owned = Self;
8663
8664        #[inline(always)]
8665        fn inline_align(_context: fidl::encoding::Context) -> usize {
8666            8
8667        }
8668
8669        #[inline(always)]
8670        fn inline_size(_context: fidl::encoding::Context) -> usize {
8671            416
8672        }
8673    }
8674
8675    unsafe impl
8676        fidl::encoding::Encode<
8677            EchoEchoVectorsWithErrorResponse,
8678            fidl::encoding::DefaultFuchsiaResourceDialect,
8679        > for &mut EchoEchoVectorsWithErrorResponse
8680    {
8681        #[inline]
8682        unsafe fn encode(
8683            self,
8684            encoder: &mut fidl::encoding::Encoder<
8685                '_,
8686                fidl::encoding::DefaultFuchsiaResourceDialect,
8687            >,
8688            offset: usize,
8689            _depth: fidl::encoding::Depth,
8690        ) -> fidl::Result<()> {
8691            encoder.debug_check_bounds::<EchoEchoVectorsWithErrorResponse>(offset);
8692            // Delegate to tuple encoding.
8693            fidl::encoding::Encode::<
8694                EchoEchoVectorsWithErrorResponse,
8695                fidl::encoding::DefaultFuchsiaResourceDialect,
8696            >::encode(
8697                (<VectorsStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8698                    &mut self.value,
8699                ),),
8700                encoder,
8701                offset,
8702                _depth,
8703            )
8704        }
8705    }
8706    unsafe impl<
8707        T0: fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
8708    >
8709        fidl::encoding::Encode<
8710            EchoEchoVectorsWithErrorResponse,
8711            fidl::encoding::DefaultFuchsiaResourceDialect,
8712        > for (T0,)
8713    {
8714        #[inline]
8715        unsafe fn encode(
8716            self,
8717            encoder: &mut fidl::encoding::Encoder<
8718                '_,
8719                fidl::encoding::DefaultFuchsiaResourceDialect,
8720            >,
8721            offset: usize,
8722            depth: fidl::encoding::Depth,
8723        ) -> fidl::Result<()> {
8724            encoder.debug_check_bounds::<EchoEchoVectorsWithErrorResponse>(offset);
8725            // Zero out padding regions. There's no need to apply masks
8726            // because the unmasked parts will be overwritten by fields.
8727            // Write the fields.
8728            self.0.encode(encoder, offset + 0, depth)?;
8729            Ok(())
8730        }
8731    }
8732
8733    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8734        for EchoEchoVectorsWithErrorResponse
8735    {
8736        #[inline(always)]
8737        fn new_empty() -> Self {
8738            Self {
8739                value: fidl::new_empty!(
8740                    VectorsStruct,
8741                    fidl::encoding::DefaultFuchsiaResourceDialect
8742                ),
8743            }
8744        }
8745
8746        #[inline]
8747        unsafe fn decode(
8748            &mut self,
8749            decoder: &mut fidl::encoding::Decoder<
8750                '_,
8751                fidl::encoding::DefaultFuchsiaResourceDialect,
8752            >,
8753            offset: usize,
8754            _depth: fidl::encoding::Depth,
8755        ) -> fidl::Result<()> {
8756            decoder.debug_check_bounds::<Self>(offset);
8757            // Verify that padding bytes are zero.
8758            fidl::decode!(
8759                VectorsStruct,
8760                fidl::encoding::DefaultFuchsiaResourceDialect,
8761                &mut self.value,
8762                decoder,
8763                offset + 0,
8764                _depth
8765            )?;
8766            Ok(())
8767        }
8768    }
8769
8770    impl fidl::encoding::ResourceTypeMarker for EchoEchoXunionsWithErrorResponse {
8771        type Borrowed<'a> = &'a mut Self;
8772        fn take_or_borrow<'a>(
8773            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8774        ) -> Self::Borrowed<'a> {
8775            value
8776        }
8777    }
8778
8779    unsafe impl fidl::encoding::TypeMarker for EchoEchoXunionsWithErrorResponse {
8780        type Owned = Self;
8781
8782        #[inline(always)]
8783        fn inline_align(_context: fidl::encoding::Context) -> usize {
8784            8
8785        }
8786
8787        #[inline(always)]
8788        fn inline_size(_context: fidl::encoding::Context) -> usize {
8789            16
8790        }
8791    }
8792
8793    unsafe impl
8794        fidl::encoding::Encode<
8795            EchoEchoXunionsWithErrorResponse,
8796            fidl::encoding::DefaultFuchsiaResourceDialect,
8797        > for &mut EchoEchoXunionsWithErrorResponse
8798    {
8799        #[inline]
8800        unsafe fn encode(
8801            self,
8802            encoder: &mut fidl::encoding::Encoder<
8803                '_,
8804                fidl::encoding::DefaultFuchsiaResourceDialect,
8805            >,
8806            offset: usize,
8807            _depth: fidl::encoding::Depth,
8808        ) -> fidl::Result<()> {
8809            encoder.debug_check_bounds::<EchoEchoXunionsWithErrorResponse>(offset);
8810            // Delegate to tuple encoding.
8811            fidl::encoding::Encode::<EchoEchoXunionsWithErrorResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
8812                (
8813                    <fidl::encoding::UnboundedVector<AllTypesXunion> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
8814                ),
8815                encoder, offset, _depth
8816            )
8817        }
8818    }
8819    unsafe impl<
8820        T0: fidl::encoding::Encode<
8821                fidl::encoding::UnboundedVector<AllTypesXunion>,
8822                fidl::encoding::DefaultFuchsiaResourceDialect,
8823            >,
8824    >
8825        fidl::encoding::Encode<
8826            EchoEchoXunionsWithErrorResponse,
8827            fidl::encoding::DefaultFuchsiaResourceDialect,
8828        > for (T0,)
8829    {
8830        #[inline]
8831        unsafe fn encode(
8832            self,
8833            encoder: &mut fidl::encoding::Encoder<
8834                '_,
8835                fidl::encoding::DefaultFuchsiaResourceDialect,
8836            >,
8837            offset: usize,
8838            depth: fidl::encoding::Depth,
8839        ) -> fidl::Result<()> {
8840            encoder.debug_check_bounds::<EchoEchoXunionsWithErrorResponse>(offset);
8841            // Zero out padding regions. There's no need to apply masks
8842            // because the unmasked parts will be overwritten by fields.
8843            // Write the fields.
8844            self.0.encode(encoder, offset + 0, depth)?;
8845            Ok(())
8846        }
8847    }
8848
8849    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8850        for EchoEchoXunionsWithErrorResponse
8851    {
8852        #[inline(always)]
8853        fn new_empty() -> Self {
8854            Self {
8855                value: fidl::new_empty!(
8856                    fidl::encoding::UnboundedVector<AllTypesXunion>,
8857                    fidl::encoding::DefaultFuchsiaResourceDialect
8858                ),
8859            }
8860        }
8861
8862        #[inline]
8863        unsafe fn decode(
8864            &mut self,
8865            decoder: &mut fidl::encoding::Decoder<
8866                '_,
8867                fidl::encoding::DefaultFuchsiaResourceDialect,
8868            >,
8869            offset: usize,
8870            _depth: fidl::encoding::Depth,
8871        ) -> fidl::Result<()> {
8872            decoder.debug_check_bounds::<Self>(offset);
8873            // Verify that padding bytes are zero.
8874            fidl::decode!(
8875                fidl::encoding::UnboundedVector<AllTypesXunion>,
8876                fidl::encoding::DefaultFuchsiaResourceDialect,
8877                &mut self.value,
8878                decoder,
8879                offset + 0,
8880                _depth
8881            )?;
8882            Ok(())
8883        }
8884    }
8885
8886    impl fidl::encoding::ResourceTypeMarker for Struct {
8887        type Borrowed<'a> = &'a mut Self;
8888        fn take_or_borrow<'a>(
8889            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8890        ) -> Self::Borrowed<'a> {
8891            value
8892        }
8893    }
8894
8895    unsafe impl fidl::encoding::TypeMarker for Struct {
8896        type Owned = Self;
8897
8898        #[inline(always)]
8899        fn inline_align(_context: fidl::encoding::Context) -> usize {
8900            8
8901        }
8902
8903        #[inline(always)]
8904        fn inline_size(_context: fidl::encoding::Context) -> usize {
8905            2912
8906        }
8907    }
8908
8909    unsafe impl fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>
8910        for &mut Struct
8911    {
8912        #[inline]
8913        unsafe fn encode(
8914            self,
8915            encoder: &mut fidl::encoding::Encoder<
8916                '_,
8917                fidl::encoding::DefaultFuchsiaResourceDialect,
8918            >,
8919            offset: usize,
8920            _depth: fidl::encoding::Depth,
8921        ) -> fidl::Result<()> {
8922            encoder.debug_check_bounds::<Struct>(offset);
8923            // Delegate to tuple encoding.
8924            fidl::encoding::Encode::<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
8925                (
8926                    <PrimitiveTypes as fidl::encoding::ValueTypeMarker>::borrow(
8927                        &self.primitive_types,
8928                    ),
8929                    <DefaultValues as fidl::encoding::ValueTypeMarker>::borrow(
8930                        &self.default_values,
8931                    ),
8932                    <Arrays as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8933                        &mut self.arrays,
8934                    ),
8935                    <Arrays2d as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8936                        &mut self.arrays_2d,
8937                    ),
8938                    <Vectors as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8939                        &mut self.vectors,
8940                    ),
8941                    <Handles as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8942                        &mut self.handles,
8943                    ),
8944                    <Strings as fidl::encoding::ValueTypeMarker>::borrow(&self.strings),
8945                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.default_enum),
8946                    <I8Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_enum),
8947                    <I16Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_enum),
8948                    <I32Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_enum),
8949                    <I64Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_enum),
8950                    <U8Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_enum),
8951                    <U16Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_enum),
8952                    <U32Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_enum),
8953                    <U64Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_enum),
8954                    <DefaultBits as fidl::encoding::ValueTypeMarker>::borrow(&self.default_bits),
8955                    <U8Bits as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_bits),
8956                    <U16Bits as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_bits),
8957                    <U32Bits as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_bits),
8958                    <U64Bits as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_bits),
8959                    <Structs as fidl::encoding::ValueTypeMarker>::borrow(&self.structs),
8960                    <Unions as fidl::encoding::ValueTypeMarker>::borrow(&self.unions),
8961                    <ThisIsATable as fidl::encoding::ValueTypeMarker>::borrow(&self.table),
8962                    <ThisIsAXunion as fidl::encoding::ValueTypeMarker>::borrow(&self.xunion),
8963                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.b),
8964                ),
8965                encoder,
8966                offset,
8967                _depth,
8968            )
8969        }
8970    }
8971    unsafe impl<
8972        T0: fidl::encoding::Encode<PrimitiveTypes, fidl::encoding::DefaultFuchsiaResourceDialect>,
8973        T1: fidl::encoding::Encode<DefaultValues, fidl::encoding::DefaultFuchsiaResourceDialect>,
8974        T2: fidl::encoding::Encode<Arrays, fidl::encoding::DefaultFuchsiaResourceDialect>,
8975        T3: fidl::encoding::Encode<Arrays2d, fidl::encoding::DefaultFuchsiaResourceDialect>,
8976        T4: fidl::encoding::Encode<Vectors, fidl::encoding::DefaultFuchsiaResourceDialect>,
8977        T5: fidl::encoding::Encode<Handles, fidl::encoding::DefaultFuchsiaResourceDialect>,
8978        T6: fidl::encoding::Encode<Strings, fidl::encoding::DefaultFuchsiaResourceDialect>,
8979        T7: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8980        T8: fidl::encoding::Encode<I8Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8981        T9: fidl::encoding::Encode<I16Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8982        T10: fidl::encoding::Encode<I32Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8983        T11: fidl::encoding::Encode<I64Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8984        T12: fidl::encoding::Encode<U8Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8985        T13: fidl::encoding::Encode<U16Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8986        T14: fidl::encoding::Encode<U32Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8987        T15: fidl::encoding::Encode<U64Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8988        T16: fidl::encoding::Encode<DefaultBits, fidl::encoding::DefaultFuchsiaResourceDialect>,
8989        T17: fidl::encoding::Encode<U8Bits, fidl::encoding::DefaultFuchsiaResourceDialect>,
8990        T18: fidl::encoding::Encode<U16Bits, fidl::encoding::DefaultFuchsiaResourceDialect>,
8991        T19: fidl::encoding::Encode<U32Bits, fidl::encoding::DefaultFuchsiaResourceDialect>,
8992        T20: fidl::encoding::Encode<U64Bits, fidl::encoding::DefaultFuchsiaResourceDialect>,
8993        T21: fidl::encoding::Encode<Structs, fidl::encoding::DefaultFuchsiaResourceDialect>,
8994        T22: fidl::encoding::Encode<Unions, fidl::encoding::DefaultFuchsiaResourceDialect>,
8995        T23: fidl::encoding::Encode<ThisIsATable, fidl::encoding::DefaultFuchsiaResourceDialect>,
8996        T24: fidl::encoding::Encode<ThisIsAXunion, fidl::encoding::DefaultFuchsiaResourceDialect>,
8997        T25: fidl::encoding::Encode<bool, fidl::encoding::DefaultFuchsiaResourceDialect>,
8998    > fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>
8999        for (
9000            T0,
9001            T1,
9002            T2,
9003            T3,
9004            T4,
9005            T5,
9006            T6,
9007            T7,
9008            T8,
9009            T9,
9010            T10,
9011            T11,
9012            T12,
9013            T13,
9014            T14,
9015            T15,
9016            T16,
9017            T17,
9018            T18,
9019            T19,
9020            T20,
9021            T21,
9022            T22,
9023            T23,
9024            T24,
9025            T25,
9026        )
9027    {
9028        #[inline]
9029        unsafe fn encode(
9030            self,
9031            encoder: &mut fidl::encoding::Encoder<
9032                '_,
9033                fidl::encoding::DefaultFuchsiaResourceDialect,
9034            >,
9035            offset: usize,
9036            depth: fidl::encoding::Depth,
9037        ) -> fidl::Result<()> {
9038            encoder.debug_check_bounds::<Struct>(offset);
9039            // Zero out padding regions. There's no need to apply masks
9040            // because the unmasked parts will be overwritten by fields.
9041            unsafe {
9042                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2640);
9043                (ptr as *mut u64).write_unaligned(0);
9044            }
9045            unsafe {
9046                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2744);
9047                (ptr as *mut u64).write_unaligned(0);
9048            }
9049            unsafe {
9050                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2752);
9051                (ptr as *mut u64).write_unaligned(0);
9052            }
9053            unsafe {
9054                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2768);
9055                (ptr as *mut u64).write_unaligned(0);
9056            }
9057            unsafe {
9058                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2784);
9059                (ptr as *mut u64).write_unaligned(0);
9060            }
9061            unsafe {
9062                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2792);
9063                (ptr as *mut u64).write_unaligned(0);
9064            }
9065            unsafe {
9066                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2904);
9067                (ptr as *mut u64).write_unaligned(0);
9068            }
9069            // Write the fields.
9070            self.0.encode(encoder, offset + 0, depth)?;
9071            self.1.encode(encoder, offset + 48, depth)?;
9072            self.2.encode(encoder, offset + 120, depth)?;
9073            self.3.encode(encoder, offset + 328, depth)?;
9074            self.4.encode(encoder, offset + 616, depth)?;
9075            self.5.encode(encoder, offset + 2536, depth)?;
9076            self.6.encode(encoder, offset + 2648, depth)?;
9077            self.7.encode(encoder, offset + 2744, depth)?;
9078            self.8.encode(encoder, offset + 2748, depth)?;
9079            self.9.encode(encoder, offset + 2750, depth)?;
9080            self.10.encode(encoder, offset + 2752, depth)?;
9081            self.11.encode(encoder, offset + 2760, depth)?;
9082            self.12.encode(encoder, offset + 2768, depth)?;
9083            self.13.encode(encoder, offset + 2770, depth)?;
9084            self.14.encode(encoder, offset + 2772, depth)?;
9085            self.15.encode(encoder, offset + 2776, depth)?;
9086            self.16.encode(encoder, offset + 2784, depth)?;
9087            self.17.encode(encoder, offset + 2788, depth)?;
9088            self.18.encode(encoder, offset + 2790, depth)?;
9089            self.19.encode(encoder, offset + 2792, depth)?;
9090            self.20.encode(encoder, offset + 2800, depth)?;
9091            self.21.encode(encoder, offset + 2808, depth)?;
9092            self.22.encode(encoder, offset + 2840, depth)?;
9093            self.23.encode(encoder, offset + 2872, depth)?;
9094            self.24.encode(encoder, offset + 2888, depth)?;
9095            self.25.encode(encoder, offset + 2904, depth)?;
9096            Ok(())
9097        }
9098    }
9099
9100    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Struct {
9101        #[inline(always)]
9102        fn new_empty() -> Self {
9103            Self {
9104                primitive_types: fidl::new_empty!(
9105                    PrimitiveTypes,
9106                    fidl::encoding::DefaultFuchsiaResourceDialect
9107                ),
9108                default_values: fidl::new_empty!(
9109                    DefaultValues,
9110                    fidl::encoding::DefaultFuchsiaResourceDialect
9111                ),
9112                arrays: fidl::new_empty!(Arrays, fidl::encoding::DefaultFuchsiaResourceDialect),
9113                arrays_2d: fidl::new_empty!(
9114                    Arrays2d,
9115                    fidl::encoding::DefaultFuchsiaResourceDialect
9116                ),
9117                vectors: fidl::new_empty!(Vectors, fidl::encoding::DefaultFuchsiaResourceDialect),
9118                handles: fidl::new_empty!(Handles, fidl::encoding::DefaultFuchsiaResourceDialect),
9119                strings: fidl::new_empty!(Strings, fidl::encoding::DefaultFuchsiaResourceDialect),
9120                default_enum: fidl::new_empty!(
9121                    DefaultEnum,
9122                    fidl::encoding::DefaultFuchsiaResourceDialect
9123                ),
9124                i8_enum: fidl::new_empty!(I8Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9125                i16_enum: fidl::new_empty!(I16Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9126                i32_enum: fidl::new_empty!(I32Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9127                i64_enum: fidl::new_empty!(I64Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9128                u8_enum: fidl::new_empty!(U8Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9129                u16_enum: fidl::new_empty!(U16Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9130                u32_enum: fidl::new_empty!(U32Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9131                u64_enum: fidl::new_empty!(U64Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9132                default_bits: fidl::new_empty!(
9133                    DefaultBits,
9134                    fidl::encoding::DefaultFuchsiaResourceDialect
9135                ),
9136                u8_bits: fidl::new_empty!(U8Bits, fidl::encoding::DefaultFuchsiaResourceDialect),
9137                u16_bits: fidl::new_empty!(U16Bits, fidl::encoding::DefaultFuchsiaResourceDialect),
9138                u32_bits: fidl::new_empty!(U32Bits, fidl::encoding::DefaultFuchsiaResourceDialect),
9139                u64_bits: fidl::new_empty!(U64Bits, fidl::encoding::DefaultFuchsiaResourceDialect),
9140                structs: fidl::new_empty!(Structs, fidl::encoding::DefaultFuchsiaResourceDialect),
9141                unions: fidl::new_empty!(Unions, fidl::encoding::DefaultFuchsiaResourceDialect),
9142                table: fidl::new_empty!(
9143                    ThisIsATable,
9144                    fidl::encoding::DefaultFuchsiaResourceDialect
9145                ),
9146                xunion: fidl::new_empty!(
9147                    ThisIsAXunion,
9148                    fidl::encoding::DefaultFuchsiaResourceDialect
9149                ),
9150                b: fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect),
9151            }
9152        }
9153
9154        #[inline]
9155        unsafe fn decode(
9156            &mut self,
9157            decoder: &mut fidl::encoding::Decoder<
9158                '_,
9159                fidl::encoding::DefaultFuchsiaResourceDialect,
9160            >,
9161            offset: usize,
9162            _depth: fidl::encoding::Depth,
9163        ) -> fidl::Result<()> {
9164            decoder.debug_check_bounds::<Self>(offset);
9165            // Verify that padding bytes are zero.
9166            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2640) };
9167            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9168            let mask = 0xffffffff00000000u64;
9169            let maskedval = padval & mask;
9170            if maskedval != 0 {
9171                return Err(fidl::Error::NonZeroPadding {
9172                    padding_start: offset + 2640 + ((mask as u64).trailing_zeros() / 8) as usize,
9173                });
9174            }
9175            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2744) };
9176            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9177            let mask = 0xff0000000000u64;
9178            let maskedval = padval & mask;
9179            if maskedval != 0 {
9180                return Err(fidl::Error::NonZeroPadding {
9181                    padding_start: offset + 2744 + ((mask as u64).trailing_zeros() / 8) as usize,
9182                });
9183            }
9184            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2752) };
9185            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9186            let mask = 0xffffffff00000000u64;
9187            let maskedval = padval & mask;
9188            if maskedval != 0 {
9189                return Err(fidl::Error::NonZeroPadding {
9190                    padding_start: offset + 2752 + ((mask as u64).trailing_zeros() / 8) as usize,
9191                });
9192            }
9193            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2768) };
9194            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9195            let mask = 0xff00u64;
9196            let maskedval = padval & mask;
9197            if maskedval != 0 {
9198                return Err(fidl::Error::NonZeroPadding {
9199                    padding_start: offset + 2768 + ((mask as u64).trailing_zeros() / 8) as usize,
9200                });
9201            }
9202            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2784) };
9203            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9204            let mask = 0xff0000000000u64;
9205            let maskedval = padval & mask;
9206            if maskedval != 0 {
9207                return Err(fidl::Error::NonZeroPadding {
9208                    padding_start: offset + 2784 + ((mask as u64).trailing_zeros() / 8) as usize,
9209                });
9210            }
9211            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2792) };
9212            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9213            let mask = 0xffffffff00000000u64;
9214            let maskedval = padval & mask;
9215            if maskedval != 0 {
9216                return Err(fidl::Error::NonZeroPadding {
9217                    padding_start: offset + 2792 + ((mask as u64).trailing_zeros() / 8) as usize,
9218                });
9219            }
9220            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2904) };
9221            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9222            let mask = 0xffffffffffffff00u64;
9223            let maskedval = padval & mask;
9224            if maskedval != 0 {
9225                return Err(fidl::Error::NonZeroPadding {
9226                    padding_start: offset + 2904 + ((mask as u64).trailing_zeros() / 8) as usize,
9227                });
9228            }
9229            fidl::decode!(
9230                PrimitiveTypes,
9231                fidl::encoding::DefaultFuchsiaResourceDialect,
9232                &mut self.primitive_types,
9233                decoder,
9234                offset + 0,
9235                _depth
9236            )?;
9237            fidl::decode!(
9238                DefaultValues,
9239                fidl::encoding::DefaultFuchsiaResourceDialect,
9240                &mut self.default_values,
9241                decoder,
9242                offset + 48,
9243                _depth
9244            )?;
9245            fidl::decode!(
9246                Arrays,
9247                fidl::encoding::DefaultFuchsiaResourceDialect,
9248                &mut self.arrays,
9249                decoder,
9250                offset + 120,
9251                _depth
9252            )?;
9253            fidl::decode!(
9254                Arrays2d,
9255                fidl::encoding::DefaultFuchsiaResourceDialect,
9256                &mut self.arrays_2d,
9257                decoder,
9258                offset + 328,
9259                _depth
9260            )?;
9261            fidl::decode!(
9262                Vectors,
9263                fidl::encoding::DefaultFuchsiaResourceDialect,
9264                &mut self.vectors,
9265                decoder,
9266                offset + 616,
9267                _depth
9268            )?;
9269            fidl::decode!(
9270                Handles,
9271                fidl::encoding::DefaultFuchsiaResourceDialect,
9272                &mut self.handles,
9273                decoder,
9274                offset + 2536,
9275                _depth
9276            )?;
9277            fidl::decode!(
9278                Strings,
9279                fidl::encoding::DefaultFuchsiaResourceDialect,
9280                &mut self.strings,
9281                decoder,
9282                offset + 2648,
9283                _depth
9284            )?;
9285            fidl::decode!(
9286                DefaultEnum,
9287                fidl::encoding::DefaultFuchsiaResourceDialect,
9288                &mut self.default_enum,
9289                decoder,
9290                offset + 2744,
9291                _depth
9292            )?;
9293            fidl::decode!(
9294                I8Enum,
9295                fidl::encoding::DefaultFuchsiaResourceDialect,
9296                &mut self.i8_enum,
9297                decoder,
9298                offset + 2748,
9299                _depth
9300            )?;
9301            fidl::decode!(
9302                I16Enum,
9303                fidl::encoding::DefaultFuchsiaResourceDialect,
9304                &mut self.i16_enum,
9305                decoder,
9306                offset + 2750,
9307                _depth
9308            )?;
9309            fidl::decode!(
9310                I32Enum,
9311                fidl::encoding::DefaultFuchsiaResourceDialect,
9312                &mut self.i32_enum,
9313                decoder,
9314                offset + 2752,
9315                _depth
9316            )?;
9317            fidl::decode!(
9318                I64Enum,
9319                fidl::encoding::DefaultFuchsiaResourceDialect,
9320                &mut self.i64_enum,
9321                decoder,
9322                offset + 2760,
9323                _depth
9324            )?;
9325            fidl::decode!(
9326                U8Enum,
9327                fidl::encoding::DefaultFuchsiaResourceDialect,
9328                &mut self.u8_enum,
9329                decoder,
9330                offset + 2768,
9331                _depth
9332            )?;
9333            fidl::decode!(
9334                U16Enum,
9335                fidl::encoding::DefaultFuchsiaResourceDialect,
9336                &mut self.u16_enum,
9337                decoder,
9338                offset + 2770,
9339                _depth
9340            )?;
9341            fidl::decode!(
9342                U32Enum,
9343                fidl::encoding::DefaultFuchsiaResourceDialect,
9344                &mut self.u32_enum,
9345                decoder,
9346                offset + 2772,
9347                _depth
9348            )?;
9349            fidl::decode!(
9350                U64Enum,
9351                fidl::encoding::DefaultFuchsiaResourceDialect,
9352                &mut self.u64_enum,
9353                decoder,
9354                offset + 2776,
9355                _depth
9356            )?;
9357            fidl::decode!(
9358                DefaultBits,
9359                fidl::encoding::DefaultFuchsiaResourceDialect,
9360                &mut self.default_bits,
9361                decoder,
9362                offset + 2784,
9363                _depth
9364            )?;
9365            fidl::decode!(
9366                U8Bits,
9367                fidl::encoding::DefaultFuchsiaResourceDialect,
9368                &mut self.u8_bits,
9369                decoder,
9370                offset + 2788,
9371                _depth
9372            )?;
9373            fidl::decode!(
9374                U16Bits,
9375                fidl::encoding::DefaultFuchsiaResourceDialect,
9376                &mut self.u16_bits,
9377                decoder,
9378                offset + 2790,
9379                _depth
9380            )?;
9381            fidl::decode!(
9382                U32Bits,
9383                fidl::encoding::DefaultFuchsiaResourceDialect,
9384                &mut self.u32_bits,
9385                decoder,
9386                offset + 2792,
9387                _depth
9388            )?;
9389            fidl::decode!(
9390                U64Bits,
9391                fidl::encoding::DefaultFuchsiaResourceDialect,
9392                &mut self.u64_bits,
9393                decoder,
9394                offset + 2800,
9395                _depth
9396            )?;
9397            fidl::decode!(
9398                Structs,
9399                fidl::encoding::DefaultFuchsiaResourceDialect,
9400                &mut self.structs,
9401                decoder,
9402                offset + 2808,
9403                _depth
9404            )?;
9405            fidl::decode!(
9406                Unions,
9407                fidl::encoding::DefaultFuchsiaResourceDialect,
9408                &mut self.unions,
9409                decoder,
9410                offset + 2840,
9411                _depth
9412            )?;
9413            fidl::decode!(
9414                ThisIsATable,
9415                fidl::encoding::DefaultFuchsiaResourceDialect,
9416                &mut self.table,
9417                decoder,
9418                offset + 2872,
9419                _depth
9420            )?;
9421            fidl::decode!(
9422                ThisIsAXunion,
9423                fidl::encoding::DefaultFuchsiaResourceDialect,
9424                &mut self.xunion,
9425                decoder,
9426                offset + 2888,
9427                _depth
9428            )?;
9429            fidl::decode!(
9430                bool,
9431                fidl::encoding::DefaultFuchsiaResourceDialect,
9432                &mut self.b,
9433                decoder,
9434                offset + 2904,
9435                _depth
9436            )?;
9437            Ok(())
9438        }
9439    }
9440
9441    impl fidl::encoding::ResourceTypeMarker for VectorsStruct {
9442        type Borrowed<'a> = &'a mut Self;
9443        fn take_or_borrow<'a>(
9444            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
9445        ) -> Self::Borrowed<'a> {
9446            value
9447        }
9448    }
9449
9450    unsafe impl fidl::encoding::TypeMarker for VectorsStruct {
9451        type Owned = Self;
9452
9453        #[inline(always)]
9454        fn inline_align(_context: fidl::encoding::Context) -> usize {
9455            8
9456        }
9457
9458        #[inline(always)]
9459        fn inline_size(_context: fidl::encoding::Context) -> usize {
9460            416
9461        }
9462    }
9463
9464    unsafe impl fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
9465        for &mut VectorsStruct
9466    {
9467        #[inline]
9468        unsafe fn encode(
9469            self,
9470            encoder: &mut fidl::encoding::Encoder<
9471                '_,
9472                fidl::encoding::DefaultFuchsiaResourceDialect,
9473            >,
9474            offset: usize,
9475            _depth: fidl::encoding::Depth,
9476        ) -> fidl::Result<()> {
9477            encoder.debug_check_bounds::<VectorsStruct>(offset);
9478            // Delegate to tuple encoding.
9479            fidl::encoding::Encode::<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
9480                (
9481                    <fidl::encoding::Vector<bool, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.bools),
9482                    <fidl::encoding::Vector<i8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int8s),
9483                    <fidl::encoding::Vector<i16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int16s),
9484                    <fidl::encoding::Vector<i32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int32s),
9485                    <fidl::encoding::Vector<i64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int64s),
9486                    <fidl::encoding::Vector<u8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint8s),
9487                    <fidl::encoding::Vector<u16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint16s),
9488                    <fidl::encoding::Vector<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint32s),
9489                    <fidl::encoding::Vector<u64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint64s),
9490                    <fidl::encoding::Vector<f32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.float32s),
9491                    <fidl::encoding::Vector<f64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.float64s),
9492                    <fidl::encoding::Vector<DefaultEnum, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.enums),
9493                    <fidl::encoding::Vector<DefaultBits, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.bits),
9494                    <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),
9495                    <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),
9496                    <fidl::encoding::Vector<fidl::encoding::UnboundedString, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.strings),
9497                    <fidl::encoding::Vector<fidl::encoding::Optional<fidl::encoding::UnboundedString>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_strings),
9498                    <fidl::encoding::Vector<ThisIsAStruct, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.structs),
9499                    <fidl::encoding::Vector<fidl::encoding::Boxed<ThisIsAStruct>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_structs),
9500                    <fidl::encoding::Vector<ThisIsAUnion, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.unions),
9501                    <fidl::encoding::Vector<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_unions),
9502                    <fidl::encoding::Vector<fidl::encoding::Array<u32, 3>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.arrays),
9503                    <fidl::encoding::Vector<fidl::encoding::UnboundedVector<u32>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.vectors),
9504                    <fidl::encoding::Vector<fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_vectors),
9505                    <fidl::encoding::Vector<ThisIsATable, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.tables),
9506                    <fidl::encoding::Vector<ThisIsAXunion, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.xunions),
9507                ),
9508                encoder, offset, _depth
9509            )
9510        }
9511    }
9512    unsafe impl<
9513        T0: fidl::encoding::Encode<
9514                fidl::encoding::Vector<bool, 3>,
9515                fidl::encoding::DefaultFuchsiaResourceDialect,
9516            >,
9517        T1: fidl::encoding::Encode<
9518                fidl::encoding::Vector<i8, 3>,
9519                fidl::encoding::DefaultFuchsiaResourceDialect,
9520            >,
9521        T2: fidl::encoding::Encode<
9522                fidl::encoding::Vector<i16, 3>,
9523                fidl::encoding::DefaultFuchsiaResourceDialect,
9524            >,
9525        T3: fidl::encoding::Encode<
9526                fidl::encoding::Vector<i32, 3>,
9527                fidl::encoding::DefaultFuchsiaResourceDialect,
9528            >,
9529        T4: fidl::encoding::Encode<
9530                fidl::encoding::Vector<i64, 3>,
9531                fidl::encoding::DefaultFuchsiaResourceDialect,
9532            >,
9533        T5: fidl::encoding::Encode<
9534                fidl::encoding::Vector<u8, 3>,
9535                fidl::encoding::DefaultFuchsiaResourceDialect,
9536            >,
9537        T6: fidl::encoding::Encode<
9538                fidl::encoding::Vector<u16, 3>,
9539                fidl::encoding::DefaultFuchsiaResourceDialect,
9540            >,
9541        T7: fidl::encoding::Encode<
9542                fidl::encoding::Vector<u32, 3>,
9543                fidl::encoding::DefaultFuchsiaResourceDialect,
9544            >,
9545        T8: fidl::encoding::Encode<
9546                fidl::encoding::Vector<u64, 3>,
9547                fidl::encoding::DefaultFuchsiaResourceDialect,
9548            >,
9549        T9: fidl::encoding::Encode<
9550                fidl::encoding::Vector<f32, 3>,
9551                fidl::encoding::DefaultFuchsiaResourceDialect,
9552            >,
9553        T10: fidl::encoding::Encode<
9554                fidl::encoding::Vector<f64, 3>,
9555                fidl::encoding::DefaultFuchsiaResourceDialect,
9556            >,
9557        T11: fidl::encoding::Encode<
9558                fidl::encoding::Vector<DefaultEnum, 3>,
9559                fidl::encoding::DefaultFuchsiaResourceDialect,
9560            >,
9561        T12: fidl::encoding::Encode<
9562                fidl::encoding::Vector<DefaultBits, 3>,
9563                fidl::encoding::DefaultFuchsiaResourceDialect,
9564            >,
9565        T13: fidl::encoding::Encode<
9566                fidl::encoding::Vector<
9567                    fidl::encoding::HandleType<
9568                        fidl::NullableHandle,
9569                        { fidl::ObjectType::NONE.into_raw() },
9570                        2147483648,
9571                    >,
9572                    3,
9573                >,
9574                fidl::encoding::DefaultFuchsiaResourceDialect,
9575            >,
9576        T14: fidl::encoding::Encode<
9577                fidl::encoding::Vector<
9578                    fidl::encoding::Optional<
9579                        fidl::encoding::HandleType<
9580                            fidl::NullableHandle,
9581                            { fidl::ObjectType::NONE.into_raw() },
9582                            2147483648,
9583                        >,
9584                    >,
9585                    3,
9586                >,
9587                fidl::encoding::DefaultFuchsiaResourceDialect,
9588            >,
9589        T15: fidl::encoding::Encode<
9590                fidl::encoding::Vector<fidl::encoding::UnboundedString, 3>,
9591                fidl::encoding::DefaultFuchsiaResourceDialect,
9592            >,
9593        T16: fidl::encoding::Encode<
9594                fidl::encoding::Vector<
9595                    fidl::encoding::Optional<fidl::encoding::UnboundedString>,
9596                    3,
9597                >,
9598                fidl::encoding::DefaultFuchsiaResourceDialect,
9599            >,
9600        T17: fidl::encoding::Encode<
9601                fidl::encoding::Vector<ThisIsAStruct, 3>,
9602                fidl::encoding::DefaultFuchsiaResourceDialect,
9603            >,
9604        T18: fidl::encoding::Encode<
9605                fidl::encoding::Vector<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
9606                fidl::encoding::DefaultFuchsiaResourceDialect,
9607            >,
9608        T19: fidl::encoding::Encode<
9609                fidl::encoding::Vector<ThisIsAUnion, 3>,
9610                fidl::encoding::DefaultFuchsiaResourceDialect,
9611            >,
9612        T20: fidl::encoding::Encode<
9613                fidl::encoding::Vector<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
9614                fidl::encoding::DefaultFuchsiaResourceDialect,
9615            >,
9616        T21: fidl::encoding::Encode<
9617                fidl::encoding::Vector<fidl::encoding::Array<u32, 3>, 3>,
9618                fidl::encoding::DefaultFuchsiaResourceDialect,
9619            >,
9620        T22: fidl::encoding::Encode<
9621                fidl::encoding::Vector<fidl::encoding::UnboundedVector<u32>, 3>,
9622                fidl::encoding::DefaultFuchsiaResourceDialect,
9623            >,
9624        T23: fidl::encoding::Encode<
9625                fidl::encoding::Vector<
9626                    fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
9627                    3,
9628                >,
9629                fidl::encoding::DefaultFuchsiaResourceDialect,
9630            >,
9631        T24: fidl::encoding::Encode<
9632                fidl::encoding::Vector<ThisIsATable, 3>,
9633                fidl::encoding::DefaultFuchsiaResourceDialect,
9634            >,
9635        T25: fidl::encoding::Encode<
9636                fidl::encoding::Vector<ThisIsAXunion, 3>,
9637                fidl::encoding::DefaultFuchsiaResourceDialect,
9638            >,
9639    > fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
9640        for (
9641            T0,
9642            T1,
9643            T2,
9644            T3,
9645            T4,
9646            T5,
9647            T6,
9648            T7,
9649            T8,
9650            T9,
9651            T10,
9652            T11,
9653            T12,
9654            T13,
9655            T14,
9656            T15,
9657            T16,
9658            T17,
9659            T18,
9660            T19,
9661            T20,
9662            T21,
9663            T22,
9664            T23,
9665            T24,
9666            T25,
9667        )
9668    {
9669        #[inline]
9670        unsafe fn encode(
9671            self,
9672            encoder: &mut fidl::encoding::Encoder<
9673                '_,
9674                fidl::encoding::DefaultFuchsiaResourceDialect,
9675            >,
9676            offset: usize,
9677            depth: fidl::encoding::Depth,
9678        ) -> fidl::Result<()> {
9679            encoder.debug_check_bounds::<VectorsStruct>(offset);
9680            // Zero out padding regions. There's no need to apply masks
9681            // because the unmasked parts will be overwritten by fields.
9682            // Write the fields.
9683            self.0.encode(encoder, offset + 0, depth)?;
9684            self.1.encode(encoder, offset + 16, depth)?;
9685            self.2.encode(encoder, offset + 32, depth)?;
9686            self.3.encode(encoder, offset + 48, depth)?;
9687            self.4.encode(encoder, offset + 64, depth)?;
9688            self.5.encode(encoder, offset + 80, depth)?;
9689            self.6.encode(encoder, offset + 96, depth)?;
9690            self.7.encode(encoder, offset + 112, depth)?;
9691            self.8.encode(encoder, offset + 128, depth)?;
9692            self.9.encode(encoder, offset + 144, depth)?;
9693            self.10.encode(encoder, offset + 160, depth)?;
9694            self.11.encode(encoder, offset + 176, depth)?;
9695            self.12.encode(encoder, offset + 192, depth)?;
9696            self.13.encode(encoder, offset + 208, depth)?;
9697            self.14.encode(encoder, offset + 224, depth)?;
9698            self.15.encode(encoder, offset + 240, depth)?;
9699            self.16.encode(encoder, offset + 256, depth)?;
9700            self.17.encode(encoder, offset + 272, depth)?;
9701            self.18.encode(encoder, offset + 288, depth)?;
9702            self.19.encode(encoder, offset + 304, depth)?;
9703            self.20.encode(encoder, offset + 320, depth)?;
9704            self.21.encode(encoder, offset + 336, depth)?;
9705            self.22.encode(encoder, offset + 352, depth)?;
9706            self.23.encode(encoder, offset + 368, depth)?;
9707            self.24.encode(encoder, offset + 384, depth)?;
9708            self.25.encode(encoder, offset + 400, depth)?;
9709            Ok(())
9710        }
9711    }
9712
9713    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for VectorsStruct {
9714        #[inline(always)]
9715        fn new_empty() -> Self {
9716            Self {
9717                bools: fidl::new_empty!(fidl::encoding::Vector<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9718                int8s: fidl::new_empty!(fidl::encoding::Vector<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9719                int16s: fidl::new_empty!(fidl::encoding::Vector<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9720                int32s: fidl::new_empty!(fidl::encoding::Vector<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9721                int64s: fidl::new_empty!(fidl::encoding::Vector<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9722                uint8s: fidl::new_empty!(fidl::encoding::Vector<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9723                uint16s: fidl::new_empty!(fidl::encoding::Vector<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9724                uint32s: fidl::new_empty!(fidl::encoding::Vector<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9725                uint64s: fidl::new_empty!(fidl::encoding::Vector<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9726                float32s: fidl::new_empty!(fidl::encoding::Vector<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9727                float64s: fidl::new_empty!(fidl::encoding::Vector<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9728                enums: fidl::new_empty!(fidl::encoding::Vector<DefaultEnum, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9729                bits: fidl::new_empty!(fidl::encoding::Vector<DefaultBits, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9730                handles: fidl::new_empty!(
9731                    fidl::encoding::Vector<
9732                        fidl::encoding::HandleType<
9733                            fidl::NullableHandle,
9734                            { fidl::ObjectType::NONE.into_raw() },
9735                            2147483648,
9736                        >,
9737                        3,
9738                    >,
9739                    fidl::encoding::DefaultFuchsiaResourceDialect
9740                ),
9741                nullable_handles: fidl::new_empty!(
9742                    fidl::encoding::Vector<
9743                        fidl::encoding::Optional<
9744                            fidl::encoding::HandleType<
9745                                fidl::NullableHandle,
9746                                { fidl::ObjectType::NONE.into_raw() },
9747                                2147483648,
9748                            >,
9749                        >,
9750                        3,
9751                    >,
9752                    fidl::encoding::DefaultFuchsiaResourceDialect
9753                ),
9754                strings: fidl::new_empty!(fidl::encoding::Vector<fidl::encoding::UnboundedString, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9755                nullable_strings: fidl::new_empty!(
9756                    fidl::encoding::Vector<
9757                        fidl::encoding::Optional<fidl::encoding::UnboundedString>,
9758                        3,
9759                    >,
9760                    fidl::encoding::DefaultFuchsiaResourceDialect
9761                ),
9762                structs: fidl::new_empty!(fidl::encoding::Vector<ThisIsAStruct, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9763                nullable_structs: fidl::new_empty!(
9764                    fidl::encoding::Vector<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
9765                    fidl::encoding::DefaultFuchsiaResourceDialect
9766                ),
9767                unions: fidl::new_empty!(fidl::encoding::Vector<ThisIsAUnion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9768                nullable_unions: fidl::new_empty!(
9769                    fidl::encoding::Vector<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
9770                    fidl::encoding::DefaultFuchsiaResourceDialect
9771                ),
9772                arrays: fidl::new_empty!(
9773                    fidl::encoding::Vector<fidl::encoding::Array<u32, 3>, 3>,
9774                    fidl::encoding::DefaultFuchsiaResourceDialect
9775                ),
9776                vectors: fidl::new_empty!(
9777                    fidl::encoding::Vector<fidl::encoding::UnboundedVector<u32>, 3>,
9778                    fidl::encoding::DefaultFuchsiaResourceDialect
9779                ),
9780                nullable_vectors: fidl::new_empty!(
9781                    fidl::encoding::Vector<
9782                        fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
9783                        3,
9784                    >,
9785                    fidl::encoding::DefaultFuchsiaResourceDialect
9786                ),
9787                tables: fidl::new_empty!(fidl::encoding::Vector<ThisIsATable, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9788                xunions: fidl::new_empty!(fidl::encoding::Vector<ThisIsAXunion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9789            }
9790        }
9791
9792        #[inline]
9793        unsafe fn decode(
9794            &mut self,
9795            decoder: &mut fidl::encoding::Decoder<
9796                '_,
9797                fidl::encoding::DefaultFuchsiaResourceDialect,
9798            >,
9799            offset: usize,
9800            _depth: fidl::encoding::Depth,
9801        ) -> fidl::Result<()> {
9802            decoder.debug_check_bounds::<Self>(offset);
9803            // Verify that padding bytes are zero.
9804            fidl::decode!(fidl::encoding::Vector<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.bools, decoder, offset + 0, _depth)?;
9805            fidl::decode!(fidl::encoding::Vector<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int8s, decoder, offset + 16, _depth)?;
9806            fidl::decode!(fidl::encoding::Vector<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int16s, decoder, offset + 32, _depth)?;
9807            fidl::decode!(fidl::encoding::Vector<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int32s, decoder, offset + 48, _depth)?;
9808            fidl::decode!(fidl::encoding::Vector<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int64s, decoder, offset + 64, _depth)?;
9809            fidl::decode!(fidl::encoding::Vector<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint8s, decoder, offset + 80, _depth)?;
9810            fidl::decode!(fidl::encoding::Vector<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint16s, decoder, offset + 96, _depth)?;
9811            fidl::decode!(fidl::encoding::Vector<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint32s, decoder, offset + 112, _depth)?;
9812            fidl::decode!(fidl::encoding::Vector<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint64s, decoder, offset + 128, _depth)?;
9813            fidl::decode!(fidl::encoding::Vector<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.float32s, decoder, offset + 144, _depth)?;
9814            fidl::decode!(fidl::encoding::Vector<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.float64s, decoder, offset + 160, _depth)?;
9815            fidl::decode!(fidl::encoding::Vector<DefaultEnum, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.enums, decoder, offset + 176, _depth)?;
9816            fidl::decode!(fidl::encoding::Vector<DefaultBits, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.bits, decoder, offset + 192, _depth)?;
9817            fidl::decode!(
9818                fidl::encoding::Vector<
9819                    fidl::encoding::HandleType<
9820                        fidl::NullableHandle,
9821                        { fidl::ObjectType::NONE.into_raw() },
9822                        2147483648,
9823                    >,
9824                    3,
9825                >,
9826                fidl::encoding::DefaultFuchsiaResourceDialect,
9827                &mut self.handles,
9828                decoder,
9829                offset + 208,
9830                _depth
9831            )?;
9832            fidl::decode!(
9833                fidl::encoding::Vector<
9834                    fidl::encoding::Optional<
9835                        fidl::encoding::HandleType<
9836                            fidl::NullableHandle,
9837                            { fidl::ObjectType::NONE.into_raw() },
9838                            2147483648,
9839                        >,
9840                    >,
9841                    3,
9842                >,
9843                fidl::encoding::DefaultFuchsiaResourceDialect,
9844                &mut self.nullable_handles,
9845                decoder,
9846                offset + 224,
9847                _depth
9848            )?;
9849            fidl::decode!(fidl::encoding::Vector<fidl::encoding::UnboundedString, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.strings, decoder, offset + 240, _depth)?;
9850            fidl::decode!(
9851                fidl::encoding::Vector<
9852                    fidl::encoding::Optional<fidl::encoding::UnboundedString>,
9853                    3,
9854                >,
9855                fidl::encoding::DefaultFuchsiaResourceDialect,
9856                &mut self.nullable_strings,
9857                decoder,
9858                offset + 256,
9859                _depth
9860            )?;
9861            fidl::decode!(fidl::encoding::Vector<ThisIsAStruct, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.structs, decoder, offset + 272, _depth)?;
9862            fidl::decode!(
9863                fidl::encoding::Vector<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
9864                fidl::encoding::DefaultFuchsiaResourceDialect,
9865                &mut self.nullable_structs,
9866                decoder,
9867                offset + 288,
9868                _depth
9869            )?;
9870            fidl::decode!(fidl::encoding::Vector<ThisIsAUnion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.unions, decoder, offset + 304, _depth)?;
9871            fidl::decode!(
9872                fidl::encoding::Vector<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
9873                fidl::encoding::DefaultFuchsiaResourceDialect,
9874                &mut self.nullable_unions,
9875                decoder,
9876                offset + 320,
9877                _depth
9878            )?;
9879            fidl::decode!(
9880                fidl::encoding::Vector<fidl::encoding::Array<u32, 3>, 3>,
9881                fidl::encoding::DefaultFuchsiaResourceDialect,
9882                &mut self.arrays,
9883                decoder,
9884                offset + 336,
9885                _depth
9886            )?;
9887            fidl::decode!(
9888                fidl::encoding::Vector<fidl::encoding::UnboundedVector<u32>, 3>,
9889                fidl::encoding::DefaultFuchsiaResourceDialect,
9890                &mut self.vectors,
9891                decoder,
9892                offset + 352,
9893                _depth
9894            )?;
9895            fidl::decode!(
9896                fidl::encoding::Vector<
9897                    fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
9898                    3,
9899                >,
9900                fidl::encoding::DefaultFuchsiaResourceDialect,
9901                &mut self.nullable_vectors,
9902                decoder,
9903                offset + 368,
9904                _depth
9905            )?;
9906            fidl::decode!(fidl::encoding::Vector<ThisIsATable, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.tables, decoder, offset + 384, _depth)?;
9907            fidl::decode!(fidl::encoding::Vector<ThisIsAXunion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.xunions, decoder, offset + 400, _depth)?;
9908            Ok(())
9909        }
9910    }
9911
9912    impl fidl::encoding::ResourceTypeMarker for Arrays {
9913        type Borrowed<'a> = &'a mut Self;
9914        fn take_or_borrow<'a>(
9915            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
9916        ) -> Self::Borrowed<'a> {
9917            value
9918        }
9919    }
9920
9921    unsafe impl fidl::encoding::TypeMarker for Arrays {
9922        type Owned = Self;
9923
9924        #[inline(always)]
9925        fn inline_align(_context: fidl::encoding::Context) -> usize {
9926            8
9927        }
9928
9929        #[inline(always)]
9930        fn inline_size(_context: fidl::encoding::Context) -> usize {
9931            208
9932        }
9933    }
9934
9935    unsafe impl fidl::encoding::Encode<Arrays, fidl::encoding::DefaultFuchsiaResourceDialect>
9936        for &mut Arrays
9937    {
9938        #[inline]
9939        unsafe fn encode(
9940            self,
9941            encoder: &mut fidl::encoding::Encoder<
9942                '_,
9943                fidl::encoding::DefaultFuchsiaResourceDialect,
9944            >,
9945            offset: usize,
9946            _depth: fidl::encoding::Depth,
9947        ) -> fidl::Result<()> {
9948            encoder.debug_check_bounds::<Arrays>(offset);
9949            // Delegate to tuple encoding.
9950            fidl::encoding::Encode::<Arrays, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
9951                (
9952                    <fidl::encoding::Array<bool, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9953                        &self.b_0,
9954                    ),
9955                    <fidl::encoding::Array<i8, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9956                        &self.i8_0,
9957                    ),
9958                    <fidl::encoding::Array<i16, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9959                        &self.i16_0,
9960                    ),
9961                    <fidl::encoding::Array<i32, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9962                        &self.i32_0,
9963                    ),
9964                    <fidl::encoding::Array<i64, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9965                        &self.i64_0,
9966                    ),
9967                    <fidl::encoding::Array<u8, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9968                        &self.u8_0,
9969                    ),
9970                    <fidl::encoding::Array<u16, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9971                        &self.u16_0,
9972                    ),
9973                    <fidl::encoding::Array<u32, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9974                        &self.u32_0,
9975                    ),
9976                    <fidl::encoding::Array<u64, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9977                        &self.u64_0,
9978                    ),
9979                    <fidl::encoding::Array<f32, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9980                        &self.f32_0,
9981                    ),
9982                    <fidl::encoding::Array<f64, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9983                        &self.f64_0,
9984                    ),
9985                    <fidl::encoding::Array<
9986                        fidl::encoding::HandleType<
9987                            fidl::NullableHandle,
9988                            { fidl::ObjectType::NONE.into_raw() },
9989                            2147483648,
9990                        >,
9991                        1,
9992                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
9993                        &mut self.handle_0
9994                    ),
9995                    <fidl::encoding::Array<bool, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9996                        &self.b_1,
9997                    ),
9998                    <fidl::encoding::Array<i8, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9999                        &self.i8_1,
10000                    ),
10001                    <fidl::encoding::Array<i16, 3> as fidl::encoding::ValueTypeMarker>::borrow(
10002                        &self.i16_1,
10003                    ),
10004                    <fidl::encoding::Array<i32, 3> as fidl::encoding::ValueTypeMarker>::borrow(
10005                        &self.i32_1,
10006                    ),
10007                    <fidl::encoding::Array<i64, 3> as fidl::encoding::ValueTypeMarker>::borrow(
10008                        &self.i64_1,
10009                    ),
10010                    <fidl::encoding::Array<u8, 3> as fidl::encoding::ValueTypeMarker>::borrow(
10011                        &self.u8_1,
10012                    ),
10013                    <fidl::encoding::Array<u16, 3> as fidl::encoding::ValueTypeMarker>::borrow(
10014                        &self.u16_1,
10015                    ),
10016                    <fidl::encoding::Array<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow(
10017                        &self.u32_1,
10018                    ),
10019                    <fidl::encoding::Array<u64, 3> as fidl::encoding::ValueTypeMarker>::borrow(
10020                        &self.u64_1,
10021                    ),
10022                    <fidl::encoding::Array<f32, 3> as fidl::encoding::ValueTypeMarker>::borrow(
10023                        &self.f32_1,
10024                    ),
10025                    <fidl::encoding::Array<f64, 3> as fidl::encoding::ValueTypeMarker>::borrow(
10026                        &self.f64_1,
10027                    ),
10028                    <fidl::encoding::Array<
10029                        fidl::encoding::HandleType<
10030                            fidl::NullableHandle,
10031                            { fidl::ObjectType::NONE.into_raw() },
10032                            2147483648,
10033                        >,
10034                        3,
10035                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10036                        &mut self.handle_1
10037                    ),
10038                ),
10039                encoder,
10040                offset,
10041                _depth,
10042            )
10043        }
10044    }
10045    unsafe impl<
10046        T0: fidl::encoding::Encode<
10047                fidl::encoding::Array<bool, 1>,
10048                fidl::encoding::DefaultFuchsiaResourceDialect,
10049            >,
10050        T1: fidl::encoding::Encode<
10051                fidl::encoding::Array<i8, 1>,
10052                fidl::encoding::DefaultFuchsiaResourceDialect,
10053            >,
10054        T2: fidl::encoding::Encode<
10055                fidl::encoding::Array<i16, 1>,
10056                fidl::encoding::DefaultFuchsiaResourceDialect,
10057            >,
10058        T3: fidl::encoding::Encode<
10059                fidl::encoding::Array<i32, 1>,
10060                fidl::encoding::DefaultFuchsiaResourceDialect,
10061            >,
10062        T4: fidl::encoding::Encode<
10063                fidl::encoding::Array<i64, 1>,
10064                fidl::encoding::DefaultFuchsiaResourceDialect,
10065            >,
10066        T5: fidl::encoding::Encode<
10067                fidl::encoding::Array<u8, 1>,
10068                fidl::encoding::DefaultFuchsiaResourceDialect,
10069            >,
10070        T6: fidl::encoding::Encode<
10071                fidl::encoding::Array<u16, 1>,
10072                fidl::encoding::DefaultFuchsiaResourceDialect,
10073            >,
10074        T7: fidl::encoding::Encode<
10075                fidl::encoding::Array<u32, 1>,
10076                fidl::encoding::DefaultFuchsiaResourceDialect,
10077            >,
10078        T8: fidl::encoding::Encode<
10079                fidl::encoding::Array<u64, 1>,
10080                fidl::encoding::DefaultFuchsiaResourceDialect,
10081            >,
10082        T9: fidl::encoding::Encode<
10083                fidl::encoding::Array<f32, 1>,
10084                fidl::encoding::DefaultFuchsiaResourceDialect,
10085            >,
10086        T10: fidl::encoding::Encode<
10087                fidl::encoding::Array<f64, 1>,
10088                fidl::encoding::DefaultFuchsiaResourceDialect,
10089            >,
10090        T11: fidl::encoding::Encode<
10091                fidl::encoding::Array<
10092                    fidl::encoding::HandleType<
10093                        fidl::NullableHandle,
10094                        { fidl::ObjectType::NONE.into_raw() },
10095                        2147483648,
10096                    >,
10097                    1,
10098                >,
10099                fidl::encoding::DefaultFuchsiaResourceDialect,
10100            >,
10101        T12: fidl::encoding::Encode<
10102                fidl::encoding::Array<bool, 3>,
10103                fidl::encoding::DefaultFuchsiaResourceDialect,
10104            >,
10105        T13: fidl::encoding::Encode<
10106                fidl::encoding::Array<i8, 3>,
10107                fidl::encoding::DefaultFuchsiaResourceDialect,
10108            >,
10109        T14: fidl::encoding::Encode<
10110                fidl::encoding::Array<i16, 3>,
10111                fidl::encoding::DefaultFuchsiaResourceDialect,
10112            >,
10113        T15: fidl::encoding::Encode<
10114                fidl::encoding::Array<i32, 3>,
10115                fidl::encoding::DefaultFuchsiaResourceDialect,
10116            >,
10117        T16: fidl::encoding::Encode<
10118                fidl::encoding::Array<i64, 3>,
10119                fidl::encoding::DefaultFuchsiaResourceDialect,
10120            >,
10121        T17: fidl::encoding::Encode<
10122                fidl::encoding::Array<u8, 3>,
10123                fidl::encoding::DefaultFuchsiaResourceDialect,
10124            >,
10125        T18: fidl::encoding::Encode<
10126                fidl::encoding::Array<u16, 3>,
10127                fidl::encoding::DefaultFuchsiaResourceDialect,
10128            >,
10129        T19: fidl::encoding::Encode<
10130                fidl::encoding::Array<u32, 3>,
10131                fidl::encoding::DefaultFuchsiaResourceDialect,
10132            >,
10133        T20: fidl::encoding::Encode<
10134                fidl::encoding::Array<u64, 3>,
10135                fidl::encoding::DefaultFuchsiaResourceDialect,
10136            >,
10137        T21: fidl::encoding::Encode<
10138                fidl::encoding::Array<f32, 3>,
10139                fidl::encoding::DefaultFuchsiaResourceDialect,
10140            >,
10141        T22: fidl::encoding::Encode<
10142                fidl::encoding::Array<f64, 3>,
10143                fidl::encoding::DefaultFuchsiaResourceDialect,
10144            >,
10145        T23: fidl::encoding::Encode<
10146                fidl::encoding::Array<
10147                    fidl::encoding::HandleType<
10148                        fidl::NullableHandle,
10149                        { fidl::ObjectType::NONE.into_raw() },
10150                        2147483648,
10151                    >,
10152                    3,
10153                >,
10154                fidl::encoding::DefaultFuchsiaResourceDialect,
10155            >,
10156    > fidl::encoding::Encode<Arrays, fidl::encoding::DefaultFuchsiaResourceDialect>
10157        for (
10158            T0,
10159            T1,
10160            T2,
10161            T3,
10162            T4,
10163            T5,
10164            T6,
10165            T7,
10166            T8,
10167            T9,
10168            T10,
10169            T11,
10170            T12,
10171            T13,
10172            T14,
10173            T15,
10174            T16,
10175            T17,
10176            T18,
10177            T19,
10178            T20,
10179            T21,
10180            T22,
10181            T23,
10182        )
10183    {
10184        #[inline]
10185        unsafe fn encode(
10186            self,
10187            encoder: &mut fidl::encoding::Encoder<
10188                '_,
10189                fidl::encoding::DefaultFuchsiaResourceDialect,
10190            >,
10191            offset: usize,
10192            depth: fidl::encoding::Depth,
10193        ) -> fidl::Result<()> {
10194            encoder.debug_check_bounds::<Arrays>(offset);
10195            // Zero out padding regions. There's no need to apply masks
10196            // because the unmasked parts will be overwritten by fields.
10197            unsafe {
10198                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
10199                (ptr as *mut u64).write_unaligned(0);
10200            }
10201            unsafe {
10202                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
10203                (ptr as *mut u64).write_unaligned(0);
10204            }
10205            unsafe {
10206                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(72);
10207                (ptr as *mut u64).write_unaligned(0);
10208            }
10209            unsafe {
10210                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(104);
10211                (ptr as *mut u64).write_unaligned(0);
10212            }
10213            unsafe {
10214                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(112);
10215                (ptr as *mut u64).write_unaligned(0);
10216            }
10217            unsafe {
10218                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(160);
10219                (ptr as *mut u64).write_unaligned(0);
10220            }
10221            unsafe {
10222                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(200);
10223                (ptr as *mut u64).write_unaligned(0);
10224            }
10225            // Write the fields.
10226            self.0.encode(encoder, offset + 0, depth)?;
10227            self.1.encode(encoder, offset + 1, depth)?;
10228            self.2.encode(encoder, offset + 2, depth)?;
10229            self.3.encode(encoder, offset + 4, depth)?;
10230            self.4.encode(encoder, offset + 8, depth)?;
10231            self.5.encode(encoder, offset + 16, depth)?;
10232            self.6.encode(encoder, offset + 18, depth)?;
10233            self.7.encode(encoder, offset + 20, depth)?;
10234            self.8.encode(encoder, offset + 24, depth)?;
10235            self.9.encode(encoder, offset + 32, depth)?;
10236            self.10.encode(encoder, offset + 40, depth)?;
10237            self.11.encode(encoder, offset + 48, depth)?;
10238            self.12.encode(encoder, offset + 52, depth)?;
10239            self.13.encode(encoder, offset + 55, depth)?;
10240            self.14.encode(encoder, offset + 58, depth)?;
10241            self.15.encode(encoder, offset + 64, depth)?;
10242            self.16.encode(encoder, offset + 80, depth)?;
10243            self.17.encode(encoder, offset + 104, depth)?;
10244            self.18.encode(encoder, offset + 108, depth)?;
10245            self.19.encode(encoder, offset + 116, depth)?;
10246            self.20.encode(encoder, offset + 128, depth)?;
10247            self.21.encode(encoder, offset + 152, depth)?;
10248            self.22.encode(encoder, offset + 168, depth)?;
10249            self.23.encode(encoder, offset + 192, depth)?;
10250            Ok(())
10251        }
10252    }
10253
10254    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Arrays {
10255        #[inline(always)]
10256        fn new_empty() -> Self {
10257            Self {
10258                b_0: fidl::new_empty!(fidl::encoding::Array<bool, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10259                i8_0: fidl::new_empty!(fidl::encoding::Array<i8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10260                i16_0: fidl::new_empty!(fidl::encoding::Array<i16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10261                i32_0: fidl::new_empty!(fidl::encoding::Array<i32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10262                i64_0: fidl::new_empty!(fidl::encoding::Array<i64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10263                u8_0: fidl::new_empty!(fidl::encoding::Array<u8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10264                u16_0: fidl::new_empty!(fidl::encoding::Array<u16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10265                u32_0: fidl::new_empty!(fidl::encoding::Array<u32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10266                u64_0: fidl::new_empty!(fidl::encoding::Array<u64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10267                f32_0: fidl::new_empty!(fidl::encoding::Array<f32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10268                f64_0: fidl::new_empty!(fidl::encoding::Array<f64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10269                handle_0: fidl::new_empty!(
10270                    fidl::encoding::Array<
10271                        fidl::encoding::HandleType<
10272                            fidl::NullableHandle,
10273                            { fidl::ObjectType::NONE.into_raw() },
10274                            2147483648,
10275                        >,
10276                        1,
10277                    >,
10278                    fidl::encoding::DefaultFuchsiaResourceDialect
10279                ),
10280                b_1: fidl::new_empty!(fidl::encoding::Array<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10281                i8_1: fidl::new_empty!(fidl::encoding::Array<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10282                i16_1: fidl::new_empty!(fidl::encoding::Array<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10283                i32_1: fidl::new_empty!(fidl::encoding::Array<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10284                i64_1: fidl::new_empty!(fidl::encoding::Array<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10285                u8_1: fidl::new_empty!(fidl::encoding::Array<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10286                u16_1: fidl::new_empty!(fidl::encoding::Array<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10287                u32_1: fidl::new_empty!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10288                u64_1: fidl::new_empty!(fidl::encoding::Array<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10289                f32_1: fidl::new_empty!(fidl::encoding::Array<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10290                f64_1: fidl::new_empty!(fidl::encoding::Array<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10291                handle_1: fidl::new_empty!(
10292                    fidl::encoding::Array<
10293                        fidl::encoding::HandleType<
10294                            fidl::NullableHandle,
10295                            { fidl::ObjectType::NONE.into_raw() },
10296                            2147483648,
10297                        >,
10298                        3,
10299                    >,
10300                    fidl::encoding::DefaultFuchsiaResourceDialect
10301                ),
10302            }
10303        }
10304
10305        #[inline]
10306        unsafe fn decode(
10307            &mut self,
10308            decoder: &mut fidl::encoding::Decoder<
10309                '_,
10310                fidl::encoding::DefaultFuchsiaResourceDialect,
10311            >,
10312            offset: usize,
10313            _depth: fidl::encoding::Depth,
10314        ) -> fidl::Result<()> {
10315            decoder.debug_check_bounds::<Self>(offset);
10316            // Verify that padding bytes are zero.
10317            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
10318            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10319            let mask = 0xff00u64;
10320            let maskedval = padval & mask;
10321            if maskedval != 0 {
10322                return Err(fidl::Error::NonZeroPadding {
10323                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
10324                });
10325            }
10326            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
10327            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10328            let mask = 0xffffffff00000000u64;
10329            let maskedval = padval & mask;
10330            if maskedval != 0 {
10331                return Err(fidl::Error::NonZeroPadding {
10332                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
10333                });
10334            }
10335            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(72) };
10336            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10337            let mask = 0xffffffff00000000u64;
10338            let maskedval = padval & mask;
10339            if maskedval != 0 {
10340                return Err(fidl::Error::NonZeroPadding {
10341                    padding_start: offset + 72 + ((mask as u64).trailing_zeros() / 8) as usize,
10342                });
10343            }
10344            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(104) };
10345            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10346            let mask = 0xff000000u64;
10347            let maskedval = padval & mask;
10348            if maskedval != 0 {
10349                return Err(fidl::Error::NonZeroPadding {
10350                    padding_start: offset + 104 + ((mask as u64).trailing_zeros() / 8) as usize,
10351                });
10352            }
10353            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(112) };
10354            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10355            let mask = 0xffff0000u64;
10356            let maskedval = padval & mask;
10357            if maskedval != 0 {
10358                return Err(fidl::Error::NonZeroPadding {
10359                    padding_start: offset + 112 + ((mask as u64).trailing_zeros() / 8) as usize,
10360                });
10361            }
10362            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(160) };
10363            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10364            let mask = 0xffffffff00000000u64;
10365            let maskedval = padval & mask;
10366            if maskedval != 0 {
10367                return Err(fidl::Error::NonZeroPadding {
10368                    padding_start: offset + 160 + ((mask as u64).trailing_zeros() / 8) as usize,
10369                });
10370            }
10371            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(200) };
10372            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10373            let mask = 0xffffffff00000000u64;
10374            let maskedval = padval & mask;
10375            if maskedval != 0 {
10376                return Err(fidl::Error::NonZeroPadding {
10377                    padding_start: offset + 200 + ((mask as u64).trailing_zeros() / 8) as usize,
10378                });
10379            }
10380            fidl::decode!(fidl::encoding::Array<bool, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.b_0, decoder, offset + 0, _depth)?;
10381            fidl::decode!(fidl::encoding::Array<i8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i8_0, decoder, offset + 1, _depth)?;
10382            fidl::decode!(fidl::encoding::Array<i16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i16_0, decoder, offset + 2, _depth)?;
10383            fidl::decode!(fidl::encoding::Array<i32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i32_0, decoder, offset + 4, _depth)?;
10384            fidl::decode!(fidl::encoding::Array<i64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i64_0, decoder, offset + 8, _depth)?;
10385            fidl::decode!(fidl::encoding::Array<u8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u8_0, decoder, offset + 16, _depth)?;
10386            fidl::decode!(fidl::encoding::Array<u16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u16_0, decoder, offset + 18, _depth)?;
10387            fidl::decode!(fidl::encoding::Array<u32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u32_0, decoder, offset + 20, _depth)?;
10388            fidl::decode!(fidl::encoding::Array<u64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u64_0, decoder, offset + 24, _depth)?;
10389            fidl::decode!(fidl::encoding::Array<f32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f32_0, decoder, offset + 32, _depth)?;
10390            fidl::decode!(fidl::encoding::Array<f64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f64_0, decoder, offset + 40, _depth)?;
10391            fidl::decode!(
10392                fidl::encoding::Array<
10393                    fidl::encoding::HandleType<
10394                        fidl::NullableHandle,
10395                        { fidl::ObjectType::NONE.into_raw() },
10396                        2147483648,
10397                    >,
10398                    1,
10399                >,
10400                fidl::encoding::DefaultFuchsiaResourceDialect,
10401                &mut self.handle_0,
10402                decoder,
10403                offset + 48,
10404                _depth
10405            )?;
10406            fidl::decode!(fidl::encoding::Array<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.b_1, decoder, offset + 52, _depth)?;
10407            fidl::decode!(fidl::encoding::Array<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i8_1, decoder, offset + 55, _depth)?;
10408            fidl::decode!(fidl::encoding::Array<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i16_1, decoder, offset + 58, _depth)?;
10409            fidl::decode!(fidl::encoding::Array<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i32_1, decoder, offset + 64, _depth)?;
10410            fidl::decode!(fidl::encoding::Array<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i64_1, decoder, offset + 80, _depth)?;
10411            fidl::decode!(fidl::encoding::Array<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u8_1, decoder, offset + 104, _depth)?;
10412            fidl::decode!(fidl::encoding::Array<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u16_1, decoder, offset + 108, _depth)?;
10413            fidl::decode!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u32_1, decoder, offset + 116, _depth)?;
10414            fidl::decode!(fidl::encoding::Array<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u64_1, decoder, offset + 128, _depth)?;
10415            fidl::decode!(fidl::encoding::Array<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f32_1, decoder, offset + 152, _depth)?;
10416            fidl::decode!(fidl::encoding::Array<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f64_1, decoder, offset + 168, _depth)?;
10417            fidl::decode!(
10418                fidl::encoding::Array<
10419                    fidl::encoding::HandleType<
10420                        fidl::NullableHandle,
10421                        { fidl::ObjectType::NONE.into_raw() },
10422                        2147483648,
10423                    >,
10424                    3,
10425                >,
10426                fidl::encoding::DefaultFuchsiaResourceDialect,
10427                &mut self.handle_1,
10428                decoder,
10429                offset + 192,
10430                _depth
10431            )?;
10432            Ok(())
10433        }
10434    }
10435
10436    impl fidl::encoding::ResourceTypeMarker for Arrays2d {
10437        type Borrowed<'a> = &'a mut Self;
10438        fn take_or_borrow<'a>(
10439            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
10440        ) -> Self::Borrowed<'a> {
10441            value
10442        }
10443    }
10444
10445    unsafe impl fidl::encoding::TypeMarker for Arrays2d {
10446        type Owned = Self;
10447
10448        #[inline(always)]
10449        fn inline_align(_context: fidl::encoding::Context) -> usize {
10450            8
10451        }
10452
10453        #[inline(always)]
10454        fn inline_size(_context: fidl::encoding::Context) -> usize {
10455            288
10456        }
10457    }
10458
10459    unsafe impl fidl::encoding::Encode<Arrays2d, fidl::encoding::DefaultFuchsiaResourceDialect>
10460        for &mut Arrays2d
10461    {
10462        #[inline]
10463        unsafe fn encode(
10464            self,
10465            encoder: &mut fidl::encoding::Encoder<
10466                '_,
10467                fidl::encoding::DefaultFuchsiaResourceDialect,
10468            >,
10469            offset: usize,
10470            _depth: fidl::encoding::Depth,
10471        ) -> fidl::Result<()> {
10472            encoder.debug_check_bounds::<Arrays2d>(offset);
10473            // Delegate to tuple encoding.
10474            fidl::encoding::Encode::<Arrays2d, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
10475                (
10476                    <fidl::encoding::Array<fidl::encoding::Array<bool, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.b),
10477                    <fidl::encoding::Array<fidl::encoding::Array<i8, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8),
10478                    <fidl::encoding::Array<fidl::encoding::Array<i16, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16),
10479                    <fidl::encoding::Array<fidl::encoding::Array<i32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32),
10480                    <fidl::encoding::Array<fidl::encoding::Array<i64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64),
10481                    <fidl::encoding::Array<fidl::encoding::Array<u8, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8),
10482                    <fidl::encoding::Array<fidl::encoding::Array<u16, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16),
10483                    <fidl::encoding::Array<fidl::encoding::Array<u32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32),
10484                    <fidl::encoding::Array<fidl::encoding::Array<u64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64),
10485                    <fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32),
10486                    <fidl::encoding::Array<fidl::encoding::Array<f64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64),
10487                    <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),
10488                ),
10489                encoder, offset, _depth
10490            )
10491        }
10492    }
10493    unsafe impl<
10494        T0: fidl::encoding::Encode<
10495                fidl::encoding::Array<fidl::encoding::Array<bool, 2>, 3>,
10496                fidl::encoding::DefaultFuchsiaResourceDialect,
10497            >,
10498        T1: fidl::encoding::Encode<
10499                fidl::encoding::Array<fidl::encoding::Array<i8, 2>, 3>,
10500                fidl::encoding::DefaultFuchsiaResourceDialect,
10501            >,
10502        T2: fidl::encoding::Encode<
10503                fidl::encoding::Array<fidl::encoding::Array<i16, 2>, 3>,
10504                fidl::encoding::DefaultFuchsiaResourceDialect,
10505            >,
10506        T3: fidl::encoding::Encode<
10507                fidl::encoding::Array<fidl::encoding::Array<i32, 2>, 3>,
10508                fidl::encoding::DefaultFuchsiaResourceDialect,
10509            >,
10510        T4: fidl::encoding::Encode<
10511                fidl::encoding::Array<fidl::encoding::Array<i64, 2>, 3>,
10512                fidl::encoding::DefaultFuchsiaResourceDialect,
10513            >,
10514        T5: fidl::encoding::Encode<
10515                fidl::encoding::Array<fidl::encoding::Array<u8, 2>, 3>,
10516                fidl::encoding::DefaultFuchsiaResourceDialect,
10517            >,
10518        T6: fidl::encoding::Encode<
10519                fidl::encoding::Array<fidl::encoding::Array<u16, 2>, 3>,
10520                fidl::encoding::DefaultFuchsiaResourceDialect,
10521            >,
10522        T7: fidl::encoding::Encode<
10523                fidl::encoding::Array<fidl::encoding::Array<u32, 2>, 3>,
10524                fidl::encoding::DefaultFuchsiaResourceDialect,
10525            >,
10526        T8: fidl::encoding::Encode<
10527                fidl::encoding::Array<fidl::encoding::Array<u64, 2>, 3>,
10528                fidl::encoding::DefaultFuchsiaResourceDialect,
10529            >,
10530        T9: fidl::encoding::Encode<
10531                fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 3>,
10532                fidl::encoding::DefaultFuchsiaResourceDialect,
10533            >,
10534        T10: fidl::encoding::Encode<
10535                fidl::encoding::Array<fidl::encoding::Array<f64, 2>, 3>,
10536                fidl::encoding::DefaultFuchsiaResourceDialect,
10537            >,
10538        T11: fidl::encoding::Encode<
10539                fidl::encoding::Array<
10540                    fidl::encoding::Array<
10541                        fidl::encoding::HandleType<
10542                            fidl::NullableHandle,
10543                            { fidl::ObjectType::NONE.into_raw() },
10544                            2147483648,
10545                        >,
10546                        2,
10547                    >,
10548                    3,
10549                >,
10550                fidl::encoding::DefaultFuchsiaResourceDialect,
10551            >,
10552    > fidl::encoding::Encode<Arrays2d, fidl::encoding::DefaultFuchsiaResourceDialect>
10553        for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
10554    {
10555        #[inline]
10556        unsafe fn encode(
10557            self,
10558            encoder: &mut fidl::encoding::Encoder<
10559                '_,
10560                fidl::encoding::DefaultFuchsiaResourceDialect,
10561            >,
10562            offset: usize,
10563            depth: fidl::encoding::Depth,
10564        ) -> fidl::Result<()> {
10565            encoder.debug_check_bounds::<Arrays2d>(offset);
10566            // Zero out padding regions. There's no need to apply masks
10567            // because the unmasked parts will be overwritten by fields.
10568            unsafe {
10569                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(112);
10570                (ptr as *mut u64).write_unaligned(0);
10571            }
10572            unsafe {
10573                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(136);
10574                (ptr as *mut u64).write_unaligned(0);
10575            }
10576            // Write the fields.
10577            self.0.encode(encoder, offset + 0, depth)?;
10578            self.1.encode(encoder, offset + 6, depth)?;
10579            self.2.encode(encoder, offset + 12, depth)?;
10580            self.3.encode(encoder, offset + 24, depth)?;
10581            self.4.encode(encoder, offset + 48, depth)?;
10582            self.5.encode(encoder, offset + 96, depth)?;
10583            self.6.encode(encoder, offset + 102, depth)?;
10584            self.7.encode(encoder, offset + 116, depth)?;
10585            self.8.encode(encoder, offset + 144, depth)?;
10586            self.9.encode(encoder, offset + 192, depth)?;
10587            self.10.encode(encoder, offset + 216, depth)?;
10588            self.11.encode(encoder, offset + 264, depth)?;
10589            Ok(())
10590        }
10591    }
10592
10593    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Arrays2d {
10594        #[inline(always)]
10595        fn new_empty() -> Self {
10596            Self {
10597                b: fidl::new_empty!(
10598                    fidl::encoding::Array<fidl::encoding::Array<bool, 2>, 3>,
10599                    fidl::encoding::DefaultFuchsiaResourceDialect
10600                ),
10601                i8: fidl::new_empty!(
10602                    fidl::encoding::Array<fidl::encoding::Array<i8, 2>, 3>,
10603                    fidl::encoding::DefaultFuchsiaResourceDialect
10604                ),
10605                i16: fidl::new_empty!(
10606                    fidl::encoding::Array<fidl::encoding::Array<i16, 2>, 3>,
10607                    fidl::encoding::DefaultFuchsiaResourceDialect
10608                ),
10609                i32: fidl::new_empty!(
10610                    fidl::encoding::Array<fidl::encoding::Array<i32, 2>, 3>,
10611                    fidl::encoding::DefaultFuchsiaResourceDialect
10612                ),
10613                i64: fidl::new_empty!(
10614                    fidl::encoding::Array<fidl::encoding::Array<i64, 2>, 3>,
10615                    fidl::encoding::DefaultFuchsiaResourceDialect
10616                ),
10617                u8: fidl::new_empty!(
10618                    fidl::encoding::Array<fidl::encoding::Array<u8, 2>, 3>,
10619                    fidl::encoding::DefaultFuchsiaResourceDialect
10620                ),
10621                u16: fidl::new_empty!(
10622                    fidl::encoding::Array<fidl::encoding::Array<u16, 2>, 3>,
10623                    fidl::encoding::DefaultFuchsiaResourceDialect
10624                ),
10625                u32: fidl::new_empty!(
10626                    fidl::encoding::Array<fidl::encoding::Array<u32, 2>, 3>,
10627                    fidl::encoding::DefaultFuchsiaResourceDialect
10628                ),
10629                u64: fidl::new_empty!(
10630                    fidl::encoding::Array<fidl::encoding::Array<u64, 2>, 3>,
10631                    fidl::encoding::DefaultFuchsiaResourceDialect
10632                ),
10633                f32: fidl::new_empty!(
10634                    fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 3>,
10635                    fidl::encoding::DefaultFuchsiaResourceDialect
10636                ),
10637                f64: fidl::new_empty!(
10638                    fidl::encoding::Array<fidl::encoding::Array<f64, 2>, 3>,
10639                    fidl::encoding::DefaultFuchsiaResourceDialect
10640                ),
10641                handle_handle: fidl::new_empty!(
10642                    fidl::encoding::Array<
10643                        fidl::encoding::Array<
10644                            fidl::encoding::HandleType<
10645                                fidl::NullableHandle,
10646                                { fidl::ObjectType::NONE.into_raw() },
10647                                2147483648,
10648                            >,
10649                            2,
10650                        >,
10651                        3,
10652                    >,
10653                    fidl::encoding::DefaultFuchsiaResourceDialect
10654                ),
10655            }
10656        }
10657
10658        #[inline]
10659        unsafe fn decode(
10660            &mut self,
10661            decoder: &mut fidl::encoding::Decoder<
10662                '_,
10663                fidl::encoding::DefaultFuchsiaResourceDialect,
10664            >,
10665            offset: usize,
10666            _depth: fidl::encoding::Depth,
10667        ) -> fidl::Result<()> {
10668            decoder.debug_check_bounds::<Self>(offset);
10669            // Verify that padding bytes are zero.
10670            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(112) };
10671            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10672            let mask = 0xffff0000u64;
10673            let maskedval = padval & mask;
10674            if maskedval != 0 {
10675                return Err(fidl::Error::NonZeroPadding {
10676                    padding_start: offset + 112 + ((mask as u64).trailing_zeros() / 8) as usize,
10677                });
10678            }
10679            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(136) };
10680            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10681            let mask = 0xffffffff00000000u64;
10682            let maskedval = padval & mask;
10683            if maskedval != 0 {
10684                return Err(fidl::Error::NonZeroPadding {
10685                    padding_start: offset + 136 + ((mask as u64).trailing_zeros() / 8) as usize,
10686                });
10687            }
10688            fidl::decode!(
10689                fidl::encoding::Array<fidl::encoding::Array<bool, 2>, 3>,
10690                fidl::encoding::DefaultFuchsiaResourceDialect,
10691                &mut self.b,
10692                decoder,
10693                offset + 0,
10694                _depth
10695            )?;
10696            fidl::decode!(
10697                fidl::encoding::Array<fidl::encoding::Array<i8, 2>, 3>,
10698                fidl::encoding::DefaultFuchsiaResourceDialect,
10699                &mut self.i8,
10700                decoder,
10701                offset + 6,
10702                _depth
10703            )?;
10704            fidl::decode!(
10705                fidl::encoding::Array<fidl::encoding::Array<i16, 2>, 3>,
10706                fidl::encoding::DefaultFuchsiaResourceDialect,
10707                &mut self.i16,
10708                decoder,
10709                offset + 12,
10710                _depth
10711            )?;
10712            fidl::decode!(
10713                fidl::encoding::Array<fidl::encoding::Array<i32, 2>, 3>,
10714                fidl::encoding::DefaultFuchsiaResourceDialect,
10715                &mut self.i32,
10716                decoder,
10717                offset + 24,
10718                _depth
10719            )?;
10720            fidl::decode!(
10721                fidl::encoding::Array<fidl::encoding::Array<i64, 2>, 3>,
10722                fidl::encoding::DefaultFuchsiaResourceDialect,
10723                &mut self.i64,
10724                decoder,
10725                offset + 48,
10726                _depth
10727            )?;
10728            fidl::decode!(
10729                fidl::encoding::Array<fidl::encoding::Array<u8, 2>, 3>,
10730                fidl::encoding::DefaultFuchsiaResourceDialect,
10731                &mut self.u8,
10732                decoder,
10733                offset + 96,
10734                _depth
10735            )?;
10736            fidl::decode!(
10737                fidl::encoding::Array<fidl::encoding::Array<u16, 2>, 3>,
10738                fidl::encoding::DefaultFuchsiaResourceDialect,
10739                &mut self.u16,
10740                decoder,
10741                offset + 102,
10742                _depth
10743            )?;
10744            fidl::decode!(
10745                fidl::encoding::Array<fidl::encoding::Array<u32, 2>, 3>,
10746                fidl::encoding::DefaultFuchsiaResourceDialect,
10747                &mut self.u32,
10748                decoder,
10749                offset + 116,
10750                _depth
10751            )?;
10752            fidl::decode!(
10753                fidl::encoding::Array<fidl::encoding::Array<u64, 2>, 3>,
10754                fidl::encoding::DefaultFuchsiaResourceDialect,
10755                &mut self.u64,
10756                decoder,
10757                offset + 144,
10758                _depth
10759            )?;
10760            fidl::decode!(
10761                fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 3>,
10762                fidl::encoding::DefaultFuchsiaResourceDialect,
10763                &mut self.f32,
10764                decoder,
10765                offset + 192,
10766                _depth
10767            )?;
10768            fidl::decode!(
10769                fidl::encoding::Array<fidl::encoding::Array<f64, 2>, 3>,
10770                fidl::encoding::DefaultFuchsiaResourceDialect,
10771                &mut self.f64,
10772                decoder,
10773                offset + 216,
10774                _depth
10775            )?;
10776            fidl::decode!(
10777                fidl::encoding::Array<
10778                    fidl::encoding::Array<
10779                        fidl::encoding::HandleType<
10780                            fidl::NullableHandle,
10781                            { fidl::ObjectType::NONE.into_raw() },
10782                            2147483648,
10783                        >,
10784                        2,
10785                    >,
10786                    3,
10787                >,
10788                fidl::encoding::DefaultFuchsiaResourceDialect,
10789                &mut self.handle_handle,
10790                decoder,
10791                offset + 264,
10792                _depth
10793            )?;
10794            Ok(())
10795        }
10796    }
10797
10798    impl fidl::encoding::ResourceTypeMarker for Handles {
10799        type Borrowed<'a> = &'a mut Self;
10800        fn take_or_borrow<'a>(
10801            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
10802        ) -> Self::Borrowed<'a> {
10803            value
10804        }
10805    }
10806
10807    unsafe impl fidl::encoding::TypeMarker for Handles {
10808        type Owned = Self;
10809
10810        #[inline(always)]
10811        fn inline_align(_context: fidl::encoding::Context) -> usize {
10812            4
10813        }
10814
10815        #[inline(always)]
10816        fn inline_size(_context: fidl::encoding::Context) -> usize {
10817            108
10818        }
10819    }
10820
10821    unsafe impl fidl::encoding::Encode<Handles, fidl::encoding::DefaultFuchsiaResourceDialect>
10822        for &mut Handles
10823    {
10824        #[inline]
10825        unsafe fn encode(
10826            self,
10827            encoder: &mut fidl::encoding::Encoder<
10828                '_,
10829                fidl::encoding::DefaultFuchsiaResourceDialect,
10830            >,
10831            offset: usize,
10832            _depth: fidl::encoding::Depth,
10833        ) -> fidl::Result<()> {
10834            encoder.debug_check_bounds::<Handles>(offset);
10835            // Delegate to tuple encoding.
10836            fidl::encoding::Encode::<Handles, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
10837                (
10838                    <fidl::encoding::HandleType<
10839                        fidl::NullableHandle,
10840                        { fidl::ObjectType::NONE.into_raw() },
10841                        2147483648,
10842                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10843                        &mut self.handle_handle,
10844                    ),
10845                    <fidl::encoding::HandleType<
10846                        fidl::Process,
10847                        { fidl::ObjectType::PROCESS.into_raw() },
10848                        2147483648,
10849                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10850                        &mut self.process_handle,
10851                    ),
10852                    <fidl::encoding::HandleType<
10853                        fidl::Thread,
10854                        { fidl::ObjectType::THREAD.into_raw() },
10855                        2147483648,
10856                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10857                        &mut self.thread_handle,
10858                    ),
10859                    <fidl::encoding::HandleType<
10860                        fidl::Vmo,
10861                        { fidl::ObjectType::VMO.into_raw() },
10862                        2147483648,
10863                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10864                        &mut self.vmo_handle
10865                    ),
10866                    <fidl::encoding::HandleType<
10867                        fidl::Event,
10868                        { fidl::ObjectType::EVENT.into_raw() },
10869                        2147483648,
10870                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10871                        &mut self.event_handle,
10872                    ),
10873                    <fidl::encoding::HandleType<
10874                        fidl::Port,
10875                        { fidl::ObjectType::PORT.into_raw() },
10876                        2147483648,
10877                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10878                        &mut self.port_handle
10879                    ),
10880                    <fidl::encoding::HandleType<
10881                        fidl::Socket,
10882                        { fidl::ObjectType::SOCKET.into_raw() },
10883                        2147483648,
10884                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10885                        &mut self.socket_handle,
10886                    ),
10887                    <fidl::encoding::HandleType<
10888                        fidl::EventPair,
10889                        { fidl::ObjectType::EVENTPAIR.into_raw() },
10890                        2147483648,
10891                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10892                        &mut self.eventpair_handle,
10893                    ),
10894                    <fidl::encoding::HandleType<
10895                        fidl::Job,
10896                        { fidl::ObjectType::JOB.into_raw() },
10897                        2147483648,
10898                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10899                        &mut self.job_handle
10900                    ),
10901                    <fidl::encoding::HandleType<
10902                        fidl::Vmar,
10903                        { fidl::ObjectType::VMAR.into_raw() },
10904                        2147483648,
10905                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10906                        &mut self.vmar_handle
10907                    ),
10908                    <fidl::encoding::HandleType<
10909                        fidl::Fifo,
10910                        { fidl::ObjectType::FIFO.into_raw() },
10911                        2147483648,
10912                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10913                        &mut self.fifo_handle
10914                    ),
10915                    <fidl::encoding::HandleType<
10916                        fidl::Timer,
10917                        { fidl::ObjectType::TIMER.into_raw() },
10918                        2147483648,
10919                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10920                        &mut self.timer_handle,
10921                    ),
10922                    <fidl::encoding::Optional<
10923                        fidl::encoding::HandleType<
10924                            fidl::NullableHandle,
10925                            { fidl::ObjectType::NONE.into_raw() },
10926                            2147483648,
10927                        >,
10928                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10929                        &mut self.nullable_handle_handle,
10930                    ),
10931                    <fidl::encoding::Optional<
10932                        fidl::encoding::HandleType<
10933                            fidl::Process,
10934                            { fidl::ObjectType::PROCESS.into_raw() },
10935                            2147483648,
10936                        >,
10937                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10938                        &mut self.nullable_process_handle,
10939                    ),
10940                    <fidl::encoding::Optional<
10941                        fidl::encoding::HandleType<
10942                            fidl::Thread,
10943                            { fidl::ObjectType::THREAD.into_raw() },
10944                            2147483648,
10945                        >,
10946                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10947                        &mut self.nullable_thread_handle,
10948                    ),
10949                    <fidl::encoding::Optional<
10950                        fidl::encoding::HandleType<
10951                            fidl::Vmo,
10952                            { fidl::ObjectType::VMO.into_raw() },
10953                            2147483648,
10954                        >,
10955                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10956                        &mut self.nullable_vmo_handle,
10957                    ),
10958                    <fidl::encoding::Optional<
10959                        fidl::encoding::HandleType<
10960                            fidl::Channel,
10961                            { fidl::ObjectType::CHANNEL.into_raw() },
10962                            2147483648,
10963                        >,
10964                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10965                        &mut self.nullable_channel_handle,
10966                    ),
10967                    <fidl::encoding::Optional<
10968                        fidl::encoding::HandleType<
10969                            fidl::Event,
10970                            { fidl::ObjectType::EVENT.into_raw() },
10971                            2147483648,
10972                        >,
10973                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10974                        &mut self.nullable_event_handle,
10975                    ),
10976                    <fidl::encoding::Optional<
10977                        fidl::encoding::HandleType<
10978                            fidl::Port,
10979                            { fidl::ObjectType::PORT.into_raw() },
10980                            2147483648,
10981                        >,
10982                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10983                        &mut self.nullable_port_handle,
10984                    ),
10985                    <fidl::encoding::Optional<
10986                        fidl::encoding::HandleType<
10987                            fidl::Interrupt,
10988                            { fidl::ObjectType::INTERRUPT.into_raw() },
10989                            2147483648,
10990                        >,
10991                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10992                        &mut self.nullable_interrupt_handle,
10993                    ),
10994                    <fidl::encoding::Optional<
10995                        fidl::encoding::HandleType<
10996                            fidl::DebugLog,
10997                            { fidl::ObjectType::DEBUGLOG.into_raw() },
10998                            2147483648,
10999                        >,
11000                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
11001                        &mut self.nullable_log_handle,
11002                    ),
11003                    <fidl::encoding::Optional<
11004                        fidl::encoding::HandleType<
11005                            fidl::Socket,
11006                            { fidl::ObjectType::SOCKET.into_raw() },
11007                            2147483648,
11008                        >,
11009                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
11010                        &mut self.nullable_socket_handle,
11011                    ),
11012                    <fidl::encoding::Optional<
11013                        fidl::encoding::HandleType<
11014                            fidl::EventPair,
11015                            { fidl::ObjectType::EVENTPAIR.into_raw() },
11016                            2147483648,
11017                        >,
11018                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
11019                        &mut self.nullable_eventpair_handle,
11020                    ),
11021                    <fidl::encoding::Optional<
11022                        fidl::encoding::HandleType<
11023                            fidl::Job,
11024                            { fidl::ObjectType::JOB.into_raw() },
11025                            2147483648,
11026                        >,
11027                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
11028                        &mut self.nullable_job_handle,
11029                    ),
11030                    <fidl::encoding::Optional<
11031                        fidl::encoding::HandleType<
11032                            fidl::Vmar,
11033                            { fidl::ObjectType::VMAR.into_raw() },
11034                            2147483648,
11035                        >,
11036                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
11037                        &mut self.nullable_vmar_handle,
11038                    ),
11039                    <fidl::encoding::Optional<
11040                        fidl::encoding::HandleType<
11041                            fidl::Fifo,
11042                            { fidl::ObjectType::FIFO.into_raw() },
11043                            2147483648,
11044                        >,
11045                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
11046                        &mut self.nullable_fifo_handle,
11047                    ),
11048                    <fidl::encoding::Optional<
11049                        fidl::encoding::HandleType<
11050                            fidl::Timer,
11051                            { fidl::ObjectType::TIMER.into_raw() },
11052                            2147483648,
11053                        >,
11054                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
11055                        &mut self.nullable_timer_handle,
11056                    ),
11057                ),
11058                encoder,
11059                offset,
11060                _depth,
11061            )
11062        }
11063    }
11064    unsafe impl<
11065        T0: fidl::encoding::Encode<
11066                fidl::encoding::HandleType<
11067                    fidl::NullableHandle,
11068                    { fidl::ObjectType::NONE.into_raw() },
11069                    2147483648,
11070                >,
11071                fidl::encoding::DefaultFuchsiaResourceDialect,
11072            >,
11073        T1: fidl::encoding::Encode<
11074                fidl::encoding::HandleType<
11075                    fidl::Process,
11076                    { fidl::ObjectType::PROCESS.into_raw() },
11077                    2147483648,
11078                >,
11079                fidl::encoding::DefaultFuchsiaResourceDialect,
11080            >,
11081        T2: fidl::encoding::Encode<
11082                fidl::encoding::HandleType<
11083                    fidl::Thread,
11084                    { fidl::ObjectType::THREAD.into_raw() },
11085                    2147483648,
11086                >,
11087                fidl::encoding::DefaultFuchsiaResourceDialect,
11088            >,
11089        T3: fidl::encoding::Encode<
11090                fidl::encoding::HandleType<
11091                    fidl::Vmo,
11092                    { fidl::ObjectType::VMO.into_raw() },
11093                    2147483648,
11094                >,
11095                fidl::encoding::DefaultFuchsiaResourceDialect,
11096            >,
11097        T4: fidl::encoding::Encode<
11098                fidl::encoding::HandleType<
11099                    fidl::Event,
11100                    { fidl::ObjectType::EVENT.into_raw() },
11101                    2147483648,
11102                >,
11103                fidl::encoding::DefaultFuchsiaResourceDialect,
11104            >,
11105        T5: fidl::encoding::Encode<
11106                fidl::encoding::HandleType<
11107                    fidl::Port,
11108                    { fidl::ObjectType::PORT.into_raw() },
11109                    2147483648,
11110                >,
11111                fidl::encoding::DefaultFuchsiaResourceDialect,
11112            >,
11113        T6: fidl::encoding::Encode<
11114                fidl::encoding::HandleType<
11115                    fidl::Socket,
11116                    { fidl::ObjectType::SOCKET.into_raw() },
11117                    2147483648,
11118                >,
11119                fidl::encoding::DefaultFuchsiaResourceDialect,
11120            >,
11121        T7: fidl::encoding::Encode<
11122                fidl::encoding::HandleType<
11123                    fidl::EventPair,
11124                    { fidl::ObjectType::EVENTPAIR.into_raw() },
11125                    2147483648,
11126                >,
11127                fidl::encoding::DefaultFuchsiaResourceDialect,
11128            >,
11129        T8: fidl::encoding::Encode<
11130                fidl::encoding::HandleType<
11131                    fidl::Job,
11132                    { fidl::ObjectType::JOB.into_raw() },
11133                    2147483648,
11134                >,
11135                fidl::encoding::DefaultFuchsiaResourceDialect,
11136            >,
11137        T9: fidl::encoding::Encode<
11138                fidl::encoding::HandleType<
11139                    fidl::Vmar,
11140                    { fidl::ObjectType::VMAR.into_raw() },
11141                    2147483648,
11142                >,
11143                fidl::encoding::DefaultFuchsiaResourceDialect,
11144            >,
11145        T10: fidl::encoding::Encode<
11146                fidl::encoding::HandleType<
11147                    fidl::Fifo,
11148                    { fidl::ObjectType::FIFO.into_raw() },
11149                    2147483648,
11150                >,
11151                fidl::encoding::DefaultFuchsiaResourceDialect,
11152            >,
11153        T11: fidl::encoding::Encode<
11154                fidl::encoding::HandleType<
11155                    fidl::Timer,
11156                    { fidl::ObjectType::TIMER.into_raw() },
11157                    2147483648,
11158                >,
11159                fidl::encoding::DefaultFuchsiaResourceDialect,
11160            >,
11161        T12: fidl::encoding::Encode<
11162                fidl::encoding::Optional<
11163                    fidl::encoding::HandleType<
11164                        fidl::NullableHandle,
11165                        { fidl::ObjectType::NONE.into_raw() },
11166                        2147483648,
11167                    >,
11168                >,
11169                fidl::encoding::DefaultFuchsiaResourceDialect,
11170            >,
11171        T13: fidl::encoding::Encode<
11172                fidl::encoding::Optional<
11173                    fidl::encoding::HandleType<
11174                        fidl::Process,
11175                        { fidl::ObjectType::PROCESS.into_raw() },
11176                        2147483648,
11177                    >,
11178                >,
11179                fidl::encoding::DefaultFuchsiaResourceDialect,
11180            >,
11181        T14: fidl::encoding::Encode<
11182                fidl::encoding::Optional<
11183                    fidl::encoding::HandleType<
11184                        fidl::Thread,
11185                        { fidl::ObjectType::THREAD.into_raw() },
11186                        2147483648,
11187                    >,
11188                >,
11189                fidl::encoding::DefaultFuchsiaResourceDialect,
11190            >,
11191        T15: fidl::encoding::Encode<
11192                fidl::encoding::Optional<
11193                    fidl::encoding::HandleType<
11194                        fidl::Vmo,
11195                        { fidl::ObjectType::VMO.into_raw() },
11196                        2147483648,
11197                    >,
11198                >,
11199                fidl::encoding::DefaultFuchsiaResourceDialect,
11200            >,
11201        T16: fidl::encoding::Encode<
11202                fidl::encoding::Optional<
11203                    fidl::encoding::HandleType<
11204                        fidl::Channel,
11205                        { fidl::ObjectType::CHANNEL.into_raw() },
11206                        2147483648,
11207                    >,
11208                >,
11209                fidl::encoding::DefaultFuchsiaResourceDialect,
11210            >,
11211        T17: fidl::encoding::Encode<
11212                fidl::encoding::Optional<
11213                    fidl::encoding::HandleType<
11214                        fidl::Event,
11215                        { fidl::ObjectType::EVENT.into_raw() },
11216                        2147483648,
11217                    >,
11218                >,
11219                fidl::encoding::DefaultFuchsiaResourceDialect,
11220            >,
11221        T18: fidl::encoding::Encode<
11222                fidl::encoding::Optional<
11223                    fidl::encoding::HandleType<
11224                        fidl::Port,
11225                        { fidl::ObjectType::PORT.into_raw() },
11226                        2147483648,
11227                    >,
11228                >,
11229                fidl::encoding::DefaultFuchsiaResourceDialect,
11230            >,
11231        T19: fidl::encoding::Encode<
11232                fidl::encoding::Optional<
11233                    fidl::encoding::HandleType<
11234                        fidl::Interrupt,
11235                        { fidl::ObjectType::INTERRUPT.into_raw() },
11236                        2147483648,
11237                    >,
11238                >,
11239                fidl::encoding::DefaultFuchsiaResourceDialect,
11240            >,
11241        T20: fidl::encoding::Encode<
11242                fidl::encoding::Optional<
11243                    fidl::encoding::HandleType<
11244                        fidl::DebugLog,
11245                        { fidl::ObjectType::DEBUGLOG.into_raw() },
11246                        2147483648,
11247                    >,
11248                >,
11249                fidl::encoding::DefaultFuchsiaResourceDialect,
11250            >,
11251        T21: fidl::encoding::Encode<
11252                fidl::encoding::Optional<
11253                    fidl::encoding::HandleType<
11254                        fidl::Socket,
11255                        { fidl::ObjectType::SOCKET.into_raw() },
11256                        2147483648,
11257                    >,
11258                >,
11259                fidl::encoding::DefaultFuchsiaResourceDialect,
11260            >,
11261        T22: fidl::encoding::Encode<
11262                fidl::encoding::Optional<
11263                    fidl::encoding::HandleType<
11264                        fidl::EventPair,
11265                        { fidl::ObjectType::EVENTPAIR.into_raw() },
11266                        2147483648,
11267                    >,
11268                >,
11269                fidl::encoding::DefaultFuchsiaResourceDialect,
11270            >,
11271        T23: fidl::encoding::Encode<
11272                fidl::encoding::Optional<
11273                    fidl::encoding::HandleType<
11274                        fidl::Job,
11275                        { fidl::ObjectType::JOB.into_raw() },
11276                        2147483648,
11277                    >,
11278                >,
11279                fidl::encoding::DefaultFuchsiaResourceDialect,
11280            >,
11281        T24: fidl::encoding::Encode<
11282                fidl::encoding::Optional<
11283                    fidl::encoding::HandleType<
11284                        fidl::Vmar,
11285                        { fidl::ObjectType::VMAR.into_raw() },
11286                        2147483648,
11287                    >,
11288                >,
11289                fidl::encoding::DefaultFuchsiaResourceDialect,
11290            >,
11291        T25: fidl::encoding::Encode<
11292                fidl::encoding::Optional<
11293                    fidl::encoding::HandleType<
11294                        fidl::Fifo,
11295                        { fidl::ObjectType::FIFO.into_raw() },
11296                        2147483648,
11297                    >,
11298                >,
11299                fidl::encoding::DefaultFuchsiaResourceDialect,
11300            >,
11301        T26: fidl::encoding::Encode<
11302                fidl::encoding::Optional<
11303                    fidl::encoding::HandleType<
11304                        fidl::Timer,
11305                        { fidl::ObjectType::TIMER.into_raw() },
11306                        2147483648,
11307                    >,
11308                >,
11309                fidl::encoding::DefaultFuchsiaResourceDialect,
11310            >,
11311    > fidl::encoding::Encode<Handles, fidl::encoding::DefaultFuchsiaResourceDialect>
11312        for (
11313            T0,
11314            T1,
11315            T2,
11316            T3,
11317            T4,
11318            T5,
11319            T6,
11320            T7,
11321            T8,
11322            T9,
11323            T10,
11324            T11,
11325            T12,
11326            T13,
11327            T14,
11328            T15,
11329            T16,
11330            T17,
11331            T18,
11332            T19,
11333            T20,
11334            T21,
11335            T22,
11336            T23,
11337            T24,
11338            T25,
11339            T26,
11340        )
11341    {
11342        #[inline]
11343        unsafe fn encode(
11344            self,
11345            encoder: &mut fidl::encoding::Encoder<
11346                '_,
11347                fidl::encoding::DefaultFuchsiaResourceDialect,
11348            >,
11349            offset: usize,
11350            depth: fidl::encoding::Depth,
11351        ) -> fidl::Result<()> {
11352            encoder.debug_check_bounds::<Handles>(offset);
11353            // Zero out padding regions. There's no need to apply masks
11354            // because the unmasked parts will be overwritten by fields.
11355            // Write the fields.
11356            self.0.encode(encoder, offset + 0, depth)?;
11357            self.1.encode(encoder, offset + 4, depth)?;
11358            self.2.encode(encoder, offset + 8, depth)?;
11359            self.3.encode(encoder, offset + 12, depth)?;
11360            self.4.encode(encoder, offset + 16, depth)?;
11361            self.5.encode(encoder, offset + 20, depth)?;
11362            self.6.encode(encoder, offset + 24, depth)?;
11363            self.7.encode(encoder, offset + 28, depth)?;
11364            self.8.encode(encoder, offset + 32, depth)?;
11365            self.9.encode(encoder, offset + 36, depth)?;
11366            self.10.encode(encoder, offset + 40, depth)?;
11367            self.11.encode(encoder, offset + 44, depth)?;
11368            self.12.encode(encoder, offset + 48, depth)?;
11369            self.13.encode(encoder, offset + 52, depth)?;
11370            self.14.encode(encoder, offset + 56, depth)?;
11371            self.15.encode(encoder, offset + 60, depth)?;
11372            self.16.encode(encoder, offset + 64, depth)?;
11373            self.17.encode(encoder, offset + 68, depth)?;
11374            self.18.encode(encoder, offset + 72, depth)?;
11375            self.19.encode(encoder, offset + 76, depth)?;
11376            self.20.encode(encoder, offset + 80, depth)?;
11377            self.21.encode(encoder, offset + 84, depth)?;
11378            self.22.encode(encoder, offset + 88, depth)?;
11379            self.23.encode(encoder, offset + 92, depth)?;
11380            self.24.encode(encoder, offset + 96, depth)?;
11381            self.25.encode(encoder, offset + 100, depth)?;
11382            self.26.encode(encoder, offset + 104, depth)?;
11383            Ok(())
11384        }
11385    }
11386
11387    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Handles {
11388        #[inline(always)]
11389        fn new_empty() -> Self {
11390            Self {
11391                handle_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11392                process_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Process, { fidl::ObjectType::PROCESS.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11393                thread_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Thread, { fidl::ObjectType::THREAD.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11394                vmo_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11395                event_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11396                port_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Port, { fidl::ObjectType::PORT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11397                socket_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11398                eventpair_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11399                job_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Job, { fidl::ObjectType::JOB.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11400                vmar_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmar, { fidl::ObjectType::VMAR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11401                fifo_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Fifo, { fidl::ObjectType::FIFO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11402                timer_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Timer, { fidl::ObjectType::TIMER.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11403                nullable_handle_handle: fidl::new_empty!(
11404                    fidl::encoding::Optional<
11405                        fidl::encoding::HandleType<
11406                            fidl::NullableHandle,
11407                            { fidl::ObjectType::NONE.into_raw() },
11408                            2147483648,
11409                        >,
11410                    >,
11411                    fidl::encoding::DefaultFuchsiaResourceDialect
11412                ),
11413                nullable_process_handle: fidl::new_empty!(
11414                    fidl::encoding::Optional<
11415                        fidl::encoding::HandleType<
11416                            fidl::Process,
11417                            { fidl::ObjectType::PROCESS.into_raw() },
11418                            2147483648,
11419                        >,
11420                    >,
11421                    fidl::encoding::DefaultFuchsiaResourceDialect
11422                ),
11423                nullable_thread_handle: fidl::new_empty!(
11424                    fidl::encoding::Optional<
11425                        fidl::encoding::HandleType<
11426                            fidl::Thread,
11427                            { fidl::ObjectType::THREAD.into_raw() },
11428                            2147483648,
11429                        >,
11430                    >,
11431                    fidl::encoding::DefaultFuchsiaResourceDialect
11432                ),
11433                nullable_vmo_handle: fidl::new_empty!(
11434                    fidl::encoding::Optional<
11435                        fidl::encoding::HandleType<
11436                            fidl::Vmo,
11437                            { fidl::ObjectType::VMO.into_raw() },
11438                            2147483648,
11439                        >,
11440                    >,
11441                    fidl::encoding::DefaultFuchsiaResourceDialect
11442                ),
11443                nullable_channel_handle: fidl::new_empty!(
11444                    fidl::encoding::Optional<
11445                        fidl::encoding::HandleType<
11446                            fidl::Channel,
11447                            { fidl::ObjectType::CHANNEL.into_raw() },
11448                            2147483648,
11449                        >,
11450                    >,
11451                    fidl::encoding::DefaultFuchsiaResourceDialect
11452                ),
11453                nullable_event_handle: fidl::new_empty!(
11454                    fidl::encoding::Optional<
11455                        fidl::encoding::HandleType<
11456                            fidl::Event,
11457                            { fidl::ObjectType::EVENT.into_raw() },
11458                            2147483648,
11459                        >,
11460                    >,
11461                    fidl::encoding::DefaultFuchsiaResourceDialect
11462                ),
11463                nullable_port_handle: fidl::new_empty!(
11464                    fidl::encoding::Optional<
11465                        fidl::encoding::HandleType<
11466                            fidl::Port,
11467                            { fidl::ObjectType::PORT.into_raw() },
11468                            2147483648,
11469                        >,
11470                    >,
11471                    fidl::encoding::DefaultFuchsiaResourceDialect
11472                ),
11473                nullable_interrupt_handle: fidl::new_empty!(
11474                    fidl::encoding::Optional<
11475                        fidl::encoding::HandleType<
11476                            fidl::Interrupt,
11477                            { fidl::ObjectType::INTERRUPT.into_raw() },
11478                            2147483648,
11479                        >,
11480                    >,
11481                    fidl::encoding::DefaultFuchsiaResourceDialect
11482                ),
11483                nullable_log_handle: fidl::new_empty!(
11484                    fidl::encoding::Optional<
11485                        fidl::encoding::HandleType<
11486                            fidl::DebugLog,
11487                            { fidl::ObjectType::DEBUGLOG.into_raw() },
11488                            2147483648,
11489                        >,
11490                    >,
11491                    fidl::encoding::DefaultFuchsiaResourceDialect
11492                ),
11493                nullable_socket_handle: fidl::new_empty!(
11494                    fidl::encoding::Optional<
11495                        fidl::encoding::HandleType<
11496                            fidl::Socket,
11497                            { fidl::ObjectType::SOCKET.into_raw() },
11498                            2147483648,
11499                        >,
11500                    >,
11501                    fidl::encoding::DefaultFuchsiaResourceDialect
11502                ),
11503                nullable_eventpair_handle: fidl::new_empty!(
11504                    fidl::encoding::Optional<
11505                        fidl::encoding::HandleType<
11506                            fidl::EventPair,
11507                            { fidl::ObjectType::EVENTPAIR.into_raw() },
11508                            2147483648,
11509                        >,
11510                    >,
11511                    fidl::encoding::DefaultFuchsiaResourceDialect
11512                ),
11513                nullable_job_handle: fidl::new_empty!(
11514                    fidl::encoding::Optional<
11515                        fidl::encoding::HandleType<
11516                            fidl::Job,
11517                            { fidl::ObjectType::JOB.into_raw() },
11518                            2147483648,
11519                        >,
11520                    >,
11521                    fidl::encoding::DefaultFuchsiaResourceDialect
11522                ),
11523                nullable_vmar_handle: fidl::new_empty!(
11524                    fidl::encoding::Optional<
11525                        fidl::encoding::HandleType<
11526                            fidl::Vmar,
11527                            { fidl::ObjectType::VMAR.into_raw() },
11528                            2147483648,
11529                        >,
11530                    >,
11531                    fidl::encoding::DefaultFuchsiaResourceDialect
11532                ),
11533                nullable_fifo_handle: fidl::new_empty!(
11534                    fidl::encoding::Optional<
11535                        fidl::encoding::HandleType<
11536                            fidl::Fifo,
11537                            { fidl::ObjectType::FIFO.into_raw() },
11538                            2147483648,
11539                        >,
11540                    >,
11541                    fidl::encoding::DefaultFuchsiaResourceDialect
11542                ),
11543                nullable_timer_handle: fidl::new_empty!(
11544                    fidl::encoding::Optional<
11545                        fidl::encoding::HandleType<
11546                            fidl::Timer,
11547                            { fidl::ObjectType::TIMER.into_raw() },
11548                            2147483648,
11549                        >,
11550                    >,
11551                    fidl::encoding::DefaultFuchsiaResourceDialect
11552                ),
11553            }
11554        }
11555
11556        #[inline]
11557        unsafe fn decode(
11558            &mut self,
11559            decoder: &mut fidl::encoding::Decoder<
11560                '_,
11561                fidl::encoding::DefaultFuchsiaResourceDialect,
11562            >,
11563            offset: usize,
11564            _depth: fidl::encoding::Depth,
11565        ) -> fidl::Result<()> {
11566            decoder.debug_check_bounds::<Self>(offset);
11567            // Verify that padding bytes are zero.
11568            fidl::decode!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.handle_handle, decoder, offset + 0, _depth)?;
11569            fidl::decode!(fidl::encoding::HandleType<fidl::Process, { fidl::ObjectType::PROCESS.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.process_handle, decoder, offset + 4, _depth)?;
11570            fidl::decode!(fidl::encoding::HandleType<fidl::Thread, { fidl::ObjectType::THREAD.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.thread_handle, decoder, offset + 8, _depth)?;
11571            fidl::decode!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.vmo_handle, decoder, offset + 12, _depth)?;
11572            fidl::decode!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.event_handle, decoder, offset + 16, _depth)?;
11573            fidl::decode!(fidl::encoding::HandleType<fidl::Port, { fidl::ObjectType::PORT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.port_handle, decoder, offset + 20, _depth)?;
11574            fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.socket_handle, decoder, offset + 24, _depth)?;
11575            fidl::decode!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.eventpair_handle, decoder, offset + 28, _depth)?;
11576            fidl::decode!(fidl::encoding::HandleType<fidl::Job, { fidl::ObjectType::JOB.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.job_handle, decoder, offset + 32, _depth)?;
11577            fidl::decode!(fidl::encoding::HandleType<fidl::Vmar, { fidl::ObjectType::VMAR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.vmar_handle, decoder, offset + 36, _depth)?;
11578            fidl::decode!(fidl::encoding::HandleType<fidl::Fifo, { fidl::ObjectType::FIFO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.fifo_handle, decoder, offset + 40, _depth)?;
11579            fidl::decode!(fidl::encoding::HandleType<fidl::Timer, { fidl::ObjectType::TIMER.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.timer_handle, decoder, offset + 44, _depth)?;
11580            fidl::decode!(
11581                fidl::encoding::Optional<
11582                    fidl::encoding::HandleType<
11583                        fidl::NullableHandle,
11584                        { fidl::ObjectType::NONE.into_raw() },
11585                        2147483648,
11586                    >,
11587                >,
11588                fidl::encoding::DefaultFuchsiaResourceDialect,
11589                &mut self.nullable_handle_handle,
11590                decoder,
11591                offset + 48,
11592                _depth
11593            )?;
11594            fidl::decode!(
11595                fidl::encoding::Optional<
11596                    fidl::encoding::HandleType<
11597                        fidl::Process,
11598                        { fidl::ObjectType::PROCESS.into_raw() },
11599                        2147483648,
11600                    >,
11601                >,
11602                fidl::encoding::DefaultFuchsiaResourceDialect,
11603                &mut self.nullable_process_handle,
11604                decoder,
11605                offset + 52,
11606                _depth
11607            )?;
11608            fidl::decode!(
11609                fidl::encoding::Optional<
11610                    fidl::encoding::HandleType<
11611                        fidl::Thread,
11612                        { fidl::ObjectType::THREAD.into_raw() },
11613                        2147483648,
11614                    >,
11615                >,
11616                fidl::encoding::DefaultFuchsiaResourceDialect,
11617                &mut self.nullable_thread_handle,
11618                decoder,
11619                offset + 56,
11620                _depth
11621            )?;
11622            fidl::decode!(
11623                fidl::encoding::Optional<
11624                    fidl::encoding::HandleType<
11625                        fidl::Vmo,
11626                        { fidl::ObjectType::VMO.into_raw() },
11627                        2147483648,
11628                    >,
11629                >,
11630                fidl::encoding::DefaultFuchsiaResourceDialect,
11631                &mut self.nullable_vmo_handle,
11632                decoder,
11633                offset + 60,
11634                _depth
11635            )?;
11636            fidl::decode!(
11637                fidl::encoding::Optional<
11638                    fidl::encoding::HandleType<
11639                        fidl::Channel,
11640                        { fidl::ObjectType::CHANNEL.into_raw() },
11641                        2147483648,
11642                    >,
11643                >,
11644                fidl::encoding::DefaultFuchsiaResourceDialect,
11645                &mut self.nullable_channel_handle,
11646                decoder,
11647                offset + 64,
11648                _depth
11649            )?;
11650            fidl::decode!(
11651                fidl::encoding::Optional<
11652                    fidl::encoding::HandleType<
11653                        fidl::Event,
11654                        { fidl::ObjectType::EVENT.into_raw() },
11655                        2147483648,
11656                    >,
11657                >,
11658                fidl::encoding::DefaultFuchsiaResourceDialect,
11659                &mut self.nullable_event_handle,
11660                decoder,
11661                offset + 68,
11662                _depth
11663            )?;
11664            fidl::decode!(
11665                fidl::encoding::Optional<
11666                    fidl::encoding::HandleType<
11667                        fidl::Port,
11668                        { fidl::ObjectType::PORT.into_raw() },
11669                        2147483648,
11670                    >,
11671                >,
11672                fidl::encoding::DefaultFuchsiaResourceDialect,
11673                &mut self.nullable_port_handle,
11674                decoder,
11675                offset + 72,
11676                _depth
11677            )?;
11678            fidl::decode!(
11679                fidl::encoding::Optional<
11680                    fidl::encoding::HandleType<
11681                        fidl::Interrupt,
11682                        { fidl::ObjectType::INTERRUPT.into_raw() },
11683                        2147483648,
11684                    >,
11685                >,
11686                fidl::encoding::DefaultFuchsiaResourceDialect,
11687                &mut self.nullable_interrupt_handle,
11688                decoder,
11689                offset + 76,
11690                _depth
11691            )?;
11692            fidl::decode!(
11693                fidl::encoding::Optional<
11694                    fidl::encoding::HandleType<
11695                        fidl::DebugLog,
11696                        { fidl::ObjectType::DEBUGLOG.into_raw() },
11697                        2147483648,
11698                    >,
11699                >,
11700                fidl::encoding::DefaultFuchsiaResourceDialect,
11701                &mut self.nullable_log_handle,
11702                decoder,
11703                offset + 80,
11704                _depth
11705            )?;
11706            fidl::decode!(
11707                fidl::encoding::Optional<
11708                    fidl::encoding::HandleType<
11709                        fidl::Socket,
11710                        { fidl::ObjectType::SOCKET.into_raw() },
11711                        2147483648,
11712                    >,
11713                >,
11714                fidl::encoding::DefaultFuchsiaResourceDialect,
11715                &mut self.nullable_socket_handle,
11716                decoder,
11717                offset + 84,
11718                _depth
11719            )?;
11720            fidl::decode!(
11721                fidl::encoding::Optional<
11722                    fidl::encoding::HandleType<
11723                        fidl::EventPair,
11724                        { fidl::ObjectType::EVENTPAIR.into_raw() },
11725                        2147483648,
11726                    >,
11727                >,
11728                fidl::encoding::DefaultFuchsiaResourceDialect,
11729                &mut self.nullable_eventpair_handle,
11730                decoder,
11731                offset + 88,
11732                _depth
11733            )?;
11734            fidl::decode!(
11735                fidl::encoding::Optional<
11736                    fidl::encoding::HandleType<
11737                        fidl::Job,
11738                        { fidl::ObjectType::JOB.into_raw() },
11739                        2147483648,
11740                    >,
11741                >,
11742                fidl::encoding::DefaultFuchsiaResourceDialect,
11743                &mut self.nullable_job_handle,
11744                decoder,
11745                offset + 92,
11746                _depth
11747            )?;
11748            fidl::decode!(
11749                fidl::encoding::Optional<
11750                    fidl::encoding::HandleType<
11751                        fidl::Vmar,
11752                        { fidl::ObjectType::VMAR.into_raw() },
11753                        2147483648,
11754                    >,
11755                >,
11756                fidl::encoding::DefaultFuchsiaResourceDialect,
11757                &mut self.nullable_vmar_handle,
11758                decoder,
11759                offset + 96,
11760                _depth
11761            )?;
11762            fidl::decode!(
11763                fidl::encoding::Optional<
11764                    fidl::encoding::HandleType<
11765                        fidl::Fifo,
11766                        { fidl::ObjectType::FIFO.into_raw() },
11767                        2147483648,
11768                    >,
11769                >,
11770                fidl::encoding::DefaultFuchsiaResourceDialect,
11771                &mut self.nullable_fifo_handle,
11772                decoder,
11773                offset + 100,
11774                _depth
11775            )?;
11776            fidl::decode!(
11777                fidl::encoding::Optional<
11778                    fidl::encoding::HandleType<
11779                        fidl::Timer,
11780                        { fidl::ObjectType::TIMER.into_raw() },
11781                        2147483648,
11782                    >,
11783                >,
11784                fidl::encoding::DefaultFuchsiaResourceDialect,
11785                &mut self.nullable_timer_handle,
11786                decoder,
11787                offset + 104,
11788                _depth
11789            )?;
11790            Ok(())
11791        }
11792    }
11793
11794    impl fidl::encoding::ResourceTypeMarker for Vectors {
11795        type Borrowed<'a> = &'a mut Self;
11796        fn take_or_borrow<'a>(
11797            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
11798        ) -> Self::Borrowed<'a> {
11799            value
11800        }
11801    }
11802
11803    unsafe impl fidl::encoding::TypeMarker for Vectors {
11804        type Owned = Self;
11805
11806        #[inline(always)]
11807        fn inline_align(_context: fidl::encoding::Context) -> usize {
11808            8
11809        }
11810
11811        #[inline(always)]
11812        fn inline_size(_context: fidl::encoding::Context) -> usize {
11813            1920
11814        }
11815    }
11816
11817    unsafe impl fidl::encoding::Encode<Vectors, fidl::encoding::DefaultFuchsiaResourceDialect>
11818        for &mut Vectors
11819    {
11820        #[inline]
11821        unsafe fn encode(
11822            self,
11823            encoder: &mut fidl::encoding::Encoder<
11824                '_,
11825                fidl::encoding::DefaultFuchsiaResourceDialect,
11826            >,
11827            offset: usize,
11828            _depth: fidl::encoding::Depth,
11829        ) -> fidl::Result<()> {
11830            encoder.debug_check_bounds::<Vectors>(offset);
11831            // Delegate to tuple encoding.
11832            fidl::encoding::Encode::<Vectors, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
11833                (
11834                    <fidl::encoding::UnboundedVector<bool> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_0),
11835                    <fidl::encoding::UnboundedVector<i8> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_0),
11836                    <fidl::encoding::UnboundedVector<i16> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_0),
11837                    <fidl::encoding::UnboundedVector<i32> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_0),
11838                    <fidl::encoding::UnboundedVector<i64> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_0),
11839                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_0),
11840                    <fidl::encoding::UnboundedVector<u16> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_0),
11841                    <fidl::encoding::UnboundedVector<u32> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_0),
11842                    <fidl::encoding::UnboundedVector<u64> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_0),
11843                    <fidl::encoding::UnboundedVector<f32> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_0),
11844                    <fidl::encoding::UnboundedVector<f64> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_0),
11845                    <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),
11846                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_1),
11847                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_1),
11848                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_1),
11849                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_1),
11850                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_1),
11851                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_1),
11852                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_1),
11853                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_1),
11854                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_1),
11855                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_1),
11856                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_1),
11857                    <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),
11858                    <fidl::encoding::Vector<bool, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_sized_0),
11859                    <fidl::encoding::Vector<i8, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_sized_0),
11860                    <fidl::encoding::Vector<i16, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_sized_0),
11861                    <fidl::encoding::Vector<i32, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_sized_0),
11862                    <fidl::encoding::Vector<i64, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_sized_0),
11863                    <fidl::encoding::Vector<u8, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_sized_0),
11864                    <fidl::encoding::Vector<u16, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_sized_0),
11865                    <fidl::encoding::Vector<u32, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_sized_0),
11866                    <fidl::encoding::Vector<u64, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_sized_0),
11867                    <fidl::encoding::Vector<f32, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_sized_0),
11868                    <fidl::encoding::Vector<f64, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_sized_0),
11869                    <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),
11870                    <fidl::encoding::Vector<bool, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_sized_1),
11871                    <fidl::encoding::Vector<i8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_sized_1),
11872                    <fidl::encoding::Vector<i16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_sized_1),
11873                    <fidl::encoding::Vector<i32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_sized_1),
11874                    <fidl::encoding::Vector<i64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_sized_1),
11875                    <fidl::encoding::Vector<u8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_sized_1),
11876                    <fidl::encoding::Vector<u16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_sized_1),
11877                    <fidl::encoding::Vector<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_sized_1),
11878                    <fidl::encoding::Vector<u64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_sized_1),
11879                    <fidl::encoding::Vector<f32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_sized_1),
11880                    <fidl::encoding::Vector<f64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_sized_1),
11881                    <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),
11882                    <fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_sized_2),
11883                    <fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_sized_2),
11884                    <fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_sized_2),
11885                    <fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_sized_2),
11886                    <fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_sized_2),
11887                    <fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_sized_2),
11888                    <fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_sized_2),
11889                    <fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_sized_2),
11890                    <fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_sized_2),
11891                    <fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_sized_2),
11892                    <fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_sized_2),
11893                    <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),
11894                    <fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_nullable_0),
11895                    <fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_nullable_0),
11896                    <fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_nullable_0),
11897                    <fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_nullable_0),
11898                    <fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_nullable_0),
11899                    <fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_nullable_0),
11900                    <fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_nullable_0),
11901                    <fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_nullable_0),
11902                    <fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_nullable_0),
11903                    <fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_nullable_0),
11904                    <fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_nullable_0),
11905                    <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),
11906                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_nullable_1),
11907                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_nullable_1),
11908                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_nullable_1),
11909                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_nullable_1),
11910                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_nullable_1),
11911                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_nullable_1),
11912                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_nullable_1),
11913                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_nullable_1),
11914                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_nullable_1),
11915                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_nullable_1),
11916                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_nullable_1),
11917                    <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),
11918                    <fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_nullable_sized_0),
11919                    <fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_nullable_sized_0),
11920                    <fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_nullable_sized_0),
11921                    <fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_nullable_sized_0),
11922                    <fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_nullable_sized_0),
11923                    <fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_nullable_sized_0),
11924                    <fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_nullable_sized_0),
11925                    <fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_nullable_sized_0),
11926                    <fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_nullable_sized_0),
11927                    <fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_nullable_sized_0),
11928                    <fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_nullable_sized_0),
11929                    <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),
11930                    <fidl::encoding::Optional<fidl::encoding::Vector<bool, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_nullable_sized_1),
11931                    <fidl::encoding::Optional<fidl::encoding::Vector<i8, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_nullable_sized_1),
11932                    <fidl::encoding::Optional<fidl::encoding::Vector<i16, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_nullable_sized_1),
11933                    <fidl::encoding::Optional<fidl::encoding::Vector<i32, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_nullable_sized_1),
11934                    <fidl::encoding::Optional<fidl::encoding::Vector<i64, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_nullable_sized_1),
11935                    <fidl::encoding::Optional<fidl::encoding::Vector<u8, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_nullable_sized_1),
11936                    <fidl::encoding::Optional<fidl::encoding::Vector<u16, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_nullable_sized_1),
11937                    <fidl::encoding::Optional<fidl::encoding::Vector<u32, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_nullable_sized_1),
11938                    <fidl::encoding::Optional<fidl::encoding::Vector<u64, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_nullable_sized_1),
11939                    <fidl::encoding::Optional<fidl::encoding::Vector<f32, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_nullable_sized_1),
11940                    <fidl::encoding::Optional<fidl::encoding::Vector<f64, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_nullable_sized_1),
11941                    <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),
11942                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_nullable_sized_2),
11943                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_nullable_sized_2),
11944                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_nullable_sized_2),
11945                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_nullable_sized_2),
11946                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_nullable_sized_2),
11947                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_nullable_sized_2),
11948                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_nullable_sized_2),
11949                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_nullable_sized_2),
11950                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_nullable_sized_2),
11951                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_nullable_sized_2),
11952                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_nullable_sized_2),
11953                    <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),
11954                ),
11955                encoder, offset, _depth
11956            )
11957        }
11958    }
11959    unsafe impl<
11960        T0: fidl::encoding::Encode<
11961                fidl::encoding::UnboundedVector<bool>,
11962                fidl::encoding::DefaultFuchsiaResourceDialect,
11963            >,
11964        T1: fidl::encoding::Encode<
11965                fidl::encoding::UnboundedVector<i8>,
11966                fidl::encoding::DefaultFuchsiaResourceDialect,
11967            >,
11968        T2: fidl::encoding::Encode<
11969                fidl::encoding::UnboundedVector<i16>,
11970                fidl::encoding::DefaultFuchsiaResourceDialect,
11971            >,
11972        T3: fidl::encoding::Encode<
11973                fidl::encoding::UnboundedVector<i32>,
11974                fidl::encoding::DefaultFuchsiaResourceDialect,
11975            >,
11976        T4: fidl::encoding::Encode<
11977                fidl::encoding::UnboundedVector<i64>,
11978                fidl::encoding::DefaultFuchsiaResourceDialect,
11979            >,
11980        T5: fidl::encoding::Encode<
11981                fidl::encoding::UnboundedVector<u8>,
11982                fidl::encoding::DefaultFuchsiaResourceDialect,
11983            >,
11984        T6: fidl::encoding::Encode<
11985                fidl::encoding::UnboundedVector<u16>,
11986                fidl::encoding::DefaultFuchsiaResourceDialect,
11987            >,
11988        T7: fidl::encoding::Encode<
11989                fidl::encoding::UnboundedVector<u32>,
11990                fidl::encoding::DefaultFuchsiaResourceDialect,
11991            >,
11992        T8: fidl::encoding::Encode<
11993                fidl::encoding::UnboundedVector<u64>,
11994                fidl::encoding::DefaultFuchsiaResourceDialect,
11995            >,
11996        T9: fidl::encoding::Encode<
11997                fidl::encoding::UnboundedVector<f32>,
11998                fidl::encoding::DefaultFuchsiaResourceDialect,
11999            >,
12000        T10: fidl::encoding::Encode<
12001                fidl::encoding::UnboundedVector<f64>,
12002                fidl::encoding::DefaultFuchsiaResourceDialect,
12003            >,
12004        T11: fidl::encoding::Encode<
12005                fidl::encoding::UnboundedVector<
12006                    fidl::encoding::HandleType<
12007                        fidl::NullableHandle,
12008                        { fidl::ObjectType::NONE.into_raw() },
12009                        2147483648,
12010                    >,
12011                >,
12012                fidl::encoding::DefaultFuchsiaResourceDialect,
12013            >,
12014        T12: fidl::encoding::Encode<
12015                fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
12016                fidl::encoding::DefaultFuchsiaResourceDialect,
12017            >,
12018        T13: fidl::encoding::Encode<
12019                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
12020                fidl::encoding::DefaultFuchsiaResourceDialect,
12021            >,
12022        T14: fidl::encoding::Encode<
12023                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
12024                fidl::encoding::DefaultFuchsiaResourceDialect,
12025            >,
12026        T15: fidl::encoding::Encode<
12027                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
12028                fidl::encoding::DefaultFuchsiaResourceDialect,
12029            >,
12030        T16: fidl::encoding::Encode<
12031                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
12032                fidl::encoding::DefaultFuchsiaResourceDialect,
12033            >,
12034        T17: fidl::encoding::Encode<
12035                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
12036                fidl::encoding::DefaultFuchsiaResourceDialect,
12037            >,
12038        T18: fidl::encoding::Encode<
12039                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
12040                fidl::encoding::DefaultFuchsiaResourceDialect,
12041            >,
12042        T19: fidl::encoding::Encode<
12043                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
12044                fidl::encoding::DefaultFuchsiaResourceDialect,
12045            >,
12046        T20: fidl::encoding::Encode<
12047                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
12048                fidl::encoding::DefaultFuchsiaResourceDialect,
12049            >,
12050        T21: fidl::encoding::Encode<
12051                fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
12052                fidl::encoding::DefaultFuchsiaResourceDialect,
12053            >,
12054        T22: fidl::encoding::Encode<
12055                fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
12056                fidl::encoding::DefaultFuchsiaResourceDialect,
12057            >,
12058        T23: fidl::encoding::Encode<
12059                fidl::encoding::UnboundedVector<
12060                    fidl::encoding::Vector<
12061                        fidl::encoding::HandleType<
12062                            fidl::NullableHandle,
12063                            { fidl::ObjectType::NONE.into_raw() },
12064                            2147483648,
12065                        >,
12066                        2,
12067                    >,
12068                >,
12069                fidl::encoding::DefaultFuchsiaResourceDialect,
12070            >,
12071        T24: fidl::encoding::Encode<
12072                fidl::encoding::Vector<bool, 1>,
12073                fidl::encoding::DefaultFuchsiaResourceDialect,
12074            >,
12075        T25: fidl::encoding::Encode<
12076                fidl::encoding::Vector<i8, 1>,
12077                fidl::encoding::DefaultFuchsiaResourceDialect,
12078            >,
12079        T26: fidl::encoding::Encode<
12080                fidl::encoding::Vector<i16, 1>,
12081                fidl::encoding::DefaultFuchsiaResourceDialect,
12082            >,
12083        T27: fidl::encoding::Encode<
12084                fidl::encoding::Vector<i32, 1>,
12085                fidl::encoding::DefaultFuchsiaResourceDialect,
12086            >,
12087        T28: fidl::encoding::Encode<
12088                fidl::encoding::Vector<i64, 1>,
12089                fidl::encoding::DefaultFuchsiaResourceDialect,
12090            >,
12091        T29: fidl::encoding::Encode<
12092                fidl::encoding::Vector<u8, 1>,
12093                fidl::encoding::DefaultFuchsiaResourceDialect,
12094            >,
12095        T30: fidl::encoding::Encode<
12096                fidl::encoding::Vector<u16, 1>,
12097                fidl::encoding::DefaultFuchsiaResourceDialect,
12098            >,
12099        T31: fidl::encoding::Encode<
12100                fidl::encoding::Vector<u32, 1>,
12101                fidl::encoding::DefaultFuchsiaResourceDialect,
12102            >,
12103        T32: fidl::encoding::Encode<
12104                fidl::encoding::Vector<u64, 1>,
12105                fidl::encoding::DefaultFuchsiaResourceDialect,
12106            >,
12107        T33: fidl::encoding::Encode<
12108                fidl::encoding::Vector<f32, 1>,
12109                fidl::encoding::DefaultFuchsiaResourceDialect,
12110            >,
12111        T34: fidl::encoding::Encode<
12112                fidl::encoding::Vector<f64, 1>,
12113                fidl::encoding::DefaultFuchsiaResourceDialect,
12114            >,
12115        T35: fidl::encoding::Encode<
12116                fidl::encoding::Vector<
12117                    fidl::encoding::HandleType<
12118                        fidl::NullableHandle,
12119                        { fidl::ObjectType::NONE.into_raw() },
12120                        2147483648,
12121                    >,
12122                    1,
12123                >,
12124                fidl::encoding::DefaultFuchsiaResourceDialect,
12125            >,
12126        T36: fidl::encoding::Encode<
12127                fidl::encoding::Vector<bool, 3>,
12128                fidl::encoding::DefaultFuchsiaResourceDialect,
12129            >,
12130        T37: fidl::encoding::Encode<
12131                fidl::encoding::Vector<i8, 3>,
12132                fidl::encoding::DefaultFuchsiaResourceDialect,
12133            >,
12134        T38: fidl::encoding::Encode<
12135                fidl::encoding::Vector<i16, 3>,
12136                fidl::encoding::DefaultFuchsiaResourceDialect,
12137            >,
12138        T39: fidl::encoding::Encode<
12139                fidl::encoding::Vector<i32, 3>,
12140                fidl::encoding::DefaultFuchsiaResourceDialect,
12141            >,
12142        T40: fidl::encoding::Encode<
12143                fidl::encoding::Vector<i64, 3>,
12144                fidl::encoding::DefaultFuchsiaResourceDialect,
12145            >,
12146        T41: fidl::encoding::Encode<
12147                fidl::encoding::Vector<u8, 3>,
12148                fidl::encoding::DefaultFuchsiaResourceDialect,
12149            >,
12150        T42: fidl::encoding::Encode<
12151                fidl::encoding::Vector<u16, 3>,
12152                fidl::encoding::DefaultFuchsiaResourceDialect,
12153            >,
12154        T43: fidl::encoding::Encode<
12155                fidl::encoding::Vector<u32, 3>,
12156                fidl::encoding::DefaultFuchsiaResourceDialect,
12157            >,
12158        T44: fidl::encoding::Encode<
12159                fidl::encoding::Vector<u64, 3>,
12160                fidl::encoding::DefaultFuchsiaResourceDialect,
12161            >,
12162        T45: fidl::encoding::Encode<
12163                fidl::encoding::Vector<f32, 3>,
12164                fidl::encoding::DefaultFuchsiaResourceDialect,
12165            >,
12166        T46: fidl::encoding::Encode<
12167                fidl::encoding::Vector<f64, 3>,
12168                fidl::encoding::DefaultFuchsiaResourceDialect,
12169            >,
12170        T47: fidl::encoding::Encode<
12171                fidl::encoding::Vector<
12172                    fidl::encoding::HandleType<
12173                        fidl::NullableHandle,
12174                        { fidl::ObjectType::NONE.into_raw() },
12175                        2147483648,
12176                    >,
12177                    3,
12178                >,
12179                fidl::encoding::DefaultFuchsiaResourceDialect,
12180            >,
12181        T48: fidl::encoding::Encode<
12182                fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
12183                fidl::encoding::DefaultFuchsiaResourceDialect,
12184            >,
12185        T49: fidl::encoding::Encode<
12186                fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>,
12187                fidl::encoding::DefaultFuchsiaResourceDialect,
12188            >,
12189        T50: fidl::encoding::Encode<
12190                fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>,
12191                fidl::encoding::DefaultFuchsiaResourceDialect,
12192            >,
12193        T51: fidl::encoding::Encode<
12194                fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>,
12195                fidl::encoding::DefaultFuchsiaResourceDialect,
12196            >,
12197        T52: fidl::encoding::Encode<
12198                fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>,
12199                fidl::encoding::DefaultFuchsiaResourceDialect,
12200            >,
12201        T53: fidl::encoding::Encode<
12202                fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>,
12203                fidl::encoding::DefaultFuchsiaResourceDialect,
12204            >,
12205        T54: fidl::encoding::Encode<
12206                fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>,
12207                fidl::encoding::DefaultFuchsiaResourceDialect,
12208            >,
12209        T55: fidl::encoding::Encode<
12210                fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>,
12211                fidl::encoding::DefaultFuchsiaResourceDialect,
12212            >,
12213        T56: fidl::encoding::Encode<
12214                fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>,
12215                fidl::encoding::DefaultFuchsiaResourceDialect,
12216            >,
12217        T57: fidl::encoding::Encode<
12218                fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>,
12219                fidl::encoding::DefaultFuchsiaResourceDialect,
12220            >,
12221        T58: fidl::encoding::Encode<
12222                fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>,
12223                fidl::encoding::DefaultFuchsiaResourceDialect,
12224            >,
12225        T59: fidl::encoding::Encode<
12226                fidl::encoding::Vector<
12227                    fidl::encoding::Vector<
12228                        fidl::encoding::HandleType<
12229                            fidl::NullableHandle,
12230                            { fidl::ObjectType::NONE.into_raw() },
12231                            2147483648,
12232                        >,
12233                        2,
12234                    >,
12235                    3,
12236                >,
12237                fidl::encoding::DefaultFuchsiaResourceDialect,
12238            >,
12239        T60: fidl::encoding::Encode<
12240                fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
12241                fidl::encoding::DefaultFuchsiaResourceDialect,
12242            >,
12243        T61: fidl::encoding::Encode<
12244                fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
12245                fidl::encoding::DefaultFuchsiaResourceDialect,
12246            >,
12247        T62: fidl::encoding::Encode<
12248                fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
12249                fidl::encoding::DefaultFuchsiaResourceDialect,
12250            >,
12251        T63: fidl::encoding::Encode<
12252                fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
12253                fidl::encoding::DefaultFuchsiaResourceDialect,
12254            >,
12255        T64: fidl::encoding::Encode<
12256                fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
12257                fidl::encoding::DefaultFuchsiaResourceDialect,
12258            >,
12259        T65: fidl::encoding::Encode<
12260                fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
12261                fidl::encoding::DefaultFuchsiaResourceDialect,
12262            >,
12263        T66: fidl::encoding::Encode<
12264                fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
12265                fidl::encoding::DefaultFuchsiaResourceDialect,
12266            >,
12267        T67: fidl::encoding::Encode<
12268                fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
12269                fidl::encoding::DefaultFuchsiaResourceDialect,
12270            >,
12271        T68: fidl::encoding::Encode<
12272                fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
12273                fidl::encoding::DefaultFuchsiaResourceDialect,
12274            >,
12275        T69: fidl::encoding::Encode<
12276                fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
12277                fidl::encoding::DefaultFuchsiaResourceDialect,
12278            >,
12279        T70: fidl::encoding::Encode<
12280                fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
12281                fidl::encoding::DefaultFuchsiaResourceDialect,
12282            >,
12283        T71: fidl::encoding::Encode<
12284                fidl::encoding::Optional<
12285                    fidl::encoding::Vector<
12286                        fidl::encoding::HandleType<
12287                            fidl::NullableHandle,
12288                            { fidl::ObjectType::NONE.into_raw() },
12289                            2147483648,
12290                        >,
12291                        1,
12292                    >,
12293                >,
12294                fidl::encoding::DefaultFuchsiaResourceDialect,
12295            >,
12296        T72: fidl::encoding::Encode<
12297                fidl::encoding::Optional<
12298                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
12299                >,
12300                fidl::encoding::DefaultFuchsiaResourceDialect,
12301            >,
12302        T73: fidl::encoding::Encode<
12303                fidl::encoding::Optional<
12304                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
12305                >,
12306                fidl::encoding::DefaultFuchsiaResourceDialect,
12307            >,
12308        T74: fidl::encoding::Encode<
12309                fidl::encoding::Optional<
12310                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
12311                >,
12312                fidl::encoding::DefaultFuchsiaResourceDialect,
12313            >,
12314        T75: fidl::encoding::Encode<
12315                fidl::encoding::Optional<
12316                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
12317                >,
12318                fidl::encoding::DefaultFuchsiaResourceDialect,
12319            >,
12320        T76: fidl::encoding::Encode<
12321                fidl::encoding::Optional<
12322                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
12323                >,
12324                fidl::encoding::DefaultFuchsiaResourceDialect,
12325            >,
12326        T77: fidl::encoding::Encode<
12327                fidl::encoding::Optional<
12328                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
12329                >,
12330                fidl::encoding::DefaultFuchsiaResourceDialect,
12331            >,
12332        T78: fidl::encoding::Encode<
12333                fidl::encoding::Optional<
12334                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
12335                >,
12336                fidl::encoding::DefaultFuchsiaResourceDialect,
12337            >,
12338        T79: fidl::encoding::Encode<
12339                fidl::encoding::Optional<
12340                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
12341                >,
12342                fidl::encoding::DefaultFuchsiaResourceDialect,
12343            >,
12344        T80: fidl::encoding::Encode<
12345                fidl::encoding::Optional<
12346                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
12347                >,
12348                fidl::encoding::DefaultFuchsiaResourceDialect,
12349            >,
12350        T81: fidl::encoding::Encode<
12351                fidl::encoding::Optional<
12352                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
12353                >,
12354                fidl::encoding::DefaultFuchsiaResourceDialect,
12355            >,
12356        T82: fidl::encoding::Encode<
12357                fidl::encoding::Optional<
12358                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
12359                >,
12360                fidl::encoding::DefaultFuchsiaResourceDialect,
12361            >,
12362        T83: fidl::encoding::Encode<
12363                fidl::encoding::Optional<
12364                    fidl::encoding::UnboundedVector<
12365                        fidl::encoding::Vector<
12366                            fidl::encoding::HandleType<
12367                                fidl::NullableHandle,
12368                                { fidl::ObjectType::NONE.into_raw() },
12369                                2147483648,
12370                            >,
12371                            2,
12372                        >,
12373                    >,
12374                >,
12375                fidl::encoding::DefaultFuchsiaResourceDialect,
12376            >,
12377        T84: fidl::encoding::Encode<
12378                fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
12379                fidl::encoding::DefaultFuchsiaResourceDialect,
12380            >,
12381        T85: fidl::encoding::Encode<
12382                fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
12383                fidl::encoding::DefaultFuchsiaResourceDialect,
12384            >,
12385        T86: fidl::encoding::Encode<
12386                fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
12387                fidl::encoding::DefaultFuchsiaResourceDialect,
12388            >,
12389        T87: fidl::encoding::Encode<
12390                fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
12391                fidl::encoding::DefaultFuchsiaResourceDialect,
12392            >,
12393        T88: fidl::encoding::Encode<
12394                fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
12395                fidl::encoding::DefaultFuchsiaResourceDialect,
12396            >,
12397        T89: fidl::encoding::Encode<
12398                fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
12399                fidl::encoding::DefaultFuchsiaResourceDialect,
12400            >,
12401        T90: fidl::encoding::Encode<
12402                fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
12403                fidl::encoding::DefaultFuchsiaResourceDialect,
12404            >,
12405        T91: fidl::encoding::Encode<
12406                fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
12407                fidl::encoding::DefaultFuchsiaResourceDialect,
12408            >,
12409        T92: fidl::encoding::Encode<
12410                fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
12411                fidl::encoding::DefaultFuchsiaResourceDialect,
12412            >,
12413        T93: fidl::encoding::Encode<
12414                fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
12415                fidl::encoding::DefaultFuchsiaResourceDialect,
12416            >,
12417        T94: fidl::encoding::Encode<
12418                fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
12419                fidl::encoding::DefaultFuchsiaResourceDialect,
12420            >,
12421        T95: fidl::encoding::Encode<
12422                fidl::encoding::Optional<
12423                    fidl::encoding::Vector<
12424                        fidl::encoding::HandleType<
12425                            fidl::NullableHandle,
12426                            { fidl::ObjectType::NONE.into_raw() },
12427                            2147483648,
12428                        >,
12429                        1,
12430                    >,
12431                >,
12432                fidl::encoding::DefaultFuchsiaResourceDialect,
12433            >,
12434        T96: fidl::encoding::Encode<
12435                fidl::encoding::Optional<fidl::encoding::Vector<bool, 3>>,
12436                fidl::encoding::DefaultFuchsiaResourceDialect,
12437            >,
12438        T97: fidl::encoding::Encode<
12439                fidl::encoding::Optional<fidl::encoding::Vector<i8, 3>>,
12440                fidl::encoding::DefaultFuchsiaResourceDialect,
12441            >,
12442        T98: fidl::encoding::Encode<
12443                fidl::encoding::Optional<fidl::encoding::Vector<i16, 3>>,
12444                fidl::encoding::DefaultFuchsiaResourceDialect,
12445            >,
12446        T99: fidl::encoding::Encode<
12447                fidl::encoding::Optional<fidl::encoding::Vector<i32, 3>>,
12448                fidl::encoding::DefaultFuchsiaResourceDialect,
12449            >,
12450        T100: fidl::encoding::Encode<
12451                fidl::encoding::Optional<fidl::encoding::Vector<i64, 3>>,
12452                fidl::encoding::DefaultFuchsiaResourceDialect,
12453            >,
12454        T101: fidl::encoding::Encode<
12455                fidl::encoding::Optional<fidl::encoding::Vector<u8, 3>>,
12456                fidl::encoding::DefaultFuchsiaResourceDialect,
12457            >,
12458        T102: fidl::encoding::Encode<
12459                fidl::encoding::Optional<fidl::encoding::Vector<u16, 3>>,
12460                fidl::encoding::DefaultFuchsiaResourceDialect,
12461            >,
12462        T103: fidl::encoding::Encode<
12463                fidl::encoding::Optional<fidl::encoding::Vector<u32, 3>>,
12464                fidl::encoding::DefaultFuchsiaResourceDialect,
12465            >,
12466        T104: fidl::encoding::Encode<
12467                fidl::encoding::Optional<fidl::encoding::Vector<u64, 3>>,
12468                fidl::encoding::DefaultFuchsiaResourceDialect,
12469            >,
12470        T105: fidl::encoding::Encode<
12471                fidl::encoding::Optional<fidl::encoding::Vector<f32, 3>>,
12472                fidl::encoding::DefaultFuchsiaResourceDialect,
12473            >,
12474        T106: fidl::encoding::Encode<
12475                fidl::encoding::Optional<fidl::encoding::Vector<f64, 3>>,
12476                fidl::encoding::DefaultFuchsiaResourceDialect,
12477            >,
12478        T107: fidl::encoding::Encode<
12479                fidl::encoding::Optional<
12480                    fidl::encoding::Vector<
12481                        fidl::encoding::HandleType<
12482                            fidl::NullableHandle,
12483                            { fidl::ObjectType::NONE.into_raw() },
12484                            2147483648,
12485                        >,
12486                        3,
12487                    >,
12488                >,
12489                fidl::encoding::DefaultFuchsiaResourceDialect,
12490            >,
12491        T108: fidl::encoding::Encode<
12492                fidl::encoding::Optional<
12493                    fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
12494                >,
12495                fidl::encoding::DefaultFuchsiaResourceDialect,
12496            >,
12497        T109: fidl::encoding::Encode<
12498                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>>,
12499                fidl::encoding::DefaultFuchsiaResourceDialect,
12500            >,
12501        T110: fidl::encoding::Encode<
12502                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>>,
12503                fidl::encoding::DefaultFuchsiaResourceDialect,
12504            >,
12505        T111: fidl::encoding::Encode<
12506                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>>,
12507                fidl::encoding::DefaultFuchsiaResourceDialect,
12508            >,
12509        T112: fidl::encoding::Encode<
12510                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>>,
12511                fidl::encoding::DefaultFuchsiaResourceDialect,
12512            >,
12513        T113: fidl::encoding::Encode<
12514                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>>,
12515                fidl::encoding::DefaultFuchsiaResourceDialect,
12516            >,
12517        T114: fidl::encoding::Encode<
12518                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>>,
12519                fidl::encoding::DefaultFuchsiaResourceDialect,
12520            >,
12521        T115: fidl::encoding::Encode<
12522                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>>,
12523                fidl::encoding::DefaultFuchsiaResourceDialect,
12524            >,
12525        T116: fidl::encoding::Encode<
12526                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>>,
12527                fidl::encoding::DefaultFuchsiaResourceDialect,
12528            >,
12529        T117: fidl::encoding::Encode<
12530                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>>,
12531                fidl::encoding::DefaultFuchsiaResourceDialect,
12532            >,
12533        T118: fidl::encoding::Encode<
12534                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>>,
12535                fidl::encoding::DefaultFuchsiaResourceDialect,
12536            >,
12537        T119: fidl::encoding::Encode<
12538                fidl::encoding::Optional<
12539                    fidl::encoding::Vector<
12540                        fidl::encoding::Vector<
12541                            fidl::encoding::HandleType<
12542                                fidl::NullableHandle,
12543                                { fidl::ObjectType::NONE.into_raw() },
12544                                2147483648,
12545                            >,
12546                            2,
12547                        >,
12548                        3,
12549                    >,
12550                >,
12551                fidl::encoding::DefaultFuchsiaResourceDialect,
12552            >,
12553    > fidl::encoding::Encode<Vectors, fidl::encoding::DefaultFuchsiaResourceDialect>
12554        for (
12555            T0,
12556            T1,
12557            T2,
12558            T3,
12559            T4,
12560            T5,
12561            T6,
12562            T7,
12563            T8,
12564            T9,
12565            T10,
12566            T11,
12567            T12,
12568            T13,
12569            T14,
12570            T15,
12571            T16,
12572            T17,
12573            T18,
12574            T19,
12575            T20,
12576            T21,
12577            T22,
12578            T23,
12579            T24,
12580            T25,
12581            T26,
12582            T27,
12583            T28,
12584            T29,
12585            T30,
12586            T31,
12587            T32,
12588            T33,
12589            T34,
12590            T35,
12591            T36,
12592            T37,
12593            T38,
12594            T39,
12595            T40,
12596            T41,
12597            T42,
12598            T43,
12599            T44,
12600            T45,
12601            T46,
12602            T47,
12603            T48,
12604            T49,
12605            T50,
12606            T51,
12607            T52,
12608            T53,
12609            T54,
12610            T55,
12611            T56,
12612            T57,
12613            T58,
12614            T59,
12615            T60,
12616            T61,
12617            T62,
12618            T63,
12619            T64,
12620            T65,
12621            T66,
12622            T67,
12623            T68,
12624            T69,
12625            T70,
12626            T71,
12627            T72,
12628            T73,
12629            T74,
12630            T75,
12631            T76,
12632            T77,
12633            T78,
12634            T79,
12635            T80,
12636            T81,
12637            T82,
12638            T83,
12639            T84,
12640            T85,
12641            T86,
12642            T87,
12643            T88,
12644            T89,
12645            T90,
12646            T91,
12647            T92,
12648            T93,
12649            T94,
12650            T95,
12651            T96,
12652            T97,
12653            T98,
12654            T99,
12655            T100,
12656            T101,
12657            T102,
12658            T103,
12659            T104,
12660            T105,
12661            T106,
12662            T107,
12663            T108,
12664            T109,
12665            T110,
12666            T111,
12667            T112,
12668            T113,
12669            T114,
12670            T115,
12671            T116,
12672            T117,
12673            T118,
12674            T119,
12675        )
12676    {
12677        #[inline]
12678        unsafe fn encode(
12679            self,
12680            encoder: &mut fidl::encoding::Encoder<
12681                '_,
12682                fidl::encoding::DefaultFuchsiaResourceDialect,
12683            >,
12684            offset: usize,
12685            depth: fidl::encoding::Depth,
12686        ) -> fidl::Result<()> {
12687            encoder.debug_check_bounds::<Vectors>(offset);
12688            // Zero out padding regions. There's no need to apply masks
12689            // because the unmasked parts will be overwritten by fields.
12690            // Write the fields.
12691            self.0.encode(encoder, offset + 0, depth)?;
12692            self.1.encode(encoder, offset + 16, depth)?;
12693            self.2.encode(encoder, offset + 32, depth)?;
12694            self.3.encode(encoder, offset + 48, depth)?;
12695            self.4.encode(encoder, offset + 64, depth)?;
12696            self.5.encode(encoder, offset + 80, depth)?;
12697            self.6.encode(encoder, offset + 96, depth)?;
12698            self.7.encode(encoder, offset + 112, depth)?;
12699            self.8.encode(encoder, offset + 128, depth)?;
12700            self.9.encode(encoder, offset + 144, depth)?;
12701            self.10.encode(encoder, offset + 160, depth)?;
12702            self.11.encode(encoder, offset + 176, depth)?;
12703            self.12.encode(encoder, offset + 192, depth)?;
12704            self.13.encode(encoder, offset + 208, depth)?;
12705            self.14.encode(encoder, offset + 224, depth)?;
12706            self.15.encode(encoder, offset + 240, depth)?;
12707            self.16.encode(encoder, offset + 256, depth)?;
12708            self.17.encode(encoder, offset + 272, depth)?;
12709            self.18.encode(encoder, offset + 288, depth)?;
12710            self.19.encode(encoder, offset + 304, depth)?;
12711            self.20.encode(encoder, offset + 320, depth)?;
12712            self.21.encode(encoder, offset + 336, depth)?;
12713            self.22.encode(encoder, offset + 352, depth)?;
12714            self.23.encode(encoder, offset + 368, depth)?;
12715            self.24.encode(encoder, offset + 384, depth)?;
12716            self.25.encode(encoder, offset + 400, depth)?;
12717            self.26.encode(encoder, offset + 416, depth)?;
12718            self.27.encode(encoder, offset + 432, depth)?;
12719            self.28.encode(encoder, offset + 448, depth)?;
12720            self.29.encode(encoder, offset + 464, depth)?;
12721            self.30.encode(encoder, offset + 480, depth)?;
12722            self.31.encode(encoder, offset + 496, depth)?;
12723            self.32.encode(encoder, offset + 512, depth)?;
12724            self.33.encode(encoder, offset + 528, depth)?;
12725            self.34.encode(encoder, offset + 544, depth)?;
12726            self.35.encode(encoder, offset + 560, depth)?;
12727            self.36.encode(encoder, offset + 576, depth)?;
12728            self.37.encode(encoder, offset + 592, depth)?;
12729            self.38.encode(encoder, offset + 608, depth)?;
12730            self.39.encode(encoder, offset + 624, depth)?;
12731            self.40.encode(encoder, offset + 640, depth)?;
12732            self.41.encode(encoder, offset + 656, depth)?;
12733            self.42.encode(encoder, offset + 672, depth)?;
12734            self.43.encode(encoder, offset + 688, depth)?;
12735            self.44.encode(encoder, offset + 704, depth)?;
12736            self.45.encode(encoder, offset + 720, depth)?;
12737            self.46.encode(encoder, offset + 736, depth)?;
12738            self.47.encode(encoder, offset + 752, depth)?;
12739            self.48.encode(encoder, offset + 768, depth)?;
12740            self.49.encode(encoder, offset + 784, depth)?;
12741            self.50.encode(encoder, offset + 800, depth)?;
12742            self.51.encode(encoder, offset + 816, depth)?;
12743            self.52.encode(encoder, offset + 832, depth)?;
12744            self.53.encode(encoder, offset + 848, depth)?;
12745            self.54.encode(encoder, offset + 864, depth)?;
12746            self.55.encode(encoder, offset + 880, depth)?;
12747            self.56.encode(encoder, offset + 896, depth)?;
12748            self.57.encode(encoder, offset + 912, depth)?;
12749            self.58.encode(encoder, offset + 928, depth)?;
12750            self.59.encode(encoder, offset + 944, depth)?;
12751            self.60.encode(encoder, offset + 960, depth)?;
12752            self.61.encode(encoder, offset + 976, depth)?;
12753            self.62.encode(encoder, offset + 992, depth)?;
12754            self.63.encode(encoder, offset + 1008, depth)?;
12755            self.64.encode(encoder, offset + 1024, depth)?;
12756            self.65.encode(encoder, offset + 1040, depth)?;
12757            self.66.encode(encoder, offset + 1056, depth)?;
12758            self.67.encode(encoder, offset + 1072, depth)?;
12759            self.68.encode(encoder, offset + 1088, depth)?;
12760            self.69.encode(encoder, offset + 1104, depth)?;
12761            self.70.encode(encoder, offset + 1120, depth)?;
12762            self.71.encode(encoder, offset + 1136, depth)?;
12763            self.72.encode(encoder, offset + 1152, depth)?;
12764            self.73.encode(encoder, offset + 1168, depth)?;
12765            self.74.encode(encoder, offset + 1184, depth)?;
12766            self.75.encode(encoder, offset + 1200, depth)?;
12767            self.76.encode(encoder, offset + 1216, depth)?;
12768            self.77.encode(encoder, offset + 1232, depth)?;
12769            self.78.encode(encoder, offset + 1248, depth)?;
12770            self.79.encode(encoder, offset + 1264, depth)?;
12771            self.80.encode(encoder, offset + 1280, depth)?;
12772            self.81.encode(encoder, offset + 1296, depth)?;
12773            self.82.encode(encoder, offset + 1312, depth)?;
12774            self.83.encode(encoder, offset + 1328, depth)?;
12775            self.84.encode(encoder, offset + 1344, depth)?;
12776            self.85.encode(encoder, offset + 1360, depth)?;
12777            self.86.encode(encoder, offset + 1376, depth)?;
12778            self.87.encode(encoder, offset + 1392, depth)?;
12779            self.88.encode(encoder, offset + 1408, depth)?;
12780            self.89.encode(encoder, offset + 1424, depth)?;
12781            self.90.encode(encoder, offset + 1440, depth)?;
12782            self.91.encode(encoder, offset + 1456, depth)?;
12783            self.92.encode(encoder, offset + 1472, depth)?;
12784            self.93.encode(encoder, offset + 1488, depth)?;
12785            self.94.encode(encoder, offset + 1504, depth)?;
12786            self.95.encode(encoder, offset + 1520, depth)?;
12787            self.96.encode(encoder, offset + 1536, depth)?;
12788            self.97.encode(encoder, offset + 1552, depth)?;
12789            self.98.encode(encoder, offset + 1568, depth)?;
12790            self.99.encode(encoder, offset + 1584, depth)?;
12791            self.100.encode(encoder, offset + 1600, depth)?;
12792            self.101.encode(encoder, offset + 1616, depth)?;
12793            self.102.encode(encoder, offset + 1632, depth)?;
12794            self.103.encode(encoder, offset + 1648, depth)?;
12795            self.104.encode(encoder, offset + 1664, depth)?;
12796            self.105.encode(encoder, offset + 1680, depth)?;
12797            self.106.encode(encoder, offset + 1696, depth)?;
12798            self.107.encode(encoder, offset + 1712, depth)?;
12799            self.108.encode(encoder, offset + 1728, depth)?;
12800            self.109.encode(encoder, offset + 1744, depth)?;
12801            self.110.encode(encoder, offset + 1760, depth)?;
12802            self.111.encode(encoder, offset + 1776, depth)?;
12803            self.112.encode(encoder, offset + 1792, depth)?;
12804            self.113.encode(encoder, offset + 1808, depth)?;
12805            self.114.encode(encoder, offset + 1824, depth)?;
12806            self.115.encode(encoder, offset + 1840, depth)?;
12807            self.116.encode(encoder, offset + 1856, depth)?;
12808            self.117.encode(encoder, offset + 1872, depth)?;
12809            self.118.encode(encoder, offset + 1888, depth)?;
12810            self.119.encode(encoder, offset + 1904, depth)?;
12811            Ok(())
12812        }
12813    }
12814
12815    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Vectors {
12816        #[inline(always)]
12817        fn new_empty() -> Self {
12818            Self {
12819                b_0: fidl::new_empty!(
12820                    fidl::encoding::UnboundedVector<bool>,
12821                    fidl::encoding::DefaultFuchsiaResourceDialect
12822                ),
12823                i8_0: fidl::new_empty!(
12824                    fidl::encoding::UnboundedVector<i8>,
12825                    fidl::encoding::DefaultFuchsiaResourceDialect
12826                ),
12827                i16_0: fidl::new_empty!(
12828                    fidl::encoding::UnboundedVector<i16>,
12829                    fidl::encoding::DefaultFuchsiaResourceDialect
12830                ),
12831                i32_0: fidl::new_empty!(
12832                    fidl::encoding::UnboundedVector<i32>,
12833                    fidl::encoding::DefaultFuchsiaResourceDialect
12834                ),
12835                i64_0: fidl::new_empty!(
12836                    fidl::encoding::UnboundedVector<i64>,
12837                    fidl::encoding::DefaultFuchsiaResourceDialect
12838                ),
12839                u8_0: fidl::new_empty!(
12840                    fidl::encoding::UnboundedVector<u8>,
12841                    fidl::encoding::DefaultFuchsiaResourceDialect
12842                ),
12843                u16_0: fidl::new_empty!(
12844                    fidl::encoding::UnboundedVector<u16>,
12845                    fidl::encoding::DefaultFuchsiaResourceDialect
12846                ),
12847                u32_0: fidl::new_empty!(
12848                    fidl::encoding::UnboundedVector<u32>,
12849                    fidl::encoding::DefaultFuchsiaResourceDialect
12850                ),
12851                u64_0: fidl::new_empty!(
12852                    fidl::encoding::UnboundedVector<u64>,
12853                    fidl::encoding::DefaultFuchsiaResourceDialect
12854                ),
12855                f32_0: fidl::new_empty!(
12856                    fidl::encoding::UnboundedVector<f32>,
12857                    fidl::encoding::DefaultFuchsiaResourceDialect
12858                ),
12859                f64_0: fidl::new_empty!(
12860                    fidl::encoding::UnboundedVector<f64>,
12861                    fidl::encoding::DefaultFuchsiaResourceDialect
12862                ),
12863                handle_0: fidl::new_empty!(
12864                    fidl::encoding::UnboundedVector<
12865                        fidl::encoding::HandleType<
12866                            fidl::NullableHandle,
12867                            { fidl::ObjectType::NONE.into_raw() },
12868                            2147483648,
12869                        >,
12870                    >,
12871                    fidl::encoding::DefaultFuchsiaResourceDialect
12872                ),
12873                b_1: fidl::new_empty!(
12874                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
12875                    fidl::encoding::DefaultFuchsiaResourceDialect
12876                ),
12877                i8_1: fidl::new_empty!(
12878                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
12879                    fidl::encoding::DefaultFuchsiaResourceDialect
12880                ),
12881                i16_1: fidl::new_empty!(
12882                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
12883                    fidl::encoding::DefaultFuchsiaResourceDialect
12884                ),
12885                i32_1: fidl::new_empty!(
12886                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
12887                    fidl::encoding::DefaultFuchsiaResourceDialect
12888                ),
12889                i64_1: fidl::new_empty!(
12890                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
12891                    fidl::encoding::DefaultFuchsiaResourceDialect
12892                ),
12893                u8_1: fidl::new_empty!(
12894                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
12895                    fidl::encoding::DefaultFuchsiaResourceDialect
12896                ),
12897                u16_1: fidl::new_empty!(
12898                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
12899                    fidl::encoding::DefaultFuchsiaResourceDialect
12900                ),
12901                u32_1: fidl::new_empty!(
12902                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
12903                    fidl::encoding::DefaultFuchsiaResourceDialect
12904                ),
12905                u64_1: fidl::new_empty!(
12906                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
12907                    fidl::encoding::DefaultFuchsiaResourceDialect
12908                ),
12909                f32_1: fidl::new_empty!(
12910                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
12911                    fidl::encoding::DefaultFuchsiaResourceDialect
12912                ),
12913                f64_1: fidl::new_empty!(
12914                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
12915                    fidl::encoding::DefaultFuchsiaResourceDialect
12916                ),
12917                handle_1: fidl::new_empty!(
12918                    fidl::encoding::UnboundedVector<
12919                        fidl::encoding::Vector<
12920                            fidl::encoding::HandleType<
12921                                fidl::NullableHandle,
12922                                { fidl::ObjectType::NONE.into_raw() },
12923                                2147483648,
12924                            >,
12925                            2,
12926                        >,
12927                    >,
12928                    fidl::encoding::DefaultFuchsiaResourceDialect
12929                ),
12930                b_sized_0: fidl::new_empty!(fidl::encoding::Vector<bool, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12931                i8_sized_0: fidl::new_empty!(fidl::encoding::Vector<i8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12932                i16_sized_0: fidl::new_empty!(fidl::encoding::Vector<i16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12933                i32_sized_0: fidl::new_empty!(fidl::encoding::Vector<i32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12934                i64_sized_0: fidl::new_empty!(fidl::encoding::Vector<i64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12935                u8_sized_0: fidl::new_empty!(fidl::encoding::Vector<u8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12936                u16_sized_0: fidl::new_empty!(fidl::encoding::Vector<u16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12937                u32_sized_0: fidl::new_empty!(fidl::encoding::Vector<u32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12938                u64_sized_0: fidl::new_empty!(fidl::encoding::Vector<u64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12939                f32_sized_0: fidl::new_empty!(fidl::encoding::Vector<f32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12940                f64_sized_0: fidl::new_empty!(fidl::encoding::Vector<f64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12941                handle_sized_0: fidl::new_empty!(
12942                    fidl::encoding::Vector<
12943                        fidl::encoding::HandleType<
12944                            fidl::NullableHandle,
12945                            { fidl::ObjectType::NONE.into_raw() },
12946                            2147483648,
12947                        >,
12948                        1,
12949                    >,
12950                    fidl::encoding::DefaultFuchsiaResourceDialect
12951                ),
12952                b_sized_1: fidl::new_empty!(fidl::encoding::Vector<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12953                i8_sized_1: fidl::new_empty!(fidl::encoding::Vector<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12954                i16_sized_1: fidl::new_empty!(fidl::encoding::Vector<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12955                i32_sized_1: fidl::new_empty!(fidl::encoding::Vector<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12956                i64_sized_1: fidl::new_empty!(fidl::encoding::Vector<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12957                u8_sized_1: fidl::new_empty!(fidl::encoding::Vector<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12958                u16_sized_1: fidl::new_empty!(fidl::encoding::Vector<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12959                u32_sized_1: fidl::new_empty!(fidl::encoding::Vector<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12960                u64_sized_1: fidl::new_empty!(fidl::encoding::Vector<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12961                f32_sized_1: fidl::new_empty!(fidl::encoding::Vector<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12962                f64_sized_1: fidl::new_empty!(fidl::encoding::Vector<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12963                handle_sized_1: fidl::new_empty!(
12964                    fidl::encoding::Vector<
12965                        fidl::encoding::HandleType<
12966                            fidl::NullableHandle,
12967                            { fidl::ObjectType::NONE.into_raw() },
12968                            2147483648,
12969                        >,
12970                        3,
12971                    >,
12972                    fidl::encoding::DefaultFuchsiaResourceDialect
12973                ),
12974                b_sized_2: fidl::new_empty!(
12975                    fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
12976                    fidl::encoding::DefaultFuchsiaResourceDialect
12977                ),
12978                i8_sized_2: fidl::new_empty!(
12979                    fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>,
12980                    fidl::encoding::DefaultFuchsiaResourceDialect
12981                ),
12982                i16_sized_2: fidl::new_empty!(
12983                    fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>,
12984                    fidl::encoding::DefaultFuchsiaResourceDialect
12985                ),
12986                i32_sized_2: fidl::new_empty!(
12987                    fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>,
12988                    fidl::encoding::DefaultFuchsiaResourceDialect
12989                ),
12990                i64_sized_2: fidl::new_empty!(
12991                    fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>,
12992                    fidl::encoding::DefaultFuchsiaResourceDialect
12993                ),
12994                u8_sized_2: fidl::new_empty!(
12995                    fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>,
12996                    fidl::encoding::DefaultFuchsiaResourceDialect
12997                ),
12998                u16_sized_2: fidl::new_empty!(
12999                    fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>,
13000                    fidl::encoding::DefaultFuchsiaResourceDialect
13001                ),
13002                u32_sized_2: fidl::new_empty!(
13003                    fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>,
13004                    fidl::encoding::DefaultFuchsiaResourceDialect
13005                ),
13006                u64_sized_2: fidl::new_empty!(
13007                    fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>,
13008                    fidl::encoding::DefaultFuchsiaResourceDialect
13009                ),
13010                f32_sized_2: fidl::new_empty!(
13011                    fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>,
13012                    fidl::encoding::DefaultFuchsiaResourceDialect
13013                ),
13014                f64_sized_2: fidl::new_empty!(
13015                    fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>,
13016                    fidl::encoding::DefaultFuchsiaResourceDialect
13017                ),
13018                handle_sized_2: fidl::new_empty!(
13019                    fidl::encoding::Vector<
13020                        fidl::encoding::Vector<
13021                            fidl::encoding::HandleType<
13022                                fidl::NullableHandle,
13023                                { fidl::ObjectType::NONE.into_raw() },
13024                                2147483648,
13025                            >,
13026                            2,
13027                        >,
13028                        3,
13029                    >,
13030                    fidl::encoding::DefaultFuchsiaResourceDialect
13031                ),
13032                b_nullable_0: fidl::new_empty!(
13033                    fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
13034                    fidl::encoding::DefaultFuchsiaResourceDialect
13035                ),
13036                i8_nullable_0: fidl::new_empty!(
13037                    fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
13038                    fidl::encoding::DefaultFuchsiaResourceDialect
13039                ),
13040                i16_nullable_0: fidl::new_empty!(
13041                    fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
13042                    fidl::encoding::DefaultFuchsiaResourceDialect
13043                ),
13044                i32_nullable_0: fidl::new_empty!(
13045                    fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
13046                    fidl::encoding::DefaultFuchsiaResourceDialect
13047                ),
13048                i64_nullable_0: fidl::new_empty!(
13049                    fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
13050                    fidl::encoding::DefaultFuchsiaResourceDialect
13051                ),
13052                u8_nullable_0: fidl::new_empty!(
13053                    fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
13054                    fidl::encoding::DefaultFuchsiaResourceDialect
13055                ),
13056                u16_nullable_0: fidl::new_empty!(
13057                    fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
13058                    fidl::encoding::DefaultFuchsiaResourceDialect
13059                ),
13060                u32_nullable_0: fidl::new_empty!(
13061                    fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
13062                    fidl::encoding::DefaultFuchsiaResourceDialect
13063                ),
13064                u64_nullable_0: fidl::new_empty!(
13065                    fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
13066                    fidl::encoding::DefaultFuchsiaResourceDialect
13067                ),
13068                f32_nullable_0: fidl::new_empty!(
13069                    fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
13070                    fidl::encoding::DefaultFuchsiaResourceDialect
13071                ),
13072                f64_nullable_0: fidl::new_empty!(
13073                    fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
13074                    fidl::encoding::DefaultFuchsiaResourceDialect
13075                ),
13076                handle_nullable_0: fidl::new_empty!(
13077                    fidl::encoding::Optional<
13078                        fidl::encoding::Vector<
13079                            fidl::encoding::HandleType<
13080                                fidl::NullableHandle,
13081                                { fidl::ObjectType::NONE.into_raw() },
13082                                2147483648,
13083                            >,
13084                            1,
13085                        >,
13086                    >,
13087                    fidl::encoding::DefaultFuchsiaResourceDialect
13088                ),
13089                b_nullable_1: fidl::new_empty!(
13090                    fidl::encoding::Optional<
13091                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
13092                    >,
13093                    fidl::encoding::DefaultFuchsiaResourceDialect
13094                ),
13095                i8_nullable_1: fidl::new_empty!(
13096                    fidl::encoding::Optional<
13097                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
13098                    >,
13099                    fidl::encoding::DefaultFuchsiaResourceDialect
13100                ),
13101                i16_nullable_1: fidl::new_empty!(
13102                    fidl::encoding::Optional<
13103                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
13104                    >,
13105                    fidl::encoding::DefaultFuchsiaResourceDialect
13106                ),
13107                i32_nullable_1: fidl::new_empty!(
13108                    fidl::encoding::Optional<
13109                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
13110                    >,
13111                    fidl::encoding::DefaultFuchsiaResourceDialect
13112                ),
13113                i64_nullable_1: fidl::new_empty!(
13114                    fidl::encoding::Optional<
13115                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
13116                    >,
13117                    fidl::encoding::DefaultFuchsiaResourceDialect
13118                ),
13119                u8_nullable_1: fidl::new_empty!(
13120                    fidl::encoding::Optional<
13121                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
13122                    >,
13123                    fidl::encoding::DefaultFuchsiaResourceDialect
13124                ),
13125                u16_nullable_1: fidl::new_empty!(
13126                    fidl::encoding::Optional<
13127                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
13128                    >,
13129                    fidl::encoding::DefaultFuchsiaResourceDialect
13130                ),
13131                u32_nullable_1: fidl::new_empty!(
13132                    fidl::encoding::Optional<
13133                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
13134                    >,
13135                    fidl::encoding::DefaultFuchsiaResourceDialect
13136                ),
13137                u64_nullable_1: fidl::new_empty!(
13138                    fidl::encoding::Optional<
13139                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
13140                    >,
13141                    fidl::encoding::DefaultFuchsiaResourceDialect
13142                ),
13143                f32_nullable_1: fidl::new_empty!(
13144                    fidl::encoding::Optional<
13145                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
13146                    >,
13147                    fidl::encoding::DefaultFuchsiaResourceDialect
13148                ),
13149                f64_nullable_1: fidl::new_empty!(
13150                    fidl::encoding::Optional<
13151                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
13152                    >,
13153                    fidl::encoding::DefaultFuchsiaResourceDialect
13154                ),
13155                handle_nullable_1: fidl::new_empty!(
13156                    fidl::encoding::Optional<
13157                        fidl::encoding::UnboundedVector<
13158                            fidl::encoding::Vector<
13159                                fidl::encoding::HandleType<
13160                                    fidl::NullableHandle,
13161                                    { fidl::ObjectType::NONE.into_raw() },
13162                                    2147483648,
13163                                >,
13164                                2,
13165                            >,
13166                        >,
13167                    >,
13168                    fidl::encoding::DefaultFuchsiaResourceDialect
13169                ),
13170                b_nullable_sized_0: fidl::new_empty!(
13171                    fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
13172                    fidl::encoding::DefaultFuchsiaResourceDialect
13173                ),
13174                i8_nullable_sized_0: fidl::new_empty!(
13175                    fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
13176                    fidl::encoding::DefaultFuchsiaResourceDialect
13177                ),
13178                i16_nullable_sized_0: fidl::new_empty!(
13179                    fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
13180                    fidl::encoding::DefaultFuchsiaResourceDialect
13181                ),
13182                i32_nullable_sized_0: fidl::new_empty!(
13183                    fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
13184                    fidl::encoding::DefaultFuchsiaResourceDialect
13185                ),
13186                i64_nullable_sized_0: fidl::new_empty!(
13187                    fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
13188                    fidl::encoding::DefaultFuchsiaResourceDialect
13189                ),
13190                u8_nullable_sized_0: fidl::new_empty!(
13191                    fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
13192                    fidl::encoding::DefaultFuchsiaResourceDialect
13193                ),
13194                u16_nullable_sized_0: fidl::new_empty!(
13195                    fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
13196                    fidl::encoding::DefaultFuchsiaResourceDialect
13197                ),
13198                u32_nullable_sized_0: fidl::new_empty!(
13199                    fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
13200                    fidl::encoding::DefaultFuchsiaResourceDialect
13201                ),
13202                u64_nullable_sized_0: fidl::new_empty!(
13203                    fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
13204                    fidl::encoding::DefaultFuchsiaResourceDialect
13205                ),
13206                f32_nullable_sized_0: fidl::new_empty!(
13207                    fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
13208                    fidl::encoding::DefaultFuchsiaResourceDialect
13209                ),
13210                f64_nullable_sized_0: fidl::new_empty!(
13211                    fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
13212                    fidl::encoding::DefaultFuchsiaResourceDialect
13213                ),
13214                handle_nullable_sized_0: fidl::new_empty!(
13215                    fidl::encoding::Optional<
13216                        fidl::encoding::Vector<
13217                            fidl::encoding::HandleType<
13218                                fidl::NullableHandle,
13219                                { fidl::ObjectType::NONE.into_raw() },
13220                                2147483648,
13221                            >,
13222                            1,
13223                        >,
13224                    >,
13225                    fidl::encoding::DefaultFuchsiaResourceDialect
13226                ),
13227                b_nullable_sized_1: fidl::new_empty!(
13228                    fidl::encoding::Optional<fidl::encoding::Vector<bool, 3>>,
13229                    fidl::encoding::DefaultFuchsiaResourceDialect
13230                ),
13231                i8_nullable_sized_1: fidl::new_empty!(
13232                    fidl::encoding::Optional<fidl::encoding::Vector<i8, 3>>,
13233                    fidl::encoding::DefaultFuchsiaResourceDialect
13234                ),
13235                i16_nullable_sized_1: fidl::new_empty!(
13236                    fidl::encoding::Optional<fidl::encoding::Vector<i16, 3>>,
13237                    fidl::encoding::DefaultFuchsiaResourceDialect
13238                ),
13239                i32_nullable_sized_1: fidl::new_empty!(
13240                    fidl::encoding::Optional<fidl::encoding::Vector<i32, 3>>,
13241                    fidl::encoding::DefaultFuchsiaResourceDialect
13242                ),
13243                i64_nullable_sized_1: fidl::new_empty!(
13244                    fidl::encoding::Optional<fidl::encoding::Vector<i64, 3>>,
13245                    fidl::encoding::DefaultFuchsiaResourceDialect
13246                ),
13247                u8_nullable_sized_1: fidl::new_empty!(
13248                    fidl::encoding::Optional<fidl::encoding::Vector<u8, 3>>,
13249                    fidl::encoding::DefaultFuchsiaResourceDialect
13250                ),
13251                u16_nullable_sized_1: fidl::new_empty!(
13252                    fidl::encoding::Optional<fidl::encoding::Vector<u16, 3>>,
13253                    fidl::encoding::DefaultFuchsiaResourceDialect
13254                ),
13255                u32_nullable_sized_1: fidl::new_empty!(
13256                    fidl::encoding::Optional<fidl::encoding::Vector<u32, 3>>,
13257                    fidl::encoding::DefaultFuchsiaResourceDialect
13258                ),
13259                u64_nullable_sized_1: fidl::new_empty!(
13260                    fidl::encoding::Optional<fidl::encoding::Vector<u64, 3>>,
13261                    fidl::encoding::DefaultFuchsiaResourceDialect
13262                ),
13263                f32_nullable_sized_1: fidl::new_empty!(
13264                    fidl::encoding::Optional<fidl::encoding::Vector<f32, 3>>,
13265                    fidl::encoding::DefaultFuchsiaResourceDialect
13266                ),
13267                f64_nullable_sized_1: fidl::new_empty!(
13268                    fidl::encoding::Optional<fidl::encoding::Vector<f64, 3>>,
13269                    fidl::encoding::DefaultFuchsiaResourceDialect
13270                ),
13271                handle_nullable_sized_1: fidl::new_empty!(
13272                    fidl::encoding::Optional<
13273                        fidl::encoding::Vector<
13274                            fidl::encoding::HandleType<
13275                                fidl::NullableHandle,
13276                                { fidl::ObjectType::NONE.into_raw() },
13277                                2147483648,
13278                            >,
13279                            3,
13280                        >,
13281                    >,
13282                    fidl::encoding::DefaultFuchsiaResourceDialect
13283                ),
13284                b_nullable_sized_2: fidl::new_empty!(
13285                    fidl::encoding::Optional<
13286                        fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
13287                    >,
13288                    fidl::encoding::DefaultFuchsiaResourceDialect
13289                ),
13290                i8_nullable_sized_2: fidl::new_empty!(
13291                    fidl::encoding::Optional<
13292                        fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>,
13293                    >,
13294                    fidl::encoding::DefaultFuchsiaResourceDialect
13295                ),
13296                i16_nullable_sized_2: fidl::new_empty!(
13297                    fidl::encoding::Optional<
13298                        fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>,
13299                    >,
13300                    fidl::encoding::DefaultFuchsiaResourceDialect
13301                ),
13302                i32_nullable_sized_2: fidl::new_empty!(
13303                    fidl::encoding::Optional<
13304                        fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>,
13305                    >,
13306                    fidl::encoding::DefaultFuchsiaResourceDialect
13307                ),
13308                i64_nullable_sized_2: fidl::new_empty!(
13309                    fidl::encoding::Optional<
13310                        fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>,
13311                    >,
13312                    fidl::encoding::DefaultFuchsiaResourceDialect
13313                ),
13314                u8_nullable_sized_2: fidl::new_empty!(
13315                    fidl::encoding::Optional<
13316                        fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>,
13317                    >,
13318                    fidl::encoding::DefaultFuchsiaResourceDialect
13319                ),
13320                u16_nullable_sized_2: fidl::new_empty!(
13321                    fidl::encoding::Optional<
13322                        fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>,
13323                    >,
13324                    fidl::encoding::DefaultFuchsiaResourceDialect
13325                ),
13326                u32_nullable_sized_2: fidl::new_empty!(
13327                    fidl::encoding::Optional<
13328                        fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>,
13329                    >,
13330                    fidl::encoding::DefaultFuchsiaResourceDialect
13331                ),
13332                u64_nullable_sized_2: fidl::new_empty!(
13333                    fidl::encoding::Optional<
13334                        fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>,
13335                    >,
13336                    fidl::encoding::DefaultFuchsiaResourceDialect
13337                ),
13338                f32_nullable_sized_2: fidl::new_empty!(
13339                    fidl::encoding::Optional<
13340                        fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>,
13341                    >,
13342                    fidl::encoding::DefaultFuchsiaResourceDialect
13343                ),
13344                f64_nullable_sized_2: fidl::new_empty!(
13345                    fidl::encoding::Optional<
13346                        fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>,
13347                    >,
13348                    fidl::encoding::DefaultFuchsiaResourceDialect
13349                ),
13350                handle_nullable_sized_2: fidl::new_empty!(
13351                    fidl::encoding::Optional<
13352                        fidl::encoding::Vector<
13353                            fidl::encoding::Vector<
13354                                fidl::encoding::HandleType<
13355                                    fidl::NullableHandle,
13356                                    { fidl::ObjectType::NONE.into_raw() },
13357                                    2147483648,
13358                                >,
13359                                2,
13360                            >,
13361                            3,
13362                        >,
13363                    >,
13364                    fidl::encoding::DefaultFuchsiaResourceDialect
13365                ),
13366            }
13367        }
13368
13369        #[inline]
13370        unsafe fn decode(
13371            &mut self,
13372            decoder: &mut fidl::encoding::Decoder<
13373                '_,
13374                fidl::encoding::DefaultFuchsiaResourceDialect,
13375            >,
13376            offset: usize,
13377            _depth: fidl::encoding::Depth,
13378        ) -> fidl::Result<()> {
13379            decoder.debug_check_bounds::<Self>(offset);
13380            // Verify that padding bytes are zero.
13381            fidl::decode!(
13382                fidl::encoding::UnboundedVector<bool>,
13383                fidl::encoding::DefaultFuchsiaResourceDialect,
13384                &mut self.b_0,
13385                decoder,
13386                offset + 0,
13387                _depth
13388            )?;
13389            fidl::decode!(
13390                fidl::encoding::UnboundedVector<i8>,
13391                fidl::encoding::DefaultFuchsiaResourceDialect,
13392                &mut self.i8_0,
13393                decoder,
13394                offset + 16,
13395                _depth
13396            )?;
13397            fidl::decode!(
13398                fidl::encoding::UnboundedVector<i16>,
13399                fidl::encoding::DefaultFuchsiaResourceDialect,
13400                &mut self.i16_0,
13401                decoder,
13402                offset + 32,
13403                _depth
13404            )?;
13405            fidl::decode!(
13406                fidl::encoding::UnboundedVector<i32>,
13407                fidl::encoding::DefaultFuchsiaResourceDialect,
13408                &mut self.i32_0,
13409                decoder,
13410                offset + 48,
13411                _depth
13412            )?;
13413            fidl::decode!(
13414                fidl::encoding::UnboundedVector<i64>,
13415                fidl::encoding::DefaultFuchsiaResourceDialect,
13416                &mut self.i64_0,
13417                decoder,
13418                offset + 64,
13419                _depth
13420            )?;
13421            fidl::decode!(
13422                fidl::encoding::UnboundedVector<u8>,
13423                fidl::encoding::DefaultFuchsiaResourceDialect,
13424                &mut self.u8_0,
13425                decoder,
13426                offset + 80,
13427                _depth
13428            )?;
13429            fidl::decode!(
13430                fidl::encoding::UnboundedVector<u16>,
13431                fidl::encoding::DefaultFuchsiaResourceDialect,
13432                &mut self.u16_0,
13433                decoder,
13434                offset + 96,
13435                _depth
13436            )?;
13437            fidl::decode!(
13438                fidl::encoding::UnboundedVector<u32>,
13439                fidl::encoding::DefaultFuchsiaResourceDialect,
13440                &mut self.u32_0,
13441                decoder,
13442                offset + 112,
13443                _depth
13444            )?;
13445            fidl::decode!(
13446                fidl::encoding::UnboundedVector<u64>,
13447                fidl::encoding::DefaultFuchsiaResourceDialect,
13448                &mut self.u64_0,
13449                decoder,
13450                offset + 128,
13451                _depth
13452            )?;
13453            fidl::decode!(
13454                fidl::encoding::UnboundedVector<f32>,
13455                fidl::encoding::DefaultFuchsiaResourceDialect,
13456                &mut self.f32_0,
13457                decoder,
13458                offset + 144,
13459                _depth
13460            )?;
13461            fidl::decode!(
13462                fidl::encoding::UnboundedVector<f64>,
13463                fidl::encoding::DefaultFuchsiaResourceDialect,
13464                &mut self.f64_0,
13465                decoder,
13466                offset + 160,
13467                _depth
13468            )?;
13469            fidl::decode!(
13470                fidl::encoding::UnboundedVector<
13471                    fidl::encoding::HandleType<
13472                        fidl::NullableHandle,
13473                        { fidl::ObjectType::NONE.into_raw() },
13474                        2147483648,
13475                    >,
13476                >,
13477                fidl::encoding::DefaultFuchsiaResourceDialect,
13478                &mut self.handle_0,
13479                decoder,
13480                offset + 176,
13481                _depth
13482            )?;
13483            fidl::decode!(
13484                fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
13485                fidl::encoding::DefaultFuchsiaResourceDialect,
13486                &mut self.b_1,
13487                decoder,
13488                offset + 192,
13489                _depth
13490            )?;
13491            fidl::decode!(
13492                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
13493                fidl::encoding::DefaultFuchsiaResourceDialect,
13494                &mut self.i8_1,
13495                decoder,
13496                offset + 208,
13497                _depth
13498            )?;
13499            fidl::decode!(
13500                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
13501                fidl::encoding::DefaultFuchsiaResourceDialect,
13502                &mut self.i16_1,
13503                decoder,
13504                offset + 224,
13505                _depth
13506            )?;
13507            fidl::decode!(
13508                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
13509                fidl::encoding::DefaultFuchsiaResourceDialect,
13510                &mut self.i32_1,
13511                decoder,
13512                offset + 240,
13513                _depth
13514            )?;
13515            fidl::decode!(
13516                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
13517                fidl::encoding::DefaultFuchsiaResourceDialect,
13518                &mut self.i64_1,
13519                decoder,
13520                offset + 256,
13521                _depth
13522            )?;
13523            fidl::decode!(
13524                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
13525                fidl::encoding::DefaultFuchsiaResourceDialect,
13526                &mut self.u8_1,
13527                decoder,
13528                offset + 272,
13529                _depth
13530            )?;
13531            fidl::decode!(
13532                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
13533                fidl::encoding::DefaultFuchsiaResourceDialect,
13534                &mut self.u16_1,
13535                decoder,
13536                offset + 288,
13537                _depth
13538            )?;
13539            fidl::decode!(
13540                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
13541                fidl::encoding::DefaultFuchsiaResourceDialect,
13542                &mut self.u32_1,
13543                decoder,
13544                offset + 304,
13545                _depth
13546            )?;
13547            fidl::decode!(
13548                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
13549                fidl::encoding::DefaultFuchsiaResourceDialect,
13550                &mut self.u64_1,
13551                decoder,
13552                offset + 320,
13553                _depth
13554            )?;
13555            fidl::decode!(
13556                fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
13557                fidl::encoding::DefaultFuchsiaResourceDialect,
13558                &mut self.f32_1,
13559                decoder,
13560                offset + 336,
13561                _depth
13562            )?;
13563            fidl::decode!(
13564                fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
13565                fidl::encoding::DefaultFuchsiaResourceDialect,
13566                &mut self.f64_1,
13567                decoder,
13568                offset + 352,
13569                _depth
13570            )?;
13571            fidl::decode!(
13572                fidl::encoding::UnboundedVector<
13573                    fidl::encoding::Vector<
13574                        fidl::encoding::HandleType<
13575                            fidl::NullableHandle,
13576                            { fidl::ObjectType::NONE.into_raw() },
13577                            2147483648,
13578                        >,
13579                        2,
13580                    >,
13581                >,
13582                fidl::encoding::DefaultFuchsiaResourceDialect,
13583                &mut self.handle_1,
13584                decoder,
13585                offset + 368,
13586                _depth
13587            )?;
13588            fidl::decode!(fidl::encoding::Vector<bool, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.b_sized_0, decoder, offset + 384, _depth)?;
13589            fidl::decode!(fidl::encoding::Vector<i8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i8_sized_0, decoder, offset + 400, _depth)?;
13590            fidl::decode!(fidl::encoding::Vector<i16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i16_sized_0, decoder, offset + 416, _depth)?;
13591            fidl::decode!(fidl::encoding::Vector<i32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i32_sized_0, decoder, offset + 432, _depth)?;
13592            fidl::decode!(fidl::encoding::Vector<i64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i64_sized_0, decoder, offset + 448, _depth)?;
13593            fidl::decode!(fidl::encoding::Vector<u8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u8_sized_0, decoder, offset + 464, _depth)?;
13594            fidl::decode!(fidl::encoding::Vector<u16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u16_sized_0, decoder, offset + 480, _depth)?;
13595            fidl::decode!(fidl::encoding::Vector<u32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u32_sized_0, decoder, offset + 496, _depth)?;
13596            fidl::decode!(fidl::encoding::Vector<u64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u64_sized_0, decoder, offset + 512, _depth)?;
13597            fidl::decode!(fidl::encoding::Vector<f32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f32_sized_0, decoder, offset + 528, _depth)?;
13598            fidl::decode!(fidl::encoding::Vector<f64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f64_sized_0, decoder, offset + 544, _depth)?;
13599            fidl::decode!(
13600                fidl::encoding::Vector<
13601                    fidl::encoding::HandleType<
13602                        fidl::NullableHandle,
13603                        { fidl::ObjectType::NONE.into_raw() },
13604                        2147483648,
13605                    >,
13606                    1,
13607                >,
13608                fidl::encoding::DefaultFuchsiaResourceDialect,
13609                &mut self.handle_sized_0,
13610                decoder,
13611                offset + 560,
13612                _depth
13613            )?;
13614            fidl::decode!(fidl::encoding::Vector<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.b_sized_1, decoder, offset + 576, _depth)?;
13615            fidl::decode!(fidl::encoding::Vector<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i8_sized_1, decoder, offset + 592, _depth)?;
13616            fidl::decode!(fidl::encoding::Vector<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i16_sized_1, decoder, offset + 608, _depth)?;
13617            fidl::decode!(fidl::encoding::Vector<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i32_sized_1, decoder, offset + 624, _depth)?;
13618            fidl::decode!(fidl::encoding::Vector<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i64_sized_1, decoder, offset + 640, _depth)?;
13619            fidl::decode!(fidl::encoding::Vector<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u8_sized_1, decoder, offset + 656, _depth)?;
13620            fidl::decode!(fidl::encoding::Vector<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u16_sized_1, decoder, offset + 672, _depth)?;
13621            fidl::decode!(fidl::encoding::Vector<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u32_sized_1, decoder, offset + 688, _depth)?;
13622            fidl::decode!(fidl::encoding::Vector<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u64_sized_1, decoder, offset + 704, _depth)?;
13623            fidl::decode!(fidl::encoding::Vector<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f32_sized_1, decoder, offset + 720, _depth)?;
13624            fidl::decode!(fidl::encoding::Vector<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f64_sized_1, decoder, offset + 736, _depth)?;
13625            fidl::decode!(
13626                fidl::encoding::Vector<
13627                    fidl::encoding::HandleType<
13628                        fidl::NullableHandle,
13629                        { fidl::ObjectType::NONE.into_raw() },
13630                        2147483648,
13631                    >,
13632                    3,
13633                >,
13634                fidl::encoding::DefaultFuchsiaResourceDialect,
13635                &mut self.handle_sized_1,
13636                decoder,
13637                offset + 752,
13638                _depth
13639            )?;
13640            fidl::decode!(
13641                fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
13642                fidl::encoding::DefaultFuchsiaResourceDialect,
13643                &mut self.b_sized_2,
13644                decoder,
13645                offset + 768,
13646                _depth
13647            )?;
13648            fidl::decode!(
13649                fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>,
13650                fidl::encoding::DefaultFuchsiaResourceDialect,
13651                &mut self.i8_sized_2,
13652                decoder,
13653                offset + 784,
13654                _depth
13655            )?;
13656            fidl::decode!(
13657                fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>,
13658                fidl::encoding::DefaultFuchsiaResourceDialect,
13659                &mut self.i16_sized_2,
13660                decoder,
13661                offset + 800,
13662                _depth
13663            )?;
13664            fidl::decode!(
13665                fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>,
13666                fidl::encoding::DefaultFuchsiaResourceDialect,
13667                &mut self.i32_sized_2,
13668                decoder,
13669                offset + 816,
13670                _depth
13671            )?;
13672            fidl::decode!(
13673                fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>,
13674                fidl::encoding::DefaultFuchsiaResourceDialect,
13675                &mut self.i64_sized_2,
13676                decoder,
13677                offset + 832,
13678                _depth
13679            )?;
13680            fidl::decode!(
13681                fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>,
13682                fidl::encoding::DefaultFuchsiaResourceDialect,
13683                &mut self.u8_sized_2,
13684                decoder,
13685                offset + 848,
13686                _depth
13687            )?;
13688            fidl::decode!(
13689                fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>,
13690                fidl::encoding::DefaultFuchsiaResourceDialect,
13691                &mut self.u16_sized_2,
13692                decoder,
13693                offset + 864,
13694                _depth
13695            )?;
13696            fidl::decode!(
13697                fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>,
13698                fidl::encoding::DefaultFuchsiaResourceDialect,
13699                &mut self.u32_sized_2,
13700                decoder,
13701                offset + 880,
13702                _depth
13703            )?;
13704            fidl::decode!(
13705                fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>,
13706                fidl::encoding::DefaultFuchsiaResourceDialect,
13707                &mut self.u64_sized_2,
13708                decoder,
13709                offset + 896,
13710                _depth
13711            )?;
13712            fidl::decode!(
13713                fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>,
13714                fidl::encoding::DefaultFuchsiaResourceDialect,
13715                &mut self.f32_sized_2,
13716                decoder,
13717                offset + 912,
13718                _depth
13719            )?;
13720            fidl::decode!(
13721                fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>,
13722                fidl::encoding::DefaultFuchsiaResourceDialect,
13723                &mut self.f64_sized_2,
13724                decoder,
13725                offset + 928,
13726                _depth
13727            )?;
13728            fidl::decode!(
13729                fidl::encoding::Vector<
13730                    fidl::encoding::Vector<
13731                        fidl::encoding::HandleType<
13732                            fidl::NullableHandle,
13733                            { fidl::ObjectType::NONE.into_raw() },
13734                            2147483648,
13735                        >,
13736                        2,
13737                    >,
13738                    3,
13739                >,
13740                fidl::encoding::DefaultFuchsiaResourceDialect,
13741                &mut self.handle_sized_2,
13742                decoder,
13743                offset + 944,
13744                _depth
13745            )?;
13746            fidl::decode!(
13747                fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
13748                fidl::encoding::DefaultFuchsiaResourceDialect,
13749                &mut self.b_nullable_0,
13750                decoder,
13751                offset + 960,
13752                _depth
13753            )?;
13754            fidl::decode!(
13755                fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
13756                fidl::encoding::DefaultFuchsiaResourceDialect,
13757                &mut self.i8_nullable_0,
13758                decoder,
13759                offset + 976,
13760                _depth
13761            )?;
13762            fidl::decode!(
13763                fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
13764                fidl::encoding::DefaultFuchsiaResourceDialect,
13765                &mut self.i16_nullable_0,
13766                decoder,
13767                offset + 992,
13768                _depth
13769            )?;
13770            fidl::decode!(
13771                fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
13772                fidl::encoding::DefaultFuchsiaResourceDialect,
13773                &mut self.i32_nullable_0,
13774                decoder,
13775                offset + 1008,
13776                _depth
13777            )?;
13778            fidl::decode!(
13779                fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
13780                fidl::encoding::DefaultFuchsiaResourceDialect,
13781                &mut self.i64_nullable_0,
13782                decoder,
13783                offset + 1024,
13784                _depth
13785            )?;
13786            fidl::decode!(
13787                fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
13788                fidl::encoding::DefaultFuchsiaResourceDialect,
13789                &mut self.u8_nullable_0,
13790                decoder,
13791                offset + 1040,
13792                _depth
13793            )?;
13794            fidl::decode!(
13795                fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
13796                fidl::encoding::DefaultFuchsiaResourceDialect,
13797                &mut self.u16_nullable_0,
13798                decoder,
13799                offset + 1056,
13800                _depth
13801            )?;
13802            fidl::decode!(
13803                fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
13804                fidl::encoding::DefaultFuchsiaResourceDialect,
13805                &mut self.u32_nullable_0,
13806                decoder,
13807                offset + 1072,
13808                _depth
13809            )?;
13810            fidl::decode!(
13811                fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
13812                fidl::encoding::DefaultFuchsiaResourceDialect,
13813                &mut self.u64_nullable_0,
13814                decoder,
13815                offset + 1088,
13816                _depth
13817            )?;
13818            fidl::decode!(
13819                fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
13820                fidl::encoding::DefaultFuchsiaResourceDialect,
13821                &mut self.f32_nullable_0,
13822                decoder,
13823                offset + 1104,
13824                _depth
13825            )?;
13826            fidl::decode!(
13827                fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
13828                fidl::encoding::DefaultFuchsiaResourceDialect,
13829                &mut self.f64_nullable_0,
13830                decoder,
13831                offset + 1120,
13832                _depth
13833            )?;
13834            fidl::decode!(
13835                fidl::encoding::Optional<
13836                    fidl::encoding::Vector<
13837                        fidl::encoding::HandleType<
13838                            fidl::NullableHandle,
13839                            { fidl::ObjectType::NONE.into_raw() },
13840                            2147483648,
13841                        >,
13842                        1,
13843                    >,
13844                >,
13845                fidl::encoding::DefaultFuchsiaResourceDialect,
13846                &mut self.handle_nullable_0,
13847                decoder,
13848                offset + 1136,
13849                _depth
13850            )?;
13851            fidl::decode!(
13852                fidl::encoding::Optional<
13853                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
13854                >,
13855                fidl::encoding::DefaultFuchsiaResourceDialect,
13856                &mut self.b_nullable_1,
13857                decoder,
13858                offset + 1152,
13859                _depth
13860            )?;
13861            fidl::decode!(
13862                fidl::encoding::Optional<
13863                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
13864                >,
13865                fidl::encoding::DefaultFuchsiaResourceDialect,
13866                &mut self.i8_nullable_1,
13867                decoder,
13868                offset + 1168,
13869                _depth
13870            )?;
13871            fidl::decode!(
13872                fidl::encoding::Optional<
13873                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
13874                >,
13875                fidl::encoding::DefaultFuchsiaResourceDialect,
13876                &mut self.i16_nullable_1,
13877                decoder,
13878                offset + 1184,
13879                _depth
13880            )?;
13881            fidl::decode!(
13882                fidl::encoding::Optional<
13883                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
13884                >,
13885                fidl::encoding::DefaultFuchsiaResourceDialect,
13886                &mut self.i32_nullable_1,
13887                decoder,
13888                offset + 1200,
13889                _depth
13890            )?;
13891            fidl::decode!(
13892                fidl::encoding::Optional<
13893                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
13894                >,
13895                fidl::encoding::DefaultFuchsiaResourceDialect,
13896                &mut self.i64_nullable_1,
13897                decoder,
13898                offset + 1216,
13899                _depth
13900            )?;
13901            fidl::decode!(
13902                fidl::encoding::Optional<
13903                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
13904                >,
13905                fidl::encoding::DefaultFuchsiaResourceDialect,
13906                &mut self.u8_nullable_1,
13907                decoder,
13908                offset + 1232,
13909                _depth
13910            )?;
13911            fidl::decode!(
13912                fidl::encoding::Optional<
13913                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
13914                >,
13915                fidl::encoding::DefaultFuchsiaResourceDialect,
13916                &mut self.u16_nullable_1,
13917                decoder,
13918                offset + 1248,
13919                _depth
13920            )?;
13921            fidl::decode!(
13922                fidl::encoding::Optional<
13923                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
13924                >,
13925                fidl::encoding::DefaultFuchsiaResourceDialect,
13926                &mut self.u32_nullable_1,
13927                decoder,
13928                offset + 1264,
13929                _depth
13930            )?;
13931            fidl::decode!(
13932                fidl::encoding::Optional<
13933                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
13934                >,
13935                fidl::encoding::DefaultFuchsiaResourceDialect,
13936                &mut self.u64_nullable_1,
13937                decoder,
13938                offset + 1280,
13939                _depth
13940            )?;
13941            fidl::decode!(
13942                fidl::encoding::Optional<
13943                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
13944                >,
13945                fidl::encoding::DefaultFuchsiaResourceDialect,
13946                &mut self.f32_nullable_1,
13947                decoder,
13948                offset + 1296,
13949                _depth
13950            )?;
13951            fidl::decode!(
13952                fidl::encoding::Optional<
13953                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
13954                >,
13955                fidl::encoding::DefaultFuchsiaResourceDialect,
13956                &mut self.f64_nullable_1,
13957                decoder,
13958                offset + 1312,
13959                _depth
13960            )?;
13961            fidl::decode!(
13962                fidl::encoding::Optional<
13963                    fidl::encoding::UnboundedVector<
13964                        fidl::encoding::Vector<
13965                            fidl::encoding::HandleType<
13966                                fidl::NullableHandle,
13967                                { fidl::ObjectType::NONE.into_raw() },
13968                                2147483648,
13969                            >,
13970                            2,
13971                        >,
13972                    >,
13973                >,
13974                fidl::encoding::DefaultFuchsiaResourceDialect,
13975                &mut self.handle_nullable_1,
13976                decoder,
13977                offset + 1328,
13978                _depth
13979            )?;
13980            fidl::decode!(
13981                fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
13982                fidl::encoding::DefaultFuchsiaResourceDialect,
13983                &mut self.b_nullable_sized_0,
13984                decoder,
13985                offset + 1344,
13986                _depth
13987            )?;
13988            fidl::decode!(
13989                fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
13990                fidl::encoding::DefaultFuchsiaResourceDialect,
13991                &mut self.i8_nullable_sized_0,
13992                decoder,
13993                offset + 1360,
13994                _depth
13995            )?;
13996            fidl::decode!(
13997                fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
13998                fidl::encoding::DefaultFuchsiaResourceDialect,
13999                &mut self.i16_nullable_sized_0,
14000                decoder,
14001                offset + 1376,
14002                _depth
14003            )?;
14004            fidl::decode!(
14005                fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
14006                fidl::encoding::DefaultFuchsiaResourceDialect,
14007                &mut self.i32_nullable_sized_0,
14008                decoder,
14009                offset + 1392,
14010                _depth
14011            )?;
14012            fidl::decode!(
14013                fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
14014                fidl::encoding::DefaultFuchsiaResourceDialect,
14015                &mut self.i64_nullable_sized_0,
14016                decoder,
14017                offset + 1408,
14018                _depth
14019            )?;
14020            fidl::decode!(
14021                fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
14022                fidl::encoding::DefaultFuchsiaResourceDialect,
14023                &mut self.u8_nullable_sized_0,
14024                decoder,
14025                offset + 1424,
14026                _depth
14027            )?;
14028            fidl::decode!(
14029                fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
14030                fidl::encoding::DefaultFuchsiaResourceDialect,
14031                &mut self.u16_nullable_sized_0,
14032                decoder,
14033                offset + 1440,
14034                _depth
14035            )?;
14036            fidl::decode!(
14037                fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
14038                fidl::encoding::DefaultFuchsiaResourceDialect,
14039                &mut self.u32_nullable_sized_0,
14040                decoder,
14041                offset + 1456,
14042                _depth
14043            )?;
14044            fidl::decode!(
14045                fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
14046                fidl::encoding::DefaultFuchsiaResourceDialect,
14047                &mut self.u64_nullable_sized_0,
14048                decoder,
14049                offset + 1472,
14050                _depth
14051            )?;
14052            fidl::decode!(
14053                fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
14054                fidl::encoding::DefaultFuchsiaResourceDialect,
14055                &mut self.f32_nullable_sized_0,
14056                decoder,
14057                offset + 1488,
14058                _depth
14059            )?;
14060            fidl::decode!(
14061                fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
14062                fidl::encoding::DefaultFuchsiaResourceDialect,
14063                &mut self.f64_nullable_sized_0,
14064                decoder,
14065                offset + 1504,
14066                _depth
14067            )?;
14068            fidl::decode!(
14069                fidl::encoding::Optional<
14070                    fidl::encoding::Vector<
14071                        fidl::encoding::HandleType<
14072                            fidl::NullableHandle,
14073                            { fidl::ObjectType::NONE.into_raw() },
14074                            2147483648,
14075                        >,
14076                        1,
14077                    >,
14078                >,
14079                fidl::encoding::DefaultFuchsiaResourceDialect,
14080                &mut self.handle_nullable_sized_0,
14081                decoder,
14082                offset + 1520,
14083                _depth
14084            )?;
14085            fidl::decode!(
14086                fidl::encoding::Optional<fidl::encoding::Vector<bool, 3>>,
14087                fidl::encoding::DefaultFuchsiaResourceDialect,
14088                &mut self.b_nullable_sized_1,
14089                decoder,
14090                offset + 1536,
14091                _depth
14092            )?;
14093            fidl::decode!(
14094                fidl::encoding::Optional<fidl::encoding::Vector<i8, 3>>,
14095                fidl::encoding::DefaultFuchsiaResourceDialect,
14096                &mut self.i8_nullable_sized_1,
14097                decoder,
14098                offset + 1552,
14099                _depth
14100            )?;
14101            fidl::decode!(
14102                fidl::encoding::Optional<fidl::encoding::Vector<i16, 3>>,
14103                fidl::encoding::DefaultFuchsiaResourceDialect,
14104                &mut self.i16_nullable_sized_1,
14105                decoder,
14106                offset + 1568,
14107                _depth
14108            )?;
14109            fidl::decode!(
14110                fidl::encoding::Optional<fidl::encoding::Vector<i32, 3>>,
14111                fidl::encoding::DefaultFuchsiaResourceDialect,
14112                &mut self.i32_nullable_sized_1,
14113                decoder,
14114                offset + 1584,
14115                _depth
14116            )?;
14117            fidl::decode!(
14118                fidl::encoding::Optional<fidl::encoding::Vector<i64, 3>>,
14119                fidl::encoding::DefaultFuchsiaResourceDialect,
14120                &mut self.i64_nullable_sized_1,
14121                decoder,
14122                offset + 1600,
14123                _depth
14124            )?;
14125            fidl::decode!(
14126                fidl::encoding::Optional<fidl::encoding::Vector<u8, 3>>,
14127                fidl::encoding::DefaultFuchsiaResourceDialect,
14128                &mut self.u8_nullable_sized_1,
14129                decoder,
14130                offset + 1616,
14131                _depth
14132            )?;
14133            fidl::decode!(
14134                fidl::encoding::Optional<fidl::encoding::Vector<u16, 3>>,
14135                fidl::encoding::DefaultFuchsiaResourceDialect,
14136                &mut self.u16_nullable_sized_1,
14137                decoder,
14138                offset + 1632,
14139                _depth
14140            )?;
14141            fidl::decode!(
14142                fidl::encoding::Optional<fidl::encoding::Vector<u32, 3>>,
14143                fidl::encoding::DefaultFuchsiaResourceDialect,
14144                &mut self.u32_nullable_sized_1,
14145                decoder,
14146                offset + 1648,
14147                _depth
14148            )?;
14149            fidl::decode!(
14150                fidl::encoding::Optional<fidl::encoding::Vector<u64, 3>>,
14151                fidl::encoding::DefaultFuchsiaResourceDialect,
14152                &mut self.u64_nullable_sized_1,
14153                decoder,
14154                offset + 1664,
14155                _depth
14156            )?;
14157            fidl::decode!(
14158                fidl::encoding::Optional<fidl::encoding::Vector<f32, 3>>,
14159                fidl::encoding::DefaultFuchsiaResourceDialect,
14160                &mut self.f32_nullable_sized_1,
14161                decoder,
14162                offset + 1680,
14163                _depth
14164            )?;
14165            fidl::decode!(
14166                fidl::encoding::Optional<fidl::encoding::Vector<f64, 3>>,
14167                fidl::encoding::DefaultFuchsiaResourceDialect,
14168                &mut self.f64_nullable_sized_1,
14169                decoder,
14170                offset + 1696,
14171                _depth
14172            )?;
14173            fidl::decode!(
14174                fidl::encoding::Optional<
14175                    fidl::encoding::Vector<
14176                        fidl::encoding::HandleType<
14177                            fidl::NullableHandle,
14178                            { fidl::ObjectType::NONE.into_raw() },
14179                            2147483648,
14180                        >,
14181                        3,
14182                    >,
14183                >,
14184                fidl::encoding::DefaultFuchsiaResourceDialect,
14185                &mut self.handle_nullable_sized_1,
14186                decoder,
14187                offset + 1712,
14188                _depth
14189            )?;
14190            fidl::decode!(
14191                fidl::encoding::Optional<
14192                    fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
14193                >,
14194                fidl::encoding::DefaultFuchsiaResourceDialect,
14195                &mut self.b_nullable_sized_2,
14196                decoder,
14197                offset + 1728,
14198                _depth
14199            )?;
14200            fidl::decode!(
14201                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>>,
14202                fidl::encoding::DefaultFuchsiaResourceDialect,
14203                &mut self.i8_nullable_sized_2,
14204                decoder,
14205                offset + 1744,
14206                _depth
14207            )?;
14208            fidl::decode!(
14209                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>>,
14210                fidl::encoding::DefaultFuchsiaResourceDialect,
14211                &mut self.i16_nullable_sized_2,
14212                decoder,
14213                offset + 1760,
14214                _depth
14215            )?;
14216            fidl::decode!(
14217                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>>,
14218                fidl::encoding::DefaultFuchsiaResourceDialect,
14219                &mut self.i32_nullable_sized_2,
14220                decoder,
14221                offset + 1776,
14222                _depth
14223            )?;
14224            fidl::decode!(
14225                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>>,
14226                fidl::encoding::DefaultFuchsiaResourceDialect,
14227                &mut self.i64_nullable_sized_2,
14228                decoder,
14229                offset + 1792,
14230                _depth
14231            )?;
14232            fidl::decode!(
14233                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>>,
14234                fidl::encoding::DefaultFuchsiaResourceDialect,
14235                &mut self.u8_nullable_sized_2,
14236                decoder,
14237                offset + 1808,
14238                _depth
14239            )?;
14240            fidl::decode!(
14241                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>>,
14242                fidl::encoding::DefaultFuchsiaResourceDialect,
14243                &mut self.u16_nullable_sized_2,
14244                decoder,
14245                offset + 1824,
14246                _depth
14247            )?;
14248            fidl::decode!(
14249                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>>,
14250                fidl::encoding::DefaultFuchsiaResourceDialect,
14251                &mut self.u32_nullable_sized_2,
14252                decoder,
14253                offset + 1840,
14254                _depth
14255            )?;
14256            fidl::decode!(
14257                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>>,
14258                fidl::encoding::DefaultFuchsiaResourceDialect,
14259                &mut self.u64_nullable_sized_2,
14260                decoder,
14261                offset + 1856,
14262                _depth
14263            )?;
14264            fidl::decode!(
14265                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>>,
14266                fidl::encoding::DefaultFuchsiaResourceDialect,
14267                &mut self.f32_nullable_sized_2,
14268                decoder,
14269                offset + 1872,
14270                _depth
14271            )?;
14272            fidl::decode!(
14273                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>>,
14274                fidl::encoding::DefaultFuchsiaResourceDialect,
14275                &mut self.f64_nullable_sized_2,
14276                decoder,
14277                offset + 1888,
14278                _depth
14279            )?;
14280            fidl::decode!(
14281                fidl::encoding::Optional<
14282                    fidl::encoding::Vector<
14283                        fidl::encoding::Vector<
14284                            fidl::encoding::HandleType<
14285                                fidl::NullableHandle,
14286                                { fidl::ObjectType::NONE.into_raw() },
14287                                2147483648,
14288                            >,
14289                            2,
14290                        >,
14291                        3,
14292                    >,
14293                >,
14294                fidl::encoding::DefaultFuchsiaResourceDialect,
14295                &mut self.handle_nullable_sized_2,
14296                decoder,
14297                offset + 1904,
14298                _depth
14299            )?;
14300            Ok(())
14301        }
14302    }
14303
14304    impl AllTypesTable {
14305        #[inline(always)]
14306        fn max_ordinal_present(&self) -> u64 {
14307            if let Some(_) = self.xunion_member {
14308                return 21;
14309            }
14310            if let Some(_) = self.table_member {
14311                return 20;
14312            }
14313            if let Some(_) = self.vector_member {
14314                return 19;
14315            }
14316            if let Some(_) = self.array_member {
14317                return 18;
14318            }
14319            if let Some(_) = self.union_member {
14320                return 17;
14321            }
14322            if let Some(_) = self.struct_member {
14323                return 16;
14324            }
14325            if let Some(_) = self.string_member {
14326                return 15;
14327            }
14328            if let Some(_) = self.handle_member {
14329                return 14;
14330            }
14331            if let Some(_) = self.bits_member {
14332                return 13;
14333            }
14334            if let Some(_) = self.enum_member {
14335                return 12;
14336            }
14337            if let Some(_) = self.float64_member {
14338                return 11;
14339            }
14340            if let Some(_) = self.float32_member {
14341                return 10;
14342            }
14343            if let Some(_) = self.uint64_member {
14344                return 9;
14345            }
14346            if let Some(_) = self.uint32_member {
14347                return 8;
14348            }
14349            if let Some(_) = self.uint16_member {
14350                return 7;
14351            }
14352            if let Some(_) = self.uint8_member {
14353                return 6;
14354            }
14355            if let Some(_) = self.int64_member {
14356                return 5;
14357            }
14358            if let Some(_) = self.int32_member {
14359                return 4;
14360            }
14361            if let Some(_) = self.int16_member {
14362                return 3;
14363            }
14364            if let Some(_) = self.int8_member {
14365                return 2;
14366            }
14367            if let Some(_) = self.bool_member {
14368                return 1;
14369            }
14370            0
14371        }
14372    }
14373
14374    impl fidl::encoding::ResourceTypeMarker for AllTypesTable {
14375        type Borrowed<'a> = &'a mut Self;
14376        fn take_or_borrow<'a>(
14377            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
14378        ) -> Self::Borrowed<'a> {
14379            value
14380        }
14381    }
14382
14383    unsafe impl fidl::encoding::TypeMarker for AllTypesTable {
14384        type Owned = Self;
14385
14386        #[inline(always)]
14387        fn inline_align(_context: fidl::encoding::Context) -> usize {
14388            8
14389        }
14390
14391        #[inline(always)]
14392        fn inline_size(_context: fidl::encoding::Context) -> usize {
14393            16
14394        }
14395    }
14396
14397    unsafe impl fidl::encoding::Encode<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>
14398        for &mut AllTypesTable
14399    {
14400        unsafe fn encode(
14401            self,
14402            encoder: &mut fidl::encoding::Encoder<
14403                '_,
14404                fidl::encoding::DefaultFuchsiaResourceDialect,
14405            >,
14406            offset: usize,
14407            mut depth: fidl::encoding::Depth,
14408        ) -> fidl::Result<()> {
14409            encoder.debug_check_bounds::<AllTypesTable>(offset);
14410            // Vector header
14411            let max_ordinal: u64 = self.max_ordinal_present();
14412            encoder.write_num(max_ordinal, offset);
14413            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
14414            // Calling encoder.out_of_line_offset(0) is not allowed.
14415            if max_ordinal == 0 {
14416                return Ok(());
14417            }
14418            depth.increment()?;
14419            let envelope_size = 8;
14420            let bytes_len = max_ordinal as usize * envelope_size;
14421            #[allow(unused_variables)]
14422            let offset = encoder.out_of_line_offset(bytes_len);
14423            let mut _prev_end_offset: usize = 0;
14424            if 1 > max_ordinal {
14425                return Ok(());
14426            }
14427
14428            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14429            // are envelope_size bytes.
14430            let cur_offset: usize = (1 - 1) * envelope_size;
14431
14432            // Zero reserved fields.
14433            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14434
14435            // Safety:
14436            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14437            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14438            //   envelope_size bytes, there is always sufficient room.
14439            fidl::encoding::encode_in_envelope_optional::<
14440                bool,
14441                fidl::encoding::DefaultFuchsiaResourceDialect,
14442            >(
14443                self.bool_member.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
14444                encoder,
14445                offset + cur_offset,
14446                depth,
14447            )?;
14448
14449            _prev_end_offset = cur_offset + envelope_size;
14450            if 2 > max_ordinal {
14451                return Ok(());
14452            }
14453
14454            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14455            // are envelope_size bytes.
14456            let cur_offset: usize = (2 - 1) * envelope_size;
14457
14458            // Zero reserved fields.
14459            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14460
14461            // Safety:
14462            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14463            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14464            //   envelope_size bytes, there is always sufficient room.
14465            fidl::encoding::encode_in_envelope_optional::<
14466                i8,
14467                fidl::encoding::DefaultFuchsiaResourceDialect,
14468            >(
14469                self.int8_member.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
14470                encoder,
14471                offset + cur_offset,
14472                depth,
14473            )?;
14474
14475            _prev_end_offset = cur_offset + envelope_size;
14476            if 3 > max_ordinal {
14477                return Ok(());
14478            }
14479
14480            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14481            // are envelope_size bytes.
14482            let cur_offset: usize = (3 - 1) * envelope_size;
14483
14484            // Zero reserved fields.
14485            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14486
14487            // Safety:
14488            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14489            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14490            //   envelope_size bytes, there is always sufficient room.
14491            fidl::encoding::encode_in_envelope_optional::<
14492                i16,
14493                fidl::encoding::DefaultFuchsiaResourceDialect,
14494            >(
14495                self.int16_member.as_ref().map(<i16 as fidl::encoding::ValueTypeMarker>::borrow),
14496                encoder,
14497                offset + cur_offset,
14498                depth,
14499            )?;
14500
14501            _prev_end_offset = cur_offset + envelope_size;
14502            if 4 > max_ordinal {
14503                return Ok(());
14504            }
14505
14506            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14507            // are envelope_size bytes.
14508            let cur_offset: usize = (4 - 1) * envelope_size;
14509
14510            // Zero reserved fields.
14511            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14512
14513            // Safety:
14514            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14515            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14516            //   envelope_size bytes, there is always sufficient room.
14517            fidl::encoding::encode_in_envelope_optional::<
14518                i32,
14519                fidl::encoding::DefaultFuchsiaResourceDialect,
14520            >(
14521                self.int32_member.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
14522                encoder,
14523                offset + cur_offset,
14524                depth,
14525            )?;
14526
14527            _prev_end_offset = cur_offset + envelope_size;
14528            if 5 > max_ordinal {
14529                return Ok(());
14530            }
14531
14532            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14533            // are envelope_size bytes.
14534            let cur_offset: usize = (5 - 1) * envelope_size;
14535
14536            // Zero reserved fields.
14537            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14538
14539            // Safety:
14540            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14541            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14542            //   envelope_size bytes, there is always sufficient room.
14543            fidl::encoding::encode_in_envelope_optional::<
14544                i64,
14545                fidl::encoding::DefaultFuchsiaResourceDialect,
14546            >(
14547                self.int64_member.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
14548                encoder,
14549                offset + cur_offset,
14550                depth,
14551            )?;
14552
14553            _prev_end_offset = cur_offset + envelope_size;
14554            if 6 > max_ordinal {
14555                return Ok(());
14556            }
14557
14558            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14559            // are envelope_size bytes.
14560            let cur_offset: usize = (6 - 1) * envelope_size;
14561
14562            // Zero reserved fields.
14563            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14564
14565            // Safety:
14566            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14567            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14568            //   envelope_size bytes, there is always sufficient room.
14569            fidl::encoding::encode_in_envelope_optional::<
14570                u8,
14571                fidl::encoding::DefaultFuchsiaResourceDialect,
14572            >(
14573                self.uint8_member.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
14574                encoder,
14575                offset + cur_offset,
14576                depth,
14577            )?;
14578
14579            _prev_end_offset = cur_offset + envelope_size;
14580            if 7 > max_ordinal {
14581                return Ok(());
14582            }
14583
14584            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14585            // are envelope_size bytes.
14586            let cur_offset: usize = (7 - 1) * envelope_size;
14587
14588            // Zero reserved fields.
14589            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14590
14591            // Safety:
14592            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14593            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14594            //   envelope_size bytes, there is always sufficient room.
14595            fidl::encoding::encode_in_envelope_optional::<
14596                u16,
14597                fidl::encoding::DefaultFuchsiaResourceDialect,
14598            >(
14599                self.uint16_member.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
14600                encoder,
14601                offset + cur_offset,
14602                depth,
14603            )?;
14604
14605            _prev_end_offset = cur_offset + envelope_size;
14606            if 8 > max_ordinal {
14607                return Ok(());
14608            }
14609
14610            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14611            // are envelope_size bytes.
14612            let cur_offset: usize = (8 - 1) * envelope_size;
14613
14614            // Zero reserved fields.
14615            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14616
14617            // Safety:
14618            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14619            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14620            //   envelope_size bytes, there is always sufficient room.
14621            fidl::encoding::encode_in_envelope_optional::<
14622                u32,
14623                fidl::encoding::DefaultFuchsiaResourceDialect,
14624            >(
14625                self.uint32_member.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
14626                encoder,
14627                offset + cur_offset,
14628                depth,
14629            )?;
14630
14631            _prev_end_offset = cur_offset + envelope_size;
14632            if 9 > max_ordinal {
14633                return Ok(());
14634            }
14635
14636            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14637            // are envelope_size bytes.
14638            let cur_offset: usize = (9 - 1) * envelope_size;
14639
14640            // Zero reserved fields.
14641            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14642
14643            // Safety:
14644            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14645            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14646            //   envelope_size bytes, there is always sufficient room.
14647            fidl::encoding::encode_in_envelope_optional::<
14648                u64,
14649                fidl::encoding::DefaultFuchsiaResourceDialect,
14650            >(
14651                self.uint64_member.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
14652                encoder,
14653                offset + cur_offset,
14654                depth,
14655            )?;
14656
14657            _prev_end_offset = cur_offset + envelope_size;
14658            if 10 > max_ordinal {
14659                return Ok(());
14660            }
14661
14662            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14663            // are envelope_size bytes.
14664            let cur_offset: usize = (10 - 1) * envelope_size;
14665
14666            // Zero reserved fields.
14667            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14668
14669            // Safety:
14670            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14671            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14672            //   envelope_size bytes, there is always sufficient room.
14673            fidl::encoding::encode_in_envelope_optional::<
14674                f32,
14675                fidl::encoding::DefaultFuchsiaResourceDialect,
14676            >(
14677                self.float32_member.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
14678                encoder,
14679                offset + cur_offset,
14680                depth,
14681            )?;
14682
14683            _prev_end_offset = cur_offset + envelope_size;
14684            if 11 > max_ordinal {
14685                return Ok(());
14686            }
14687
14688            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14689            // are envelope_size bytes.
14690            let cur_offset: usize = (11 - 1) * envelope_size;
14691
14692            // Zero reserved fields.
14693            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14694
14695            // Safety:
14696            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14697            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14698            //   envelope_size bytes, there is always sufficient room.
14699            fidl::encoding::encode_in_envelope_optional::<
14700                f64,
14701                fidl::encoding::DefaultFuchsiaResourceDialect,
14702            >(
14703                self.float64_member.as_ref().map(<f64 as fidl::encoding::ValueTypeMarker>::borrow),
14704                encoder,
14705                offset + cur_offset,
14706                depth,
14707            )?;
14708
14709            _prev_end_offset = cur_offset + envelope_size;
14710            if 12 > max_ordinal {
14711                return Ok(());
14712            }
14713
14714            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14715            // are envelope_size bytes.
14716            let cur_offset: usize = (12 - 1) * envelope_size;
14717
14718            // Zero reserved fields.
14719            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14720
14721            // Safety:
14722            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14723            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14724            //   envelope_size bytes, there is always sufficient room.
14725            fidl::encoding::encode_in_envelope_optional::<
14726                DefaultEnum,
14727                fidl::encoding::DefaultFuchsiaResourceDialect,
14728            >(
14729                self.enum_member
14730                    .as_ref()
14731                    .map(<DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow),
14732                encoder,
14733                offset + cur_offset,
14734                depth,
14735            )?;
14736
14737            _prev_end_offset = cur_offset + envelope_size;
14738            if 13 > max_ordinal {
14739                return Ok(());
14740            }
14741
14742            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14743            // are envelope_size bytes.
14744            let cur_offset: usize = (13 - 1) * envelope_size;
14745
14746            // Zero reserved fields.
14747            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14748
14749            // Safety:
14750            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14751            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14752            //   envelope_size bytes, there is always sufficient room.
14753            fidl::encoding::encode_in_envelope_optional::<
14754                DefaultBits,
14755                fidl::encoding::DefaultFuchsiaResourceDialect,
14756            >(
14757                self.bits_member
14758                    .as_ref()
14759                    .map(<DefaultBits as fidl::encoding::ValueTypeMarker>::borrow),
14760                encoder,
14761                offset + cur_offset,
14762                depth,
14763            )?;
14764
14765            _prev_end_offset = cur_offset + envelope_size;
14766            if 14 > max_ordinal {
14767                return Ok(());
14768            }
14769
14770            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14771            // are envelope_size bytes.
14772            let cur_offset: usize = (14 - 1) * envelope_size;
14773
14774            // Zero reserved fields.
14775            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14776
14777            // Safety:
14778            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14779            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14780            //   envelope_size bytes, there is always sufficient room.
14781            fidl::encoding::encode_in_envelope_optional::<
14782                fidl::encoding::HandleType<
14783                    fidl::NullableHandle,
14784                    { fidl::ObjectType::NONE.into_raw() },
14785                    2147483648,
14786                >,
14787                fidl::encoding::DefaultFuchsiaResourceDialect,
14788            >(
14789                self.handle_member.as_mut().map(
14790                    <fidl::encoding::HandleType<
14791                        fidl::NullableHandle,
14792                        { fidl::ObjectType::NONE.into_raw() },
14793                        2147483648,
14794                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
14795                ),
14796                encoder,
14797                offset + cur_offset,
14798                depth,
14799            )?;
14800
14801            _prev_end_offset = cur_offset + envelope_size;
14802            if 15 > max_ordinal {
14803                return Ok(());
14804            }
14805
14806            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14807            // are envelope_size bytes.
14808            let cur_offset: usize = (15 - 1) * envelope_size;
14809
14810            // Zero reserved fields.
14811            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14812
14813            // Safety:
14814            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14815            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14816            //   envelope_size bytes, there is always sufficient room.
14817            fidl::encoding::encode_in_envelope_optional::<
14818                fidl::encoding::UnboundedString,
14819                fidl::encoding::DefaultFuchsiaResourceDialect,
14820            >(
14821                self.string_member.as_ref().map(
14822                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
14823                ),
14824                encoder,
14825                offset + cur_offset,
14826                depth,
14827            )?;
14828
14829            _prev_end_offset = cur_offset + envelope_size;
14830            if 16 > max_ordinal {
14831                return Ok(());
14832            }
14833
14834            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14835            // are envelope_size bytes.
14836            let cur_offset: usize = (16 - 1) * envelope_size;
14837
14838            // Zero reserved fields.
14839            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14840
14841            // Safety:
14842            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14843            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14844            //   envelope_size bytes, there is always sufficient room.
14845            fidl::encoding::encode_in_envelope_optional::<
14846                ThisIsAStruct,
14847                fidl::encoding::DefaultFuchsiaResourceDialect,
14848            >(
14849                self.struct_member
14850                    .as_ref()
14851                    .map(<ThisIsAStruct as fidl::encoding::ValueTypeMarker>::borrow),
14852                encoder,
14853                offset + cur_offset,
14854                depth,
14855            )?;
14856
14857            _prev_end_offset = cur_offset + envelope_size;
14858            if 17 > max_ordinal {
14859                return Ok(());
14860            }
14861
14862            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14863            // are envelope_size bytes.
14864            let cur_offset: usize = (17 - 1) * envelope_size;
14865
14866            // Zero reserved fields.
14867            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14868
14869            // Safety:
14870            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14871            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14872            //   envelope_size bytes, there is always sufficient room.
14873            fidl::encoding::encode_in_envelope_optional::<
14874                ThisIsAUnion,
14875                fidl::encoding::DefaultFuchsiaResourceDialect,
14876            >(
14877                self.union_member
14878                    .as_ref()
14879                    .map(<ThisIsAUnion as fidl::encoding::ValueTypeMarker>::borrow),
14880                encoder,
14881                offset + cur_offset,
14882                depth,
14883            )?;
14884
14885            _prev_end_offset = cur_offset + envelope_size;
14886            if 18 > max_ordinal {
14887                return Ok(());
14888            }
14889
14890            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14891            // are envelope_size bytes.
14892            let cur_offset: usize = (18 - 1) * envelope_size;
14893
14894            // Zero reserved fields.
14895            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14896
14897            // Safety:
14898            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14899            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14900            //   envelope_size bytes, there is always sufficient room.
14901            fidl::encoding::encode_in_envelope_optional::<
14902                fidl::encoding::Array<u32, 3>,
14903                fidl::encoding::DefaultFuchsiaResourceDialect,
14904            >(
14905                self.array_member.as_ref().map(
14906                    <fidl::encoding::Array<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow,
14907                ),
14908                encoder,
14909                offset + cur_offset,
14910                depth,
14911            )?;
14912
14913            _prev_end_offset = cur_offset + envelope_size;
14914            if 19 > max_ordinal {
14915                return Ok(());
14916            }
14917
14918            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14919            // are envelope_size bytes.
14920            let cur_offset: usize = (19 - 1) * envelope_size;
14921
14922            // Zero reserved fields.
14923            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14924
14925            // Safety:
14926            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14927            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14928            //   envelope_size bytes, there is always sufficient room.
14929            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u32>, fidl::encoding::DefaultFuchsiaResourceDialect>(
14930            self.vector_member.as_ref().map(<fidl::encoding::UnboundedVector<u32> as fidl::encoding::ValueTypeMarker>::borrow),
14931            encoder, offset + cur_offset, depth
14932        )?;
14933
14934            _prev_end_offset = cur_offset + envelope_size;
14935            if 20 > max_ordinal {
14936                return Ok(());
14937            }
14938
14939            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14940            // are envelope_size bytes.
14941            let cur_offset: usize = (20 - 1) * envelope_size;
14942
14943            // Zero reserved fields.
14944            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14945
14946            // Safety:
14947            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14948            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14949            //   envelope_size bytes, there is always sufficient room.
14950            fidl::encoding::encode_in_envelope_optional::<
14951                ThisIsATable,
14952                fidl::encoding::DefaultFuchsiaResourceDialect,
14953            >(
14954                self.table_member
14955                    .as_ref()
14956                    .map(<ThisIsATable as fidl::encoding::ValueTypeMarker>::borrow),
14957                encoder,
14958                offset + cur_offset,
14959                depth,
14960            )?;
14961
14962            _prev_end_offset = cur_offset + envelope_size;
14963            if 21 > max_ordinal {
14964                return Ok(());
14965            }
14966
14967            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14968            // are envelope_size bytes.
14969            let cur_offset: usize = (21 - 1) * envelope_size;
14970
14971            // Zero reserved fields.
14972            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14973
14974            // Safety:
14975            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14976            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14977            //   envelope_size bytes, there is always sufficient room.
14978            fidl::encoding::encode_in_envelope_optional::<
14979                ThisIsAXunion,
14980                fidl::encoding::DefaultFuchsiaResourceDialect,
14981            >(
14982                self.xunion_member
14983                    .as_ref()
14984                    .map(<ThisIsAXunion as fidl::encoding::ValueTypeMarker>::borrow),
14985                encoder,
14986                offset + cur_offset,
14987                depth,
14988            )?;
14989
14990            _prev_end_offset = cur_offset + envelope_size;
14991
14992            Ok(())
14993        }
14994    }
14995
14996    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for AllTypesTable {
14997        #[inline(always)]
14998        fn new_empty() -> Self {
14999            Self::default()
15000        }
15001
15002        unsafe fn decode(
15003            &mut self,
15004            decoder: &mut fidl::encoding::Decoder<
15005                '_,
15006                fidl::encoding::DefaultFuchsiaResourceDialect,
15007            >,
15008            offset: usize,
15009            mut depth: fidl::encoding::Depth,
15010        ) -> fidl::Result<()> {
15011            decoder.debug_check_bounds::<Self>(offset);
15012            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
15013                None => return Err(fidl::Error::NotNullable),
15014                Some(len) => len,
15015            };
15016            // Calling decoder.out_of_line_offset(0) is not allowed.
15017            if len == 0 {
15018                return Ok(());
15019            };
15020            depth.increment()?;
15021            let envelope_size = 8;
15022            let bytes_len = len * envelope_size;
15023            let offset = decoder.out_of_line_offset(bytes_len)?;
15024            // Decode the envelope for each type.
15025            let mut _next_ordinal_to_read = 0;
15026            let mut next_offset = offset;
15027            let end_offset = offset + bytes_len;
15028            _next_ordinal_to_read += 1;
15029            if next_offset >= end_offset {
15030                return Ok(());
15031            }
15032
15033            // Decode unknown envelopes for gaps in ordinals.
15034            while _next_ordinal_to_read < 1 {
15035                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15036                _next_ordinal_to_read += 1;
15037                next_offset += envelope_size;
15038            }
15039
15040            let next_out_of_line = decoder.next_out_of_line();
15041            let handles_before = decoder.remaining_handles();
15042            if let Some((inlined, num_bytes, num_handles)) =
15043                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15044            {
15045                let member_inline_size =
15046                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15047                if inlined != (member_inline_size <= 4) {
15048                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15049                }
15050                let inner_offset;
15051                let mut inner_depth = depth.clone();
15052                if inlined {
15053                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15054                    inner_offset = next_offset;
15055                } else {
15056                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15057                    inner_depth.increment()?;
15058                }
15059                let val_ref = self.bool_member.get_or_insert_with(|| {
15060                    fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect)
15061                });
15062                fidl::decode!(
15063                    bool,
15064                    fidl::encoding::DefaultFuchsiaResourceDialect,
15065                    val_ref,
15066                    decoder,
15067                    inner_offset,
15068                    inner_depth
15069                )?;
15070                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15071                {
15072                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15073                }
15074                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15075                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15076                }
15077            }
15078
15079            next_offset += envelope_size;
15080            _next_ordinal_to_read += 1;
15081            if next_offset >= end_offset {
15082                return Ok(());
15083            }
15084
15085            // Decode unknown envelopes for gaps in ordinals.
15086            while _next_ordinal_to_read < 2 {
15087                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15088                _next_ordinal_to_read += 1;
15089                next_offset += envelope_size;
15090            }
15091
15092            let next_out_of_line = decoder.next_out_of_line();
15093            let handles_before = decoder.remaining_handles();
15094            if let Some((inlined, num_bytes, num_handles)) =
15095                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15096            {
15097                let member_inline_size =
15098                    <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15099                if inlined != (member_inline_size <= 4) {
15100                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15101                }
15102                let inner_offset;
15103                let mut inner_depth = depth.clone();
15104                if inlined {
15105                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15106                    inner_offset = next_offset;
15107                } else {
15108                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15109                    inner_depth.increment()?;
15110                }
15111                let val_ref = self.int8_member.get_or_insert_with(|| {
15112                    fidl::new_empty!(i8, fidl::encoding::DefaultFuchsiaResourceDialect)
15113                });
15114                fidl::decode!(
15115                    i8,
15116                    fidl::encoding::DefaultFuchsiaResourceDialect,
15117                    val_ref,
15118                    decoder,
15119                    inner_offset,
15120                    inner_depth
15121                )?;
15122                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15123                {
15124                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15125                }
15126                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15127                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15128                }
15129            }
15130
15131            next_offset += envelope_size;
15132            _next_ordinal_to_read += 1;
15133            if next_offset >= end_offset {
15134                return Ok(());
15135            }
15136
15137            // Decode unknown envelopes for gaps in ordinals.
15138            while _next_ordinal_to_read < 3 {
15139                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15140                _next_ordinal_to_read += 1;
15141                next_offset += envelope_size;
15142            }
15143
15144            let next_out_of_line = decoder.next_out_of_line();
15145            let handles_before = decoder.remaining_handles();
15146            if let Some((inlined, num_bytes, num_handles)) =
15147                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15148            {
15149                let member_inline_size =
15150                    <i16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15151                if inlined != (member_inline_size <= 4) {
15152                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15153                }
15154                let inner_offset;
15155                let mut inner_depth = depth.clone();
15156                if inlined {
15157                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15158                    inner_offset = next_offset;
15159                } else {
15160                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15161                    inner_depth.increment()?;
15162                }
15163                let val_ref = self.int16_member.get_or_insert_with(|| {
15164                    fidl::new_empty!(i16, fidl::encoding::DefaultFuchsiaResourceDialect)
15165                });
15166                fidl::decode!(
15167                    i16,
15168                    fidl::encoding::DefaultFuchsiaResourceDialect,
15169                    val_ref,
15170                    decoder,
15171                    inner_offset,
15172                    inner_depth
15173                )?;
15174                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15175                {
15176                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15177                }
15178                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15179                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15180                }
15181            }
15182
15183            next_offset += envelope_size;
15184            _next_ordinal_to_read += 1;
15185            if next_offset >= end_offset {
15186                return Ok(());
15187            }
15188
15189            // Decode unknown envelopes for gaps in ordinals.
15190            while _next_ordinal_to_read < 4 {
15191                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15192                _next_ordinal_to_read += 1;
15193                next_offset += envelope_size;
15194            }
15195
15196            let next_out_of_line = decoder.next_out_of_line();
15197            let handles_before = decoder.remaining_handles();
15198            if let Some((inlined, num_bytes, num_handles)) =
15199                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15200            {
15201                let member_inline_size =
15202                    <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15203                if inlined != (member_inline_size <= 4) {
15204                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15205                }
15206                let inner_offset;
15207                let mut inner_depth = depth.clone();
15208                if inlined {
15209                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15210                    inner_offset = next_offset;
15211                } else {
15212                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15213                    inner_depth.increment()?;
15214                }
15215                let val_ref = self.int32_member.get_or_insert_with(|| {
15216                    fidl::new_empty!(i32, fidl::encoding::DefaultFuchsiaResourceDialect)
15217                });
15218                fidl::decode!(
15219                    i32,
15220                    fidl::encoding::DefaultFuchsiaResourceDialect,
15221                    val_ref,
15222                    decoder,
15223                    inner_offset,
15224                    inner_depth
15225                )?;
15226                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15227                {
15228                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15229                }
15230                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15231                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15232                }
15233            }
15234
15235            next_offset += envelope_size;
15236            _next_ordinal_to_read += 1;
15237            if next_offset >= end_offset {
15238                return Ok(());
15239            }
15240
15241            // Decode unknown envelopes for gaps in ordinals.
15242            while _next_ordinal_to_read < 5 {
15243                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15244                _next_ordinal_to_read += 1;
15245                next_offset += envelope_size;
15246            }
15247
15248            let next_out_of_line = decoder.next_out_of_line();
15249            let handles_before = decoder.remaining_handles();
15250            if let Some((inlined, num_bytes, num_handles)) =
15251                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15252            {
15253                let member_inline_size =
15254                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15255                if inlined != (member_inline_size <= 4) {
15256                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15257                }
15258                let inner_offset;
15259                let mut inner_depth = depth.clone();
15260                if inlined {
15261                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15262                    inner_offset = next_offset;
15263                } else {
15264                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15265                    inner_depth.increment()?;
15266                }
15267                let val_ref = self.int64_member.get_or_insert_with(|| {
15268                    fidl::new_empty!(i64, fidl::encoding::DefaultFuchsiaResourceDialect)
15269                });
15270                fidl::decode!(
15271                    i64,
15272                    fidl::encoding::DefaultFuchsiaResourceDialect,
15273                    val_ref,
15274                    decoder,
15275                    inner_offset,
15276                    inner_depth
15277                )?;
15278                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15279                {
15280                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15281                }
15282                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15283                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15284                }
15285            }
15286
15287            next_offset += envelope_size;
15288            _next_ordinal_to_read += 1;
15289            if next_offset >= end_offset {
15290                return Ok(());
15291            }
15292
15293            // Decode unknown envelopes for gaps in ordinals.
15294            while _next_ordinal_to_read < 6 {
15295                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15296                _next_ordinal_to_read += 1;
15297                next_offset += envelope_size;
15298            }
15299
15300            let next_out_of_line = decoder.next_out_of_line();
15301            let handles_before = decoder.remaining_handles();
15302            if let Some((inlined, num_bytes, num_handles)) =
15303                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15304            {
15305                let member_inline_size =
15306                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15307                if inlined != (member_inline_size <= 4) {
15308                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15309                }
15310                let inner_offset;
15311                let mut inner_depth = depth.clone();
15312                if inlined {
15313                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15314                    inner_offset = next_offset;
15315                } else {
15316                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15317                    inner_depth.increment()?;
15318                }
15319                let val_ref = self.uint8_member.get_or_insert_with(|| {
15320                    fidl::new_empty!(u8, fidl::encoding::DefaultFuchsiaResourceDialect)
15321                });
15322                fidl::decode!(
15323                    u8,
15324                    fidl::encoding::DefaultFuchsiaResourceDialect,
15325                    val_ref,
15326                    decoder,
15327                    inner_offset,
15328                    inner_depth
15329                )?;
15330                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15331                {
15332                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15333                }
15334                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15335                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15336                }
15337            }
15338
15339            next_offset += envelope_size;
15340            _next_ordinal_to_read += 1;
15341            if next_offset >= end_offset {
15342                return Ok(());
15343            }
15344
15345            // Decode unknown envelopes for gaps in ordinals.
15346            while _next_ordinal_to_read < 7 {
15347                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15348                _next_ordinal_to_read += 1;
15349                next_offset += envelope_size;
15350            }
15351
15352            let next_out_of_line = decoder.next_out_of_line();
15353            let handles_before = decoder.remaining_handles();
15354            if let Some((inlined, num_bytes, num_handles)) =
15355                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15356            {
15357                let member_inline_size =
15358                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15359                if inlined != (member_inline_size <= 4) {
15360                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15361                }
15362                let inner_offset;
15363                let mut inner_depth = depth.clone();
15364                if inlined {
15365                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15366                    inner_offset = next_offset;
15367                } else {
15368                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15369                    inner_depth.increment()?;
15370                }
15371                let val_ref = self.uint16_member.get_or_insert_with(|| {
15372                    fidl::new_empty!(u16, fidl::encoding::DefaultFuchsiaResourceDialect)
15373                });
15374                fidl::decode!(
15375                    u16,
15376                    fidl::encoding::DefaultFuchsiaResourceDialect,
15377                    val_ref,
15378                    decoder,
15379                    inner_offset,
15380                    inner_depth
15381                )?;
15382                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15383                {
15384                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15385                }
15386                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15387                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15388                }
15389            }
15390
15391            next_offset += envelope_size;
15392            _next_ordinal_to_read += 1;
15393            if next_offset >= end_offset {
15394                return Ok(());
15395            }
15396
15397            // Decode unknown envelopes for gaps in ordinals.
15398            while _next_ordinal_to_read < 8 {
15399                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15400                _next_ordinal_to_read += 1;
15401                next_offset += envelope_size;
15402            }
15403
15404            let next_out_of_line = decoder.next_out_of_line();
15405            let handles_before = decoder.remaining_handles();
15406            if let Some((inlined, num_bytes, num_handles)) =
15407                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15408            {
15409                let member_inline_size =
15410                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15411                if inlined != (member_inline_size <= 4) {
15412                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15413                }
15414                let inner_offset;
15415                let mut inner_depth = depth.clone();
15416                if inlined {
15417                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15418                    inner_offset = next_offset;
15419                } else {
15420                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15421                    inner_depth.increment()?;
15422                }
15423                let val_ref = self.uint32_member.get_or_insert_with(|| {
15424                    fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect)
15425                });
15426                fidl::decode!(
15427                    u32,
15428                    fidl::encoding::DefaultFuchsiaResourceDialect,
15429                    val_ref,
15430                    decoder,
15431                    inner_offset,
15432                    inner_depth
15433                )?;
15434                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15435                {
15436                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15437                }
15438                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15439                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15440                }
15441            }
15442
15443            next_offset += envelope_size;
15444            _next_ordinal_to_read += 1;
15445            if next_offset >= end_offset {
15446                return Ok(());
15447            }
15448
15449            // Decode unknown envelopes for gaps in ordinals.
15450            while _next_ordinal_to_read < 9 {
15451                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15452                _next_ordinal_to_read += 1;
15453                next_offset += envelope_size;
15454            }
15455
15456            let next_out_of_line = decoder.next_out_of_line();
15457            let handles_before = decoder.remaining_handles();
15458            if let Some((inlined, num_bytes, num_handles)) =
15459                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15460            {
15461                let member_inline_size =
15462                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15463                if inlined != (member_inline_size <= 4) {
15464                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15465                }
15466                let inner_offset;
15467                let mut inner_depth = depth.clone();
15468                if inlined {
15469                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15470                    inner_offset = next_offset;
15471                } else {
15472                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15473                    inner_depth.increment()?;
15474                }
15475                let val_ref = self.uint64_member.get_or_insert_with(|| {
15476                    fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect)
15477                });
15478                fidl::decode!(
15479                    u64,
15480                    fidl::encoding::DefaultFuchsiaResourceDialect,
15481                    val_ref,
15482                    decoder,
15483                    inner_offset,
15484                    inner_depth
15485                )?;
15486                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15487                {
15488                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15489                }
15490                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15491                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15492                }
15493            }
15494
15495            next_offset += envelope_size;
15496            _next_ordinal_to_read += 1;
15497            if next_offset >= end_offset {
15498                return Ok(());
15499            }
15500
15501            // Decode unknown envelopes for gaps in ordinals.
15502            while _next_ordinal_to_read < 10 {
15503                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15504                _next_ordinal_to_read += 1;
15505                next_offset += envelope_size;
15506            }
15507
15508            let next_out_of_line = decoder.next_out_of_line();
15509            let handles_before = decoder.remaining_handles();
15510            if let Some((inlined, num_bytes, num_handles)) =
15511                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15512            {
15513                let member_inline_size =
15514                    <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15515                if inlined != (member_inline_size <= 4) {
15516                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15517                }
15518                let inner_offset;
15519                let mut inner_depth = depth.clone();
15520                if inlined {
15521                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15522                    inner_offset = next_offset;
15523                } else {
15524                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15525                    inner_depth.increment()?;
15526                }
15527                let val_ref = self.float32_member.get_or_insert_with(|| {
15528                    fidl::new_empty!(f32, fidl::encoding::DefaultFuchsiaResourceDialect)
15529                });
15530                fidl::decode!(
15531                    f32,
15532                    fidl::encoding::DefaultFuchsiaResourceDialect,
15533                    val_ref,
15534                    decoder,
15535                    inner_offset,
15536                    inner_depth
15537                )?;
15538                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15539                {
15540                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15541                }
15542                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15543                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15544                }
15545            }
15546
15547            next_offset += envelope_size;
15548            _next_ordinal_to_read += 1;
15549            if next_offset >= end_offset {
15550                return Ok(());
15551            }
15552
15553            // Decode unknown envelopes for gaps in ordinals.
15554            while _next_ordinal_to_read < 11 {
15555                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15556                _next_ordinal_to_read += 1;
15557                next_offset += envelope_size;
15558            }
15559
15560            let next_out_of_line = decoder.next_out_of_line();
15561            let handles_before = decoder.remaining_handles();
15562            if let Some((inlined, num_bytes, num_handles)) =
15563                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15564            {
15565                let member_inline_size =
15566                    <f64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15567                if inlined != (member_inline_size <= 4) {
15568                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15569                }
15570                let inner_offset;
15571                let mut inner_depth = depth.clone();
15572                if inlined {
15573                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15574                    inner_offset = next_offset;
15575                } else {
15576                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15577                    inner_depth.increment()?;
15578                }
15579                let val_ref = self.float64_member.get_or_insert_with(|| {
15580                    fidl::new_empty!(f64, fidl::encoding::DefaultFuchsiaResourceDialect)
15581                });
15582                fidl::decode!(
15583                    f64,
15584                    fidl::encoding::DefaultFuchsiaResourceDialect,
15585                    val_ref,
15586                    decoder,
15587                    inner_offset,
15588                    inner_depth
15589                )?;
15590                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15591                {
15592                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15593                }
15594                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15595                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15596                }
15597            }
15598
15599            next_offset += envelope_size;
15600            _next_ordinal_to_read += 1;
15601            if next_offset >= end_offset {
15602                return Ok(());
15603            }
15604
15605            // Decode unknown envelopes for gaps in ordinals.
15606            while _next_ordinal_to_read < 12 {
15607                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15608                _next_ordinal_to_read += 1;
15609                next_offset += envelope_size;
15610            }
15611
15612            let next_out_of_line = decoder.next_out_of_line();
15613            let handles_before = decoder.remaining_handles();
15614            if let Some((inlined, num_bytes, num_handles)) =
15615                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15616            {
15617                let member_inline_size =
15618                    <DefaultEnum as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15619                if inlined != (member_inline_size <= 4) {
15620                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15621                }
15622                let inner_offset;
15623                let mut inner_depth = depth.clone();
15624                if inlined {
15625                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15626                    inner_offset = next_offset;
15627                } else {
15628                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15629                    inner_depth.increment()?;
15630                }
15631                let val_ref = self.enum_member.get_or_insert_with(|| {
15632                    fidl::new_empty!(DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect)
15633                });
15634                fidl::decode!(
15635                    DefaultEnum,
15636                    fidl::encoding::DefaultFuchsiaResourceDialect,
15637                    val_ref,
15638                    decoder,
15639                    inner_offset,
15640                    inner_depth
15641                )?;
15642                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15643                {
15644                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15645                }
15646                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15647                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15648                }
15649            }
15650
15651            next_offset += envelope_size;
15652            _next_ordinal_to_read += 1;
15653            if next_offset >= end_offset {
15654                return Ok(());
15655            }
15656
15657            // Decode unknown envelopes for gaps in ordinals.
15658            while _next_ordinal_to_read < 13 {
15659                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15660                _next_ordinal_to_read += 1;
15661                next_offset += envelope_size;
15662            }
15663
15664            let next_out_of_line = decoder.next_out_of_line();
15665            let handles_before = decoder.remaining_handles();
15666            if let Some((inlined, num_bytes, num_handles)) =
15667                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15668            {
15669                let member_inline_size =
15670                    <DefaultBits as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15671                if inlined != (member_inline_size <= 4) {
15672                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15673                }
15674                let inner_offset;
15675                let mut inner_depth = depth.clone();
15676                if inlined {
15677                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15678                    inner_offset = next_offset;
15679                } else {
15680                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15681                    inner_depth.increment()?;
15682                }
15683                let val_ref = self.bits_member.get_or_insert_with(|| {
15684                    fidl::new_empty!(DefaultBits, fidl::encoding::DefaultFuchsiaResourceDialect)
15685                });
15686                fidl::decode!(
15687                    DefaultBits,
15688                    fidl::encoding::DefaultFuchsiaResourceDialect,
15689                    val_ref,
15690                    decoder,
15691                    inner_offset,
15692                    inner_depth
15693                )?;
15694                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15695                {
15696                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15697                }
15698                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15699                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15700                }
15701            }
15702
15703            next_offset += envelope_size;
15704            _next_ordinal_to_read += 1;
15705            if next_offset >= end_offset {
15706                return Ok(());
15707            }
15708
15709            // Decode unknown envelopes for gaps in ordinals.
15710            while _next_ordinal_to_read < 14 {
15711                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15712                _next_ordinal_to_read += 1;
15713                next_offset += envelope_size;
15714            }
15715
15716            let next_out_of_line = decoder.next_out_of_line();
15717            let handles_before = decoder.remaining_handles();
15718            if let Some((inlined, num_bytes, num_handles)) =
15719                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15720            {
15721                let member_inline_size = <fidl::encoding::HandleType<
15722                    fidl::NullableHandle,
15723                    { fidl::ObjectType::NONE.into_raw() },
15724                    2147483648,
15725                > as fidl::encoding::TypeMarker>::inline_size(
15726                    decoder.context
15727                );
15728                if inlined != (member_inline_size <= 4) {
15729                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15730                }
15731                let inner_offset;
15732                let mut inner_depth = depth.clone();
15733                if inlined {
15734                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15735                    inner_offset = next_offset;
15736                } else {
15737                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15738                    inner_depth.increment()?;
15739                }
15740                let val_ref =
15741                self.handle_member.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
15742                fidl::decode!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
15743                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15744                {
15745                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15746                }
15747                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15748                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15749                }
15750            }
15751
15752            next_offset += envelope_size;
15753            _next_ordinal_to_read += 1;
15754            if next_offset >= end_offset {
15755                return Ok(());
15756            }
15757
15758            // Decode unknown envelopes for gaps in ordinals.
15759            while _next_ordinal_to_read < 15 {
15760                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15761                _next_ordinal_to_read += 1;
15762                next_offset += envelope_size;
15763            }
15764
15765            let next_out_of_line = decoder.next_out_of_line();
15766            let handles_before = decoder.remaining_handles();
15767            if let Some((inlined, num_bytes, num_handles)) =
15768                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15769            {
15770                let member_inline_size =
15771                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
15772                        decoder.context,
15773                    );
15774                if inlined != (member_inline_size <= 4) {
15775                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15776                }
15777                let inner_offset;
15778                let mut inner_depth = depth.clone();
15779                if inlined {
15780                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15781                    inner_offset = next_offset;
15782                } else {
15783                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15784                    inner_depth.increment()?;
15785                }
15786                let val_ref = self.string_member.get_or_insert_with(|| {
15787                    fidl::new_empty!(
15788                        fidl::encoding::UnboundedString,
15789                        fidl::encoding::DefaultFuchsiaResourceDialect
15790                    )
15791                });
15792                fidl::decode!(
15793                    fidl::encoding::UnboundedString,
15794                    fidl::encoding::DefaultFuchsiaResourceDialect,
15795                    val_ref,
15796                    decoder,
15797                    inner_offset,
15798                    inner_depth
15799                )?;
15800                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15801                {
15802                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15803                }
15804                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15805                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15806                }
15807            }
15808
15809            next_offset += envelope_size;
15810            _next_ordinal_to_read += 1;
15811            if next_offset >= end_offset {
15812                return Ok(());
15813            }
15814
15815            // Decode unknown envelopes for gaps in ordinals.
15816            while _next_ordinal_to_read < 16 {
15817                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15818                _next_ordinal_to_read += 1;
15819                next_offset += envelope_size;
15820            }
15821
15822            let next_out_of_line = decoder.next_out_of_line();
15823            let handles_before = decoder.remaining_handles();
15824            if let Some((inlined, num_bytes, num_handles)) =
15825                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15826            {
15827                let member_inline_size =
15828                    <ThisIsAStruct as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15829                if inlined != (member_inline_size <= 4) {
15830                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15831                }
15832                let inner_offset;
15833                let mut inner_depth = depth.clone();
15834                if inlined {
15835                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15836                    inner_offset = next_offset;
15837                } else {
15838                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15839                    inner_depth.increment()?;
15840                }
15841                let val_ref = self.struct_member.get_or_insert_with(|| {
15842                    fidl::new_empty!(ThisIsAStruct, fidl::encoding::DefaultFuchsiaResourceDialect)
15843                });
15844                fidl::decode!(
15845                    ThisIsAStruct,
15846                    fidl::encoding::DefaultFuchsiaResourceDialect,
15847                    val_ref,
15848                    decoder,
15849                    inner_offset,
15850                    inner_depth
15851                )?;
15852                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15853                {
15854                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15855                }
15856                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15857                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15858                }
15859            }
15860
15861            next_offset += envelope_size;
15862            _next_ordinal_to_read += 1;
15863            if next_offset >= end_offset {
15864                return Ok(());
15865            }
15866
15867            // Decode unknown envelopes for gaps in ordinals.
15868            while _next_ordinal_to_read < 17 {
15869                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15870                _next_ordinal_to_read += 1;
15871                next_offset += envelope_size;
15872            }
15873
15874            let next_out_of_line = decoder.next_out_of_line();
15875            let handles_before = decoder.remaining_handles();
15876            if let Some((inlined, num_bytes, num_handles)) =
15877                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15878            {
15879                let member_inline_size =
15880                    <ThisIsAUnion as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15881                if inlined != (member_inline_size <= 4) {
15882                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15883                }
15884                let inner_offset;
15885                let mut inner_depth = depth.clone();
15886                if inlined {
15887                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15888                    inner_offset = next_offset;
15889                } else {
15890                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15891                    inner_depth.increment()?;
15892                }
15893                let val_ref = self.union_member.get_or_insert_with(|| {
15894                    fidl::new_empty!(ThisIsAUnion, fidl::encoding::DefaultFuchsiaResourceDialect)
15895                });
15896                fidl::decode!(
15897                    ThisIsAUnion,
15898                    fidl::encoding::DefaultFuchsiaResourceDialect,
15899                    val_ref,
15900                    decoder,
15901                    inner_offset,
15902                    inner_depth
15903                )?;
15904                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15905                {
15906                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15907                }
15908                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15909                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15910                }
15911            }
15912
15913            next_offset += envelope_size;
15914            _next_ordinal_to_read += 1;
15915            if next_offset >= end_offset {
15916                return Ok(());
15917            }
15918
15919            // Decode unknown envelopes for gaps in ordinals.
15920            while _next_ordinal_to_read < 18 {
15921                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15922                _next_ordinal_to_read += 1;
15923                next_offset += envelope_size;
15924            }
15925
15926            let next_out_of_line = decoder.next_out_of_line();
15927            let handles_before = decoder.remaining_handles();
15928            if let Some((inlined, num_bytes, num_handles)) =
15929                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15930            {
15931                let member_inline_size =
15932                    <fidl::encoding::Array<u32, 3> as fidl::encoding::TypeMarker>::inline_size(
15933                        decoder.context,
15934                    );
15935                if inlined != (member_inline_size <= 4) {
15936                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15937                }
15938                let inner_offset;
15939                let mut inner_depth = depth.clone();
15940                if inlined {
15941                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15942                    inner_offset = next_offset;
15943                } else {
15944                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15945                    inner_depth.increment()?;
15946                }
15947                let val_ref =
15948                self.array_member.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect));
15949                fidl::decode!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
15950                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15951                {
15952                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15953                }
15954                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15955                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15956                }
15957            }
15958
15959            next_offset += envelope_size;
15960            _next_ordinal_to_read += 1;
15961            if next_offset >= end_offset {
15962                return Ok(());
15963            }
15964
15965            // Decode unknown envelopes for gaps in ordinals.
15966            while _next_ordinal_to_read < 19 {
15967                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15968                _next_ordinal_to_read += 1;
15969                next_offset += envelope_size;
15970            }
15971
15972            let next_out_of_line = decoder.next_out_of_line();
15973            let handles_before = decoder.remaining_handles();
15974            if let Some((inlined, num_bytes, num_handles)) =
15975                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15976            {
15977                let member_inline_size = <fidl::encoding::UnboundedVector<u32> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15978                if inlined != (member_inline_size <= 4) {
15979                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15980                }
15981                let inner_offset;
15982                let mut inner_depth = depth.clone();
15983                if inlined {
15984                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15985                    inner_offset = next_offset;
15986                } else {
15987                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15988                    inner_depth.increment()?;
15989                }
15990                let val_ref = self.vector_member.get_or_insert_with(|| {
15991                    fidl::new_empty!(
15992                        fidl::encoding::UnboundedVector<u32>,
15993                        fidl::encoding::DefaultFuchsiaResourceDialect
15994                    )
15995                });
15996                fidl::decode!(
15997                    fidl::encoding::UnboundedVector<u32>,
15998                    fidl::encoding::DefaultFuchsiaResourceDialect,
15999                    val_ref,
16000                    decoder,
16001                    inner_offset,
16002                    inner_depth
16003                )?;
16004                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16005                {
16006                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16007                }
16008                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16009                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16010                }
16011            }
16012
16013            next_offset += envelope_size;
16014            _next_ordinal_to_read += 1;
16015            if next_offset >= end_offset {
16016                return Ok(());
16017            }
16018
16019            // Decode unknown envelopes for gaps in ordinals.
16020            while _next_ordinal_to_read < 20 {
16021                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16022                _next_ordinal_to_read += 1;
16023                next_offset += envelope_size;
16024            }
16025
16026            let next_out_of_line = decoder.next_out_of_line();
16027            let handles_before = decoder.remaining_handles();
16028            if let Some((inlined, num_bytes, num_handles)) =
16029                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16030            {
16031                let member_inline_size =
16032                    <ThisIsATable as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16033                if inlined != (member_inline_size <= 4) {
16034                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16035                }
16036                let inner_offset;
16037                let mut inner_depth = depth.clone();
16038                if inlined {
16039                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16040                    inner_offset = next_offset;
16041                } else {
16042                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16043                    inner_depth.increment()?;
16044                }
16045                let val_ref = self.table_member.get_or_insert_with(|| {
16046                    fidl::new_empty!(ThisIsATable, fidl::encoding::DefaultFuchsiaResourceDialect)
16047                });
16048                fidl::decode!(
16049                    ThisIsATable,
16050                    fidl::encoding::DefaultFuchsiaResourceDialect,
16051                    val_ref,
16052                    decoder,
16053                    inner_offset,
16054                    inner_depth
16055                )?;
16056                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16057                {
16058                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16059                }
16060                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16061                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16062                }
16063            }
16064
16065            next_offset += envelope_size;
16066            _next_ordinal_to_read += 1;
16067            if next_offset >= end_offset {
16068                return Ok(());
16069            }
16070
16071            // Decode unknown envelopes for gaps in ordinals.
16072            while _next_ordinal_to_read < 21 {
16073                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16074                _next_ordinal_to_read += 1;
16075                next_offset += envelope_size;
16076            }
16077
16078            let next_out_of_line = decoder.next_out_of_line();
16079            let handles_before = decoder.remaining_handles();
16080            if let Some((inlined, num_bytes, num_handles)) =
16081                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16082            {
16083                let member_inline_size =
16084                    <ThisIsAXunion as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16085                if inlined != (member_inline_size <= 4) {
16086                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16087                }
16088                let inner_offset;
16089                let mut inner_depth = depth.clone();
16090                if inlined {
16091                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16092                    inner_offset = next_offset;
16093                } else {
16094                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16095                    inner_depth.increment()?;
16096                }
16097                let val_ref = self.xunion_member.get_or_insert_with(|| {
16098                    fidl::new_empty!(ThisIsAXunion, fidl::encoding::DefaultFuchsiaResourceDialect)
16099                });
16100                fidl::decode!(
16101                    ThisIsAXunion,
16102                    fidl::encoding::DefaultFuchsiaResourceDialect,
16103                    val_ref,
16104                    decoder,
16105                    inner_offset,
16106                    inner_depth
16107                )?;
16108                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16109                {
16110                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16111                }
16112                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16113                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16114                }
16115            }
16116
16117            next_offset += envelope_size;
16118
16119            // Decode the remaining unknown envelopes.
16120            while next_offset < end_offset {
16121                _next_ordinal_to_read += 1;
16122                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16123                next_offset += envelope_size;
16124            }
16125
16126            Ok(())
16127        }
16128    }
16129
16130    impl fidl::encoding::ResourceTypeMarker for AllTypesXunion {
16131        type Borrowed<'a> = &'a mut Self;
16132        fn take_or_borrow<'a>(
16133            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
16134        ) -> Self::Borrowed<'a> {
16135            value
16136        }
16137    }
16138
16139    unsafe impl fidl::encoding::TypeMarker for AllTypesXunion {
16140        type Owned = Self;
16141
16142        #[inline(always)]
16143        fn inline_align(_context: fidl::encoding::Context) -> usize {
16144            8
16145        }
16146
16147        #[inline(always)]
16148        fn inline_size(_context: fidl::encoding::Context) -> usize {
16149            16
16150        }
16151    }
16152
16153    unsafe impl
16154        fidl::encoding::Encode<AllTypesXunion, fidl::encoding::DefaultFuchsiaResourceDialect>
16155        for &mut AllTypesXunion
16156    {
16157        #[inline]
16158        unsafe fn encode(
16159            self,
16160            encoder: &mut fidl::encoding::Encoder<
16161                '_,
16162                fidl::encoding::DefaultFuchsiaResourceDialect,
16163            >,
16164            offset: usize,
16165            _depth: fidl::encoding::Depth,
16166        ) -> fidl::Result<()> {
16167            encoder.debug_check_bounds::<AllTypesXunion>(offset);
16168            encoder.write_num::<u64>(self.ordinal(), offset);
16169            match self {
16170            AllTypesXunion::BoolMember(ref val) => {
16171                fidl::encoding::encode_in_envelope::<bool, fidl::encoding::DefaultFuchsiaResourceDialect>(
16172                    <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
16173                    encoder, offset + 8, _depth
16174                )
16175            }
16176            AllTypesXunion::Int8Member(ref val) => {
16177                fidl::encoding::encode_in_envelope::<i8, fidl::encoding::DefaultFuchsiaResourceDialect>(
16178                    <i8 as fidl::encoding::ValueTypeMarker>::borrow(val),
16179                    encoder, offset + 8, _depth
16180                )
16181            }
16182            AllTypesXunion::Int16Member(ref val) => {
16183                fidl::encoding::encode_in_envelope::<i16, fidl::encoding::DefaultFuchsiaResourceDialect>(
16184                    <i16 as fidl::encoding::ValueTypeMarker>::borrow(val),
16185                    encoder, offset + 8, _depth
16186                )
16187            }
16188            AllTypesXunion::Int32Member(ref val) => {
16189                fidl::encoding::encode_in_envelope::<i32, fidl::encoding::DefaultFuchsiaResourceDialect>(
16190                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(val),
16191                    encoder, offset + 8, _depth
16192                )
16193            }
16194            AllTypesXunion::Int64Member(ref val) => {
16195                fidl::encoding::encode_in_envelope::<i64, fidl::encoding::DefaultFuchsiaResourceDialect>(
16196                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(val),
16197                    encoder, offset + 8, _depth
16198                )
16199            }
16200            AllTypesXunion::Uint8Member(ref val) => {
16201                fidl::encoding::encode_in_envelope::<u8, fidl::encoding::DefaultFuchsiaResourceDialect>(
16202                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(val),
16203                    encoder, offset + 8, _depth
16204                )
16205            }
16206            AllTypesXunion::Uint16Member(ref val) => {
16207                fidl::encoding::encode_in_envelope::<u16, fidl::encoding::DefaultFuchsiaResourceDialect>(
16208                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(val),
16209                    encoder, offset + 8, _depth
16210                )
16211            }
16212            AllTypesXunion::Uint32Member(ref val) => {
16213                fidl::encoding::encode_in_envelope::<u32, fidl::encoding::DefaultFuchsiaResourceDialect>(
16214                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
16215                    encoder, offset + 8, _depth
16216                )
16217            }
16218            AllTypesXunion::Uint64Member(ref val) => {
16219                fidl::encoding::encode_in_envelope::<u64, fidl::encoding::DefaultFuchsiaResourceDialect>(
16220                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(val),
16221                    encoder, offset + 8, _depth
16222                )
16223            }
16224            AllTypesXunion::Float32Member(ref val) => {
16225                fidl::encoding::encode_in_envelope::<f32, fidl::encoding::DefaultFuchsiaResourceDialect>(
16226                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(val),
16227                    encoder, offset + 8, _depth
16228                )
16229            }
16230            AllTypesXunion::Float64Member(ref val) => {
16231                fidl::encoding::encode_in_envelope::<f64, fidl::encoding::DefaultFuchsiaResourceDialect>(
16232                    <f64 as fidl::encoding::ValueTypeMarker>::borrow(val),
16233                    encoder, offset + 8, _depth
16234                )
16235            }
16236            AllTypesXunion::EnumMember(ref val) => {
16237                fidl::encoding::encode_in_envelope::<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>(
16238                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(val),
16239                    encoder, offset + 8, _depth
16240                )
16241            }
16242            AllTypesXunion::BitsMember(ref val) => {
16243                fidl::encoding::encode_in_envelope::<DefaultBits, fidl::encoding::DefaultFuchsiaResourceDialect>(
16244                    <DefaultBits as fidl::encoding::ValueTypeMarker>::borrow(val),
16245                    encoder, offset + 8, _depth
16246                )
16247            }
16248            AllTypesXunion::HandleMember(ref mut val) => {
16249                fidl::encoding::encode_in_envelope::<fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect>(
16250                    <fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
16251                    encoder, offset + 8, _depth
16252                )
16253            }
16254            AllTypesXunion::StringMember(ref val) => {
16255                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedString, fidl::encoding::DefaultFuchsiaResourceDialect>(
16256                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(val),
16257                    encoder, offset + 8, _depth
16258                )
16259            }
16260            AllTypesXunion::StructMember(ref val) => {
16261                fidl::encoding::encode_in_envelope::<ThisIsAStruct, fidl::encoding::DefaultFuchsiaResourceDialect>(
16262                    <ThisIsAStruct as fidl::encoding::ValueTypeMarker>::borrow(val),
16263                    encoder, offset + 8, _depth
16264                )
16265            }
16266            AllTypesXunion::UnionMember(ref val) => {
16267                fidl::encoding::encode_in_envelope::<ThisIsAUnion, fidl::encoding::DefaultFuchsiaResourceDialect>(
16268                    <ThisIsAUnion as fidl::encoding::ValueTypeMarker>::borrow(val),
16269                    encoder, offset + 8, _depth
16270                )
16271            }
16272            AllTypesXunion::ArrayMember(ref val) => {
16273                fidl::encoding::encode_in_envelope::<fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect>(
16274                    <fidl::encoding::Array<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow(val),
16275                    encoder, offset + 8, _depth
16276                )
16277            }
16278            AllTypesXunion::VectorMember(ref val) => {
16279                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<u32>, fidl::encoding::DefaultFuchsiaResourceDialect>(
16280                    <fidl::encoding::UnboundedVector<u32> as fidl::encoding::ValueTypeMarker>::borrow(val),
16281                    encoder, offset + 8, _depth
16282                )
16283            }
16284            AllTypesXunion::TableMember(ref val) => {
16285                fidl::encoding::encode_in_envelope::<ThisIsATable, fidl::encoding::DefaultFuchsiaResourceDialect>(
16286                    <ThisIsATable as fidl::encoding::ValueTypeMarker>::borrow(val),
16287                    encoder, offset + 8, _depth
16288                )
16289            }
16290            AllTypesXunion::XunionMember(ref val) => {
16291                fidl::encoding::encode_in_envelope::<ThisIsAXunion, fidl::encoding::DefaultFuchsiaResourceDialect>(
16292                    <ThisIsAXunion as fidl::encoding::ValueTypeMarker>::borrow(val),
16293                    encoder, offset + 8, _depth
16294                )
16295            }
16296            AllTypesXunion::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
16297        }
16298        }
16299    }
16300
16301    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
16302        for AllTypesXunion
16303    {
16304        #[inline(always)]
16305        fn new_empty() -> Self {
16306            Self::__SourceBreaking { unknown_ordinal: 0 }
16307        }
16308
16309        #[inline]
16310        unsafe fn decode(
16311            &mut self,
16312            decoder: &mut fidl::encoding::Decoder<
16313                '_,
16314                fidl::encoding::DefaultFuchsiaResourceDialect,
16315            >,
16316            offset: usize,
16317            mut depth: fidl::encoding::Depth,
16318        ) -> fidl::Result<()> {
16319            decoder.debug_check_bounds::<Self>(offset);
16320            #[allow(unused_variables)]
16321            let next_out_of_line = decoder.next_out_of_line();
16322            let handles_before = decoder.remaining_handles();
16323            let (ordinal, inlined, num_bytes, num_handles) =
16324                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
16325
16326            let member_inline_size = match ordinal {
16327            1 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16328            2 => <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16329            3 => <i16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16330            4 => <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16331            5 => <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16332            6 => <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16333            7 => <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16334            8 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16335            9 => <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16336            10 => <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16337            11 => <f64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16338            12 => <DefaultEnum as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16339            13 => <DefaultBits as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16340            14 => <fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16341            15 => <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16342            16 => <ThisIsAStruct as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16343            17 => <ThisIsAUnion as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16344            18 => <fidl::encoding::Array<u32, 3> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16345            19 => <fidl::encoding::UnboundedVector<u32> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16346            20 => <ThisIsATable as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16347            21 => <ThisIsAXunion as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16348            0 => return Err(fidl::Error::UnknownUnionTag),
16349            _ => num_bytes as usize,
16350        };
16351
16352            if inlined != (member_inline_size <= 4) {
16353                return Err(fidl::Error::InvalidInlineBitInEnvelope);
16354            }
16355            let _inner_offset;
16356            if inlined {
16357                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
16358                _inner_offset = offset + 8;
16359            } else {
16360                depth.increment()?;
16361                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16362            }
16363            match ordinal {
16364                1 => {
16365                    #[allow(irrefutable_let_patterns)]
16366                    if let AllTypesXunion::BoolMember(_) = self {
16367                        // Do nothing, read the value into the object
16368                    } else {
16369                        // Initialize `self` to the right variant
16370                        *self = AllTypesXunion::BoolMember(fidl::new_empty!(
16371                            bool,
16372                            fidl::encoding::DefaultFuchsiaResourceDialect
16373                        ));
16374                    }
16375                    #[allow(irrefutable_let_patterns)]
16376                    if let AllTypesXunion::BoolMember(ref mut val) = self {
16377                        fidl::decode!(
16378                            bool,
16379                            fidl::encoding::DefaultFuchsiaResourceDialect,
16380                            val,
16381                            decoder,
16382                            _inner_offset,
16383                            depth
16384                        )?;
16385                    } else {
16386                        unreachable!()
16387                    }
16388                }
16389                2 => {
16390                    #[allow(irrefutable_let_patterns)]
16391                    if let AllTypesXunion::Int8Member(_) = self {
16392                        // Do nothing, read the value into the object
16393                    } else {
16394                        // Initialize `self` to the right variant
16395                        *self = AllTypesXunion::Int8Member(fidl::new_empty!(
16396                            i8,
16397                            fidl::encoding::DefaultFuchsiaResourceDialect
16398                        ));
16399                    }
16400                    #[allow(irrefutable_let_patterns)]
16401                    if let AllTypesXunion::Int8Member(ref mut val) = self {
16402                        fidl::decode!(
16403                            i8,
16404                            fidl::encoding::DefaultFuchsiaResourceDialect,
16405                            val,
16406                            decoder,
16407                            _inner_offset,
16408                            depth
16409                        )?;
16410                    } else {
16411                        unreachable!()
16412                    }
16413                }
16414                3 => {
16415                    #[allow(irrefutable_let_patterns)]
16416                    if let AllTypesXunion::Int16Member(_) = self {
16417                        // Do nothing, read the value into the object
16418                    } else {
16419                        // Initialize `self` to the right variant
16420                        *self = AllTypesXunion::Int16Member(fidl::new_empty!(
16421                            i16,
16422                            fidl::encoding::DefaultFuchsiaResourceDialect
16423                        ));
16424                    }
16425                    #[allow(irrefutable_let_patterns)]
16426                    if let AllTypesXunion::Int16Member(ref mut val) = self {
16427                        fidl::decode!(
16428                            i16,
16429                            fidl::encoding::DefaultFuchsiaResourceDialect,
16430                            val,
16431                            decoder,
16432                            _inner_offset,
16433                            depth
16434                        )?;
16435                    } else {
16436                        unreachable!()
16437                    }
16438                }
16439                4 => {
16440                    #[allow(irrefutable_let_patterns)]
16441                    if let AllTypesXunion::Int32Member(_) = self {
16442                        // Do nothing, read the value into the object
16443                    } else {
16444                        // Initialize `self` to the right variant
16445                        *self = AllTypesXunion::Int32Member(fidl::new_empty!(
16446                            i32,
16447                            fidl::encoding::DefaultFuchsiaResourceDialect
16448                        ));
16449                    }
16450                    #[allow(irrefutable_let_patterns)]
16451                    if let AllTypesXunion::Int32Member(ref mut val) = self {
16452                        fidl::decode!(
16453                            i32,
16454                            fidl::encoding::DefaultFuchsiaResourceDialect,
16455                            val,
16456                            decoder,
16457                            _inner_offset,
16458                            depth
16459                        )?;
16460                    } else {
16461                        unreachable!()
16462                    }
16463                }
16464                5 => {
16465                    #[allow(irrefutable_let_patterns)]
16466                    if let AllTypesXunion::Int64Member(_) = self {
16467                        // Do nothing, read the value into the object
16468                    } else {
16469                        // Initialize `self` to the right variant
16470                        *self = AllTypesXunion::Int64Member(fidl::new_empty!(
16471                            i64,
16472                            fidl::encoding::DefaultFuchsiaResourceDialect
16473                        ));
16474                    }
16475                    #[allow(irrefutable_let_patterns)]
16476                    if let AllTypesXunion::Int64Member(ref mut val) = self {
16477                        fidl::decode!(
16478                            i64,
16479                            fidl::encoding::DefaultFuchsiaResourceDialect,
16480                            val,
16481                            decoder,
16482                            _inner_offset,
16483                            depth
16484                        )?;
16485                    } else {
16486                        unreachable!()
16487                    }
16488                }
16489                6 => {
16490                    #[allow(irrefutable_let_patterns)]
16491                    if let AllTypesXunion::Uint8Member(_) = self {
16492                        // Do nothing, read the value into the object
16493                    } else {
16494                        // Initialize `self` to the right variant
16495                        *self = AllTypesXunion::Uint8Member(fidl::new_empty!(
16496                            u8,
16497                            fidl::encoding::DefaultFuchsiaResourceDialect
16498                        ));
16499                    }
16500                    #[allow(irrefutable_let_patterns)]
16501                    if let AllTypesXunion::Uint8Member(ref mut val) = self {
16502                        fidl::decode!(
16503                            u8,
16504                            fidl::encoding::DefaultFuchsiaResourceDialect,
16505                            val,
16506                            decoder,
16507                            _inner_offset,
16508                            depth
16509                        )?;
16510                    } else {
16511                        unreachable!()
16512                    }
16513                }
16514                7 => {
16515                    #[allow(irrefutable_let_patterns)]
16516                    if let AllTypesXunion::Uint16Member(_) = self {
16517                        // Do nothing, read the value into the object
16518                    } else {
16519                        // Initialize `self` to the right variant
16520                        *self = AllTypesXunion::Uint16Member(fidl::new_empty!(
16521                            u16,
16522                            fidl::encoding::DefaultFuchsiaResourceDialect
16523                        ));
16524                    }
16525                    #[allow(irrefutable_let_patterns)]
16526                    if let AllTypesXunion::Uint16Member(ref mut val) = self {
16527                        fidl::decode!(
16528                            u16,
16529                            fidl::encoding::DefaultFuchsiaResourceDialect,
16530                            val,
16531                            decoder,
16532                            _inner_offset,
16533                            depth
16534                        )?;
16535                    } else {
16536                        unreachable!()
16537                    }
16538                }
16539                8 => {
16540                    #[allow(irrefutable_let_patterns)]
16541                    if let AllTypesXunion::Uint32Member(_) = self {
16542                        // Do nothing, read the value into the object
16543                    } else {
16544                        // Initialize `self` to the right variant
16545                        *self = AllTypesXunion::Uint32Member(fidl::new_empty!(
16546                            u32,
16547                            fidl::encoding::DefaultFuchsiaResourceDialect
16548                        ));
16549                    }
16550                    #[allow(irrefutable_let_patterns)]
16551                    if let AllTypesXunion::Uint32Member(ref mut val) = self {
16552                        fidl::decode!(
16553                            u32,
16554                            fidl::encoding::DefaultFuchsiaResourceDialect,
16555                            val,
16556                            decoder,
16557                            _inner_offset,
16558                            depth
16559                        )?;
16560                    } else {
16561                        unreachable!()
16562                    }
16563                }
16564                9 => {
16565                    #[allow(irrefutable_let_patterns)]
16566                    if let AllTypesXunion::Uint64Member(_) = self {
16567                        // Do nothing, read the value into the object
16568                    } else {
16569                        // Initialize `self` to the right variant
16570                        *self = AllTypesXunion::Uint64Member(fidl::new_empty!(
16571                            u64,
16572                            fidl::encoding::DefaultFuchsiaResourceDialect
16573                        ));
16574                    }
16575                    #[allow(irrefutable_let_patterns)]
16576                    if let AllTypesXunion::Uint64Member(ref mut val) = self {
16577                        fidl::decode!(
16578                            u64,
16579                            fidl::encoding::DefaultFuchsiaResourceDialect,
16580                            val,
16581                            decoder,
16582                            _inner_offset,
16583                            depth
16584                        )?;
16585                    } else {
16586                        unreachable!()
16587                    }
16588                }
16589                10 => {
16590                    #[allow(irrefutable_let_patterns)]
16591                    if let AllTypesXunion::Float32Member(_) = self {
16592                        // Do nothing, read the value into the object
16593                    } else {
16594                        // Initialize `self` to the right variant
16595                        *self = AllTypesXunion::Float32Member(fidl::new_empty!(
16596                            f32,
16597                            fidl::encoding::DefaultFuchsiaResourceDialect
16598                        ));
16599                    }
16600                    #[allow(irrefutable_let_patterns)]
16601                    if let AllTypesXunion::Float32Member(ref mut val) = self {
16602                        fidl::decode!(
16603                            f32,
16604                            fidl::encoding::DefaultFuchsiaResourceDialect,
16605                            val,
16606                            decoder,
16607                            _inner_offset,
16608                            depth
16609                        )?;
16610                    } else {
16611                        unreachable!()
16612                    }
16613                }
16614                11 => {
16615                    #[allow(irrefutable_let_patterns)]
16616                    if let AllTypesXunion::Float64Member(_) = self {
16617                        // Do nothing, read the value into the object
16618                    } else {
16619                        // Initialize `self` to the right variant
16620                        *self = AllTypesXunion::Float64Member(fidl::new_empty!(
16621                            f64,
16622                            fidl::encoding::DefaultFuchsiaResourceDialect
16623                        ));
16624                    }
16625                    #[allow(irrefutable_let_patterns)]
16626                    if let AllTypesXunion::Float64Member(ref mut val) = self {
16627                        fidl::decode!(
16628                            f64,
16629                            fidl::encoding::DefaultFuchsiaResourceDialect,
16630                            val,
16631                            decoder,
16632                            _inner_offset,
16633                            depth
16634                        )?;
16635                    } else {
16636                        unreachable!()
16637                    }
16638                }
16639                12 => {
16640                    #[allow(irrefutable_let_patterns)]
16641                    if let AllTypesXunion::EnumMember(_) = self {
16642                        // Do nothing, read the value into the object
16643                    } else {
16644                        // Initialize `self` to the right variant
16645                        *self = AllTypesXunion::EnumMember(fidl::new_empty!(
16646                            DefaultEnum,
16647                            fidl::encoding::DefaultFuchsiaResourceDialect
16648                        ));
16649                    }
16650                    #[allow(irrefutable_let_patterns)]
16651                    if let AllTypesXunion::EnumMember(ref mut val) = self {
16652                        fidl::decode!(
16653                            DefaultEnum,
16654                            fidl::encoding::DefaultFuchsiaResourceDialect,
16655                            val,
16656                            decoder,
16657                            _inner_offset,
16658                            depth
16659                        )?;
16660                    } else {
16661                        unreachable!()
16662                    }
16663                }
16664                13 => {
16665                    #[allow(irrefutable_let_patterns)]
16666                    if let AllTypesXunion::BitsMember(_) = self {
16667                        // Do nothing, read the value into the object
16668                    } else {
16669                        // Initialize `self` to the right variant
16670                        *self = AllTypesXunion::BitsMember(fidl::new_empty!(
16671                            DefaultBits,
16672                            fidl::encoding::DefaultFuchsiaResourceDialect
16673                        ));
16674                    }
16675                    #[allow(irrefutable_let_patterns)]
16676                    if let AllTypesXunion::BitsMember(ref mut val) = self {
16677                        fidl::decode!(
16678                            DefaultBits,
16679                            fidl::encoding::DefaultFuchsiaResourceDialect,
16680                            val,
16681                            decoder,
16682                            _inner_offset,
16683                            depth
16684                        )?;
16685                    } else {
16686                        unreachable!()
16687                    }
16688                }
16689                14 => {
16690                    #[allow(irrefutable_let_patterns)]
16691                    if let AllTypesXunion::HandleMember(_) = self {
16692                        // Do nothing, read the value into the object
16693                    } else {
16694                        // Initialize `self` to the right variant
16695                        *self = AllTypesXunion::HandleMember(
16696                            fidl::new_empty!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
16697                        );
16698                    }
16699                    #[allow(irrefutable_let_patterns)]
16700                    if let AllTypesXunion::HandleMember(ref mut val) = self {
16701                        fidl::decode!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val, decoder, _inner_offset, depth)?;
16702                    } else {
16703                        unreachable!()
16704                    }
16705                }
16706                15 => {
16707                    #[allow(irrefutable_let_patterns)]
16708                    if let AllTypesXunion::StringMember(_) = self {
16709                        // Do nothing, read the value into the object
16710                    } else {
16711                        // Initialize `self` to the right variant
16712                        *self = AllTypesXunion::StringMember(fidl::new_empty!(
16713                            fidl::encoding::UnboundedString,
16714                            fidl::encoding::DefaultFuchsiaResourceDialect
16715                        ));
16716                    }
16717                    #[allow(irrefutable_let_patterns)]
16718                    if let AllTypesXunion::StringMember(ref mut val) = self {
16719                        fidl::decode!(
16720                            fidl::encoding::UnboundedString,
16721                            fidl::encoding::DefaultFuchsiaResourceDialect,
16722                            val,
16723                            decoder,
16724                            _inner_offset,
16725                            depth
16726                        )?;
16727                    } else {
16728                        unreachable!()
16729                    }
16730                }
16731                16 => {
16732                    #[allow(irrefutable_let_patterns)]
16733                    if let AllTypesXunion::StructMember(_) = self {
16734                        // Do nothing, read the value into the object
16735                    } else {
16736                        // Initialize `self` to the right variant
16737                        *self = AllTypesXunion::StructMember(fidl::new_empty!(
16738                            ThisIsAStruct,
16739                            fidl::encoding::DefaultFuchsiaResourceDialect
16740                        ));
16741                    }
16742                    #[allow(irrefutable_let_patterns)]
16743                    if let AllTypesXunion::StructMember(ref mut val) = self {
16744                        fidl::decode!(
16745                            ThisIsAStruct,
16746                            fidl::encoding::DefaultFuchsiaResourceDialect,
16747                            val,
16748                            decoder,
16749                            _inner_offset,
16750                            depth
16751                        )?;
16752                    } else {
16753                        unreachable!()
16754                    }
16755                }
16756                17 => {
16757                    #[allow(irrefutable_let_patterns)]
16758                    if let AllTypesXunion::UnionMember(_) = self {
16759                        // Do nothing, read the value into the object
16760                    } else {
16761                        // Initialize `self` to the right variant
16762                        *self = AllTypesXunion::UnionMember(fidl::new_empty!(
16763                            ThisIsAUnion,
16764                            fidl::encoding::DefaultFuchsiaResourceDialect
16765                        ));
16766                    }
16767                    #[allow(irrefutable_let_patterns)]
16768                    if let AllTypesXunion::UnionMember(ref mut val) = self {
16769                        fidl::decode!(
16770                            ThisIsAUnion,
16771                            fidl::encoding::DefaultFuchsiaResourceDialect,
16772                            val,
16773                            decoder,
16774                            _inner_offset,
16775                            depth
16776                        )?;
16777                    } else {
16778                        unreachable!()
16779                    }
16780                }
16781                18 => {
16782                    #[allow(irrefutable_let_patterns)]
16783                    if let AllTypesXunion::ArrayMember(_) = self {
16784                        // Do nothing, read the value into the object
16785                    } else {
16786                        // Initialize `self` to the right variant
16787                        *self = AllTypesXunion::ArrayMember(
16788                            fidl::new_empty!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
16789                        );
16790                    }
16791                    #[allow(irrefutable_let_patterns)]
16792                    if let AllTypesXunion::ArrayMember(ref mut val) = self {
16793                        fidl::decode!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, val, decoder, _inner_offset, depth)?;
16794                    } else {
16795                        unreachable!()
16796                    }
16797                }
16798                19 => {
16799                    #[allow(irrefutable_let_patterns)]
16800                    if let AllTypesXunion::VectorMember(_) = self {
16801                        // Do nothing, read the value into the object
16802                    } else {
16803                        // Initialize `self` to the right variant
16804                        *self = AllTypesXunion::VectorMember(fidl::new_empty!(
16805                            fidl::encoding::UnboundedVector<u32>,
16806                            fidl::encoding::DefaultFuchsiaResourceDialect
16807                        ));
16808                    }
16809                    #[allow(irrefutable_let_patterns)]
16810                    if let AllTypesXunion::VectorMember(ref mut val) = self {
16811                        fidl::decode!(
16812                            fidl::encoding::UnboundedVector<u32>,
16813                            fidl::encoding::DefaultFuchsiaResourceDialect,
16814                            val,
16815                            decoder,
16816                            _inner_offset,
16817                            depth
16818                        )?;
16819                    } else {
16820                        unreachable!()
16821                    }
16822                }
16823                20 => {
16824                    #[allow(irrefutable_let_patterns)]
16825                    if let AllTypesXunion::TableMember(_) = self {
16826                        // Do nothing, read the value into the object
16827                    } else {
16828                        // Initialize `self` to the right variant
16829                        *self = AllTypesXunion::TableMember(fidl::new_empty!(
16830                            ThisIsATable,
16831                            fidl::encoding::DefaultFuchsiaResourceDialect
16832                        ));
16833                    }
16834                    #[allow(irrefutable_let_patterns)]
16835                    if let AllTypesXunion::TableMember(ref mut val) = self {
16836                        fidl::decode!(
16837                            ThisIsATable,
16838                            fidl::encoding::DefaultFuchsiaResourceDialect,
16839                            val,
16840                            decoder,
16841                            _inner_offset,
16842                            depth
16843                        )?;
16844                    } else {
16845                        unreachable!()
16846                    }
16847                }
16848                21 => {
16849                    #[allow(irrefutable_let_patterns)]
16850                    if let AllTypesXunion::XunionMember(_) = self {
16851                        // Do nothing, read the value into the object
16852                    } else {
16853                        // Initialize `self` to the right variant
16854                        *self = AllTypesXunion::XunionMember(fidl::new_empty!(
16855                            ThisIsAXunion,
16856                            fidl::encoding::DefaultFuchsiaResourceDialect
16857                        ));
16858                    }
16859                    #[allow(irrefutable_let_patterns)]
16860                    if let AllTypesXunion::XunionMember(ref mut val) = self {
16861                        fidl::decode!(
16862                            ThisIsAXunion,
16863                            fidl::encoding::DefaultFuchsiaResourceDialect,
16864                            val,
16865                            decoder,
16866                            _inner_offset,
16867                            depth
16868                        )?;
16869                    } else {
16870                        unreachable!()
16871                    }
16872                }
16873                #[allow(deprecated)]
16874                ordinal => {
16875                    for _ in 0..num_handles {
16876                        decoder.drop_next_handle()?;
16877                    }
16878                    *self = AllTypesXunion::__SourceBreaking { unknown_ordinal: ordinal };
16879                }
16880            }
16881            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
16882                return Err(fidl::Error::InvalidNumBytesInEnvelope);
16883            }
16884            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16885                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16886            }
16887            Ok(())
16888        }
16889    }
16890}
fidl_fidl_test_compatibility/fidl_fidl_test_compatibility.rs

fidl_fidl_test_compatibility/
fidl_fidl_test_compatibility.rs
