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        let protocol_name = <ConfigMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
711        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
712    }
713
714    pub fn into_channel(self) -> fidl::Channel {
715        self.client.into_channel()
716    }
717
718    /// Waits until an event arrives and returns it. It is safe for other
719    /// threads to make concurrent requests while waiting for an event.
720    pub fn wait_for_event(
721        &self,
722        deadline: zx::MonotonicInstant,
723    ) -> Result<ConfigEvent, fidl::Error> {
724        ConfigEvent::decode(self.client.wait_for_event(deadline)?)
725    }
726
727    pub fn r#get_impls(
728        &self,
729        ___deadline: zx::MonotonicInstant,
730    ) -> Result<Vec<String>, fidl::Error> {
731        let _response =
732            self.client.send_query::<fidl::encoding::EmptyPayload, ConfigGetImplsResponse>(
733                (),
734                0x3b360c86a6dbdfe0,
735                fidl::encoding::DynamicFlags::empty(),
736                ___deadline,
737            )?;
738        Ok(_response.impls)
739    }
740}
741
742#[cfg(target_os = "fuchsia")]
743impl From<ConfigSynchronousProxy> for zx::NullableHandle {
744    fn from(value: ConfigSynchronousProxy) -> Self {
745        value.into_channel().into()
746    }
747}
748
749#[cfg(target_os = "fuchsia")]
750impl From<fidl::Channel> for ConfigSynchronousProxy {
751    fn from(value: fidl::Channel) -> Self {
752        Self::new(value)
753    }
754}
755
756#[cfg(target_os = "fuchsia")]
757impl fidl::endpoints::FromClient for ConfigSynchronousProxy {
758    type Protocol = ConfigMarker;
759
760    fn from_client(value: fidl::endpoints::ClientEnd<ConfigMarker>) -> Self {
761        Self::new(value.into_channel())
762    }
763}
764
765#[derive(Debug, Clone)]
766pub struct ConfigProxy {
767    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
768}
769
770impl fidl::endpoints::Proxy for ConfigProxy {
771    type Protocol = ConfigMarker;
772
773    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
774        Self::new(inner)
775    }
776
777    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
778        self.client.into_channel().map_err(|client| Self { client })
779    }
780
781    fn as_channel(&self) -> &::fidl::AsyncChannel {
782        self.client.as_channel()
783    }
784}
785
786impl ConfigProxy {
787    /// Create a new Proxy for fidl.test.compatibility/Config.
788    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
789        let protocol_name = <ConfigMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
790        Self { client: fidl::client::Client::new(channel, protocol_name) }
791    }
792
793    /// Get a Stream of events from the remote end of the protocol.
794    ///
795    /// # Panics
796    ///
797    /// Panics if the event stream was already taken.
798    pub fn take_event_stream(&self) -> ConfigEventStream {
799        ConfigEventStream { event_receiver: self.client.take_event_receiver() }
800    }
801
802    pub fn r#get_impls(
803        &self,
804    ) -> fidl::client::QueryResponseFut<Vec<String>, fidl::encoding::DefaultFuchsiaResourceDialect>
805    {
806        ConfigProxyInterface::r#get_impls(self)
807    }
808}
809
810impl ConfigProxyInterface for ConfigProxy {
811    type GetImplsResponseFut =
812        fidl::client::QueryResponseFut<Vec<String>, fidl::encoding::DefaultFuchsiaResourceDialect>;
813    fn r#get_impls(&self) -> Self::GetImplsResponseFut {
814        fn _decode(
815            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
816        ) -> Result<Vec<String>, fidl::Error> {
817            let _response = fidl::client::decode_transaction_body::<
818                ConfigGetImplsResponse,
819                fidl::encoding::DefaultFuchsiaResourceDialect,
820                0x3b360c86a6dbdfe0,
821            >(_buf?)?;
822            Ok(_response.impls)
823        }
824        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<String>>(
825            (),
826            0x3b360c86a6dbdfe0,
827            fidl::encoding::DynamicFlags::empty(),
828            _decode,
829        )
830    }
831}
832
833pub struct ConfigEventStream {
834    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
835}
836
837impl std::marker::Unpin for ConfigEventStream {}
838
839impl futures::stream::FusedStream for ConfigEventStream {
840    fn is_terminated(&self) -> bool {
841        self.event_receiver.is_terminated()
842    }
843}
844
845impl futures::Stream for ConfigEventStream {
846    type Item = Result<ConfigEvent, fidl::Error>;
847
848    fn poll_next(
849        mut self: std::pin::Pin<&mut Self>,
850        cx: &mut std::task::Context<'_>,
851    ) -> std::task::Poll<Option<Self::Item>> {
852        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
853            &mut self.event_receiver,
854            cx
855        )?) {
856            Some(buf) => std::task::Poll::Ready(Some(ConfigEvent::decode(buf))),
857            None => std::task::Poll::Ready(None),
858        }
859    }
860}
861
862#[derive(Debug)]
863pub enum ConfigEvent {}
864
865impl ConfigEvent {
866    /// Decodes a message buffer as a [`ConfigEvent`].
867    fn decode(
868        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
869    ) -> Result<ConfigEvent, fidl::Error> {
870        let (bytes, _handles) = buf.split_mut();
871        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
872        debug_assert_eq!(tx_header.tx_id, 0);
873        match tx_header.ordinal {
874            _ => Err(fidl::Error::UnknownOrdinal {
875                ordinal: tx_header.ordinal,
876                protocol_name: <ConfigMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
877            }),
878        }
879    }
880}
881
882/// A Stream of incoming requests for fidl.test.compatibility/Config.
883pub struct ConfigRequestStream {
884    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
885    is_terminated: bool,
886}
887
888impl std::marker::Unpin for ConfigRequestStream {}
889
890impl futures::stream::FusedStream for ConfigRequestStream {
891    fn is_terminated(&self) -> bool {
892        self.is_terminated
893    }
894}
895
896impl fidl::endpoints::RequestStream for ConfigRequestStream {
897    type Protocol = ConfigMarker;
898    type ControlHandle = ConfigControlHandle;
899
900    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
901        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
902    }
903
904    fn control_handle(&self) -> Self::ControlHandle {
905        ConfigControlHandle { inner: self.inner.clone() }
906    }
907
908    fn into_inner(
909        self,
910    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
911    {
912        (self.inner, self.is_terminated)
913    }
914
915    fn from_inner(
916        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
917        is_terminated: bool,
918    ) -> Self {
919        Self { inner, is_terminated }
920    }
921}
922
923impl futures::Stream for ConfigRequestStream {
924    type Item = Result<ConfigRequest, fidl::Error>;
925
926    fn poll_next(
927        mut self: std::pin::Pin<&mut Self>,
928        cx: &mut std::task::Context<'_>,
929    ) -> std::task::Poll<Option<Self::Item>> {
930        let this = &mut *self;
931        if this.inner.check_shutdown(cx) {
932            this.is_terminated = true;
933            return std::task::Poll::Ready(None);
934        }
935        if this.is_terminated {
936            panic!("polled ConfigRequestStream after completion");
937        }
938        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
939            |bytes, handles| {
940                match this.inner.channel().read_etc(cx, bytes, handles) {
941                    std::task::Poll::Ready(Ok(())) => {}
942                    std::task::Poll::Pending => return std::task::Poll::Pending,
943                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
944                        this.is_terminated = true;
945                        return std::task::Poll::Ready(None);
946                    }
947                    std::task::Poll::Ready(Err(e)) => {
948                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
949                            e.into(),
950                        ))));
951                    }
952                }
953
954                // A message has been received from the channel
955                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
956
957                std::task::Poll::Ready(Some(match header.ordinal {
958                    0x3b360c86a6dbdfe0 => {
959                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
960                        let mut req = fidl::new_empty!(
961                            fidl::encoding::EmptyPayload,
962                            fidl::encoding::DefaultFuchsiaResourceDialect
963                        );
964                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
965                        let control_handle = ConfigControlHandle { inner: this.inner.clone() };
966                        Ok(ConfigRequest::GetImpls {
967                            responder: ConfigGetImplsResponder {
968                                control_handle: std::mem::ManuallyDrop::new(control_handle),
969                                tx_id: header.tx_id,
970                            },
971                        })
972                    }
973                    _ => Err(fidl::Error::UnknownOrdinal {
974                        ordinal: header.ordinal,
975                        protocol_name:
976                            <ConfigMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
977                    }),
978                }))
979            },
980        )
981    }
982}
983
984#[derive(Debug)]
985pub enum ConfigRequest {
986    GetImpls { responder: ConfigGetImplsResponder },
987}
988
989impl ConfigRequest {
990    #[allow(irrefutable_let_patterns)]
991    pub fn into_get_impls(self) -> Option<(ConfigGetImplsResponder)> {
992        if let ConfigRequest::GetImpls { responder } = self { Some((responder)) } else { None }
993    }
994
995    /// Name of the method defined in FIDL
996    pub fn method_name(&self) -> &'static str {
997        match *self {
998            ConfigRequest::GetImpls { .. } => "get_impls",
999        }
1000    }
1001}
1002
1003#[derive(Debug, Clone)]
1004pub struct ConfigControlHandle {
1005    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1006}
1007
1008impl fidl::endpoints::ControlHandle for ConfigControlHandle {
1009    fn shutdown(&self) {
1010        self.inner.shutdown()
1011    }
1012
1013    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1014        self.inner.shutdown_with_epitaph(status)
1015    }
1016
1017    fn is_closed(&self) -> bool {
1018        self.inner.channel().is_closed()
1019    }
1020    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1021        self.inner.channel().on_closed()
1022    }
1023
1024    #[cfg(target_os = "fuchsia")]
1025    fn signal_peer(
1026        &self,
1027        clear_mask: zx::Signals,
1028        set_mask: zx::Signals,
1029    ) -> Result<(), zx_status::Status> {
1030        use fidl::Peered;
1031        self.inner.channel().signal_peer(clear_mask, set_mask)
1032    }
1033}
1034
1035impl ConfigControlHandle {}
1036
1037#[must_use = "FIDL methods require a response to be sent"]
1038#[derive(Debug)]
1039pub struct ConfigGetImplsResponder {
1040    control_handle: std::mem::ManuallyDrop<ConfigControlHandle>,
1041    tx_id: u32,
1042}
1043
1044/// Set the the channel to be shutdown (see [`ConfigControlHandle::shutdown`])
1045/// if the responder is dropped without sending a response, so that the client
1046/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1047impl std::ops::Drop for ConfigGetImplsResponder {
1048    fn drop(&mut self) {
1049        self.control_handle.shutdown();
1050        // Safety: drops once, never accessed again
1051        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1052    }
1053}
1054
1055impl fidl::endpoints::Responder for ConfigGetImplsResponder {
1056    type ControlHandle = ConfigControlHandle;
1057
1058    fn control_handle(&self) -> &ConfigControlHandle {
1059        &self.control_handle
1060    }
1061
1062    fn drop_without_shutdown(mut self) {
1063        // Safety: drops once, never accessed again due to mem::forget
1064        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1065        // Prevent Drop from running (which would shut down the channel)
1066        std::mem::forget(self);
1067    }
1068}
1069
1070impl ConfigGetImplsResponder {
1071    /// Sends a response to the FIDL transaction.
1072    ///
1073    /// Sets the channel to shutdown if an error occurs.
1074    pub fn send(self, mut impls: &[String]) -> Result<(), fidl::Error> {
1075        let _result = self.send_raw(impls);
1076        if _result.is_err() {
1077            self.control_handle.shutdown();
1078        }
1079        self.drop_without_shutdown();
1080        _result
1081    }
1082
1083    /// Similar to "send" but does not shutdown the channel if an error occurs.
1084    pub fn send_no_shutdown_on_err(self, mut impls: &[String]) -> Result<(), fidl::Error> {
1085        let _result = self.send_raw(impls);
1086        self.drop_without_shutdown();
1087        _result
1088    }
1089
1090    fn send_raw(&self, mut impls: &[String]) -> Result<(), fidl::Error> {
1091        self.control_handle.inner.send::<ConfigGetImplsResponse>(
1092            (impls,),
1093            self.tx_id,
1094            0x3b360c86a6dbdfe0,
1095            fidl::encoding::DynamicFlags::empty(),
1096        )
1097    }
1098}
1099
1100#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
1101pub struct EchoMarker;
1102
1103impl fidl::endpoints::ProtocolMarker for EchoMarker {
1104    type Proxy = EchoProxy;
1105    type RequestStream = EchoRequestStream;
1106    #[cfg(target_os = "fuchsia")]
1107    type SynchronousProxy = EchoSynchronousProxy;
1108
1109    const DEBUG_NAME: &'static str = "fidl.test.compatibility.Echo";
1110}
1111impl fidl::endpoints::DiscoverableProtocolMarker for EchoMarker {}
1112pub type EchoEchoMinimalWithErrorResult = Result<(), u32>;
1113pub type EchoEchoStructWithErrorResult = Result<Struct, DefaultEnum>;
1114pub type EchoEchoArraysWithErrorResult = Result<ArraysStruct, DefaultEnum>;
1115pub type EchoEchoVectorsWithErrorResult = Result<VectorsStruct, DefaultEnum>;
1116pub type EchoEchoTableWithErrorResult = Result<AllTypesTable, DefaultEnum>;
1117pub type EchoEchoXunionsWithErrorResult = Result<Vec<AllTypesXunion>, DefaultEnum>;
1118pub type EchoEchoNamedStructWithErrorResult = Result<fidl_fidl_test_imported::SimpleStruct, u32>;
1119pub type EchoEchoTablePayloadWithErrorResult = Result<ResponseTable, DefaultEnum>;
1120pub type EchoEchoUnionPayloadWithErrorResult = Result<ResponseUnion, DefaultEnum>;
1121
1122pub trait EchoProxyInterface: Send + Sync {
1123    type EchoTableRequestComposedResponseFut: std::future::Future<Output = Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error>>
1124        + Send;
1125    fn r#echo_table_request_composed(
1126        &self,
1127        payload: &fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
1128    ) -> Self::EchoTableRequestComposedResponseFut;
1129    type EchoUnionResponseWithErrorComposedResponseFut: std::future::Future<
1130            Output = Result<
1131                fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
1132                fidl::Error,
1133            >,
1134        > + Send;
1135    fn r#echo_union_response_with_error_composed(
1136        &self,
1137        value: i64,
1138        want_absolute_value: bool,
1139        forward_to_server: &str,
1140        result_err: u32,
1141        result_variant: fidl_fidl_test_imported::WantResponse,
1142    ) -> Self::EchoUnionResponseWithErrorComposedResponseFut;
1143    type EchoMinimalResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
1144    fn r#echo_minimal(&self, forward_to_server: &str) -> Self::EchoMinimalResponseFut;
1145    type EchoMinimalWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoMinimalWithErrorResult, fidl::Error>>
1146        + Send;
1147    fn r#echo_minimal_with_error(
1148        &self,
1149        forward_to_server: &str,
1150        result_variant: RespondWith,
1151    ) -> Self::EchoMinimalWithErrorResponseFut;
1152    fn r#echo_minimal_no_ret_val(&self, forward_to_server: &str) -> Result<(), fidl::Error>;
1153    type EchoStructResponseFut: std::future::Future<Output = Result<Struct, fidl::Error>> + Send;
1154    fn r#echo_struct(&self, value: Struct, forward_to_server: &str) -> Self::EchoStructResponseFut;
1155    type EchoStructWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoStructWithErrorResult, fidl::Error>>
1156        + Send;
1157    fn r#echo_struct_with_error(
1158        &self,
1159        value: Struct,
1160        result_err: DefaultEnum,
1161        forward_to_server: &str,
1162        result_variant: RespondWith,
1163    ) -> Self::EchoStructWithErrorResponseFut;
1164    fn r#echo_struct_no_ret_val(
1165        &self,
1166        value: Struct,
1167        forward_to_server: &str,
1168    ) -> Result<(), fidl::Error>;
1169    type EchoArraysResponseFut: std::future::Future<Output = Result<ArraysStruct, fidl::Error>>
1170        + Send;
1171    fn r#echo_arrays(
1172        &self,
1173        value: ArraysStruct,
1174        forward_to_server: &str,
1175    ) -> Self::EchoArraysResponseFut;
1176    type EchoArraysWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoArraysWithErrorResult, fidl::Error>>
1177        + Send;
1178    fn r#echo_arrays_with_error(
1179        &self,
1180        value: ArraysStruct,
1181        result_err: DefaultEnum,
1182        forward_to_server: &str,
1183        result_variant: RespondWith,
1184    ) -> Self::EchoArraysWithErrorResponseFut;
1185    type EchoVectorsResponseFut: std::future::Future<Output = Result<VectorsStruct, fidl::Error>>
1186        + Send;
1187    fn r#echo_vectors(
1188        &self,
1189        value: VectorsStruct,
1190        forward_to_server: &str,
1191    ) -> Self::EchoVectorsResponseFut;
1192    type EchoVectorsWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoVectorsWithErrorResult, fidl::Error>>
1193        + Send;
1194    fn r#echo_vectors_with_error(
1195        &self,
1196        value: VectorsStruct,
1197        result_err: DefaultEnum,
1198        forward_to_server: &str,
1199        result_variant: RespondWith,
1200    ) -> Self::EchoVectorsWithErrorResponseFut;
1201    type EchoTableResponseFut: std::future::Future<Output = Result<AllTypesTable, fidl::Error>>
1202        + Send;
1203    fn r#echo_table(
1204        &self,
1205        value: AllTypesTable,
1206        forward_to_server: &str,
1207    ) -> Self::EchoTableResponseFut;
1208    type EchoTableWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoTableWithErrorResult, fidl::Error>>
1209        + Send;
1210    fn r#echo_table_with_error(
1211        &self,
1212        value: AllTypesTable,
1213        result_err: DefaultEnum,
1214        forward_to_server: &str,
1215        result_variant: RespondWith,
1216    ) -> Self::EchoTableWithErrorResponseFut;
1217    type EchoXunionsResponseFut: std::future::Future<Output = Result<Vec<AllTypesXunion>, fidl::Error>>
1218        + Send;
1219    fn r#echo_xunions(
1220        &self,
1221        value: Vec<AllTypesXunion>,
1222        forward_to_server: &str,
1223    ) -> Self::EchoXunionsResponseFut;
1224    type EchoXunionsWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoXunionsWithErrorResult, fidl::Error>>
1225        + Send;
1226    fn r#echo_xunions_with_error(
1227        &self,
1228        value: Vec<AllTypesXunion>,
1229        result_err: DefaultEnum,
1230        forward_to_server: &str,
1231        result_variant: RespondWith,
1232    ) -> Self::EchoXunionsWithErrorResponseFut;
1233    type EchoNamedStructResponseFut: std::future::Future<Output = Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error>>
1234        + Send;
1235    fn r#echo_named_struct(
1236        &self,
1237        value: &fidl_fidl_test_imported::SimpleStruct,
1238        forward_to_server: &str,
1239    ) -> Self::EchoNamedStructResponseFut;
1240    type EchoNamedStructWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoNamedStructWithErrorResult, fidl::Error>>
1241        + Send;
1242    fn r#echo_named_struct_with_error(
1243        &self,
1244        value: &fidl_fidl_test_imported::SimpleStruct,
1245        result_err: u32,
1246        forward_to_server: &str,
1247        result_variant: fidl_fidl_test_imported::WantResponse,
1248    ) -> Self::EchoNamedStructWithErrorResponseFut;
1249    fn r#echo_named_struct_no_ret_val(
1250        &self,
1251        value: &fidl_fidl_test_imported::SimpleStruct,
1252        forward_to_server: &str,
1253    ) -> Result<(), fidl::Error>;
1254    type EchoTablePayloadResponseFut: std::future::Future<Output = Result<ResponseTable, fidl::Error>>
1255        + Send;
1256    fn r#echo_table_payload(&self, payload: &RequestTable) -> Self::EchoTablePayloadResponseFut;
1257    type EchoTablePayloadWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoTablePayloadWithErrorResult, fidl::Error>>
1258        + Send;
1259    fn r#echo_table_payload_with_error(
1260        &self,
1261        payload: &EchoEchoTablePayloadWithErrorRequest,
1262    ) -> Self::EchoTablePayloadWithErrorResponseFut;
1263    fn r#echo_table_payload_no_ret_val(&self, payload: &RequestTable) -> Result<(), fidl::Error>;
1264    type EchoUnionPayloadResponseFut: std::future::Future<Output = Result<ResponseUnion, fidl::Error>>
1265        + Send;
1266    fn r#echo_union_payload(&self, payload: &RequestUnion) -> Self::EchoUnionPayloadResponseFut;
1267    type EchoUnionPayloadWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoUnionPayloadWithErrorResult, fidl::Error>>
1268        + Send;
1269    fn r#echo_union_payload_with_error(
1270        &self,
1271        payload: &EchoEchoUnionPayloadWithErrorRequest,
1272    ) -> Self::EchoUnionPayloadWithErrorResponseFut;
1273    fn r#echo_union_payload_no_ret_val(&self, payload: &RequestUnion) -> Result<(), fidl::Error>;
1274}
1275#[derive(Debug)]
1276#[cfg(target_os = "fuchsia")]
1277pub struct EchoSynchronousProxy {
1278    client: fidl::client::sync::Client,
1279}
1280
1281#[cfg(target_os = "fuchsia")]
1282impl fidl::endpoints::SynchronousProxy for EchoSynchronousProxy {
1283    type Proxy = EchoProxy;
1284    type Protocol = EchoMarker;
1285
1286    fn from_channel(inner: fidl::Channel) -> Self {
1287        Self::new(inner)
1288    }
1289
1290    fn into_channel(self) -> fidl::Channel {
1291        self.client.into_channel()
1292    }
1293
1294    fn as_channel(&self) -> &fidl::Channel {
1295        self.client.as_channel()
1296    }
1297}
1298
1299#[cfg(target_os = "fuchsia")]
1300impl EchoSynchronousProxy {
1301    pub fn new(channel: fidl::Channel) -> Self {
1302        let protocol_name = <EchoMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1303        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
1304    }
1305
1306    pub fn into_channel(self) -> fidl::Channel {
1307        self.client.into_channel()
1308    }
1309
1310    /// Waits until an event arrives and returns it. It is safe for other
1311    /// threads to make concurrent requests while waiting for an event.
1312    pub fn wait_for_event(&self, deadline: zx::MonotonicInstant) -> Result<EchoEvent, fidl::Error> {
1313        EchoEvent::decode(self.client.wait_for_event(deadline)?)
1314    }
1315
1316    pub fn r#echo_table_request_composed(
1317        &self,
1318        mut payload: &fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
1319        ___deadline: zx::MonotonicInstant,
1320    ) -> Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error> {
1321        let _response = self.client.send_query::<
1322            fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
1323            fidl_fidl_test_imported::ResponseStruct,
1324        >(
1325            payload,
1326            0x1d545c738c7a8ee,
1327            fidl::encoding::DynamicFlags::empty(),
1328            ___deadline,
1329        )?;
1330        Ok(_response.value)
1331    }
1332
1333    pub fn r#echo_union_response_with_error_composed(
1334        &self,
1335        mut value: i64,
1336        mut want_absolute_value: bool,
1337        mut forward_to_server: &str,
1338        mut result_err: u32,
1339        mut result_variant: fidl_fidl_test_imported::WantResponse,
1340        ___deadline: zx::MonotonicInstant,
1341    ) -> Result<
1342        fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
1343        fidl::Error,
1344    > {
1345        let _response = self.client.send_query::<
1346            fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedRequest,
1347            fidl::encoding::ResultType<fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse, u32>,
1348        >(
1349            (value, want_absolute_value, forward_to_server, result_err, result_variant,),
1350            0x38a67e88d6106443,
1351            fidl::encoding::DynamicFlags::empty(),
1352            ___deadline,
1353        )?;
1354        Ok(_response.map(|x| x))
1355    }
1356
1357    pub fn r#echo_minimal(
1358        &self,
1359        mut forward_to_server: &str,
1360        ___deadline: zx::MonotonicInstant,
1361    ) -> Result<(), fidl::Error> {
1362        let _response =
1363            self.client.send_query::<EchoEchoMinimalRequest, fidl::encoding::EmptyPayload>(
1364                (forward_to_server,),
1365                0x39edd68c837482ec,
1366                fidl::encoding::DynamicFlags::empty(),
1367                ___deadline,
1368            )?;
1369        Ok(_response)
1370    }
1371
1372    pub fn r#echo_minimal_with_error(
1373        &self,
1374        mut forward_to_server: &str,
1375        mut result_variant: RespondWith,
1376        ___deadline: zx::MonotonicInstant,
1377    ) -> Result<EchoEchoMinimalWithErrorResult, fidl::Error> {
1378        let _response = self.client.send_query::<
1379            EchoEchoMinimalWithErrorRequest,
1380            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, u32>,
1381        >(
1382            (forward_to_server, result_variant,),
1383            0x36f4695996e35acc,
1384            fidl::encoding::DynamicFlags::empty(),
1385            ___deadline,
1386        )?;
1387        Ok(_response.map(|x| x))
1388    }
1389
1390    pub fn r#echo_minimal_no_ret_val(
1391        &self,
1392        mut forward_to_server: &str,
1393    ) -> Result<(), fidl::Error> {
1394        self.client.send::<EchoEchoMinimalNoRetValRequest>(
1395            (forward_to_server,),
1396            0x42693c143e2c3694,
1397            fidl::encoding::DynamicFlags::empty(),
1398        )
1399    }
1400
1401    pub fn r#echo_struct(
1402        &self,
1403        mut value: Struct,
1404        mut forward_to_server: &str,
1405        ___deadline: zx::MonotonicInstant,
1406    ) -> Result<Struct, fidl::Error> {
1407        let _response = self.client.send_query::<EchoEchoStructRequest, EchoEchoStructResponse>(
1408            (&mut value, forward_to_server),
1409            0x4c2f85818cc53f37,
1410            fidl::encoding::DynamicFlags::empty(),
1411            ___deadline,
1412        )?;
1413        Ok(_response.value)
1414    }
1415
1416    pub fn r#echo_struct_with_error(
1417        &self,
1418        mut value: Struct,
1419        mut result_err: DefaultEnum,
1420        mut forward_to_server: &str,
1421        mut result_variant: RespondWith,
1422        ___deadline: zx::MonotonicInstant,
1423    ) -> Result<EchoEchoStructWithErrorResult, fidl::Error> {
1424        let _response = self.client.send_query::<
1425            EchoEchoStructWithErrorRequest,
1426            fidl::encoding::ResultType<EchoEchoStructWithErrorResponse, DefaultEnum>,
1427        >(
1428            (&mut value, result_err, forward_to_server, result_variant,),
1429            0x46cb32652c4c0899,
1430            fidl::encoding::DynamicFlags::empty(),
1431            ___deadline,
1432        )?;
1433        Ok(_response.map(|x| x.value))
1434    }
1435
1436    pub fn r#echo_struct_no_ret_val(
1437        &self,
1438        mut value: Struct,
1439        mut forward_to_server: &str,
1440    ) -> Result<(), fidl::Error> {
1441        self.client.send::<EchoEchoStructNoRetValRequest>(
1442            (&mut value, forward_to_server),
1443            0x1f763e602cf5892a,
1444            fidl::encoding::DynamicFlags::empty(),
1445        )
1446    }
1447
1448    pub fn r#echo_arrays(
1449        &self,
1450        mut value: ArraysStruct,
1451        mut forward_to_server: &str,
1452        ___deadline: zx::MonotonicInstant,
1453    ) -> Result<ArraysStruct, fidl::Error> {
1454        let _response = self.client.send_query::<EchoEchoArraysRequest, EchoEchoArraysResponse>(
1455            (&mut value, forward_to_server),
1456            0x1b6019d5611f2470,
1457            fidl::encoding::DynamicFlags::empty(),
1458            ___deadline,
1459        )?;
1460        Ok(_response.value)
1461    }
1462
1463    pub fn r#echo_arrays_with_error(
1464        &self,
1465        mut value: ArraysStruct,
1466        mut result_err: DefaultEnum,
1467        mut forward_to_server: &str,
1468        mut result_variant: RespondWith,
1469        ___deadline: zx::MonotonicInstant,
1470    ) -> Result<EchoEchoArraysWithErrorResult, fidl::Error> {
1471        let _response = self.client.send_query::<
1472            EchoEchoArraysWithErrorRequest,
1473            fidl::encoding::ResultType<EchoEchoArraysWithErrorResponse, DefaultEnum>,
1474        >(
1475            (&mut value, result_err, forward_to_server, result_variant,),
1476            0x6dbf26e67e253afa,
1477            fidl::encoding::DynamicFlags::empty(),
1478            ___deadline,
1479        )?;
1480        Ok(_response.map(|x| x.value))
1481    }
1482
1483    pub fn r#echo_vectors(
1484        &self,
1485        mut value: VectorsStruct,
1486        mut forward_to_server: &str,
1487        ___deadline: zx::MonotonicInstant,
1488    ) -> Result<VectorsStruct, fidl::Error> {
1489        let _response = self.client.send_query::<EchoEchoVectorsRequest, EchoEchoVectorsResponse>(
1490            (&mut value, forward_to_server),
1491            0x1582623f0d9f6e5e,
1492            fidl::encoding::DynamicFlags::empty(),
1493            ___deadline,
1494        )?;
1495        Ok(_response.value)
1496    }
1497
1498    pub fn r#echo_vectors_with_error(
1499        &self,
1500        mut value: VectorsStruct,
1501        mut result_err: DefaultEnum,
1502        mut forward_to_server: &str,
1503        mut result_variant: RespondWith,
1504        ___deadline: zx::MonotonicInstant,
1505    ) -> Result<EchoEchoVectorsWithErrorResult, fidl::Error> {
1506        let _response = self.client.send_query::<
1507            EchoEchoVectorsWithErrorRequest,
1508            fidl::encoding::ResultType<EchoEchoVectorsWithErrorResponse, DefaultEnum>,
1509        >(
1510            (&mut value, result_err, forward_to_server, result_variant,),
1511            0x730f163401e2b3e5,
1512            fidl::encoding::DynamicFlags::empty(),
1513            ___deadline,
1514        )?;
1515        Ok(_response.map(|x| x.value))
1516    }
1517
1518    pub fn r#echo_table(
1519        &self,
1520        mut value: AllTypesTable,
1521        mut forward_to_server: &str,
1522        ___deadline: zx::MonotonicInstant,
1523    ) -> Result<AllTypesTable, fidl::Error> {
1524        let _response = self.client.send_query::<EchoEchoTableRequest, EchoEchoTableResponse>(
1525            (&mut value, forward_to_server),
1526            0x4f1fb0a512f47c4b,
1527            fidl::encoding::DynamicFlags::empty(),
1528            ___deadline,
1529        )?;
1530        Ok(_response.value)
1531    }
1532
1533    pub fn r#echo_table_with_error(
1534        &self,
1535        mut value: AllTypesTable,
1536        mut result_err: DefaultEnum,
1537        mut forward_to_server: &str,
1538        mut result_variant: RespondWith,
1539        ___deadline: zx::MonotonicInstant,
1540    ) -> Result<EchoEchoTableWithErrorResult, fidl::Error> {
1541        let _response = self.client.send_query::<
1542            EchoEchoTableWithErrorRequest,
1543            fidl::encoding::ResultType<EchoEchoTableWithErrorResponse, DefaultEnum>,
1544        >(
1545            (&mut value, result_err, forward_to_server, result_variant,),
1546            0x44e835cb1eb9a931,
1547            fidl::encoding::DynamicFlags::empty(),
1548            ___deadline,
1549        )?;
1550        Ok(_response.map(|x| x.value))
1551    }
1552
1553    pub fn r#echo_xunions(
1554        &self,
1555        mut value: Vec<AllTypesXunion>,
1556        mut forward_to_server: &str,
1557        ___deadline: zx::MonotonicInstant,
1558    ) -> Result<Vec<AllTypesXunion>, fidl::Error> {
1559        let _response = self.client.send_query::<EchoEchoXunionsRequest, EchoEchoXunionsResponse>(
1560            (value.as_mut(), forward_to_server),
1561            0x3dc181909041a583,
1562            fidl::encoding::DynamicFlags::empty(),
1563            ___deadline,
1564        )?;
1565        Ok(_response.value)
1566    }
1567
1568    pub fn r#echo_xunions_with_error(
1569        &self,
1570        mut value: Vec<AllTypesXunion>,
1571        mut result_err: DefaultEnum,
1572        mut forward_to_server: &str,
1573        mut result_variant: RespondWith,
1574        ___deadline: zx::MonotonicInstant,
1575    ) -> Result<EchoEchoXunionsWithErrorResult, fidl::Error> {
1576        let _response = self.client.send_query::<
1577            EchoEchoXunionsWithErrorRequest,
1578            fidl::encoding::ResultType<EchoEchoXunionsWithErrorResponse, DefaultEnum>,
1579        >(
1580            (value.as_mut(), result_err, forward_to_server, result_variant,),
1581            0x75184102667fa766,
1582            fidl::encoding::DynamicFlags::empty(),
1583            ___deadline,
1584        )?;
1585        Ok(_response.map(|x| x.value))
1586    }
1587
1588    pub fn r#echo_named_struct(
1589        &self,
1590        mut value: &fidl_fidl_test_imported::SimpleStruct,
1591        mut forward_to_server: &str,
1592        ___deadline: zx::MonotonicInstant,
1593    ) -> Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error> {
1594        let _response = self.client.send_query::<
1595            fidl_fidl_test_imported::RequestStruct,
1596            fidl_fidl_test_imported::ResponseStruct,
1597        >(
1598            (value, forward_to_server,),
1599            0xf2d4aa9e65f7111,
1600            fidl::encoding::DynamicFlags::empty(),
1601            ___deadline,
1602        )?;
1603        Ok(_response.value)
1604    }
1605
1606    pub fn r#echo_named_struct_with_error(
1607        &self,
1608        mut value: &fidl_fidl_test_imported::SimpleStruct,
1609        mut result_err: u32,
1610        mut forward_to_server: &str,
1611        mut result_variant: fidl_fidl_test_imported::WantResponse,
1612        ___deadline: zx::MonotonicInstant,
1613    ) -> Result<EchoEchoNamedStructWithErrorResult, fidl::Error> {
1614        let _response = self.client.send_query::<
1615            fidl_fidl_test_imported::ErrorableRequestStruct,
1616            fidl::encoding::ResultType<fidl_fidl_test_imported::ResponseStruct, u32>,
1617        >(
1618            (value, result_err, forward_to_server, result_variant,),
1619            0x5766fee9e74442e8,
1620            fidl::encoding::DynamicFlags::empty(),
1621            ___deadline,
1622        )?;
1623        Ok(_response.map(|x| x.value))
1624    }
1625
1626    pub fn r#echo_named_struct_no_ret_val(
1627        &self,
1628        mut value: &fidl_fidl_test_imported::SimpleStruct,
1629        mut forward_to_server: &str,
1630    ) -> Result<(), fidl::Error> {
1631        self.client.send::<fidl_fidl_test_imported::EventTriggeringRequestStruct>(
1632            (value, forward_to_server),
1633            0x3a50bbf7d2113ad7,
1634            fidl::encoding::DynamicFlags::empty(),
1635        )
1636    }
1637
1638    pub fn r#echo_table_payload(
1639        &self,
1640        mut payload: &RequestTable,
1641        ___deadline: zx::MonotonicInstant,
1642    ) -> Result<ResponseTable, fidl::Error> {
1643        let _response = self.client.send_query::<RequestTable, ResponseTable>(
1644            payload,
1645            0x641d98087378c003,
1646            fidl::encoding::DynamicFlags::empty(),
1647            ___deadline,
1648        )?;
1649        Ok(_response)
1650    }
1651
1652    pub fn r#echo_table_payload_with_error(
1653        &self,
1654        mut payload: &EchoEchoTablePayloadWithErrorRequest,
1655        ___deadline: zx::MonotonicInstant,
1656    ) -> Result<EchoEchoTablePayloadWithErrorResult, fidl::Error> {
1657        let _response = self.client.send_query::<
1658            EchoEchoTablePayloadWithErrorRequest,
1659            fidl::encoding::ResultType<ResponseTable, DefaultEnum>,
1660        >(
1661            payload,
1662            0x636ed243761ab66d,
1663            fidl::encoding::DynamicFlags::empty(),
1664            ___deadline,
1665        )?;
1666        Ok(_response.map(|x| x))
1667    }
1668
1669    pub fn r#echo_table_payload_no_ret_val(
1670        &self,
1671        mut payload: &RequestTable,
1672    ) -> Result<(), fidl::Error> {
1673        self.client.send::<RequestTable>(
1674            payload,
1675            0x32961f7d718569f8,
1676            fidl::encoding::DynamicFlags::empty(),
1677        )
1678    }
1679
1680    pub fn r#echo_union_payload(
1681        &self,
1682        mut payload: &RequestUnion,
1683        ___deadline: zx::MonotonicInstant,
1684    ) -> Result<ResponseUnion, fidl::Error> {
1685        let _response = self.client.send_query::<RequestUnion, ResponseUnion>(
1686            payload,
1687            0x66def9e793f10c55,
1688            fidl::encoding::DynamicFlags::empty(),
1689            ___deadline,
1690        )?;
1691        Ok(_response)
1692    }
1693
1694    pub fn r#echo_union_payload_with_error(
1695        &self,
1696        mut payload: &EchoEchoUnionPayloadWithErrorRequest,
1697        ___deadline: zx::MonotonicInstant,
1698    ) -> Result<EchoEchoUnionPayloadWithErrorResult, fidl::Error> {
1699        let _response = self.client.send_query::<
1700            EchoEchoUnionPayloadWithErrorRequest,
1701            fidl::encoding::ResultType<ResponseUnion, DefaultEnum>,
1702        >(
1703            payload,
1704            0x1be890d6e68ef063,
1705            fidl::encoding::DynamicFlags::empty(),
1706            ___deadline,
1707        )?;
1708        Ok(_response.map(|x| x))
1709    }
1710
1711    pub fn r#echo_union_payload_no_ret_val(
1712        &self,
1713        mut payload: &RequestUnion,
1714    ) -> Result<(), fidl::Error> {
1715        self.client.send::<RequestUnion>(
1716            payload,
1717            0x11518bf346430040,
1718            fidl::encoding::DynamicFlags::empty(),
1719        )
1720    }
1721}
1722
1723#[cfg(target_os = "fuchsia")]
1724impl From<EchoSynchronousProxy> for zx::NullableHandle {
1725    fn from(value: EchoSynchronousProxy) -> Self {
1726        value.into_channel().into()
1727    }
1728}
1729
1730#[cfg(target_os = "fuchsia")]
1731impl From<fidl::Channel> for EchoSynchronousProxy {
1732    fn from(value: fidl::Channel) -> Self {
1733        Self::new(value)
1734    }
1735}
1736
1737#[cfg(target_os = "fuchsia")]
1738impl fidl::endpoints::FromClient for EchoSynchronousProxy {
1739    type Protocol = EchoMarker;
1740
1741    fn from_client(value: fidl::endpoints::ClientEnd<EchoMarker>) -> Self {
1742        Self::new(value.into_channel())
1743    }
1744}
1745
1746#[derive(Debug, Clone)]
1747pub struct EchoProxy {
1748    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
1749}
1750
1751impl fidl::endpoints::Proxy for EchoProxy {
1752    type Protocol = EchoMarker;
1753
1754    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
1755        Self::new(inner)
1756    }
1757
1758    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
1759        self.client.into_channel().map_err(|client| Self { client })
1760    }
1761
1762    fn as_channel(&self) -> &::fidl::AsyncChannel {
1763        self.client.as_channel()
1764    }
1765}
1766
1767impl EchoProxy {
1768    /// Create a new Proxy for fidl.test.compatibility/Echo.
1769    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
1770        let protocol_name = <EchoMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1771        Self { client: fidl::client::Client::new(channel, protocol_name) }
1772    }
1773
1774    /// Get a Stream of events from the remote end of the protocol.
1775    ///
1776    /// # Panics
1777    ///
1778    /// Panics if the event stream was already taken.
1779    pub fn take_event_stream(&self) -> EchoEventStream {
1780        EchoEventStream { event_receiver: self.client.take_event_receiver() }
1781    }
1782
1783    pub fn r#echo_table_request_composed(
1784        &self,
1785        mut payload: &fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
1786    ) -> fidl::client::QueryResponseFut<
1787        fidl_fidl_test_imported::SimpleStruct,
1788        fidl::encoding::DefaultFuchsiaResourceDialect,
1789    > {
1790        EchoProxyInterface::r#echo_table_request_composed(self, payload)
1791    }
1792
1793    pub fn r#echo_union_response_with_error_composed(
1794        &self,
1795        mut value: i64,
1796        mut want_absolute_value: bool,
1797        mut forward_to_server: &str,
1798        mut result_err: u32,
1799        mut result_variant: fidl_fidl_test_imported::WantResponse,
1800    ) -> fidl::client::QueryResponseFut<
1801        fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
1802        fidl::encoding::DefaultFuchsiaResourceDialect,
1803    > {
1804        EchoProxyInterface::r#echo_union_response_with_error_composed(
1805            self,
1806            value,
1807            want_absolute_value,
1808            forward_to_server,
1809            result_err,
1810            result_variant,
1811        )
1812    }
1813
1814    pub fn r#echo_minimal(
1815        &self,
1816        mut forward_to_server: &str,
1817    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
1818        EchoProxyInterface::r#echo_minimal(self, forward_to_server)
1819    }
1820
1821    pub fn r#echo_minimal_with_error(
1822        &self,
1823        mut forward_to_server: &str,
1824        mut result_variant: RespondWith,
1825    ) -> fidl::client::QueryResponseFut<
1826        EchoEchoMinimalWithErrorResult,
1827        fidl::encoding::DefaultFuchsiaResourceDialect,
1828    > {
1829        EchoProxyInterface::r#echo_minimal_with_error(self, forward_to_server, result_variant)
1830    }
1831
1832    pub fn r#echo_minimal_no_ret_val(
1833        &self,
1834        mut forward_to_server: &str,
1835    ) -> Result<(), fidl::Error> {
1836        EchoProxyInterface::r#echo_minimal_no_ret_val(self, forward_to_server)
1837    }
1838
1839    pub fn r#echo_struct(
1840        &self,
1841        mut value: Struct,
1842        mut forward_to_server: &str,
1843    ) -> fidl::client::QueryResponseFut<Struct, fidl::encoding::DefaultFuchsiaResourceDialect> {
1844        EchoProxyInterface::r#echo_struct(self, value, forward_to_server)
1845    }
1846
1847    pub fn r#echo_struct_with_error(
1848        &self,
1849        mut value: Struct,
1850        mut result_err: DefaultEnum,
1851        mut forward_to_server: &str,
1852        mut result_variant: RespondWith,
1853    ) -> fidl::client::QueryResponseFut<
1854        EchoEchoStructWithErrorResult,
1855        fidl::encoding::DefaultFuchsiaResourceDialect,
1856    > {
1857        EchoProxyInterface::r#echo_struct_with_error(
1858            self,
1859            value,
1860            result_err,
1861            forward_to_server,
1862            result_variant,
1863        )
1864    }
1865
1866    pub fn r#echo_struct_no_ret_val(
1867        &self,
1868        mut value: Struct,
1869        mut forward_to_server: &str,
1870    ) -> Result<(), fidl::Error> {
1871        EchoProxyInterface::r#echo_struct_no_ret_val(self, value, forward_to_server)
1872    }
1873
1874    pub fn r#echo_arrays(
1875        &self,
1876        mut value: ArraysStruct,
1877        mut forward_to_server: &str,
1878    ) -> fidl::client::QueryResponseFut<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
1879    {
1880        EchoProxyInterface::r#echo_arrays(self, value, forward_to_server)
1881    }
1882
1883    pub fn r#echo_arrays_with_error(
1884        &self,
1885        mut value: ArraysStruct,
1886        mut result_err: DefaultEnum,
1887        mut forward_to_server: &str,
1888        mut result_variant: RespondWith,
1889    ) -> fidl::client::QueryResponseFut<
1890        EchoEchoArraysWithErrorResult,
1891        fidl::encoding::DefaultFuchsiaResourceDialect,
1892    > {
1893        EchoProxyInterface::r#echo_arrays_with_error(
1894            self,
1895            value,
1896            result_err,
1897            forward_to_server,
1898            result_variant,
1899        )
1900    }
1901
1902    pub fn r#echo_vectors(
1903        &self,
1904        mut value: VectorsStruct,
1905        mut forward_to_server: &str,
1906    ) -> fidl::client::QueryResponseFut<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
1907    {
1908        EchoProxyInterface::r#echo_vectors(self, value, forward_to_server)
1909    }
1910
1911    pub fn r#echo_vectors_with_error(
1912        &self,
1913        mut value: VectorsStruct,
1914        mut result_err: DefaultEnum,
1915        mut forward_to_server: &str,
1916        mut result_variant: RespondWith,
1917    ) -> fidl::client::QueryResponseFut<
1918        EchoEchoVectorsWithErrorResult,
1919        fidl::encoding::DefaultFuchsiaResourceDialect,
1920    > {
1921        EchoProxyInterface::r#echo_vectors_with_error(
1922            self,
1923            value,
1924            result_err,
1925            forward_to_server,
1926            result_variant,
1927        )
1928    }
1929
1930    pub fn r#echo_table(
1931        &self,
1932        mut value: AllTypesTable,
1933        mut forward_to_server: &str,
1934    ) -> fidl::client::QueryResponseFut<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>
1935    {
1936        EchoProxyInterface::r#echo_table(self, value, forward_to_server)
1937    }
1938
1939    pub fn r#echo_table_with_error(
1940        &self,
1941        mut value: AllTypesTable,
1942        mut result_err: DefaultEnum,
1943        mut forward_to_server: &str,
1944        mut result_variant: RespondWith,
1945    ) -> fidl::client::QueryResponseFut<
1946        EchoEchoTableWithErrorResult,
1947        fidl::encoding::DefaultFuchsiaResourceDialect,
1948    > {
1949        EchoProxyInterface::r#echo_table_with_error(
1950            self,
1951            value,
1952            result_err,
1953            forward_to_server,
1954            result_variant,
1955        )
1956    }
1957
1958    pub fn r#echo_xunions(
1959        &self,
1960        mut value: Vec<AllTypesXunion>,
1961        mut forward_to_server: &str,
1962    ) -> fidl::client::QueryResponseFut<
1963        Vec<AllTypesXunion>,
1964        fidl::encoding::DefaultFuchsiaResourceDialect,
1965    > {
1966        EchoProxyInterface::r#echo_xunions(self, value, forward_to_server)
1967    }
1968
1969    pub fn r#echo_xunions_with_error(
1970        &self,
1971        mut value: Vec<AllTypesXunion>,
1972        mut result_err: DefaultEnum,
1973        mut forward_to_server: &str,
1974        mut result_variant: RespondWith,
1975    ) -> fidl::client::QueryResponseFut<
1976        EchoEchoXunionsWithErrorResult,
1977        fidl::encoding::DefaultFuchsiaResourceDialect,
1978    > {
1979        EchoProxyInterface::r#echo_xunions_with_error(
1980            self,
1981            value,
1982            result_err,
1983            forward_to_server,
1984            result_variant,
1985        )
1986    }
1987
1988    pub fn r#echo_named_struct(
1989        &self,
1990        mut value: &fidl_fidl_test_imported::SimpleStruct,
1991        mut forward_to_server: &str,
1992    ) -> fidl::client::QueryResponseFut<
1993        fidl_fidl_test_imported::SimpleStruct,
1994        fidl::encoding::DefaultFuchsiaResourceDialect,
1995    > {
1996        EchoProxyInterface::r#echo_named_struct(self, value, forward_to_server)
1997    }
1998
1999    pub fn r#echo_named_struct_with_error(
2000        &self,
2001        mut value: &fidl_fidl_test_imported::SimpleStruct,
2002        mut result_err: u32,
2003        mut forward_to_server: &str,
2004        mut result_variant: fidl_fidl_test_imported::WantResponse,
2005    ) -> fidl::client::QueryResponseFut<
2006        EchoEchoNamedStructWithErrorResult,
2007        fidl::encoding::DefaultFuchsiaResourceDialect,
2008    > {
2009        EchoProxyInterface::r#echo_named_struct_with_error(
2010            self,
2011            value,
2012            result_err,
2013            forward_to_server,
2014            result_variant,
2015        )
2016    }
2017
2018    pub fn r#echo_named_struct_no_ret_val(
2019        &self,
2020        mut value: &fidl_fidl_test_imported::SimpleStruct,
2021        mut forward_to_server: &str,
2022    ) -> Result<(), fidl::Error> {
2023        EchoProxyInterface::r#echo_named_struct_no_ret_val(self, value, forward_to_server)
2024    }
2025
2026    pub fn r#echo_table_payload(
2027        &self,
2028        mut payload: &RequestTable,
2029    ) -> fidl::client::QueryResponseFut<ResponseTable, fidl::encoding::DefaultFuchsiaResourceDialect>
2030    {
2031        EchoProxyInterface::r#echo_table_payload(self, payload)
2032    }
2033
2034    pub fn r#echo_table_payload_with_error(
2035        &self,
2036        mut payload: &EchoEchoTablePayloadWithErrorRequest,
2037    ) -> fidl::client::QueryResponseFut<
2038        EchoEchoTablePayloadWithErrorResult,
2039        fidl::encoding::DefaultFuchsiaResourceDialect,
2040    > {
2041        EchoProxyInterface::r#echo_table_payload_with_error(self, payload)
2042    }
2043
2044    pub fn r#echo_table_payload_no_ret_val(
2045        &self,
2046        mut payload: &RequestTable,
2047    ) -> Result<(), fidl::Error> {
2048        EchoProxyInterface::r#echo_table_payload_no_ret_val(self, payload)
2049    }
2050
2051    pub fn r#echo_union_payload(
2052        &self,
2053        mut payload: &RequestUnion,
2054    ) -> fidl::client::QueryResponseFut<ResponseUnion, fidl::encoding::DefaultFuchsiaResourceDialect>
2055    {
2056        EchoProxyInterface::r#echo_union_payload(self, payload)
2057    }
2058
2059    pub fn r#echo_union_payload_with_error(
2060        &self,
2061        mut payload: &EchoEchoUnionPayloadWithErrorRequest,
2062    ) -> fidl::client::QueryResponseFut<
2063        EchoEchoUnionPayloadWithErrorResult,
2064        fidl::encoding::DefaultFuchsiaResourceDialect,
2065    > {
2066        EchoProxyInterface::r#echo_union_payload_with_error(self, payload)
2067    }
2068
2069    pub fn r#echo_union_payload_no_ret_val(
2070        &self,
2071        mut payload: &RequestUnion,
2072    ) -> Result<(), fidl::Error> {
2073        EchoProxyInterface::r#echo_union_payload_no_ret_val(self, payload)
2074    }
2075}
2076
2077impl EchoProxyInterface for EchoProxy {
2078    type EchoTableRequestComposedResponseFut = fidl::client::QueryResponseFut<
2079        fidl_fidl_test_imported::SimpleStruct,
2080        fidl::encoding::DefaultFuchsiaResourceDialect,
2081    >;
2082    fn r#echo_table_request_composed(
2083        &self,
2084        mut payload: &fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
2085    ) -> Self::EchoTableRequestComposedResponseFut {
2086        fn _decode(
2087            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2088        ) -> Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error> {
2089            let _response = fidl::client::decode_transaction_body::<
2090                fidl_fidl_test_imported::ResponseStruct,
2091                fidl::encoding::DefaultFuchsiaResourceDialect,
2092                0x1d545c738c7a8ee,
2093            >(_buf?)?;
2094            Ok(_response.value)
2095        }
2096        self.client.send_query_and_decode::<
2097            fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
2098            fidl_fidl_test_imported::SimpleStruct,
2099        >(
2100            payload,
2101            0x1d545c738c7a8ee,
2102            fidl::encoding::DynamicFlags::empty(),
2103            _decode,
2104        )
2105    }
2106
2107    type EchoUnionResponseWithErrorComposedResponseFut = fidl::client::QueryResponseFut<
2108        fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
2109        fidl::encoding::DefaultFuchsiaResourceDialect,
2110    >;
2111    fn r#echo_union_response_with_error_composed(
2112        &self,
2113        mut value: i64,
2114        mut want_absolute_value: bool,
2115        mut forward_to_server: &str,
2116        mut result_err: u32,
2117        mut result_variant: fidl_fidl_test_imported::WantResponse,
2118    ) -> Self::EchoUnionResponseWithErrorComposedResponseFut {
2119        fn _decode(
2120            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2121        ) -> Result<
2122            fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
2123            fidl::Error,
2124        > {
2125            let _response = fidl::client::decode_transaction_body::<
2126                fidl::encoding::ResultType<
2127                    fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse,
2128                    u32,
2129                >,
2130                fidl::encoding::DefaultFuchsiaResourceDialect,
2131                0x38a67e88d6106443,
2132            >(_buf?)?;
2133            Ok(_response.map(|x| x))
2134        }
2135        self.client.send_query_and_decode::<
2136            fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedRequest,
2137            fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
2138        >(
2139            (value, want_absolute_value, forward_to_server, result_err, result_variant,),
2140            0x38a67e88d6106443,
2141            fidl::encoding::DynamicFlags::empty(),
2142            _decode,
2143        )
2144    }
2145
2146    type EchoMinimalResponseFut =
2147        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
2148    fn r#echo_minimal(&self, mut forward_to_server: &str) -> Self::EchoMinimalResponseFut {
2149        fn _decode(
2150            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2151        ) -> Result<(), fidl::Error> {
2152            let _response = fidl::client::decode_transaction_body::<
2153                fidl::encoding::EmptyPayload,
2154                fidl::encoding::DefaultFuchsiaResourceDialect,
2155                0x39edd68c837482ec,
2156            >(_buf?)?;
2157            Ok(_response)
2158        }
2159        self.client.send_query_and_decode::<EchoEchoMinimalRequest, ()>(
2160            (forward_to_server,),
2161            0x39edd68c837482ec,
2162            fidl::encoding::DynamicFlags::empty(),
2163            _decode,
2164        )
2165    }
2166
2167    type EchoMinimalWithErrorResponseFut = fidl::client::QueryResponseFut<
2168        EchoEchoMinimalWithErrorResult,
2169        fidl::encoding::DefaultFuchsiaResourceDialect,
2170    >;
2171    fn r#echo_minimal_with_error(
2172        &self,
2173        mut forward_to_server: &str,
2174        mut result_variant: RespondWith,
2175    ) -> Self::EchoMinimalWithErrorResponseFut {
2176        fn _decode(
2177            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2178        ) -> Result<EchoEchoMinimalWithErrorResult, fidl::Error> {
2179            let _response = fidl::client::decode_transaction_body::<
2180                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, u32>,
2181                fidl::encoding::DefaultFuchsiaResourceDialect,
2182                0x36f4695996e35acc,
2183            >(_buf?)?;
2184            Ok(_response.map(|x| x))
2185        }
2186        self.client.send_query_and_decode::<
2187            EchoEchoMinimalWithErrorRequest,
2188            EchoEchoMinimalWithErrorResult,
2189        >(
2190            (forward_to_server, result_variant,),
2191            0x36f4695996e35acc,
2192            fidl::encoding::DynamicFlags::empty(),
2193            _decode,
2194        )
2195    }
2196
2197    fn r#echo_minimal_no_ret_val(&self, mut forward_to_server: &str) -> Result<(), fidl::Error> {
2198        self.client.send::<EchoEchoMinimalNoRetValRequest>(
2199            (forward_to_server,),
2200            0x42693c143e2c3694,
2201            fidl::encoding::DynamicFlags::empty(),
2202        )
2203    }
2204
2205    type EchoStructResponseFut =
2206        fidl::client::QueryResponseFut<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>;
2207    fn r#echo_struct(
2208        &self,
2209        mut value: Struct,
2210        mut forward_to_server: &str,
2211    ) -> Self::EchoStructResponseFut {
2212        fn _decode(
2213            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2214        ) -> Result<Struct, fidl::Error> {
2215            let _response = fidl::client::decode_transaction_body::<
2216                EchoEchoStructResponse,
2217                fidl::encoding::DefaultFuchsiaResourceDialect,
2218                0x4c2f85818cc53f37,
2219            >(_buf?)?;
2220            Ok(_response.value)
2221        }
2222        self.client.send_query_and_decode::<EchoEchoStructRequest, Struct>(
2223            (&mut value, forward_to_server),
2224            0x4c2f85818cc53f37,
2225            fidl::encoding::DynamicFlags::empty(),
2226            _decode,
2227        )
2228    }
2229
2230    type EchoStructWithErrorResponseFut = fidl::client::QueryResponseFut<
2231        EchoEchoStructWithErrorResult,
2232        fidl::encoding::DefaultFuchsiaResourceDialect,
2233    >;
2234    fn r#echo_struct_with_error(
2235        &self,
2236        mut value: Struct,
2237        mut result_err: DefaultEnum,
2238        mut forward_to_server: &str,
2239        mut result_variant: RespondWith,
2240    ) -> Self::EchoStructWithErrorResponseFut {
2241        fn _decode(
2242            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2243        ) -> Result<EchoEchoStructWithErrorResult, fidl::Error> {
2244            let _response = fidl::client::decode_transaction_body::<
2245                fidl::encoding::ResultType<EchoEchoStructWithErrorResponse, DefaultEnum>,
2246                fidl::encoding::DefaultFuchsiaResourceDialect,
2247                0x46cb32652c4c0899,
2248            >(_buf?)?;
2249            Ok(_response.map(|x| x.value))
2250        }
2251        self.client
2252            .send_query_and_decode::<EchoEchoStructWithErrorRequest, EchoEchoStructWithErrorResult>(
2253                (&mut value, result_err, forward_to_server, result_variant),
2254                0x46cb32652c4c0899,
2255                fidl::encoding::DynamicFlags::empty(),
2256                _decode,
2257            )
2258    }
2259
2260    fn r#echo_struct_no_ret_val(
2261        &self,
2262        mut value: Struct,
2263        mut forward_to_server: &str,
2264    ) -> Result<(), fidl::Error> {
2265        self.client.send::<EchoEchoStructNoRetValRequest>(
2266            (&mut value, forward_to_server),
2267            0x1f763e602cf5892a,
2268            fidl::encoding::DynamicFlags::empty(),
2269        )
2270    }
2271
2272    type EchoArraysResponseFut =
2273        fidl::client::QueryResponseFut<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>;
2274    fn r#echo_arrays(
2275        &self,
2276        mut value: ArraysStruct,
2277        mut forward_to_server: &str,
2278    ) -> Self::EchoArraysResponseFut {
2279        fn _decode(
2280            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2281        ) -> Result<ArraysStruct, fidl::Error> {
2282            let _response = fidl::client::decode_transaction_body::<
2283                EchoEchoArraysResponse,
2284                fidl::encoding::DefaultFuchsiaResourceDialect,
2285                0x1b6019d5611f2470,
2286            >(_buf?)?;
2287            Ok(_response.value)
2288        }
2289        self.client.send_query_and_decode::<EchoEchoArraysRequest, ArraysStruct>(
2290            (&mut value, forward_to_server),
2291            0x1b6019d5611f2470,
2292            fidl::encoding::DynamicFlags::empty(),
2293            _decode,
2294        )
2295    }
2296
2297    type EchoArraysWithErrorResponseFut = fidl::client::QueryResponseFut<
2298        EchoEchoArraysWithErrorResult,
2299        fidl::encoding::DefaultFuchsiaResourceDialect,
2300    >;
2301    fn r#echo_arrays_with_error(
2302        &self,
2303        mut value: ArraysStruct,
2304        mut result_err: DefaultEnum,
2305        mut forward_to_server: &str,
2306        mut result_variant: RespondWith,
2307    ) -> Self::EchoArraysWithErrorResponseFut {
2308        fn _decode(
2309            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2310        ) -> Result<EchoEchoArraysWithErrorResult, fidl::Error> {
2311            let _response = fidl::client::decode_transaction_body::<
2312                fidl::encoding::ResultType<EchoEchoArraysWithErrorResponse, DefaultEnum>,
2313                fidl::encoding::DefaultFuchsiaResourceDialect,
2314                0x6dbf26e67e253afa,
2315            >(_buf?)?;
2316            Ok(_response.map(|x| x.value))
2317        }
2318        self.client
2319            .send_query_and_decode::<EchoEchoArraysWithErrorRequest, EchoEchoArraysWithErrorResult>(
2320                (&mut value, result_err, forward_to_server, result_variant),
2321                0x6dbf26e67e253afa,
2322                fidl::encoding::DynamicFlags::empty(),
2323                _decode,
2324            )
2325    }
2326
2327    type EchoVectorsResponseFut = fidl::client::QueryResponseFut<
2328        VectorsStruct,
2329        fidl::encoding::DefaultFuchsiaResourceDialect,
2330    >;
2331    fn r#echo_vectors(
2332        &self,
2333        mut value: VectorsStruct,
2334        mut forward_to_server: &str,
2335    ) -> Self::EchoVectorsResponseFut {
2336        fn _decode(
2337            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2338        ) -> Result<VectorsStruct, fidl::Error> {
2339            let _response = fidl::client::decode_transaction_body::<
2340                EchoEchoVectorsResponse,
2341                fidl::encoding::DefaultFuchsiaResourceDialect,
2342                0x1582623f0d9f6e5e,
2343            >(_buf?)?;
2344            Ok(_response.value)
2345        }
2346        self.client.send_query_and_decode::<EchoEchoVectorsRequest, VectorsStruct>(
2347            (&mut value, forward_to_server),
2348            0x1582623f0d9f6e5e,
2349            fidl::encoding::DynamicFlags::empty(),
2350            _decode,
2351        )
2352    }
2353
2354    type EchoVectorsWithErrorResponseFut = fidl::client::QueryResponseFut<
2355        EchoEchoVectorsWithErrorResult,
2356        fidl::encoding::DefaultFuchsiaResourceDialect,
2357    >;
2358    fn r#echo_vectors_with_error(
2359        &self,
2360        mut value: VectorsStruct,
2361        mut result_err: DefaultEnum,
2362        mut forward_to_server: &str,
2363        mut result_variant: RespondWith,
2364    ) -> Self::EchoVectorsWithErrorResponseFut {
2365        fn _decode(
2366            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2367        ) -> Result<EchoEchoVectorsWithErrorResult, fidl::Error> {
2368            let _response = fidl::client::decode_transaction_body::<
2369                fidl::encoding::ResultType<EchoEchoVectorsWithErrorResponse, DefaultEnum>,
2370                fidl::encoding::DefaultFuchsiaResourceDialect,
2371                0x730f163401e2b3e5,
2372            >(_buf?)?;
2373            Ok(_response.map(|x| x.value))
2374        }
2375        self.client.send_query_and_decode::<
2376            EchoEchoVectorsWithErrorRequest,
2377            EchoEchoVectorsWithErrorResult,
2378        >(
2379            (&mut value, result_err, forward_to_server, result_variant,),
2380            0x730f163401e2b3e5,
2381            fidl::encoding::DynamicFlags::empty(),
2382            _decode,
2383        )
2384    }
2385
2386    type EchoTableResponseFut = fidl::client::QueryResponseFut<
2387        AllTypesTable,
2388        fidl::encoding::DefaultFuchsiaResourceDialect,
2389    >;
2390    fn r#echo_table(
2391        &self,
2392        mut value: AllTypesTable,
2393        mut forward_to_server: &str,
2394    ) -> Self::EchoTableResponseFut {
2395        fn _decode(
2396            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2397        ) -> Result<AllTypesTable, fidl::Error> {
2398            let _response = fidl::client::decode_transaction_body::<
2399                EchoEchoTableResponse,
2400                fidl::encoding::DefaultFuchsiaResourceDialect,
2401                0x4f1fb0a512f47c4b,
2402            >(_buf?)?;
2403            Ok(_response.value)
2404        }
2405        self.client.send_query_and_decode::<EchoEchoTableRequest, AllTypesTable>(
2406            (&mut value, forward_to_server),
2407            0x4f1fb0a512f47c4b,
2408            fidl::encoding::DynamicFlags::empty(),
2409            _decode,
2410        )
2411    }
2412
2413    type EchoTableWithErrorResponseFut = fidl::client::QueryResponseFut<
2414        EchoEchoTableWithErrorResult,
2415        fidl::encoding::DefaultFuchsiaResourceDialect,
2416    >;
2417    fn r#echo_table_with_error(
2418        &self,
2419        mut value: AllTypesTable,
2420        mut result_err: DefaultEnum,
2421        mut forward_to_server: &str,
2422        mut result_variant: RespondWith,
2423    ) -> Self::EchoTableWithErrorResponseFut {
2424        fn _decode(
2425            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2426        ) -> Result<EchoEchoTableWithErrorResult, fidl::Error> {
2427            let _response = fidl::client::decode_transaction_body::<
2428                fidl::encoding::ResultType<EchoEchoTableWithErrorResponse, DefaultEnum>,
2429                fidl::encoding::DefaultFuchsiaResourceDialect,
2430                0x44e835cb1eb9a931,
2431            >(_buf?)?;
2432            Ok(_response.map(|x| x.value))
2433        }
2434        self.client
2435            .send_query_and_decode::<EchoEchoTableWithErrorRequest, EchoEchoTableWithErrorResult>(
2436                (&mut value, result_err, forward_to_server, result_variant),
2437                0x44e835cb1eb9a931,
2438                fidl::encoding::DynamicFlags::empty(),
2439                _decode,
2440            )
2441    }
2442
2443    type EchoXunionsResponseFut = fidl::client::QueryResponseFut<
2444        Vec<AllTypesXunion>,
2445        fidl::encoding::DefaultFuchsiaResourceDialect,
2446    >;
2447    fn r#echo_xunions(
2448        &self,
2449        mut value: Vec<AllTypesXunion>,
2450        mut forward_to_server: &str,
2451    ) -> Self::EchoXunionsResponseFut {
2452        fn _decode(
2453            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2454        ) -> Result<Vec<AllTypesXunion>, fidl::Error> {
2455            let _response = fidl::client::decode_transaction_body::<
2456                EchoEchoXunionsResponse,
2457                fidl::encoding::DefaultFuchsiaResourceDialect,
2458                0x3dc181909041a583,
2459            >(_buf?)?;
2460            Ok(_response.value)
2461        }
2462        self.client.send_query_and_decode::<EchoEchoXunionsRequest, Vec<AllTypesXunion>>(
2463            (value.as_mut(), forward_to_server),
2464            0x3dc181909041a583,
2465            fidl::encoding::DynamicFlags::empty(),
2466            _decode,
2467        )
2468    }
2469
2470    type EchoXunionsWithErrorResponseFut = fidl::client::QueryResponseFut<
2471        EchoEchoXunionsWithErrorResult,
2472        fidl::encoding::DefaultFuchsiaResourceDialect,
2473    >;
2474    fn r#echo_xunions_with_error(
2475        &self,
2476        mut value: Vec<AllTypesXunion>,
2477        mut result_err: DefaultEnum,
2478        mut forward_to_server: &str,
2479        mut result_variant: RespondWith,
2480    ) -> Self::EchoXunionsWithErrorResponseFut {
2481        fn _decode(
2482            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2483        ) -> Result<EchoEchoXunionsWithErrorResult, fidl::Error> {
2484            let _response = fidl::client::decode_transaction_body::<
2485                fidl::encoding::ResultType<EchoEchoXunionsWithErrorResponse, DefaultEnum>,
2486                fidl::encoding::DefaultFuchsiaResourceDialect,
2487                0x75184102667fa766,
2488            >(_buf?)?;
2489            Ok(_response.map(|x| x.value))
2490        }
2491        self.client.send_query_and_decode::<
2492            EchoEchoXunionsWithErrorRequest,
2493            EchoEchoXunionsWithErrorResult,
2494        >(
2495            (value.as_mut(), result_err, forward_to_server, result_variant,),
2496            0x75184102667fa766,
2497            fidl::encoding::DynamicFlags::empty(),
2498            _decode,
2499        )
2500    }
2501
2502    type EchoNamedStructResponseFut = fidl::client::QueryResponseFut<
2503        fidl_fidl_test_imported::SimpleStruct,
2504        fidl::encoding::DefaultFuchsiaResourceDialect,
2505    >;
2506    fn r#echo_named_struct(
2507        &self,
2508        mut value: &fidl_fidl_test_imported::SimpleStruct,
2509        mut forward_to_server: &str,
2510    ) -> Self::EchoNamedStructResponseFut {
2511        fn _decode(
2512            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2513        ) -> Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error> {
2514            let _response = fidl::client::decode_transaction_body::<
2515                fidl_fidl_test_imported::ResponseStruct,
2516                fidl::encoding::DefaultFuchsiaResourceDialect,
2517                0xf2d4aa9e65f7111,
2518            >(_buf?)?;
2519            Ok(_response.value)
2520        }
2521        self.client.send_query_and_decode::<
2522            fidl_fidl_test_imported::RequestStruct,
2523            fidl_fidl_test_imported::SimpleStruct,
2524        >(
2525            (value, forward_to_server,),
2526            0xf2d4aa9e65f7111,
2527            fidl::encoding::DynamicFlags::empty(),
2528            _decode,
2529        )
2530    }
2531
2532    type EchoNamedStructWithErrorResponseFut = fidl::client::QueryResponseFut<
2533        EchoEchoNamedStructWithErrorResult,
2534        fidl::encoding::DefaultFuchsiaResourceDialect,
2535    >;
2536    fn r#echo_named_struct_with_error(
2537        &self,
2538        mut value: &fidl_fidl_test_imported::SimpleStruct,
2539        mut result_err: u32,
2540        mut forward_to_server: &str,
2541        mut result_variant: fidl_fidl_test_imported::WantResponse,
2542    ) -> Self::EchoNamedStructWithErrorResponseFut {
2543        fn _decode(
2544            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2545        ) -> Result<EchoEchoNamedStructWithErrorResult, fidl::Error> {
2546            let _response = fidl::client::decode_transaction_body::<
2547                fidl::encoding::ResultType<fidl_fidl_test_imported::ResponseStruct, u32>,
2548                fidl::encoding::DefaultFuchsiaResourceDialect,
2549                0x5766fee9e74442e8,
2550            >(_buf?)?;
2551            Ok(_response.map(|x| x.value))
2552        }
2553        self.client.send_query_and_decode::<
2554            fidl_fidl_test_imported::ErrorableRequestStruct,
2555            EchoEchoNamedStructWithErrorResult,
2556        >(
2557            (value, result_err, forward_to_server, result_variant,),
2558            0x5766fee9e74442e8,
2559            fidl::encoding::DynamicFlags::empty(),
2560            _decode,
2561        )
2562    }
2563
2564    fn r#echo_named_struct_no_ret_val(
2565        &self,
2566        mut value: &fidl_fidl_test_imported::SimpleStruct,
2567        mut forward_to_server: &str,
2568    ) -> Result<(), fidl::Error> {
2569        self.client.send::<fidl_fidl_test_imported::EventTriggeringRequestStruct>(
2570            (value, forward_to_server),
2571            0x3a50bbf7d2113ad7,
2572            fidl::encoding::DynamicFlags::empty(),
2573        )
2574    }
2575
2576    type EchoTablePayloadResponseFut = fidl::client::QueryResponseFut<
2577        ResponseTable,
2578        fidl::encoding::DefaultFuchsiaResourceDialect,
2579    >;
2580    fn r#echo_table_payload(
2581        &self,
2582        mut payload: &RequestTable,
2583    ) -> Self::EchoTablePayloadResponseFut {
2584        fn _decode(
2585            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2586        ) -> Result<ResponseTable, fidl::Error> {
2587            let _response = fidl::client::decode_transaction_body::<
2588                ResponseTable,
2589                fidl::encoding::DefaultFuchsiaResourceDialect,
2590                0x641d98087378c003,
2591            >(_buf?)?;
2592            Ok(_response)
2593        }
2594        self.client.send_query_and_decode::<RequestTable, ResponseTable>(
2595            payload,
2596            0x641d98087378c003,
2597            fidl::encoding::DynamicFlags::empty(),
2598            _decode,
2599        )
2600    }
2601
2602    type EchoTablePayloadWithErrorResponseFut = fidl::client::QueryResponseFut<
2603        EchoEchoTablePayloadWithErrorResult,
2604        fidl::encoding::DefaultFuchsiaResourceDialect,
2605    >;
2606    fn r#echo_table_payload_with_error(
2607        &self,
2608        mut payload: &EchoEchoTablePayloadWithErrorRequest,
2609    ) -> Self::EchoTablePayloadWithErrorResponseFut {
2610        fn _decode(
2611            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2612        ) -> Result<EchoEchoTablePayloadWithErrorResult, fidl::Error> {
2613            let _response = fidl::client::decode_transaction_body::<
2614                fidl::encoding::ResultType<ResponseTable, DefaultEnum>,
2615                fidl::encoding::DefaultFuchsiaResourceDialect,
2616                0x636ed243761ab66d,
2617            >(_buf?)?;
2618            Ok(_response.map(|x| x))
2619        }
2620        self.client.send_query_and_decode::<
2621            EchoEchoTablePayloadWithErrorRequest,
2622            EchoEchoTablePayloadWithErrorResult,
2623        >(
2624            payload,
2625            0x636ed243761ab66d,
2626            fidl::encoding::DynamicFlags::empty(),
2627            _decode,
2628        )
2629    }
2630
2631    fn r#echo_table_payload_no_ret_val(
2632        &self,
2633        mut payload: &RequestTable,
2634    ) -> Result<(), fidl::Error> {
2635        self.client.send::<RequestTable>(
2636            payload,
2637            0x32961f7d718569f8,
2638            fidl::encoding::DynamicFlags::empty(),
2639        )
2640    }
2641
2642    type EchoUnionPayloadResponseFut = fidl::client::QueryResponseFut<
2643        ResponseUnion,
2644        fidl::encoding::DefaultFuchsiaResourceDialect,
2645    >;
2646    fn r#echo_union_payload(
2647        &self,
2648        mut payload: &RequestUnion,
2649    ) -> Self::EchoUnionPayloadResponseFut {
2650        fn _decode(
2651            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2652        ) -> Result<ResponseUnion, fidl::Error> {
2653            let _response = fidl::client::decode_transaction_body::<
2654                ResponseUnion,
2655                fidl::encoding::DefaultFuchsiaResourceDialect,
2656                0x66def9e793f10c55,
2657            >(_buf?)?;
2658            Ok(_response)
2659        }
2660        self.client.send_query_and_decode::<RequestUnion, ResponseUnion>(
2661            payload,
2662            0x66def9e793f10c55,
2663            fidl::encoding::DynamicFlags::empty(),
2664            _decode,
2665        )
2666    }
2667
2668    type EchoUnionPayloadWithErrorResponseFut = fidl::client::QueryResponseFut<
2669        EchoEchoUnionPayloadWithErrorResult,
2670        fidl::encoding::DefaultFuchsiaResourceDialect,
2671    >;
2672    fn r#echo_union_payload_with_error(
2673        &self,
2674        mut payload: &EchoEchoUnionPayloadWithErrorRequest,
2675    ) -> Self::EchoUnionPayloadWithErrorResponseFut {
2676        fn _decode(
2677            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2678        ) -> Result<EchoEchoUnionPayloadWithErrorResult, fidl::Error> {
2679            let _response = fidl::client::decode_transaction_body::<
2680                fidl::encoding::ResultType<ResponseUnion, DefaultEnum>,
2681                fidl::encoding::DefaultFuchsiaResourceDialect,
2682                0x1be890d6e68ef063,
2683            >(_buf?)?;
2684            Ok(_response.map(|x| x))
2685        }
2686        self.client.send_query_and_decode::<
2687            EchoEchoUnionPayloadWithErrorRequest,
2688            EchoEchoUnionPayloadWithErrorResult,
2689        >(
2690            payload,
2691            0x1be890d6e68ef063,
2692            fidl::encoding::DynamicFlags::empty(),
2693            _decode,
2694        )
2695    }
2696
2697    fn r#echo_union_payload_no_ret_val(
2698        &self,
2699        mut payload: &RequestUnion,
2700    ) -> Result<(), fidl::Error> {
2701        self.client.send::<RequestUnion>(
2702            payload,
2703            0x11518bf346430040,
2704            fidl::encoding::DynamicFlags::empty(),
2705        )
2706    }
2707}
2708
2709pub struct EchoEventStream {
2710    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
2711}
2712
2713impl std::marker::Unpin for EchoEventStream {}
2714
2715impl futures::stream::FusedStream for EchoEventStream {
2716    fn is_terminated(&self) -> bool {
2717        self.event_receiver.is_terminated()
2718    }
2719}
2720
2721impl futures::Stream for EchoEventStream {
2722    type Item = Result<EchoEvent, fidl::Error>;
2723
2724    fn poll_next(
2725        mut self: std::pin::Pin<&mut Self>,
2726        cx: &mut std::task::Context<'_>,
2727    ) -> std::task::Poll<Option<Self::Item>> {
2728        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
2729            &mut self.event_receiver,
2730            cx
2731        )?) {
2732            Some(buf) => std::task::Poll::Ready(Some(EchoEvent::decode(buf))),
2733            None => std::task::Poll::Ready(None),
2734        }
2735    }
2736}
2737
2738#[derive(Debug)]
2739pub enum EchoEvent {
2740    EchoMinimalEvent {},
2741    EchoEvent { value: Struct },
2742    OnEchoNamedEvent { value: fidl_fidl_test_imported::SimpleStruct },
2743    OnEchoTablePayloadEvent { payload: ResponseTable },
2744    OnEchoUnionPayloadEvent { payload: ResponseUnion },
2745}
2746
2747impl EchoEvent {
2748    #[allow(irrefutable_let_patterns)]
2749    pub fn into_echo_minimal_event(self) -> Option<()> {
2750        if let EchoEvent::EchoMinimalEvent {} = self { Some(()) } else { None }
2751    }
2752    #[allow(irrefutable_let_patterns)]
2753    pub fn into_echo_event(self) -> Option<Struct> {
2754        if let EchoEvent::EchoEvent { value } = self { Some((value)) } else { None }
2755    }
2756    #[allow(irrefutable_let_patterns)]
2757    pub fn into_on_echo_named_event(self) -> Option<fidl_fidl_test_imported::SimpleStruct> {
2758        if let EchoEvent::OnEchoNamedEvent { value } = self { Some((value)) } else { None }
2759    }
2760    #[allow(irrefutable_let_patterns)]
2761    pub fn into_on_echo_table_payload_event(self) -> Option<ResponseTable> {
2762        if let EchoEvent::OnEchoTablePayloadEvent { payload } = self {
2763            Some((payload))
2764        } else {
2765            None
2766        }
2767    }
2768    #[allow(irrefutable_let_patterns)]
2769    pub fn into_on_echo_union_payload_event(self) -> Option<ResponseUnion> {
2770        if let EchoEvent::OnEchoUnionPayloadEvent { payload } = self {
2771            Some((payload))
2772        } else {
2773            None
2774        }
2775    }
2776
2777    /// Decodes a message buffer as a [`EchoEvent`].
2778    fn decode(
2779        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
2780    ) -> Result<EchoEvent, fidl::Error> {
2781        let (bytes, _handles) = buf.split_mut();
2782        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
2783        debug_assert_eq!(tx_header.tx_id, 0);
2784        match tx_header.ordinal {
2785            0x273b2029f1a0aee2 => {
2786                let mut out = fidl::new_empty!(
2787                    fidl::encoding::EmptyPayload,
2788                    fidl::encoding::DefaultFuchsiaResourceDialect
2789                );
2790                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&tx_header, _body_bytes, _handles, &mut out)?;
2791                Ok((EchoEvent::EchoMinimalEvent {}))
2792            }
2793            0x1219e12e0450024 => {
2794                let mut out = fidl::new_empty!(
2795                    EchoEchoEventRequest,
2796                    fidl::encoding::DefaultFuchsiaResourceDialect
2797                );
2798                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoEventRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
2799                Ok((EchoEvent::EchoEvent { value: out.value }))
2800            }
2801            0x749ebde83348a374 => {
2802                let mut out = fidl::new_empty!(
2803                    fidl_fidl_test_imported::ResponseStruct,
2804                    fidl::encoding::DefaultFuchsiaResourceDialect
2805                );
2806                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::ResponseStruct>(&tx_header, _body_bytes, _handles, &mut out)?;
2807                Ok((EchoEvent::OnEchoNamedEvent { value: out.value }))
2808            }
2809            0x708dddea1cb98430 => {
2810                let mut out =
2811                    fidl::new_empty!(ResponseTable, fidl::encoding::DefaultFuchsiaResourceDialect);
2812                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ResponseTable>(&tx_header, _body_bytes, _handles, &mut out)?;
2813                Ok((EchoEvent::OnEchoTablePayloadEvent { payload: out }))
2814            }
2815            0x642f4c265a05f4c0 => {
2816                let mut out =
2817                    fidl::new_empty!(ResponseUnion, fidl::encoding::DefaultFuchsiaResourceDialect);
2818                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ResponseUnion>(&tx_header, _body_bytes, _handles, &mut out)?;
2819                Ok((EchoEvent::OnEchoUnionPayloadEvent { payload: out }))
2820            }
2821            _ => Err(fidl::Error::UnknownOrdinal {
2822                ordinal: tx_header.ordinal,
2823                protocol_name: <EchoMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
2824            }),
2825        }
2826    }
2827}
2828
2829/// A Stream of incoming requests for fidl.test.compatibility/Echo.
2830pub struct EchoRequestStream {
2831    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
2832    is_terminated: bool,
2833}
2834
2835impl std::marker::Unpin for EchoRequestStream {}
2836
2837impl futures::stream::FusedStream for EchoRequestStream {
2838    fn is_terminated(&self) -> bool {
2839        self.is_terminated
2840    }
2841}
2842
2843impl fidl::endpoints::RequestStream for EchoRequestStream {
2844    type Protocol = EchoMarker;
2845    type ControlHandle = EchoControlHandle;
2846
2847    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
2848        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
2849    }
2850
2851    fn control_handle(&self) -> Self::ControlHandle {
2852        EchoControlHandle { inner: self.inner.clone() }
2853    }
2854
2855    fn into_inner(
2856        self,
2857    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
2858    {
2859        (self.inner, self.is_terminated)
2860    }
2861
2862    fn from_inner(
2863        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
2864        is_terminated: bool,
2865    ) -> Self {
2866        Self { inner, is_terminated }
2867    }
2868}
2869
2870impl futures::Stream for EchoRequestStream {
2871    type Item = Result<EchoRequest, fidl::Error>;
2872
2873    fn poll_next(
2874        mut self: std::pin::Pin<&mut Self>,
2875        cx: &mut std::task::Context<'_>,
2876    ) -> std::task::Poll<Option<Self::Item>> {
2877        let this = &mut *self;
2878        if this.inner.check_shutdown(cx) {
2879            this.is_terminated = true;
2880            return std::task::Poll::Ready(None);
2881        }
2882        if this.is_terminated {
2883            panic!("polled EchoRequestStream after completion");
2884        }
2885        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
2886            |bytes, handles| {
2887                match this.inner.channel().read_etc(cx, bytes, handles) {
2888                    std::task::Poll::Ready(Ok(())) => {}
2889                    std::task::Poll::Pending => return std::task::Poll::Pending,
2890                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
2891                        this.is_terminated = true;
2892                        return std::task::Poll::Ready(None);
2893                    }
2894                    std::task::Poll::Ready(Err(e)) => {
2895                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
2896                            e.into(),
2897                        ))));
2898                    }
2899                }
2900
2901                // A message has been received from the channel
2902                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
2903
2904                std::task::Poll::Ready(Some(match header.ordinal {
2905                    0x1d545c738c7a8ee => {
2906                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2907                        let mut req = fidl::new_empty!(
2908                            fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
2909                            fidl::encoding::DefaultFuchsiaResourceDialect
2910                        );
2911                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest>(&header, _body_bytes, handles, &mut req)?;
2912                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
2913                        Ok(EchoRequest::EchoTableRequestComposed {
2914                            payload: req,
2915                            responder: EchoEchoTableRequestComposedResponder {
2916                                control_handle: std::mem::ManuallyDrop::new(control_handle),
2917                                tx_id: header.tx_id,
2918                            },
2919                        })
2920                    }
2921                    0x38a67e88d6106443 => {
2922                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2923                        let mut req = fidl::new_empty!(fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
2924                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedRequest>(&header, _body_bytes, handles, &mut req)?;
2925                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
2926                        Ok(EchoRequest::EchoUnionResponseWithErrorComposed {
2927                            value: req.value,
2928                            want_absolute_value: req.want_absolute_value,
2929                            forward_to_server: req.forward_to_server,
2930                            result_err: req.result_err,
2931                            result_variant: req.result_variant,
2932
2933                            responder: EchoEchoUnionResponseWithErrorComposedResponder {
2934                                control_handle: std::mem::ManuallyDrop::new(control_handle),
2935                                tx_id: header.tx_id,
2936                            },
2937                        })
2938                    }
2939                    0x39edd68c837482ec => {
2940                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2941                        let mut req = fidl::new_empty!(
2942                            EchoEchoMinimalRequest,
2943                            fidl::encoding::DefaultFuchsiaResourceDialect
2944                        );
2945                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoMinimalRequest>(&header, _body_bytes, handles, &mut req)?;
2946                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
2947                        Ok(EchoRequest::EchoMinimal {
2948                            forward_to_server: req.forward_to_server,
2949
2950                            responder: EchoEchoMinimalResponder {
2951                                control_handle: std::mem::ManuallyDrop::new(control_handle),
2952                                tx_id: header.tx_id,
2953                            },
2954                        })
2955                    }
2956                    0x36f4695996e35acc => {
2957                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2958                        let mut req = fidl::new_empty!(
2959                            EchoEchoMinimalWithErrorRequest,
2960                            fidl::encoding::DefaultFuchsiaResourceDialect
2961                        );
2962                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoMinimalWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
2963                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
2964                        Ok(EchoRequest::EchoMinimalWithError {
2965                            forward_to_server: req.forward_to_server,
2966                            result_variant: req.result_variant,
2967
2968                            responder: EchoEchoMinimalWithErrorResponder {
2969                                control_handle: std::mem::ManuallyDrop::new(control_handle),
2970                                tx_id: header.tx_id,
2971                            },
2972                        })
2973                    }
2974                    0x42693c143e2c3694 => {
2975                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
2976                        let mut req = fidl::new_empty!(
2977                            EchoEchoMinimalNoRetValRequest,
2978                            fidl::encoding::DefaultFuchsiaResourceDialect
2979                        );
2980                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoMinimalNoRetValRequest>(&header, _body_bytes, handles, &mut req)?;
2981                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
2982                        Ok(EchoRequest::EchoMinimalNoRetVal {
2983                            forward_to_server: req.forward_to_server,
2984
2985                            control_handle,
2986                        })
2987                    }
2988                    0x4c2f85818cc53f37 => {
2989                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2990                        let mut req = fidl::new_empty!(
2991                            EchoEchoStructRequest,
2992                            fidl::encoding::DefaultFuchsiaResourceDialect
2993                        );
2994                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoStructRequest>(&header, _body_bytes, handles, &mut req)?;
2995                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
2996                        Ok(EchoRequest::EchoStruct {
2997                            value: req.value,
2998                            forward_to_server: req.forward_to_server,
2999
3000                            responder: EchoEchoStructResponder {
3001                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3002                                tx_id: header.tx_id,
3003                            },
3004                        })
3005                    }
3006                    0x46cb32652c4c0899 => {
3007                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3008                        let mut req = fidl::new_empty!(
3009                            EchoEchoStructWithErrorRequest,
3010                            fidl::encoding::DefaultFuchsiaResourceDialect
3011                        );
3012                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoStructWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3013                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3014                        Ok(EchoRequest::EchoStructWithError {
3015                            value: req.value,
3016                            result_err: req.result_err,
3017                            forward_to_server: req.forward_to_server,
3018                            result_variant: req.result_variant,
3019
3020                            responder: EchoEchoStructWithErrorResponder {
3021                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3022                                tx_id: header.tx_id,
3023                            },
3024                        })
3025                    }
3026                    0x1f763e602cf5892a => {
3027                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
3028                        let mut req = fidl::new_empty!(
3029                            EchoEchoStructNoRetValRequest,
3030                            fidl::encoding::DefaultFuchsiaResourceDialect
3031                        );
3032                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoStructNoRetValRequest>(&header, _body_bytes, handles, &mut req)?;
3033                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3034                        Ok(EchoRequest::EchoStructNoRetVal {
3035                            value: req.value,
3036                            forward_to_server: req.forward_to_server,
3037
3038                            control_handle,
3039                        })
3040                    }
3041                    0x1b6019d5611f2470 => {
3042                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3043                        let mut req = fidl::new_empty!(
3044                            EchoEchoArraysRequest,
3045                            fidl::encoding::DefaultFuchsiaResourceDialect
3046                        );
3047                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoArraysRequest>(&header, _body_bytes, handles, &mut req)?;
3048                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3049                        Ok(EchoRequest::EchoArrays {
3050                            value: req.value,
3051                            forward_to_server: req.forward_to_server,
3052
3053                            responder: EchoEchoArraysResponder {
3054                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3055                                tx_id: header.tx_id,
3056                            },
3057                        })
3058                    }
3059                    0x6dbf26e67e253afa => {
3060                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3061                        let mut req = fidl::new_empty!(
3062                            EchoEchoArraysWithErrorRequest,
3063                            fidl::encoding::DefaultFuchsiaResourceDialect
3064                        );
3065                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoArraysWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3066                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3067                        Ok(EchoRequest::EchoArraysWithError {
3068                            value: req.value,
3069                            result_err: req.result_err,
3070                            forward_to_server: req.forward_to_server,
3071                            result_variant: req.result_variant,
3072
3073                            responder: EchoEchoArraysWithErrorResponder {
3074                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3075                                tx_id: header.tx_id,
3076                            },
3077                        })
3078                    }
3079                    0x1582623f0d9f6e5e => {
3080                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3081                        let mut req = fidl::new_empty!(
3082                            EchoEchoVectorsRequest,
3083                            fidl::encoding::DefaultFuchsiaResourceDialect
3084                        );
3085                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoVectorsRequest>(&header, _body_bytes, handles, &mut req)?;
3086                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3087                        Ok(EchoRequest::EchoVectors {
3088                            value: req.value,
3089                            forward_to_server: req.forward_to_server,
3090
3091                            responder: EchoEchoVectorsResponder {
3092                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3093                                tx_id: header.tx_id,
3094                            },
3095                        })
3096                    }
3097                    0x730f163401e2b3e5 => {
3098                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3099                        let mut req = fidl::new_empty!(
3100                            EchoEchoVectorsWithErrorRequest,
3101                            fidl::encoding::DefaultFuchsiaResourceDialect
3102                        );
3103                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoVectorsWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3104                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3105                        Ok(EchoRequest::EchoVectorsWithError {
3106                            value: req.value,
3107                            result_err: req.result_err,
3108                            forward_to_server: req.forward_to_server,
3109                            result_variant: req.result_variant,
3110
3111                            responder: EchoEchoVectorsWithErrorResponder {
3112                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3113                                tx_id: header.tx_id,
3114                            },
3115                        })
3116                    }
3117                    0x4f1fb0a512f47c4b => {
3118                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3119                        let mut req = fidl::new_empty!(
3120                            EchoEchoTableRequest,
3121                            fidl::encoding::DefaultFuchsiaResourceDialect
3122                        );
3123                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoTableRequest>(&header, _body_bytes, handles, &mut req)?;
3124                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3125                        Ok(EchoRequest::EchoTable {
3126                            value: req.value,
3127                            forward_to_server: req.forward_to_server,
3128
3129                            responder: EchoEchoTableResponder {
3130                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3131                                tx_id: header.tx_id,
3132                            },
3133                        })
3134                    }
3135                    0x44e835cb1eb9a931 => {
3136                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3137                        let mut req = fidl::new_empty!(
3138                            EchoEchoTableWithErrorRequest,
3139                            fidl::encoding::DefaultFuchsiaResourceDialect
3140                        );
3141                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoTableWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3142                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3143                        Ok(EchoRequest::EchoTableWithError {
3144                            value: req.value,
3145                            result_err: req.result_err,
3146                            forward_to_server: req.forward_to_server,
3147                            result_variant: req.result_variant,
3148
3149                            responder: EchoEchoTableWithErrorResponder {
3150                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3151                                tx_id: header.tx_id,
3152                            },
3153                        })
3154                    }
3155                    0x3dc181909041a583 => {
3156                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3157                        let mut req = fidl::new_empty!(
3158                            EchoEchoXunionsRequest,
3159                            fidl::encoding::DefaultFuchsiaResourceDialect
3160                        );
3161                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoXunionsRequest>(&header, _body_bytes, handles, &mut req)?;
3162                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3163                        Ok(EchoRequest::EchoXunions {
3164                            value: req.value,
3165                            forward_to_server: req.forward_to_server,
3166
3167                            responder: EchoEchoXunionsResponder {
3168                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3169                                tx_id: header.tx_id,
3170                            },
3171                        })
3172                    }
3173                    0x75184102667fa766 => {
3174                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3175                        let mut req = fidl::new_empty!(
3176                            EchoEchoXunionsWithErrorRequest,
3177                            fidl::encoding::DefaultFuchsiaResourceDialect
3178                        );
3179                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoXunionsWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3180                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3181                        Ok(EchoRequest::EchoXunionsWithError {
3182                            value: req.value,
3183                            result_err: req.result_err,
3184                            forward_to_server: req.forward_to_server,
3185                            result_variant: req.result_variant,
3186
3187                            responder: EchoEchoXunionsWithErrorResponder {
3188                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3189                                tx_id: header.tx_id,
3190                            },
3191                        })
3192                    }
3193                    0xf2d4aa9e65f7111 => {
3194                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3195                        let mut req = fidl::new_empty!(
3196                            fidl_fidl_test_imported::RequestStruct,
3197                            fidl::encoding::DefaultFuchsiaResourceDialect
3198                        );
3199                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::RequestStruct>(&header, _body_bytes, handles, &mut req)?;
3200                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3201                        Ok(EchoRequest::EchoNamedStruct {
3202                            value: req.value,
3203                            forward_to_server: req.forward_to_server,
3204
3205                            responder: EchoEchoNamedStructResponder {
3206                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3207                                tx_id: header.tx_id,
3208                            },
3209                        })
3210                    }
3211                    0x5766fee9e74442e8 => {
3212                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3213                        let mut req = fidl::new_empty!(
3214                            fidl_fidl_test_imported::ErrorableRequestStruct,
3215                            fidl::encoding::DefaultFuchsiaResourceDialect
3216                        );
3217                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::ErrorableRequestStruct>(&header, _body_bytes, handles, &mut req)?;
3218                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3219                        Ok(EchoRequest::EchoNamedStructWithError {
3220                            value: req.value,
3221                            result_err: req.result_err,
3222                            forward_to_server: req.forward_to_server,
3223                            result_variant: req.result_variant,
3224
3225                            responder: EchoEchoNamedStructWithErrorResponder {
3226                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3227                                tx_id: header.tx_id,
3228                            },
3229                        })
3230                    }
3231                    0x3a50bbf7d2113ad7 => {
3232                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
3233                        let mut req = fidl::new_empty!(
3234                            fidl_fidl_test_imported::EventTriggeringRequestStruct,
3235                            fidl::encoding::DefaultFuchsiaResourceDialect
3236                        );
3237                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::EventTriggeringRequestStruct>(&header, _body_bytes, handles, &mut req)?;
3238                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3239                        Ok(EchoRequest::EchoNamedStructNoRetVal {
3240                            value: req.value,
3241                            forward_to_server: req.forward_to_server,
3242
3243                            control_handle,
3244                        })
3245                    }
3246                    0x641d98087378c003 => {
3247                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3248                        let mut req = fidl::new_empty!(
3249                            RequestTable,
3250                            fidl::encoding::DefaultFuchsiaResourceDialect
3251                        );
3252                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RequestTable>(&header, _body_bytes, handles, &mut req)?;
3253                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3254                        Ok(EchoRequest::EchoTablePayload {
3255                            payload: req,
3256                            responder: EchoEchoTablePayloadResponder {
3257                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3258                                tx_id: header.tx_id,
3259                            },
3260                        })
3261                    }
3262                    0x636ed243761ab66d => {
3263                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3264                        let mut req = fidl::new_empty!(
3265                            EchoEchoTablePayloadWithErrorRequest,
3266                            fidl::encoding::DefaultFuchsiaResourceDialect
3267                        );
3268                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoTablePayloadWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3269                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3270                        Ok(EchoRequest::EchoTablePayloadWithError {
3271                            payload: req,
3272                            responder: EchoEchoTablePayloadWithErrorResponder {
3273                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3274                                tx_id: header.tx_id,
3275                            },
3276                        })
3277                    }
3278                    0x32961f7d718569f8 => {
3279                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
3280                        let mut req = fidl::new_empty!(
3281                            RequestTable,
3282                            fidl::encoding::DefaultFuchsiaResourceDialect
3283                        );
3284                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RequestTable>(&header, _body_bytes, handles, &mut req)?;
3285                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3286                        Ok(EchoRequest::EchoTablePayloadNoRetVal { payload: req, control_handle })
3287                    }
3288                    0x66def9e793f10c55 => {
3289                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3290                        let mut req = fidl::new_empty!(
3291                            RequestUnion,
3292                            fidl::encoding::DefaultFuchsiaResourceDialect
3293                        );
3294                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RequestUnion>(&header, _body_bytes, handles, &mut req)?;
3295                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3296                        Ok(EchoRequest::EchoUnionPayload {
3297                            payload: req,
3298                            responder: EchoEchoUnionPayloadResponder {
3299                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3300                                tx_id: header.tx_id,
3301                            },
3302                        })
3303                    }
3304                    0x1be890d6e68ef063 => {
3305                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3306                        let mut req = fidl::new_empty!(
3307                            EchoEchoUnionPayloadWithErrorRequest,
3308                            fidl::encoding::DefaultFuchsiaResourceDialect
3309                        );
3310                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoUnionPayloadWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3311                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3312                        Ok(EchoRequest::EchoUnionPayloadWithError {
3313                            payload: req,
3314                            responder: EchoEchoUnionPayloadWithErrorResponder {
3315                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3316                                tx_id: header.tx_id,
3317                            },
3318                        })
3319                    }
3320                    0x11518bf346430040 => {
3321                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
3322                        let mut req = fidl::new_empty!(
3323                            RequestUnion,
3324                            fidl::encoding::DefaultFuchsiaResourceDialect
3325                        );
3326                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RequestUnion>(&header, _body_bytes, handles, &mut req)?;
3327                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3328                        Ok(EchoRequest::EchoUnionPayloadNoRetVal { payload: req, control_handle })
3329                    }
3330                    _ => Err(fidl::Error::UnknownOrdinal {
3331                        ordinal: header.ordinal,
3332                        protocol_name: <EchoMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
3333                    }),
3334                }))
3335            },
3336        )
3337    }
3338}
3339
3340#[derive(Debug)]
3341pub enum EchoRequest {
3342    EchoTableRequestComposed {
3343        payload: fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
3344        responder: EchoEchoTableRequestComposedResponder,
3345    },
3346    EchoUnionResponseWithErrorComposed {
3347        value: i64,
3348        want_absolute_value: bool,
3349        forward_to_server: String,
3350        result_err: u32,
3351        result_variant: fidl_fidl_test_imported::WantResponse,
3352        responder: EchoEchoUnionResponseWithErrorComposedResponder,
3353    },
3354    EchoMinimal {
3355        forward_to_server: String,
3356        responder: EchoEchoMinimalResponder,
3357    },
3358    EchoMinimalWithError {
3359        forward_to_server: String,
3360        result_variant: RespondWith,
3361        responder: EchoEchoMinimalWithErrorResponder,
3362    },
3363    EchoMinimalNoRetVal {
3364        forward_to_server: String,
3365        control_handle: EchoControlHandle,
3366    },
3367    EchoStruct {
3368        value: Struct,
3369        forward_to_server: String,
3370        responder: EchoEchoStructResponder,
3371    },
3372    EchoStructWithError {
3373        value: Struct,
3374        result_err: DefaultEnum,
3375        forward_to_server: String,
3376        result_variant: RespondWith,
3377        responder: EchoEchoStructWithErrorResponder,
3378    },
3379    EchoStructNoRetVal {
3380        value: Struct,
3381        forward_to_server: String,
3382        control_handle: EchoControlHandle,
3383    },
3384    EchoArrays {
3385        value: ArraysStruct,
3386        forward_to_server: String,
3387        responder: EchoEchoArraysResponder,
3388    },
3389    EchoArraysWithError {
3390        value: ArraysStruct,
3391        result_err: DefaultEnum,
3392        forward_to_server: String,
3393        result_variant: RespondWith,
3394        responder: EchoEchoArraysWithErrorResponder,
3395    },
3396    EchoVectors {
3397        value: VectorsStruct,
3398        forward_to_server: String,
3399        responder: EchoEchoVectorsResponder,
3400    },
3401    EchoVectorsWithError {
3402        value: VectorsStruct,
3403        result_err: DefaultEnum,
3404        forward_to_server: String,
3405        result_variant: RespondWith,
3406        responder: EchoEchoVectorsWithErrorResponder,
3407    },
3408    EchoTable {
3409        value: AllTypesTable,
3410        forward_to_server: String,
3411        responder: EchoEchoTableResponder,
3412    },
3413    EchoTableWithError {
3414        value: AllTypesTable,
3415        result_err: DefaultEnum,
3416        forward_to_server: String,
3417        result_variant: RespondWith,
3418        responder: EchoEchoTableWithErrorResponder,
3419    },
3420    EchoXunions {
3421        value: Vec<AllTypesXunion>,
3422        forward_to_server: String,
3423        responder: EchoEchoXunionsResponder,
3424    },
3425    EchoXunionsWithError {
3426        value: Vec<AllTypesXunion>,
3427        result_err: DefaultEnum,
3428        forward_to_server: String,
3429        result_variant: RespondWith,
3430        responder: EchoEchoXunionsWithErrorResponder,
3431    },
3432    EchoNamedStruct {
3433        value: fidl_fidl_test_imported::SimpleStruct,
3434        forward_to_server: String,
3435        responder: EchoEchoNamedStructResponder,
3436    },
3437    EchoNamedStructWithError {
3438        value: fidl_fidl_test_imported::SimpleStruct,
3439        result_err: u32,
3440        forward_to_server: String,
3441        result_variant: fidl_fidl_test_imported::WantResponse,
3442        responder: EchoEchoNamedStructWithErrorResponder,
3443    },
3444    EchoNamedStructNoRetVal {
3445        value: fidl_fidl_test_imported::SimpleStruct,
3446        forward_to_server: String,
3447        control_handle: EchoControlHandle,
3448    },
3449    EchoTablePayload {
3450        payload: RequestTable,
3451        responder: EchoEchoTablePayloadResponder,
3452    },
3453    EchoTablePayloadWithError {
3454        payload: EchoEchoTablePayloadWithErrorRequest,
3455        responder: EchoEchoTablePayloadWithErrorResponder,
3456    },
3457    EchoTablePayloadNoRetVal {
3458        payload: RequestTable,
3459        control_handle: EchoControlHandle,
3460    },
3461    EchoUnionPayload {
3462        payload: RequestUnion,
3463        responder: EchoEchoUnionPayloadResponder,
3464    },
3465    EchoUnionPayloadWithError {
3466        payload: EchoEchoUnionPayloadWithErrorRequest,
3467        responder: EchoEchoUnionPayloadWithErrorResponder,
3468    },
3469    EchoUnionPayloadNoRetVal {
3470        payload: RequestUnion,
3471        control_handle: EchoControlHandle,
3472    },
3473}
3474
3475impl EchoRequest {
3476    #[allow(irrefutable_let_patterns)]
3477    pub fn into_echo_table_request_composed(
3478        self,
3479    ) -> Option<(
3480        fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
3481        EchoEchoTableRequestComposedResponder,
3482    )> {
3483        if let EchoRequest::EchoTableRequestComposed { payload, responder } = self {
3484            Some((payload, responder))
3485        } else {
3486            None
3487        }
3488    }
3489
3490    #[allow(irrefutable_let_patterns)]
3491    pub fn into_echo_union_response_with_error_composed(
3492        self,
3493    ) -> Option<(
3494        i64,
3495        bool,
3496        String,
3497        u32,
3498        fidl_fidl_test_imported::WantResponse,
3499        EchoEchoUnionResponseWithErrorComposedResponder,
3500    )> {
3501        if let EchoRequest::EchoUnionResponseWithErrorComposed {
3502            value,
3503            want_absolute_value,
3504            forward_to_server,
3505            result_err,
3506            result_variant,
3507            responder,
3508        } = self
3509        {
3510            Some((
3511                value,
3512                want_absolute_value,
3513                forward_to_server,
3514                result_err,
3515                result_variant,
3516                responder,
3517            ))
3518        } else {
3519            None
3520        }
3521    }
3522
3523    #[allow(irrefutable_let_patterns)]
3524    pub fn into_echo_minimal(self) -> Option<(String, EchoEchoMinimalResponder)> {
3525        if let EchoRequest::EchoMinimal { forward_to_server, responder } = self {
3526            Some((forward_to_server, responder))
3527        } else {
3528            None
3529        }
3530    }
3531
3532    #[allow(irrefutable_let_patterns)]
3533    pub fn into_echo_minimal_with_error(
3534        self,
3535    ) -> Option<(String, RespondWith, EchoEchoMinimalWithErrorResponder)> {
3536        if let EchoRequest::EchoMinimalWithError { forward_to_server, result_variant, responder } =
3537            self
3538        {
3539            Some((forward_to_server, result_variant, responder))
3540        } else {
3541            None
3542        }
3543    }
3544
3545    #[allow(irrefutable_let_patterns)]
3546    pub fn into_echo_minimal_no_ret_val(self) -> Option<(String, EchoControlHandle)> {
3547        if let EchoRequest::EchoMinimalNoRetVal { forward_to_server, control_handle } = self {
3548            Some((forward_to_server, control_handle))
3549        } else {
3550            None
3551        }
3552    }
3553
3554    #[allow(irrefutable_let_patterns)]
3555    pub fn into_echo_struct(self) -> Option<(Struct, String, EchoEchoStructResponder)> {
3556        if let EchoRequest::EchoStruct { value, forward_to_server, responder } = self {
3557            Some((value, forward_to_server, responder))
3558        } else {
3559            None
3560        }
3561    }
3562
3563    #[allow(irrefutable_let_patterns)]
3564    pub fn into_echo_struct_with_error(
3565        self,
3566    ) -> Option<(Struct, DefaultEnum, String, RespondWith, EchoEchoStructWithErrorResponder)> {
3567        if let EchoRequest::EchoStructWithError {
3568            value,
3569            result_err,
3570            forward_to_server,
3571            result_variant,
3572            responder,
3573        } = self
3574        {
3575            Some((value, result_err, forward_to_server, result_variant, responder))
3576        } else {
3577            None
3578        }
3579    }
3580
3581    #[allow(irrefutable_let_patterns)]
3582    pub fn into_echo_struct_no_ret_val(self) -> Option<(Struct, String, EchoControlHandle)> {
3583        if let EchoRequest::EchoStructNoRetVal { value, forward_to_server, control_handle } = self {
3584            Some((value, forward_to_server, control_handle))
3585        } else {
3586            None
3587        }
3588    }
3589
3590    #[allow(irrefutable_let_patterns)]
3591    pub fn into_echo_arrays(self) -> Option<(ArraysStruct, String, EchoEchoArraysResponder)> {
3592        if let EchoRequest::EchoArrays { value, forward_to_server, responder } = self {
3593            Some((value, forward_to_server, responder))
3594        } else {
3595            None
3596        }
3597    }
3598
3599    #[allow(irrefutable_let_patterns)]
3600    pub fn into_echo_arrays_with_error(
3601        self,
3602    ) -> Option<(ArraysStruct, DefaultEnum, String, RespondWith, EchoEchoArraysWithErrorResponder)>
3603    {
3604        if let EchoRequest::EchoArraysWithError {
3605            value,
3606            result_err,
3607            forward_to_server,
3608            result_variant,
3609            responder,
3610        } = self
3611        {
3612            Some((value, result_err, forward_to_server, result_variant, responder))
3613        } else {
3614            None
3615        }
3616    }
3617
3618    #[allow(irrefutable_let_patterns)]
3619    pub fn into_echo_vectors(self) -> Option<(VectorsStruct, String, EchoEchoVectorsResponder)> {
3620        if let EchoRequest::EchoVectors { value, forward_to_server, responder } = self {
3621            Some((value, forward_to_server, responder))
3622        } else {
3623            None
3624        }
3625    }
3626
3627    #[allow(irrefutable_let_patterns)]
3628    pub fn into_echo_vectors_with_error(
3629        self,
3630    ) -> Option<(VectorsStruct, DefaultEnum, String, RespondWith, EchoEchoVectorsWithErrorResponder)>
3631    {
3632        if let EchoRequest::EchoVectorsWithError {
3633            value,
3634            result_err,
3635            forward_to_server,
3636            result_variant,
3637            responder,
3638        } = self
3639        {
3640            Some((value, result_err, forward_to_server, result_variant, responder))
3641        } else {
3642            None
3643        }
3644    }
3645
3646    #[allow(irrefutable_let_patterns)]
3647    pub fn into_echo_table(self) -> Option<(AllTypesTable, String, EchoEchoTableResponder)> {
3648        if let EchoRequest::EchoTable { value, forward_to_server, responder } = self {
3649            Some((value, forward_to_server, responder))
3650        } else {
3651            None
3652        }
3653    }
3654
3655    #[allow(irrefutable_let_patterns)]
3656    pub fn into_echo_table_with_error(
3657        self,
3658    ) -> Option<(AllTypesTable, DefaultEnum, String, RespondWith, EchoEchoTableWithErrorResponder)>
3659    {
3660        if let EchoRequest::EchoTableWithError {
3661            value,
3662            result_err,
3663            forward_to_server,
3664            result_variant,
3665            responder,
3666        } = self
3667        {
3668            Some((value, result_err, forward_to_server, result_variant, responder))
3669        } else {
3670            None
3671        }
3672    }
3673
3674    #[allow(irrefutable_let_patterns)]
3675    pub fn into_echo_xunions(
3676        self,
3677    ) -> Option<(Vec<AllTypesXunion>, String, EchoEchoXunionsResponder)> {
3678        if let EchoRequest::EchoXunions { value, forward_to_server, responder } = self {
3679            Some((value, forward_to_server, responder))
3680        } else {
3681            None
3682        }
3683    }
3684
3685    #[allow(irrefutable_let_patterns)]
3686    pub fn into_echo_xunions_with_error(
3687        self,
3688    ) -> Option<(
3689        Vec<AllTypesXunion>,
3690        DefaultEnum,
3691        String,
3692        RespondWith,
3693        EchoEchoXunionsWithErrorResponder,
3694    )> {
3695        if let EchoRequest::EchoXunionsWithError {
3696            value,
3697            result_err,
3698            forward_to_server,
3699            result_variant,
3700            responder,
3701        } = self
3702        {
3703            Some((value, result_err, forward_to_server, result_variant, responder))
3704        } else {
3705            None
3706        }
3707    }
3708
3709    #[allow(irrefutable_let_patterns)]
3710    pub fn into_echo_named_struct(
3711        self,
3712    ) -> Option<(fidl_fidl_test_imported::SimpleStruct, String, EchoEchoNamedStructResponder)> {
3713        if let EchoRequest::EchoNamedStruct { value, forward_to_server, responder } = self {
3714            Some((value, forward_to_server, responder))
3715        } else {
3716            None
3717        }
3718    }
3719
3720    #[allow(irrefutable_let_patterns)]
3721    pub fn into_echo_named_struct_with_error(
3722        self,
3723    ) -> Option<(
3724        fidl_fidl_test_imported::SimpleStruct,
3725        u32,
3726        String,
3727        fidl_fidl_test_imported::WantResponse,
3728        EchoEchoNamedStructWithErrorResponder,
3729    )> {
3730        if let EchoRequest::EchoNamedStructWithError {
3731            value,
3732            result_err,
3733            forward_to_server,
3734            result_variant,
3735            responder,
3736        } = self
3737        {
3738            Some((value, result_err, forward_to_server, result_variant, responder))
3739        } else {
3740            None
3741        }
3742    }
3743
3744    #[allow(irrefutable_let_patterns)]
3745    pub fn into_echo_named_struct_no_ret_val(
3746        self,
3747    ) -> Option<(fidl_fidl_test_imported::SimpleStruct, String, EchoControlHandle)> {
3748        if let EchoRequest::EchoNamedStructNoRetVal { value, forward_to_server, control_handle } =
3749            self
3750        {
3751            Some((value, forward_to_server, control_handle))
3752        } else {
3753            None
3754        }
3755    }
3756
3757    #[allow(irrefutable_let_patterns)]
3758    pub fn into_echo_table_payload(self) -> Option<(RequestTable, EchoEchoTablePayloadResponder)> {
3759        if let EchoRequest::EchoTablePayload { payload, responder } = self {
3760            Some((payload, responder))
3761        } else {
3762            None
3763        }
3764    }
3765
3766    #[allow(irrefutable_let_patterns)]
3767    pub fn into_echo_table_payload_with_error(
3768        self,
3769    ) -> Option<(EchoEchoTablePayloadWithErrorRequest, EchoEchoTablePayloadWithErrorResponder)>
3770    {
3771        if let EchoRequest::EchoTablePayloadWithError { payload, responder } = self {
3772            Some((payload, responder))
3773        } else {
3774            None
3775        }
3776    }
3777
3778    #[allow(irrefutable_let_patterns)]
3779    pub fn into_echo_table_payload_no_ret_val(self) -> Option<(RequestTable, EchoControlHandle)> {
3780        if let EchoRequest::EchoTablePayloadNoRetVal { payload, control_handle } = self {
3781            Some((payload, control_handle))
3782        } else {
3783            None
3784        }
3785    }
3786
3787    #[allow(irrefutable_let_patterns)]
3788    pub fn into_echo_union_payload(self) -> Option<(RequestUnion, EchoEchoUnionPayloadResponder)> {
3789        if let EchoRequest::EchoUnionPayload { payload, responder } = self {
3790            Some((payload, responder))
3791        } else {
3792            None
3793        }
3794    }
3795
3796    #[allow(irrefutable_let_patterns)]
3797    pub fn into_echo_union_payload_with_error(
3798        self,
3799    ) -> Option<(EchoEchoUnionPayloadWithErrorRequest, EchoEchoUnionPayloadWithErrorResponder)>
3800    {
3801        if let EchoRequest::EchoUnionPayloadWithError { payload, responder } = self {
3802            Some((payload, responder))
3803        } else {
3804            None
3805        }
3806    }
3807
3808    #[allow(irrefutable_let_patterns)]
3809    pub fn into_echo_union_payload_no_ret_val(self) -> Option<(RequestUnion, EchoControlHandle)> {
3810        if let EchoRequest::EchoUnionPayloadNoRetVal { payload, control_handle } = self {
3811            Some((payload, control_handle))
3812        } else {
3813            None
3814        }
3815    }
3816
3817    /// Name of the method defined in FIDL
3818    pub fn method_name(&self) -> &'static str {
3819        match *self {
3820            EchoRequest::EchoTableRequestComposed { .. } => "echo_table_request_composed",
3821            EchoRequest::EchoUnionResponseWithErrorComposed { .. } => {
3822                "echo_union_response_with_error_composed"
3823            }
3824            EchoRequest::EchoMinimal { .. } => "echo_minimal",
3825            EchoRequest::EchoMinimalWithError { .. } => "echo_minimal_with_error",
3826            EchoRequest::EchoMinimalNoRetVal { .. } => "echo_minimal_no_ret_val",
3827            EchoRequest::EchoStruct { .. } => "echo_struct",
3828            EchoRequest::EchoStructWithError { .. } => "echo_struct_with_error",
3829            EchoRequest::EchoStructNoRetVal { .. } => "echo_struct_no_ret_val",
3830            EchoRequest::EchoArrays { .. } => "echo_arrays",
3831            EchoRequest::EchoArraysWithError { .. } => "echo_arrays_with_error",
3832            EchoRequest::EchoVectors { .. } => "echo_vectors",
3833            EchoRequest::EchoVectorsWithError { .. } => "echo_vectors_with_error",
3834            EchoRequest::EchoTable { .. } => "echo_table",
3835            EchoRequest::EchoTableWithError { .. } => "echo_table_with_error",
3836            EchoRequest::EchoXunions { .. } => "echo_xunions",
3837            EchoRequest::EchoXunionsWithError { .. } => "echo_xunions_with_error",
3838            EchoRequest::EchoNamedStruct { .. } => "echo_named_struct",
3839            EchoRequest::EchoNamedStructWithError { .. } => "echo_named_struct_with_error",
3840            EchoRequest::EchoNamedStructNoRetVal { .. } => "echo_named_struct_no_ret_val",
3841            EchoRequest::EchoTablePayload { .. } => "echo_table_payload",
3842            EchoRequest::EchoTablePayloadWithError { .. } => "echo_table_payload_with_error",
3843            EchoRequest::EchoTablePayloadNoRetVal { .. } => "echo_table_payload_no_ret_val",
3844            EchoRequest::EchoUnionPayload { .. } => "echo_union_payload",
3845            EchoRequest::EchoUnionPayloadWithError { .. } => "echo_union_payload_with_error",
3846            EchoRequest::EchoUnionPayloadNoRetVal { .. } => "echo_union_payload_no_ret_val",
3847        }
3848    }
3849}
3850
3851#[derive(Debug, Clone)]
3852pub struct EchoControlHandle {
3853    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
3854}
3855
3856impl fidl::endpoints::ControlHandle for EchoControlHandle {
3857    fn shutdown(&self) {
3858        self.inner.shutdown()
3859    }
3860
3861    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
3862        self.inner.shutdown_with_epitaph(status)
3863    }
3864
3865    fn is_closed(&self) -> bool {
3866        self.inner.channel().is_closed()
3867    }
3868    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
3869        self.inner.channel().on_closed()
3870    }
3871
3872    #[cfg(target_os = "fuchsia")]
3873    fn signal_peer(
3874        &self,
3875        clear_mask: zx::Signals,
3876        set_mask: zx::Signals,
3877    ) -> Result<(), zx_status::Status> {
3878        use fidl::Peered;
3879        self.inner.channel().signal_peer(clear_mask, set_mask)
3880    }
3881}
3882
3883impl EchoControlHandle {
3884    pub fn send_echo_minimal_event(&self) -> Result<(), fidl::Error> {
3885        self.inner.send::<fidl::encoding::EmptyPayload>(
3886            (),
3887            0,
3888            0x273b2029f1a0aee2,
3889            fidl::encoding::DynamicFlags::empty(),
3890        )
3891    }
3892
3893    pub fn send_echo_event(&self, mut value: Struct) -> Result<(), fidl::Error> {
3894        self.inner.send::<EchoEchoEventRequest>(
3895            (&mut value,),
3896            0,
3897            0x1219e12e0450024,
3898            fidl::encoding::DynamicFlags::empty(),
3899        )
3900    }
3901
3902    pub fn send_on_echo_named_event(
3903        &self,
3904        mut value: &fidl_fidl_test_imported::SimpleStruct,
3905    ) -> Result<(), fidl::Error> {
3906        self.inner.send::<fidl_fidl_test_imported::ResponseStruct>(
3907            (value,),
3908            0,
3909            0x749ebde83348a374,
3910            fidl::encoding::DynamicFlags::empty(),
3911        )
3912    }
3913
3914    pub fn send_on_echo_table_payload_event(
3915        &self,
3916        mut payload: &ResponseTable,
3917    ) -> Result<(), fidl::Error> {
3918        self.inner.send::<ResponseTable>(
3919            payload,
3920            0,
3921            0x708dddea1cb98430,
3922            fidl::encoding::DynamicFlags::empty(),
3923        )
3924    }
3925
3926    pub fn send_on_echo_union_payload_event(
3927        &self,
3928        mut payload: &ResponseUnion,
3929    ) -> Result<(), fidl::Error> {
3930        self.inner.send::<ResponseUnion>(
3931            payload,
3932            0,
3933            0x642f4c265a05f4c0,
3934            fidl::encoding::DynamicFlags::empty(),
3935        )
3936    }
3937}
3938
3939#[must_use = "FIDL methods require a response to be sent"]
3940#[derive(Debug)]
3941pub struct EchoEchoTableRequestComposedResponder {
3942    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
3943    tx_id: u32,
3944}
3945
3946/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
3947/// if the responder is dropped without sending a response, so that the client
3948/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
3949impl std::ops::Drop for EchoEchoTableRequestComposedResponder {
3950    fn drop(&mut self) {
3951        self.control_handle.shutdown();
3952        // Safety: drops once, never accessed again
3953        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3954    }
3955}
3956
3957impl fidl::endpoints::Responder for EchoEchoTableRequestComposedResponder {
3958    type ControlHandle = EchoControlHandle;
3959
3960    fn control_handle(&self) -> &EchoControlHandle {
3961        &self.control_handle
3962    }
3963
3964    fn drop_without_shutdown(mut self) {
3965        // Safety: drops once, never accessed again due to mem::forget
3966        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3967        // Prevent Drop from running (which would shut down the channel)
3968        std::mem::forget(self);
3969    }
3970}
3971
3972impl EchoEchoTableRequestComposedResponder {
3973    /// Sends a response to the FIDL transaction.
3974    ///
3975    /// Sets the channel to shutdown if an error occurs.
3976    pub fn send(
3977        self,
3978        mut value: &fidl_fidl_test_imported::SimpleStruct,
3979    ) -> Result<(), fidl::Error> {
3980        let _result = self.send_raw(value);
3981        if _result.is_err() {
3982            self.control_handle.shutdown();
3983        }
3984        self.drop_without_shutdown();
3985        _result
3986    }
3987
3988    /// Similar to "send" but does not shutdown the channel if an error occurs.
3989    pub fn send_no_shutdown_on_err(
3990        self,
3991        mut value: &fidl_fidl_test_imported::SimpleStruct,
3992    ) -> Result<(), fidl::Error> {
3993        let _result = self.send_raw(value);
3994        self.drop_without_shutdown();
3995        _result
3996    }
3997
3998    fn send_raw(
3999        &self,
4000        mut value: &fidl_fidl_test_imported::SimpleStruct,
4001    ) -> Result<(), fidl::Error> {
4002        self.control_handle.inner.send::<fidl_fidl_test_imported::ResponseStruct>(
4003            (value,),
4004            self.tx_id,
4005            0x1d545c738c7a8ee,
4006            fidl::encoding::DynamicFlags::empty(),
4007        )
4008    }
4009}
4010
4011#[must_use = "FIDL methods require a response to be sent"]
4012#[derive(Debug)]
4013pub struct EchoEchoUnionResponseWithErrorComposedResponder {
4014    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4015    tx_id: u32,
4016}
4017
4018/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4019/// if the responder is dropped without sending a response, so that the client
4020/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4021impl std::ops::Drop for EchoEchoUnionResponseWithErrorComposedResponder {
4022    fn drop(&mut self) {
4023        self.control_handle.shutdown();
4024        // Safety: drops once, never accessed again
4025        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4026    }
4027}
4028
4029impl fidl::endpoints::Responder for EchoEchoUnionResponseWithErrorComposedResponder {
4030    type ControlHandle = EchoControlHandle;
4031
4032    fn control_handle(&self) -> &EchoControlHandle {
4033        &self.control_handle
4034    }
4035
4036    fn drop_without_shutdown(mut self) {
4037        // Safety: drops once, never accessed again due to mem::forget
4038        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4039        // Prevent Drop from running (which would shut down the channel)
4040        std::mem::forget(self);
4041    }
4042}
4043
4044impl EchoEchoUnionResponseWithErrorComposedResponder {
4045    /// Sends a response to the FIDL transaction.
4046    ///
4047    /// Sets the channel to shutdown if an error occurs.
4048    pub fn send(
4049        self,
4050        mut result: Result<
4051            &fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse,
4052            u32,
4053        >,
4054    ) -> Result<(), fidl::Error> {
4055        let _result = self.send_raw(result);
4056        if _result.is_err() {
4057            self.control_handle.shutdown();
4058        }
4059        self.drop_without_shutdown();
4060        _result
4061    }
4062
4063    /// Similar to "send" but does not shutdown the channel if an error occurs.
4064    pub fn send_no_shutdown_on_err(
4065        self,
4066        mut result: Result<
4067            &fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse,
4068            u32,
4069        >,
4070    ) -> Result<(), fidl::Error> {
4071        let _result = self.send_raw(result);
4072        self.drop_without_shutdown();
4073        _result
4074    }
4075
4076    fn send_raw(
4077        &self,
4078        mut result: Result<
4079            &fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse,
4080            u32,
4081        >,
4082    ) -> Result<(), fidl::Error> {
4083        self.control_handle.inner.send::<fidl::encoding::ResultType<
4084            fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse,
4085            u32,
4086        >>(
4087            result,
4088            self.tx_id,
4089            0x38a67e88d6106443,
4090            fidl::encoding::DynamicFlags::empty(),
4091        )
4092    }
4093}
4094
4095#[must_use = "FIDL methods require a response to be sent"]
4096#[derive(Debug)]
4097pub struct EchoEchoMinimalResponder {
4098    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4099    tx_id: u32,
4100}
4101
4102/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4103/// if the responder is dropped without sending a response, so that the client
4104/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4105impl std::ops::Drop for EchoEchoMinimalResponder {
4106    fn drop(&mut self) {
4107        self.control_handle.shutdown();
4108        // Safety: drops once, never accessed again
4109        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4110    }
4111}
4112
4113impl fidl::endpoints::Responder for EchoEchoMinimalResponder {
4114    type ControlHandle = EchoControlHandle;
4115
4116    fn control_handle(&self) -> &EchoControlHandle {
4117        &self.control_handle
4118    }
4119
4120    fn drop_without_shutdown(mut self) {
4121        // Safety: drops once, never accessed again due to mem::forget
4122        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4123        // Prevent Drop from running (which would shut down the channel)
4124        std::mem::forget(self);
4125    }
4126}
4127
4128impl EchoEchoMinimalResponder {
4129    /// Sends a response to the FIDL transaction.
4130    ///
4131    /// Sets the channel to shutdown if an error occurs.
4132    pub fn send(self) -> Result<(), fidl::Error> {
4133        let _result = self.send_raw();
4134        if _result.is_err() {
4135            self.control_handle.shutdown();
4136        }
4137        self.drop_without_shutdown();
4138        _result
4139    }
4140
4141    /// Similar to "send" but does not shutdown the channel if an error occurs.
4142    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
4143        let _result = self.send_raw();
4144        self.drop_without_shutdown();
4145        _result
4146    }
4147
4148    fn send_raw(&self) -> Result<(), fidl::Error> {
4149        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
4150            (),
4151            self.tx_id,
4152            0x39edd68c837482ec,
4153            fidl::encoding::DynamicFlags::empty(),
4154        )
4155    }
4156}
4157
4158#[must_use = "FIDL methods require a response to be sent"]
4159#[derive(Debug)]
4160pub struct EchoEchoMinimalWithErrorResponder {
4161    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4162    tx_id: u32,
4163}
4164
4165/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4166/// if the responder is dropped without sending a response, so that the client
4167/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4168impl std::ops::Drop for EchoEchoMinimalWithErrorResponder {
4169    fn drop(&mut self) {
4170        self.control_handle.shutdown();
4171        // Safety: drops once, never accessed again
4172        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4173    }
4174}
4175
4176impl fidl::endpoints::Responder for EchoEchoMinimalWithErrorResponder {
4177    type ControlHandle = EchoControlHandle;
4178
4179    fn control_handle(&self) -> &EchoControlHandle {
4180        &self.control_handle
4181    }
4182
4183    fn drop_without_shutdown(mut self) {
4184        // Safety: drops once, never accessed again due to mem::forget
4185        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4186        // Prevent Drop from running (which would shut down the channel)
4187        std::mem::forget(self);
4188    }
4189}
4190
4191impl EchoEchoMinimalWithErrorResponder {
4192    /// Sends a response to the FIDL transaction.
4193    ///
4194    /// Sets the channel to shutdown if an error occurs.
4195    pub fn send(self, mut result: Result<(), u32>) -> Result<(), fidl::Error> {
4196        let _result = self.send_raw(result);
4197        if _result.is_err() {
4198            self.control_handle.shutdown();
4199        }
4200        self.drop_without_shutdown();
4201        _result
4202    }
4203
4204    /// Similar to "send" but does not shutdown the channel if an error occurs.
4205    pub fn send_no_shutdown_on_err(self, mut result: Result<(), u32>) -> Result<(), fidl::Error> {
4206        let _result = self.send_raw(result);
4207        self.drop_without_shutdown();
4208        _result
4209    }
4210
4211    fn send_raw(&self, mut result: Result<(), u32>) -> Result<(), fidl::Error> {
4212        self.control_handle
4213            .inner
4214            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, u32>>(
4215                result,
4216                self.tx_id,
4217                0x36f4695996e35acc,
4218                fidl::encoding::DynamicFlags::empty(),
4219            )
4220    }
4221}
4222
4223#[must_use = "FIDL methods require a response to be sent"]
4224#[derive(Debug)]
4225pub struct EchoEchoStructResponder {
4226    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4227    tx_id: u32,
4228}
4229
4230/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4231/// if the responder is dropped without sending a response, so that the client
4232/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4233impl std::ops::Drop for EchoEchoStructResponder {
4234    fn drop(&mut self) {
4235        self.control_handle.shutdown();
4236        // Safety: drops once, never accessed again
4237        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4238    }
4239}
4240
4241impl fidl::endpoints::Responder for EchoEchoStructResponder {
4242    type ControlHandle = EchoControlHandle;
4243
4244    fn control_handle(&self) -> &EchoControlHandle {
4245        &self.control_handle
4246    }
4247
4248    fn drop_without_shutdown(mut self) {
4249        // Safety: drops once, never accessed again due to mem::forget
4250        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4251        // Prevent Drop from running (which would shut down the channel)
4252        std::mem::forget(self);
4253    }
4254}
4255
4256impl EchoEchoStructResponder {
4257    /// Sends a response to the FIDL transaction.
4258    ///
4259    /// Sets the channel to shutdown if an error occurs.
4260    pub fn send(self, mut value: Struct) -> Result<(), fidl::Error> {
4261        let _result = self.send_raw(value);
4262        if _result.is_err() {
4263            self.control_handle.shutdown();
4264        }
4265        self.drop_without_shutdown();
4266        _result
4267    }
4268
4269    /// Similar to "send" but does not shutdown the channel if an error occurs.
4270    pub fn send_no_shutdown_on_err(self, mut value: Struct) -> Result<(), fidl::Error> {
4271        let _result = self.send_raw(value);
4272        self.drop_without_shutdown();
4273        _result
4274    }
4275
4276    fn send_raw(&self, mut value: Struct) -> Result<(), fidl::Error> {
4277        self.control_handle.inner.send::<EchoEchoStructResponse>(
4278            (&mut value,),
4279            self.tx_id,
4280            0x4c2f85818cc53f37,
4281            fidl::encoding::DynamicFlags::empty(),
4282        )
4283    }
4284}
4285
4286#[must_use = "FIDL methods require a response to be sent"]
4287#[derive(Debug)]
4288pub struct EchoEchoStructWithErrorResponder {
4289    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4290    tx_id: u32,
4291}
4292
4293/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4294/// if the responder is dropped without sending a response, so that the client
4295/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4296impl std::ops::Drop for EchoEchoStructWithErrorResponder {
4297    fn drop(&mut self) {
4298        self.control_handle.shutdown();
4299        // Safety: drops once, never accessed again
4300        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4301    }
4302}
4303
4304impl fidl::endpoints::Responder for EchoEchoStructWithErrorResponder {
4305    type ControlHandle = EchoControlHandle;
4306
4307    fn control_handle(&self) -> &EchoControlHandle {
4308        &self.control_handle
4309    }
4310
4311    fn drop_without_shutdown(mut self) {
4312        // Safety: drops once, never accessed again due to mem::forget
4313        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4314        // Prevent Drop from running (which would shut down the channel)
4315        std::mem::forget(self);
4316    }
4317}
4318
4319impl EchoEchoStructWithErrorResponder {
4320    /// Sends a response to the FIDL transaction.
4321    ///
4322    /// Sets the channel to shutdown if an error occurs.
4323    pub fn send(self, mut result: Result<Struct, DefaultEnum>) -> Result<(), fidl::Error> {
4324        let _result = self.send_raw(result);
4325        if _result.is_err() {
4326            self.control_handle.shutdown();
4327        }
4328        self.drop_without_shutdown();
4329        _result
4330    }
4331
4332    /// Similar to "send" but does not shutdown the channel if an error occurs.
4333    pub fn send_no_shutdown_on_err(
4334        self,
4335        mut result: Result<Struct, DefaultEnum>,
4336    ) -> Result<(), fidl::Error> {
4337        let _result = self.send_raw(result);
4338        self.drop_without_shutdown();
4339        _result
4340    }
4341
4342    fn send_raw(&self, mut result: Result<Struct, DefaultEnum>) -> Result<(), fidl::Error> {
4343        self.control_handle.inner.send::<fidl::encoding::ResultType<
4344            EchoEchoStructWithErrorResponse,
4345            DefaultEnum,
4346        >>(
4347            result.as_mut().map_err(|e| *e).map(|value| (value,)),
4348            self.tx_id,
4349            0x46cb32652c4c0899,
4350            fidl::encoding::DynamicFlags::empty(),
4351        )
4352    }
4353}
4354
4355#[must_use = "FIDL methods require a response to be sent"]
4356#[derive(Debug)]
4357pub struct EchoEchoArraysResponder {
4358    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4359    tx_id: u32,
4360}
4361
4362/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4363/// if the responder is dropped without sending a response, so that the client
4364/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4365impl std::ops::Drop for EchoEchoArraysResponder {
4366    fn drop(&mut self) {
4367        self.control_handle.shutdown();
4368        // Safety: drops once, never accessed again
4369        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4370    }
4371}
4372
4373impl fidl::endpoints::Responder for EchoEchoArraysResponder {
4374    type ControlHandle = EchoControlHandle;
4375
4376    fn control_handle(&self) -> &EchoControlHandle {
4377        &self.control_handle
4378    }
4379
4380    fn drop_without_shutdown(mut self) {
4381        // Safety: drops once, never accessed again due to mem::forget
4382        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4383        // Prevent Drop from running (which would shut down the channel)
4384        std::mem::forget(self);
4385    }
4386}
4387
4388impl EchoEchoArraysResponder {
4389    /// Sends a response to the FIDL transaction.
4390    ///
4391    /// Sets the channel to shutdown if an error occurs.
4392    pub fn send(self, mut value: ArraysStruct) -> Result<(), fidl::Error> {
4393        let _result = self.send_raw(value);
4394        if _result.is_err() {
4395            self.control_handle.shutdown();
4396        }
4397        self.drop_without_shutdown();
4398        _result
4399    }
4400
4401    /// Similar to "send" but does not shutdown the channel if an error occurs.
4402    pub fn send_no_shutdown_on_err(self, mut value: ArraysStruct) -> Result<(), fidl::Error> {
4403        let _result = self.send_raw(value);
4404        self.drop_without_shutdown();
4405        _result
4406    }
4407
4408    fn send_raw(&self, mut value: ArraysStruct) -> Result<(), fidl::Error> {
4409        self.control_handle.inner.send::<EchoEchoArraysResponse>(
4410            (&mut value,),
4411            self.tx_id,
4412            0x1b6019d5611f2470,
4413            fidl::encoding::DynamicFlags::empty(),
4414        )
4415    }
4416}
4417
4418#[must_use = "FIDL methods require a response to be sent"]
4419#[derive(Debug)]
4420pub struct EchoEchoArraysWithErrorResponder {
4421    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4422    tx_id: u32,
4423}
4424
4425/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4426/// if the responder is dropped without sending a response, so that the client
4427/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4428impl std::ops::Drop for EchoEchoArraysWithErrorResponder {
4429    fn drop(&mut self) {
4430        self.control_handle.shutdown();
4431        // Safety: drops once, never accessed again
4432        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4433    }
4434}
4435
4436impl fidl::endpoints::Responder for EchoEchoArraysWithErrorResponder {
4437    type ControlHandle = EchoControlHandle;
4438
4439    fn control_handle(&self) -> &EchoControlHandle {
4440        &self.control_handle
4441    }
4442
4443    fn drop_without_shutdown(mut self) {
4444        // Safety: drops once, never accessed again due to mem::forget
4445        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4446        // Prevent Drop from running (which would shut down the channel)
4447        std::mem::forget(self);
4448    }
4449}
4450
4451impl EchoEchoArraysWithErrorResponder {
4452    /// Sends a response to the FIDL transaction.
4453    ///
4454    /// Sets the channel to shutdown if an error occurs.
4455    pub fn send(self, mut result: Result<ArraysStruct, DefaultEnum>) -> Result<(), fidl::Error> {
4456        let _result = self.send_raw(result);
4457        if _result.is_err() {
4458            self.control_handle.shutdown();
4459        }
4460        self.drop_without_shutdown();
4461        _result
4462    }
4463
4464    /// Similar to "send" but does not shutdown the channel if an error occurs.
4465    pub fn send_no_shutdown_on_err(
4466        self,
4467        mut result: Result<ArraysStruct, DefaultEnum>,
4468    ) -> Result<(), fidl::Error> {
4469        let _result = self.send_raw(result);
4470        self.drop_without_shutdown();
4471        _result
4472    }
4473
4474    fn send_raw(&self, mut result: Result<ArraysStruct, DefaultEnum>) -> Result<(), fidl::Error> {
4475        self.control_handle.inner.send::<fidl::encoding::ResultType<
4476            EchoEchoArraysWithErrorResponse,
4477            DefaultEnum,
4478        >>(
4479            result.as_mut().map_err(|e| *e).map(|value| (value,)),
4480            self.tx_id,
4481            0x6dbf26e67e253afa,
4482            fidl::encoding::DynamicFlags::empty(),
4483        )
4484    }
4485}
4486
4487#[must_use = "FIDL methods require a response to be sent"]
4488#[derive(Debug)]
4489pub struct EchoEchoVectorsResponder {
4490    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4491    tx_id: u32,
4492}
4493
4494/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4495/// if the responder is dropped without sending a response, so that the client
4496/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4497impl std::ops::Drop for EchoEchoVectorsResponder {
4498    fn drop(&mut self) {
4499        self.control_handle.shutdown();
4500        // Safety: drops once, never accessed again
4501        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4502    }
4503}
4504
4505impl fidl::endpoints::Responder for EchoEchoVectorsResponder {
4506    type ControlHandle = EchoControlHandle;
4507
4508    fn control_handle(&self) -> &EchoControlHandle {
4509        &self.control_handle
4510    }
4511
4512    fn drop_without_shutdown(mut self) {
4513        // Safety: drops once, never accessed again due to mem::forget
4514        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4515        // Prevent Drop from running (which would shut down the channel)
4516        std::mem::forget(self);
4517    }
4518}
4519
4520impl EchoEchoVectorsResponder {
4521    /// Sends a response to the FIDL transaction.
4522    ///
4523    /// Sets the channel to shutdown if an error occurs.
4524    pub fn send(self, mut value: VectorsStruct) -> Result<(), fidl::Error> {
4525        let _result = self.send_raw(value);
4526        if _result.is_err() {
4527            self.control_handle.shutdown();
4528        }
4529        self.drop_without_shutdown();
4530        _result
4531    }
4532
4533    /// Similar to "send" but does not shutdown the channel if an error occurs.
4534    pub fn send_no_shutdown_on_err(self, mut value: VectorsStruct) -> Result<(), fidl::Error> {
4535        let _result = self.send_raw(value);
4536        self.drop_without_shutdown();
4537        _result
4538    }
4539
4540    fn send_raw(&self, mut value: VectorsStruct) -> Result<(), fidl::Error> {
4541        self.control_handle.inner.send::<EchoEchoVectorsResponse>(
4542            (&mut value,),
4543            self.tx_id,
4544            0x1582623f0d9f6e5e,
4545            fidl::encoding::DynamicFlags::empty(),
4546        )
4547    }
4548}
4549
4550#[must_use = "FIDL methods require a response to be sent"]
4551#[derive(Debug)]
4552pub struct EchoEchoVectorsWithErrorResponder {
4553    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4554    tx_id: u32,
4555}
4556
4557/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4558/// if the responder is dropped without sending a response, so that the client
4559/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4560impl std::ops::Drop for EchoEchoVectorsWithErrorResponder {
4561    fn drop(&mut self) {
4562        self.control_handle.shutdown();
4563        // Safety: drops once, never accessed again
4564        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4565    }
4566}
4567
4568impl fidl::endpoints::Responder for EchoEchoVectorsWithErrorResponder {
4569    type ControlHandle = EchoControlHandle;
4570
4571    fn control_handle(&self) -> &EchoControlHandle {
4572        &self.control_handle
4573    }
4574
4575    fn drop_without_shutdown(mut self) {
4576        // Safety: drops once, never accessed again due to mem::forget
4577        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4578        // Prevent Drop from running (which would shut down the channel)
4579        std::mem::forget(self);
4580    }
4581}
4582
4583impl EchoEchoVectorsWithErrorResponder {
4584    /// Sends a response to the FIDL transaction.
4585    ///
4586    /// Sets the channel to shutdown if an error occurs.
4587    pub fn send(self, mut result: Result<VectorsStruct, DefaultEnum>) -> Result<(), fidl::Error> {
4588        let _result = self.send_raw(result);
4589        if _result.is_err() {
4590            self.control_handle.shutdown();
4591        }
4592        self.drop_without_shutdown();
4593        _result
4594    }
4595
4596    /// Similar to "send" but does not shutdown the channel if an error occurs.
4597    pub fn send_no_shutdown_on_err(
4598        self,
4599        mut result: Result<VectorsStruct, DefaultEnum>,
4600    ) -> Result<(), fidl::Error> {
4601        let _result = self.send_raw(result);
4602        self.drop_without_shutdown();
4603        _result
4604    }
4605
4606    fn send_raw(&self, mut result: Result<VectorsStruct, DefaultEnum>) -> Result<(), fidl::Error> {
4607        self.control_handle.inner.send::<fidl::encoding::ResultType<
4608            EchoEchoVectorsWithErrorResponse,
4609            DefaultEnum,
4610        >>(
4611            result.as_mut().map_err(|e| *e).map(|value| (value,)),
4612            self.tx_id,
4613            0x730f163401e2b3e5,
4614            fidl::encoding::DynamicFlags::empty(),
4615        )
4616    }
4617}
4618
4619#[must_use = "FIDL methods require a response to be sent"]
4620#[derive(Debug)]
4621pub struct EchoEchoTableResponder {
4622    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4623    tx_id: u32,
4624}
4625
4626/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4627/// if the responder is dropped without sending a response, so that the client
4628/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4629impl std::ops::Drop for EchoEchoTableResponder {
4630    fn drop(&mut self) {
4631        self.control_handle.shutdown();
4632        // Safety: drops once, never accessed again
4633        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4634    }
4635}
4636
4637impl fidl::endpoints::Responder for EchoEchoTableResponder {
4638    type ControlHandle = EchoControlHandle;
4639
4640    fn control_handle(&self) -> &EchoControlHandle {
4641        &self.control_handle
4642    }
4643
4644    fn drop_without_shutdown(mut self) {
4645        // Safety: drops once, never accessed again due to mem::forget
4646        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4647        // Prevent Drop from running (which would shut down the channel)
4648        std::mem::forget(self);
4649    }
4650}
4651
4652impl EchoEchoTableResponder {
4653    /// Sends a response to the FIDL transaction.
4654    ///
4655    /// Sets the channel to shutdown if an error occurs.
4656    pub fn send(self, mut value: AllTypesTable) -> Result<(), fidl::Error> {
4657        let _result = self.send_raw(value);
4658        if _result.is_err() {
4659            self.control_handle.shutdown();
4660        }
4661        self.drop_without_shutdown();
4662        _result
4663    }
4664
4665    /// Similar to "send" but does not shutdown the channel if an error occurs.
4666    pub fn send_no_shutdown_on_err(self, mut value: AllTypesTable) -> Result<(), fidl::Error> {
4667        let _result = self.send_raw(value);
4668        self.drop_without_shutdown();
4669        _result
4670    }
4671
4672    fn send_raw(&self, mut value: AllTypesTable) -> Result<(), fidl::Error> {
4673        self.control_handle.inner.send::<EchoEchoTableResponse>(
4674            (&mut value,),
4675            self.tx_id,
4676            0x4f1fb0a512f47c4b,
4677            fidl::encoding::DynamicFlags::empty(),
4678        )
4679    }
4680}
4681
4682#[must_use = "FIDL methods require a response to be sent"]
4683#[derive(Debug)]
4684pub struct EchoEchoTableWithErrorResponder {
4685    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4686    tx_id: u32,
4687}
4688
4689/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4690/// if the responder is dropped without sending a response, so that the client
4691/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4692impl std::ops::Drop for EchoEchoTableWithErrorResponder {
4693    fn drop(&mut self) {
4694        self.control_handle.shutdown();
4695        // Safety: drops once, never accessed again
4696        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4697    }
4698}
4699
4700impl fidl::endpoints::Responder for EchoEchoTableWithErrorResponder {
4701    type ControlHandle = EchoControlHandle;
4702
4703    fn control_handle(&self) -> &EchoControlHandle {
4704        &self.control_handle
4705    }
4706
4707    fn drop_without_shutdown(mut self) {
4708        // Safety: drops once, never accessed again due to mem::forget
4709        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4710        // Prevent Drop from running (which would shut down the channel)
4711        std::mem::forget(self);
4712    }
4713}
4714
4715impl EchoEchoTableWithErrorResponder {
4716    /// Sends a response to the FIDL transaction.
4717    ///
4718    /// Sets the channel to shutdown if an error occurs.
4719    pub fn send(self, mut result: Result<AllTypesTable, DefaultEnum>) -> Result<(), fidl::Error> {
4720        let _result = self.send_raw(result);
4721        if _result.is_err() {
4722            self.control_handle.shutdown();
4723        }
4724        self.drop_without_shutdown();
4725        _result
4726    }
4727
4728    /// Similar to "send" but does not shutdown the channel if an error occurs.
4729    pub fn send_no_shutdown_on_err(
4730        self,
4731        mut result: Result<AllTypesTable, DefaultEnum>,
4732    ) -> Result<(), fidl::Error> {
4733        let _result = self.send_raw(result);
4734        self.drop_without_shutdown();
4735        _result
4736    }
4737
4738    fn send_raw(&self, mut result: Result<AllTypesTable, DefaultEnum>) -> Result<(), fidl::Error> {
4739        self.control_handle.inner.send::<fidl::encoding::ResultType<
4740            EchoEchoTableWithErrorResponse,
4741            DefaultEnum,
4742        >>(
4743            result.as_mut().map_err(|e| *e).map(|value| (value,)),
4744            self.tx_id,
4745            0x44e835cb1eb9a931,
4746            fidl::encoding::DynamicFlags::empty(),
4747        )
4748    }
4749}
4750
4751#[must_use = "FIDL methods require a response to be sent"]
4752#[derive(Debug)]
4753pub struct EchoEchoXunionsResponder {
4754    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4755    tx_id: u32,
4756}
4757
4758/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4759/// if the responder is dropped without sending a response, so that the client
4760/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4761impl std::ops::Drop for EchoEchoXunionsResponder {
4762    fn drop(&mut self) {
4763        self.control_handle.shutdown();
4764        // Safety: drops once, never accessed again
4765        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4766    }
4767}
4768
4769impl fidl::endpoints::Responder for EchoEchoXunionsResponder {
4770    type ControlHandle = EchoControlHandle;
4771
4772    fn control_handle(&self) -> &EchoControlHandle {
4773        &self.control_handle
4774    }
4775
4776    fn drop_without_shutdown(mut self) {
4777        // Safety: drops once, never accessed again due to mem::forget
4778        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4779        // Prevent Drop from running (which would shut down the channel)
4780        std::mem::forget(self);
4781    }
4782}
4783
4784impl EchoEchoXunionsResponder {
4785    /// Sends a response to the FIDL transaction.
4786    ///
4787    /// Sets the channel to shutdown if an error occurs.
4788    pub fn send(self, mut value: Vec<AllTypesXunion>) -> Result<(), fidl::Error> {
4789        let _result = self.send_raw(value);
4790        if _result.is_err() {
4791            self.control_handle.shutdown();
4792        }
4793        self.drop_without_shutdown();
4794        _result
4795    }
4796
4797    /// Similar to "send" but does not shutdown the channel if an error occurs.
4798    pub fn send_no_shutdown_on_err(
4799        self,
4800        mut value: Vec<AllTypesXunion>,
4801    ) -> Result<(), fidl::Error> {
4802        let _result = self.send_raw(value);
4803        self.drop_without_shutdown();
4804        _result
4805    }
4806
4807    fn send_raw(&self, mut value: Vec<AllTypesXunion>) -> Result<(), fidl::Error> {
4808        self.control_handle.inner.send::<EchoEchoXunionsResponse>(
4809            (value.as_mut(),),
4810            self.tx_id,
4811            0x3dc181909041a583,
4812            fidl::encoding::DynamicFlags::empty(),
4813        )
4814    }
4815}
4816
4817#[must_use = "FIDL methods require a response to be sent"]
4818#[derive(Debug)]
4819pub struct EchoEchoXunionsWithErrorResponder {
4820    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4821    tx_id: u32,
4822}
4823
4824/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4825/// if the responder is dropped without sending a response, so that the client
4826/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4827impl std::ops::Drop for EchoEchoXunionsWithErrorResponder {
4828    fn drop(&mut self) {
4829        self.control_handle.shutdown();
4830        // Safety: drops once, never accessed again
4831        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4832    }
4833}
4834
4835impl fidl::endpoints::Responder for EchoEchoXunionsWithErrorResponder {
4836    type ControlHandle = EchoControlHandle;
4837
4838    fn control_handle(&self) -> &EchoControlHandle {
4839        &self.control_handle
4840    }
4841
4842    fn drop_without_shutdown(mut self) {
4843        // Safety: drops once, never accessed again due to mem::forget
4844        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4845        // Prevent Drop from running (which would shut down the channel)
4846        std::mem::forget(self);
4847    }
4848}
4849
4850impl EchoEchoXunionsWithErrorResponder {
4851    /// Sends a response to the FIDL transaction.
4852    ///
4853    /// Sets the channel to shutdown if an error occurs.
4854    pub fn send(
4855        self,
4856        mut result: Result<Vec<AllTypesXunion>, DefaultEnum>,
4857    ) -> Result<(), fidl::Error> {
4858        let _result = self.send_raw(result);
4859        if _result.is_err() {
4860            self.control_handle.shutdown();
4861        }
4862        self.drop_without_shutdown();
4863        _result
4864    }
4865
4866    /// Similar to "send" but does not shutdown the channel if an error occurs.
4867    pub fn send_no_shutdown_on_err(
4868        self,
4869        mut result: Result<Vec<AllTypesXunion>, DefaultEnum>,
4870    ) -> Result<(), fidl::Error> {
4871        let _result = self.send_raw(result);
4872        self.drop_without_shutdown();
4873        _result
4874    }
4875
4876    fn send_raw(
4877        &self,
4878        mut result: Result<Vec<AllTypesXunion>, DefaultEnum>,
4879    ) -> Result<(), fidl::Error> {
4880        self.control_handle.inner.send::<fidl::encoding::ResultType<
4881            EchoEchoXunionsWithErrorResponse,
4882            DefaultEnum,
4883        >>(
4884            result.as_mut().map_err(|e| *e).map(|value| (value.as_mut_slice(),)),
4885            self.tx_id,
4886            0x75184102667fa766,
4887            fidl::encoding::DynamicFlags::empty(),
4888        )
4889    }
4890}
4891
4892#[must_use = "FIDL methods require a response to be sent"]
4893#[derive(Debug)]
4894pub struct EchoEchoNamedStructResponder {
4895    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4896    tx_id: u32,
4897}
4898
4899/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4900/// if the responder is dropped without sending a response, so that the client
4901/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4902impl std::ops::Drop for EchoEchoNamedStructResponder {
4903    fn drop(&mut self) {
4904        self.control_handle.shutdown();
4905        // Safety: drops once, never accessed again
4906        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4907    }
4908}
4909
4910impl fidl::endpoints::Responder for EchoEchoNamedStructResponder {
4911    type ControlHandle = EchoControlHandle;
4912
4913    fn control_handle(&self) -> &EchoControlHandle {
4914        &self.control_handle
4915    }
4916
4917    fn drop_without_shutdown(mut self) {
4918        // Safety: drops once, never accessed again due to mem::forget
4919        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4920        // Prevent Drop from running (which would shut down the channel)
4921        std::mem::forget(self);
4922    }
4923}
4924
4925impl EchoEchoNamedStructResponder {
4926    /// Sends a response to the FIDL transaction.
4927    ///
4928    /// Sets the channel to shutdown if an error occurs.
4929    pub fn send(
4930        self,
4931        mut value: &fidl_fidl_test_imported::SimpleStruct,
4932    ) -> Result<(), fidl::Error> {
4933        let _result = self.send_raw(value);
4934        if _result.is_err() {
4935            self.control_handle.shutdown();
4936        }
4937        self.drop_without_shutdown();
4938        _result
4939    }
4940
4941    /// Similar to "send" but does not shutdown the channel if an error occurs.
4942    pub fn send_no_shutdown_on_err(
4943        self,
4944        mut value: &fidl_fidl_test_imported::SimpleStruct,
4945    ) -> Result<(), fidl::Error> {
4946        let _result = self.send_raw(value);
4947        self.drop_without_shutdown();
4948        _result
4949    }
4950
4951    fn send_raw(
4952        &self,
4953        mut value: &fidl_fidl_test_imported::SimpleStruct,
4954    ) -> Result<(), fidl::Error> {
4955        self.control_handle.inner.send::<fidl_fidl_test_imported::ResponseStruct>(
4956            (value,),
4957            self.tx_id,
4958            0xf2d4aa9e65f7111,
4959            fidl::encoding::DynamicFlags::empty(),
4960        )
4961    }
4962}
4963
4964#[must_use = "FIDL methods require a response to be sent"]
4965#[derive(Debug)]
4966pub struct EchoEchoNamedStructWithErrorResponder {
4967    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4968    tx_id: u32,
4969}
4970
4971/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4972/// if the responder is dropped without sending a response, so that the client
4973/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4974impl std::ops::Drop for EchoEchoNamedStructWithErrorResponder {
4975    fn drop(&mut self) {
4976        self.control_handle.shutdown();
4977        // Safety: drops once, never accessed again
4978        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4979    }
4980}
4981
4982impl fidl::endpoints::Responder for EchoEchoNamedStructWithErrorResponder {
4983    type ControlHandle = EchoControlHandle;
4984
4985    fn control_handle(&self) -> &EchoControlHandle {
4986        &self.control_handle
4987    }
4988
4989    fn drop_without_shutdown(mut self) {
4990        // Safety: drops once, never accessed again due to mem::forget
4991        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4992        // Prevent Drop from running (which would shut down the channel)
4993        std::mem::forget(self);
4994    }
4995}
4996
4997impl EchoEchoNamedStructWithErrorResponder {
4998    /// Sends a response to the FIDL transaction.
4999    ///
5000    /// Sets the channel to shutdown if an error occurs.
5001    pub fn send(
5002        self,
5003        mut result: Result<&fidl_fidl_test_imported::SimpleStruct, u32>,
5004    ) -> Result<(), fidl::Error> {
5005        let _result = self.send_raw(result);
5006        if _result.is_err() {
5007            self.control_handle.shutdown();
5008        }
5009        self.drop_without_shutdown();
5010        _result
5011    }
5012
5013    /// Similar to "send" but does not shutdown the channel if an error occurs.
5014    pub fn send_no_shutdown_on_err(
5015        self,
5016        mut result: Result<&fidl_fidl_test_imported::SimpleStruct, u32>,
5017    ) -> Result<(), fidl::Error> {
5018        let _result = self.send_raw(result);
5019        self.drop_without_shutdown();
5020        _result
5021    }
5022
5023    fn send_raw(
5024        &self,
5025        mut result: Result<&fidl_fidl_test_imported::SimpleStruct, u32>,
5026    ) -> Result<(), fidl::Error> {
5027        self.control_handle.inner.send::<fidl::encoding::ResultType<
5028            fidl_fidl_test_imported::ResponseStruct,
5029            u32,
5030        >>(
5031            result.map(|value| (value,)),
5032            self.tx_id,
5033            0x5766fee9e74442e8,
5034            fidl::encoding::DynamicFlags::empty(),
5035        )
5036    }
5037}
5038
5039#[must_use = "FIDL methods require a response to be sent"]
5040#[derive(Debug)]
5041pub struct EchoEchoTablePayloadResponder {
5042    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
5043    tx_id: u32,
5044}
5045
5046/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
5047/// if the responder is dropped without sending a response, so that the client
5048/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
5049impl std::ops::Drop for EchoEchoTablePayloadResponder {
5050    fn drop(&mut self) {
5051        self.control_handle.shutdown();
5052        // Safety: drops once, never accessed again
5053        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5054    }
5055}
5056
5057impl fidl::endpoints::Responder for EchoEchoTablePayloadResponder {
5058    type ControlHandle = EchoControlHandle;
5059
5060    fn control_handle(&self) -> &EchoControlHandle {
5061        &self.control_handle
5062    }
5063
5064    fn drop_without_shutdown(mut self) {
5065        // Safety: drops once, never accessed again due to mem::forget
5066        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5067        // Prevent Drop from running (which would shut down the channel)
5068        std::mem::forget(self);
5069    }
5070}
5071
5072impl EchoEchoTablePayloadResponder {
5073    /// Sends a response to the FIDL transaction.
5074    ///
5075    /// Sets the channel to shutdown if an error occurs.
5076    pub fn send(self, mut payload: &ResponseTable) -> Result<(), fidl::Error> {
5077        let _result = self.send_raw(payload);
5078        if _result.is_err() {
5079            self.control_handle.shutdown();
5080        }
5081        self.drop_without_shutdown();
5082        _result
5083    }
5084
5085    /// Similar to "send" but does not shutdown the channel if an error occurs.
5086    pub fn send_no_shutdown_on_err(self, mut payload: &ResponseTable) -> Result<(), fidl::Error> {
5087        let _result = self.send_raw(payload);
5088        self.drop_without_shutdown();
5089        _result
5090    }
5091
5092    fn send_raw(&self, mut payload: &ResponseTable) -> Result<(), fidl::Error> {
5093        self.control_handle.inner.send::<ResponseTable>(
5094            payload,
5095            self.tx_id,
5096            0x641d98087378c003,
5097            fidl::encoding::DynamicFlags::empty(),
5098        )
5099    }
5100}
5101
5102#[must_use = "FIDL methods require a response to be sent"]
5103#[derive(Debug)]
5104pub struct EchoEchoTablePayloadWithErrorResponder {
5105    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
5106    tx_id: u32,
5107}
5108
5109/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
5110/// if the responder is dropped without sending a response, so that the client
5111/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
5112impl std::ops::Drop for EchoEchoTablePayloadWithErrorResponder {
5113    fn drop(&mut self) {
5114        self.control_handle.shutdown();
5115        // Safety: drops once, never accessed again
5116        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5117    }
5118}
5119
5120impl fidl::endpoints::Responder for EchoEchoTablePayloadWithErrorResponder {
5121    type ControlHandle = EchoControlHandle;
5122
5123    fn control_handle(&self) -> &EchoControlHandle {
5124        &self.control_handle
5125    }
5126
5127    fn drop_without_shutdown(mut self) {
5128        // Safety: drops once, never accessed again due to mem::forget
5129        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5130        // Prevent Drop from running (which would shut down the channel)
5131        std::mem::forget(self);
5132    }
5133}
5134
5135impl EchoEchoTablePayloadWithErrorResponder {
5136    /// Sends a response to the FIDL transaction.
5137    ///
5138    /// Sets the channel to shutdown if an error occurs.
5139    pub fn send(self, mut result: Result<&ResponseTable, DefaultEnum>) -> Result<(), fidl::Error> {
5140        let _result = self.send_raw(result);
5141        if _result.is_err() {
5142            self.control_handle.shutdown();
5143        }
5144        self.drop_without_shutdown();
5145        _result
5146    }
5147
5148    /// Similar to "send" but does not shutdown the channel if an error occurs.
5149    pub fn send_no_shutdown_on_err(
5150        self,
5151        mut result: Result<&ResponseTable, DefaultEnum>,
5152    ) -> Result<(), fidl::Error> {
5153        let _result = self.send_raw(result);
5154        self.drop_without_shutdown();
5155        _result
5156    }
5157
5158    fn send_raw(&self, mut result: Result<&ResponseTable, DefaultEnum>) -> Result<(), fidl::Error> {
5159        self.control_handle.inner.send::<fidl::encoding::ResultType<ResponseTable, DefaultEnum>>(
5160            result,
5161            self.tx_id,
5162            0x636ed243761ab66d,
5163            fidl::encoding::DynamicFlags::empty(),
5164        )
5165    }
5166}
5167
5168#[must_use = "FIDL methods require a response to be sent"]
5169#[derive(Debug)]
5170pub struct EchoEchoUnionPayloadResponder {
5171    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
5172    tx_id: u32,
5173}
5174
5175/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
5176/// if the responder is dropped without sending a response, so that the client
5177/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
5178impl std::ops::Drop for EchoEchoUnionPayloadResponder {
5179    fn drop(&mut self) {
5180        self.control_handle.shutdown();
5181        // Safety: drops once, never accessed again
5182        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5183    }
5184}
5185
5186impl fidl::endpoints::Responder for EchoEchoUnionPayloadResponder {
5187    type ControlHandle = EchoControlHandle;
5188
5189    fn control_handle(&self) -> &EchoControlHandle {
5190        &self.control_handle
5191    }
5192
5193    fn drop_without_shutdown(mut self) {
5194        // Safety: drops once, never accessed again due to mem::forget
5195        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5196        // Prevent Drop from running (which would shut down the channel)
5197        std::mem::forget(self);
5198    }
5199}
5200
5201impl EchoEchoUnionPayloadResponder {
5202    /// Sends a response to the FIDL transaction.
5203    ///
5204    /// Sets the channel to shutdown if an error occurs.
5205    pub fn send(self, mut payload: &ResponseUnion) -> Result<(), fidl::Error> {
5206        let _result = self.send_raw(payload);
5207        if _result.is_err() {
5208            self.control_handle.shutdown();
5209        }
5210        self.drop_without_shutdown();
5211        _result
5212    }
5213
5214    /// Similar to "send" but does not shutdown the channel if an error occurs.
5215    pub fn send_no_shutdown_on_err(self, mut payload: &ResponseUnion) -> Result<(), fidl::Error> {
5216        let _result = self.send_raw(payload);
5217        self.drop_without_shutdown();
5218        _result
5219    }
5220
5221    fn send_raw(&self, mut payload: &ResponseUnion) -> Result<(), fidl::Error> {
5222        self.control_handle.inner.send::<ResponseUnion>(
5223            payload,
5224            self.tx_id,
5225            0x66def9e793f10c55,
5226            fidl::encoding::DynamicFlags::empty(),
5227        )
5228    }
5229}
5230
5231#[must_use = "FIDL methods require a response to be sent"]
5232#[derive(Debug)]
5233pub struct EchoEchoUnionPayloadWithErrorResponder {
5234    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
5235    tx_id: u32,
5236}
5237
5238/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
5239/// if the responder is dropped without sending a response, so that the client
5240/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
5241impl std::ops::Drop for EchoEchoUnionPayloadWithErrorResponder {
5242    fn drop(&mut self) {
5243        self.control_handle.shutdown();
5244        // Safety: drops once, never accessed again
5245        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5246    }
5247}
5248
5249impl fidl::endpoints::Responder for EchoEchoUnionPayloadWithErrorResponder {
5250    type ControlHandle = EchoControlHandle;
5251
5252    fn control_handle(&self) -> &EchoControlHandle {
5253        &self.control_handle
5254    }
5255
5256    fn drop_without_shutdown(mut self) {
5257        // Safety: drops once, never accessed again due to mem::forget
5258        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5259        // Prevent Drop from running (which would shut down the channel)
5260        std::mem::forget(self);
5261    }
5262}
5263
5264impl EchoEchoUnionPayloadWithErrorResponder {
5265    /// Sends a response to the FIDL transaction.
5266    ///
5267    /// Sets the channel to shutdown if an error occurs.
5268    pub fn send(self, mut result: Result<&ResponseUnion, DefaultEnum>) -> Result<(), fidl::Error> {
5269        let _result = self.send_raw(result);
5270        if _result.is_err() {
5271            self.control_handle.shutdown();
5272        }
5273        self.drop_without_shutdown();
5274        _result
5275    }
5276
5277    /// Similar to "send" but does not shutdown the channel if an error occurs.
5278    pub fn send_no_shutdown_on_err(
5279        self,
5280        mut result: Result<&ResponseUnion, DefaultEnum>,
5281    ) -> Result<(), fidl::Error> {
5282        let _result = self.send_raw(result);
5283        self.drop_without_shutdown();
5284        _result
5285    }
5286
5287    fn send_raw(&self, mut result: Result<&ResponseUnion, DefaultEnum>) -> Result<(), fidl::Error> {
5288        self.control_handle.inner.send::<fidl::encoding::ResultType<ResponseUnion, DefaultEnum>>(
5289            result,
5290            self.tx_id,
5291            0x1be890d6e68ef063,
5292            fidl::encoding::DynamicFlags::empty(),
5293        )
5294    }
5295}
5296
5297mod internal {
5298    use super::*;
5299
5300    impl fidl::encoding::ResourceTypeMarker for ArraysStruct {
5301        type Borrowed<'a> = &'a mut Self;
5302        fn take_or_borrow<'a>(
5303            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
5304        ) -> Self::Borrowed<'a> {
5305            value
5306        }
5307    }
5308
5309    unsafe impl fidl::encoding::TypeMarker for ArraysStruct {
5310        type Owned = Self;
5311
5312        #[inline(always)]
5313        fn inline_align(_context: fidl::encoding::Context) -> usize {
5314            8
5315        }
5316
5317        #[inline(always)]
5318        fn inline_size(_context: fidl::encoding::Context) -> usize {
5319            680
5320        }
5321    }
5322
5323    unsafe impl fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
5324        for &mut ArraysStruct
5325    {
5326        #[inline]
5327        unsafe fn encode(
5328            self,
5329            encoder: &mut fidl::encoding::Encoder<
5330                '_,
5331                fidl::encoding::DefaultFuchsiaResourceDialect,
5332            >,
5333            offset: usize,
5334            _depth: fidl::encoding::Depth,
5335        ) -> fidl::Result<()> {
5336            encoder.debug_check_bounds::<ArraysStruct>(offset);
5337            // Delegate to tuple encoding.
5338            fidl::encoding::Encode::<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
5339                (
5340                    <fidl::encoding::Array<bool, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.bools),
5341                    <fidl::encoding::Array<i8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int8s),
5342                    <fidl::encoding::Array<i16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int16s),
5343                    <fidl::encoding::Array<i32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int32s),
5344                    <fidl::encoding::Array<i64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int64s),
5345                    <fidl::encoding::Array<u8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint8s),
5346                    <fidl::encoding::Array<u16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint16s),
5347                    <fidl::encoding::Array<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint32s),
5348                    <fidl::encoding::Array<u64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint64s),
5349                    <fidl::encoding::Array<f32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.float32s),
5350                    <fidl::encoding::Array<f64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.float64s),
5351                    <fidl::encoding::Array<DefaultEnum, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.enums),
5352                    <fidl::encoding::Array<DefaultBits, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.bits),
5353                    <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),
5354                    <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),
5355                    <fidl::encoding::Array<fidl::encoding::UnboundedString, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.strings),
5356                    <fidl::encoding::Array<fidl::encoding::Optional<fidl::encoding::UnboundedString>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_strings),
5357                    <fidl::encoding::Array<ThisIsAStruct, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.structs),
5358                    <fidl::encoding::Array<fidl::encoding::Boxed<ThisIsAStruct>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_structs),
5359                    <fidl::encoding::Array<ThisIsAUnion, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.unions),
5360                    <fidl::encoding::Array<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_unions),
5361                    <fidl::encoding::Array<fidl::encoding::Array<u32, 3>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.arrays),
5362                    <fidl::encoding::Array<fidl::encoding::UnboundedVector<u32>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.vectors),
5363                    <fidl::encoding::Array<fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_vectors),
5364                    <fidl::encoding::Array<ThisIsATable, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.tables),
5365                    <fidl::encoding::Array<ThisIsAXunion, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.xunions),
5366                ),
5367                encoder, offset, _depth
5368            )
5369        }
5370    }
5371    unsafe impl<
5372        T0: fidl::encoding::Encode<
5373                fidl::encoding::Array<bool, 3>,
5374                fidl::encoding::DefaultFuchsiaResourceDialect,
5375            >,
5376        T1: fidl::encoding::Encode<
5377                fidl::encoding::Array<i8, 3>,
5378                fidl::encoding::DefaultFuchsiaResourceDialect,
5379            >,
5380        T2: fidl::encoding::Encode<
5381                fidl::encoding::Array<i16, 3>,
5382                fidl::encoding::DefaultFuchsiaResourceDialect,
5383            >,
5384        T3: fidl::encoding::Encode<
5385                fidl::encoding::Array<i32, 3>,
5386                fidl::encoding::DefaultFuchsiaResourceDialect,
5387            >,
5388        T4: fidl::encoding::Encode<
5389                fidl::encoding::Array<i64, 3>,
5390                fidl::encoding::DefaultFuchsiaResourceDialect,
5391            >,
5392        T5: fidl::encoding::Encode<
5393                fidl::encoding::Array<u8, 3>,
5394                fidl::encoding::DefaultFuchsiaResourceDialect,
5395            >,
5396        T6: fidl::encoding::Encode<
5397                fidl::encoding::Array<u16, 3>,
5398                fidl::encoding::DefaultFuchsiaResourceDialect,
5399            >,
5400        T7: fidl::encoding::Encode<
5401                fidl::encoding::Array<u32, 3>,
5402                fidl::encoding::DefaultFuchsiaResourceDialect,
5403            >,
5404        T8: fidl::encoding::Encode<
5405                fidl::encoding::Array<u64, 3>,
5406                fidl::encoding::DefaultFuchsiaResourceDialect,
5407            >,
5408        T9: fidl::encoding::Encode<
5409                fidl::encoding::Array<f32, 3>,
5410                fidl::encoding::DefaultFuchsiaResourceDialect,
5411            >,
5412        T10: fidl::encoding::Encode<
5413                fidl::encoding::Array<f64, 3>,
5414                fidl::encoding::DefaultFuchsiaResourceDialect,
5415            >,
5416        T11: fidl::encoding::Encode<
5417                fidl::encoding::Array<DefaultEnum, 3>,
5418                fidl::encoding::DefaultFuchsiaResourceDialect,
5419            >,
5420        T12: fidl::encoding::Encode<
5421                fidl::encoding::Array<DefaultBits, 3>,
5422                fidl::encoding::DefaultFuchsiaResourceDialect,
5423            >,
5424        T13: fidl::encoding::Encode<
5425                fidl::encoding::Array<
5426                    fidl::encoding::HandleType<
5427                        fidl::NullableHandle,
5428                        { fidl::ObjectType::NONE.into_raw() },
5429                        2147483648,
5430                    >,
5431                    3,
5432                >,
5433                fidl::encoding::DefaultFuchsiaResourceDialect,
5434            >,
5435        T14: fidl::encoding::Encode<
5436                fidl::encoding::Array<
5437                    fidl::encoding::Optional<
5438                        fidl::encoding::HandleType<
5439                            fidl::NullableHandle,
5440                            { fidl::ObjectType::NONE.into_raw() },
5441                            2147483648,
5442                        >,
5443                    >,
5444                    3,
5445                >,
5446                fidl::encoding::DefaultFuchsiaResourceDialect,
5447            >,
5448        T15: fidl::encoding::Encode<
5449                fidl::encoding::Array<fidl::encoding::UnboundedString, 3>,
5450                fidl::encoding::DefaultFuchsiaResourceDialect,
5451            >,
5452        T16: fidl::encoding::Encode<
5453                fidl::encoding::Array<fidl::encoding::Optional<fidl::encoding::UnboundedString>, 3>,
5454                fidl::encoding::DefaultFuchsiaResourceDialect,
5455            >,
5456        T17: fidl::encoding::Encode<
5457                fidl::encoding::Array<ThisIsAStruct, 3>,
5458                fidl::encoding::DefaultFuchsiaResourceDialect,
5459            >,
5460        T18: fidl::encoding::Encode<
5461                fidl::encoding::Array<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
5462                fidl::encoding::DefaultFuchsiaResourceDialect,
5463            >,
5464        T19: fidl::encoding::Encode<
5465                fidl::encoding::Array<ThisIsAUnion, 3>,
5466                fidl::encoding::DefaultFuchsiaResourceDialect,
5467            >,
5468        T20: fidl::encoding::Encode<
5469                fidl::encoding::Array<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
5470                fidl::encoding::DefaultFuchsiaResourceDialect,
5471            >,
5472        T21: fidl::encoding::Encode<
5473                fidl::encoding::Array<fidl::encoding::Array<u32, 3>, 3>,
5474                fidl::encoding::DefaultFuchsiaResourceDialect,
5475            >,
5476        T22: fidl::encoding::Encode<
5477                fidl::encoding::Array<fidl::encoding::UnboundedVector<u32>, 3>,
5478                fidl::encoding::DefaultFuchsiaResourceDialect,
5479            >,
5480        T23: fidl::encoding::Encode<
5481                fidl::encoding::Array<
5482                    fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
5483                    3,
5484                >,
5485                fidl::encoding::DefaultFuchsiaResourceDialect,
5486            >,
5487        T24: fidl::encoding::Encode<
5488                fidl::encoding::Array<ThisIsATable, 3>,
5489                fidl::encoding::DefaultFuchsiaResourceDialect,
5490            >,
5491        T25: fidl::encoding::Encode<
5492                fidl::encoding::Array<ThisIsAXunion, 3>,
5493                fidl::encoding::DefaultFuchsiaResourceDialect,
5494            >,
5495    > fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
5496        for (
5497            T0,
5498            T1,
5499            T2,
5500            T3,
5501            T4,
5502            T5,
5503            T6,
5504            T7,
5505            T8,
5506            T9,
5507            T10,
5508            T11,
5509            T12,
5510            T13,
5511            T14,
5512            T15,
5513            T16,
5514            T17,
5515            T18,
5516            T19,
5517            T20,
5518            T21,
5519            T22,
5520            T23,
5521            T24,
5522            T25,
5523        )
5524    {
5525        #[inline]
5526        unsafe fn encode(
5527            self,
5528            encoder: &mut fidl::encoding::Encoder<
5529                '_,
5530                fidl::encoding::DefaultFuchsiaResourceDialect,
5531            >,
5532            offset: usize,
5533            depth: fidl::encoding::Depth,
5534        ) -> fidl::Result<()> {
5535            encoder.debug_check_bounds::<ArraysStruct>(offset);
5536            // Zero out padding regions. There's no need to apply masks
5537            // because the unmasked parts will be overwritten by fields.
5538            unsafe {
5539                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(48);
5540                (ptr as *mut u64).write_unaligned(0);
5541            }
5542            unsafe {
5543                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(56);
5544                (ptr as *mut u64).write_unaligned(0);
5545            }
5546            unsafe {
5547                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(104);
5548                (ptr as *mut u64).write_unaligned(0);
5549            }
5550            unsafe {
5551                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(480);
5552                (ptr as *mut u64).write_unaligned(0);
5553            }
5554            // Write the fields.
5555            self.0.encode(encoder, offset + 0, depth)?;
5556            self.1.encode(encoder, offset + 3, depth)?;
5557            self.2.encode(encoder, offset + 6, depth)?;
5558            self.3.encode(encoder, offset + 12, depth)?;
5559            self.4.encode(encoder, offset + 24, depth)?;
5560            self.5.encode(encoder, offset + 48, depth)?;
5561            self.6.encode(encoder, offset + 52, depth)?;
5562            self.7.encode(encoder, offset + 60, depth)?;
5563            self.8.encode(encoder, offset + 72, depth)?;
5564            self.9.encode(encoder, offset + 96, depth)?;
5565            self.10.encode(encoder, offset + 112, depth)?;
5566            self.11.encode(encoder, offset + 136, depth)?;
5567            self.12.encode(encoder, offset + 148, depth)?;
5568            self.13.encode(encoder, offset + 160, depth)?;
5569            self.14.encode(encoder, offset + 172, depth)?;
5570            self.15.encode(encoder, offset + 184, depth)?;
5571            self.16.encode(encoder, offset + 232, depth)?;
5572            self.17.encode(encoder, offset + 280, depth)?;
5573            self.18.encode(encoder, offset + 328, depth)?;
5574            self.19.encode(encoder, offset + 352, depth)?;
5575            self.20.encode(encoder, offset + 400, depth)?;
5576            self.21.encode(encoder, offset + 448, depth)?;
5577            self.22.encode(encoder, offset + 488, depth)?;
5578            self.23.encode(encoder, offset + 536, depth)?;
5579            self.24.encode(encoder, offset + 584, depth)?;
5580            self.25.encode(encoder, offset + 632, depth)?;
5581            Ok(())
5582        }
5583    }
5584
5585    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for ArraysStruct {
5586        #[inline(always)]
5587        fn new_empty() -> Self {
5588            Self {
5589                bools: fidl::new_empty!(fidl::encoding::Array<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5590                int8s: fidl::new_empty!(fidl::encoding::Array<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5591                int16s: fidl::new_empty!(fidl::encoding::Array<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5592                int32s: fidl::new_empty!(fidl::encoding::Array<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5593                int64s: fidl::new_empty!(fidl::encoding::Array<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5594                uint8s: fidl::new_empty!(fidl::encoding::Array<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5595                uint16s: fidl::new_empty!(fidl::encoding::Array<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5596                uint32s: fidl::new_empty!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5597                uint64s: fidl::new_empty!(fidl::encoding::Array<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5598                float32s: fidl::new_empty!(fidl::encoding::Array<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5599                float64s: fidl::new_empty!(fidl::encoding::Array<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5600                enums: fidl::new_empty!(fidl::encoding::Array<DefaultEnum, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5601                bits: fidl::new_empty!(fidl::encoding::Array<DefaultBits, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5602                handles: fidl::new_empty!(
5603                    fidl::encoding::Array<
5604                        fidl::encoding::HandleType<
5605                            fidl::NullableHandle,
5606                            { fidl::ObjectType::NONE.into_raw() },
5607                            2147483648,
5608                        >,
5609                        3,
5610                    >,
5611                    fidl::encoding::DefaultFuchsiaResourceDialect
5612                ),
5613                nullable_handles: fidl::new_empty!(
5614                    fidl::encoding::Array<
5615                        fidl::encoding::Optional<
5616                            fidl::encoding::HandleType<
5617                                fidl::NullableHandle,
5618                                { fidl::ObjectType::NONE.into_raw() },
5619                                2147483648,
5620                            >,
5621                        >,
5622                        3,
5623                    >,
5624                    fidl::encoding::DefaultFuchsiaResourceDialect
5625                ),
5626                strings: fidl::new_empty!(fidl::encoding::Array<fidl::encoding::UnboundedString, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5627                nullable_strings: fidl::new_empty!(
5628                    fidl::encoding::Array<
5629                        fidl::encoding::Optional<fidl::encoding::UnboundedString>,
5630                        3,
5631                    >,
5632                    fidl::encoding::DefaultFuchsiaResourceDialect
5633                ),
5634                structs: fidl::new_empty!(fidl::encoding::Array<ThisIsAStruct, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5635                nullable_structs: fidl::new_empty!(
5636                    fidl::encoding::Array<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
5637                    fidl::encoding::DefaultFuchsiaResourceDialect
5638                ),
5639                unions: fidl::new_empty!(fidl::encoding::Array<ThisIsAUnion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5640                nullable_unions: fidl::new_empty!(
5641                    fidl::encoding::Array<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
5642                    fidl::encoding::DefaultFuchsiaResourceDialect
5643                ),
5644                arrays: fidl::new_empty!(
5645                    fidl::encoding::Array<fidl::encoding::Array<u32, 3>, 3>,
5646                    fidl::encoding::DefaultFuchsiaResourceDialect
5647                ),
5648                vectors: fidl::new_empty!(
5649                    fidl::encoding::Array<fidl::encoding::UnboundedVector<u32>, 3>,
5650                    fidl::encoding::DefaultFuchsiaResourceDialect
5651                ),
5652                nullable_vectors: fidl::new_empty!(
5653                    fidl::encoding::Array<
5654                        fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
5655                        3,
5656                    >,
5657                    fidl::encoding::DefaultFuchsiaResourceDialect
5658                ),
5659                tables: fidl::new_empty!(fidl::encoding::Array<ThisIsATable, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5660                xunions: fidl::new_empty!(fidl::encoding::Array<ThisIsAXunion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5661            }
5662        }
5663
5664        #[inline]
5665        unsafe fn decode(
5666            &mut self,
5667            decoder: &mut fidl::encoding::Decoder<
5668                '_,
5669                fidl::encoding::DefaultFuchsiaResourceDialect,
5670            >,
5671            offset: usize,
5672            _depth: fidl::encoding::Depth,
5673        ) -> fidl::Result<()> {
5674            decoder.debug_check_bounds::<Self>(offset);
5675            // Verify that padding bytes are zero.
5676            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(48) };
5677            let padval = unsafe { (ptr as *const u64).read_unaligned() };
5678            let mask = 0xff000000u64;
5679            let maskedval = padval & mask;
5680            if maskedval != 0 {
5681                return Err(fidl::Error::NonZeroPadding {
5682                    padding_start: offset + 48 + ((mask as u64).trailing_zeros() / 8) as usize,
5683                });
5684            }
5685            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(56) };
5686            let padval = unsafe { (ptr as *const u64).read_unaligned() };
5687            let mask = 0xffff0000u64;
5688            let maskedval = padval & mask;
5689            if maskedval != 0 {
5690                return Err(fidl::Error::NonZeroPadding {
5691                    padding_start: offset + 56 + ((mask as u64).trailing_zeros() / 8) as usize,
5692                });
5693            }
5694            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(104) };
5695            let padval = unsafe { (ptr as *const u64).read_unaligned() };
5696            let mask = 0xffffffff00000000u64;
5697            let maskedval = padval & mask;
5698            if maskedval != 0 {
5699                return Err(fidl::Error::NonZeroPadding {
5700                    padding_start: offset + 104 + ((mask as u64).trailing_zeros() / 8) as usize,
5701                });
5702            }
5703            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(480) };
5704            let padval = unsafe { (ptr as *const u64).read_unaligned() };
5705            let mask = 0xffffffff00000000u64;
5706            let maskedval = padval & mask;
5707            if maskedval != 0 {
5708                return Err(fidl::Error::NonZeroPadding {
5709                    padding_start: offset + 480 + ((mask as u64).trailing_zeros() / 8) as usize,
5710                });
5711            }
5712            fidl::decode!(fidl::encoding::Array<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.bools, decoder, offset + 0, _depth)?;
5713            fidl::decode!(fidl::encoding::Array<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int8s, decoder, offset + 3, _depth)?;
5714            fidl::decode!(fidl::encoding::Array<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int16s, decoder, offset + 6, _depth)?;
5715            fidl::decode!(fidl::encoding::Array<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int32s, decoder, offset + 12, _depth)?;
5716            fidl::decode!(fidl::encoding::Array<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int64s, decoder, offset + 24, _depth)?;
5717            fidl::decode!(fidl::encoding::Array<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint8s, decoder, offset + 48, _depth)?;
5718            fidl::decode!(fidl::encoding::Array<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint16s, decoder, offset + 52, _depth)?;
5719            fidl::decode!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint32s, decoder, offset + 60, _depth)?;
5720            fidl::decode!(fidl::encoding::Array<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint64s, decoder, offset + 72, _depth)?;
5721            fidl::decode!(fidl::encoding::Array<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.float32s, decoder, offset + 96, _depth)?;
5722            fidl::decode!(fidl::encoding::Array<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.float64s, decoder, offset + 112, _depth)?;
5723            fidl::decode!(fidl::encoding::Array<DefaultEnum, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.enums, decoder, offset + 136, _depth)?;
5724            fidl::decode!(fidl::encoding::Array<DefaultBits, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.bits, decoder, offset + 148, _depth)?;
5725            fidl::decode!(
5726                fidl::encoding::Array<
5727                    fidl::encoding::HandleType<
5728                        fidl::NullableHandle,
5729                        { fidl::ObjectType::NONE.into_raw() },
5730                        2147483648,
5731                    >,
5732                    3,
5733                >,
5734                fidl::encoding::DefaultFuchsiaResourceDialect,
5735                &mut self.handles,
5736                decoder,
5737                offset + 160,
5738                _depth
5739            )?;
5740            fidl::decode!(
5741                fidl::encoding::Array<
5742                    fidl::encoding::Optional<
5743                        fidl::encoding::HandleType<
5744                            fidl::NullableHandle,
5745                            { fidl::ObjectType::NONE.into_raw() },
5746                            2147483648,
5747                        >,
5748                    >,
5749                    3,
5750                >,
5751                fidl::encoding::DefaultFuchsiaResourceDialect,
5752                &mut self.nullable_handles,
5753                decoder,
5754                offset + 172,
5755                _depth
5756            )?;
5757            fidl::decode!(fidl::encoding::Array<fidl::encoding::UnboundedString, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.strings, decoder, offset + 184, _depth)?;
5758            fidl::decode!(
5759                fidl::encoding::Array<fidl::encoding::Optional<fidl::encoding::UnboundedString>, 3>,
5760                fidl::encoding::DefaultFuchsiaResourceDialect,
5761                &mut self.nullable_strings,
5762                decoder,
5763                offset + 232,
5764                _depth
5765            )?;
5766            fidl::decode!(fidl::encoding::Array<ThisIsAStruct, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.structs, decoder, offset + 280, _depth)?;
5767            fidl::decode!(
5768                fidl::encoding::Array<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
5769                fidl::encoding::DefaultFuchsiaResourceDialect,
5770                &mut self.nullable_structs,
5771                decoder,
5772                offset + 328,
5773                _depth
5774            )?;
5775            fidl::decode!(fidl::encoding::Array<ThisIsAUnion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.unions, decoder, offset + 352, _depth)?;
5776            fidl::decode!(
5777                fidl::encoding::Array<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
5778                fidl::encoding::DefaultFuchsiaResourceDialect,
5779                &mut self.nullable_unions,
5780                decoder,
5781                offset + 400,
5782                _depth
5783            )?;
5784            fidl::decode!(
5785                fidl::encoding::Array<fidl::encoding::Array<u32, 3>, 3>,
5786                fidl::encoding::DefaultFuchsiaResourceDialect,
5787                &mut self.arrays,
5788                decoder,
5789                offset + 448,
5790                _depth
5791            )?;
5792            fidl::decode!(
5793                fidl::encoding::Array<fidl::encoding::UnboundedVector<u32>, 3>,
5794                fidl::encoding::DefaultFuchsiaResourceDialect,
5795                &mut self.vectors,
5796                decoder,
5797                offset + 488,
5798                _depth
5799            )?;
5800            fidl::decode!(
5801                fidl::encoding::Array<
5802                    fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
5803                    3,
5804                >,
5805                fidl::encoding::DefaultFuchsiaResourceDialect,
5806                &mut self.nullable_vectors,
5807                decoder,
5808                offset + 536,
5809                _depth
5810            )?;
5811            fidl::decode!(fidl::encoding::Array<ThisIsATable, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.tables, decoder, offset + 584, _depth)?;
5812            fidl::decode!(fidl::encoding::Array<ThisIsAXunion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.xunions, decoder, offset + 632, _depth)?;
5813            Ok(())
5814        }
5815    }
5816
5817    impl fidl::encoding::ResourceTypeMarker for EchoEchoArraysRequest {
5818        type Borrowed<'a> = &'a mut Self;
5819        fn take_or_borrow<'a>(
5820            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
5821        ) -> Self::Borrowed<'a> {
5822            value
5823        }
5824    }
5825
5826    unsafe impl fidl::encoding::TypeMarker for EchoEchoArraysRequest {
5827        type Owned = Self;
5828
5829        #[inline(always)]
5830        fn inline_align(_context: fidl::encoding::Context) -> usize {
5831            8
5832        }
5833
5834        #[inline(always)]
5835        fn inline_size(_context: fidl::encoding::Context) -> usize {
5836            696
5837        }
5838    }
5839
5840    unsafe impl
5841        fidl::encoding::Encode<EchoEchoArraysRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
5842        for &mut EchoEchoArraysRequest
5843    {
5844        #[inline]
5845        unsafe fn encode(
5846            self,
5847            encoder: &mut fidl::encoding::Encoder<
5848                '_,
5849                fidl::encoding::DefaultFuchsiaResourceDialect,
5850            >,
5851            offset: usize,
5852            _depth: fidl::encoding::Depth,
5853        ) -> fidl::Result<()> {
5854            encoder.debug_check_bounds::<EchoEchoArraysRequest>(offset);
5855            // Delegate to tuple encoding.
5856            fidl::encoding::Encode::<
5857                EchoEchoArraysRequest,
5858                fidl::encoding::DefaultFuchsiaResourceDialect,
5859            >::encode(
5860                (
5861                    <ArraysStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
5862                        &mut self.value,
5863                    ),
5864                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
5865                        &self.forward_to_server,
5866                    ),
5867                ),
5868                encoder,
5869                offset,
5870                _depth,
5871            )
5872        }
5873    }
5874    unsafe impl<
5875        T0: fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
5876        T1: fidl::encoding::Encode<
5877                fidl::encoding::UnboundedString,
5878                fidl::encoding::DefaultFuchsiaResourceDialect,
5879            >,
5880    >
5881        fidl::encoding::Encode<EchoEchoArraysRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
5882        for (T0, T1)
5883    {
5884        #[inline]
5885        unsafe fn encode(
5886            self,
5887            encoder: &mut fidl::encoding::Encoder<
5888                '_,
5889                fidl::encoding::DefaultFuchsiaResourceDialect,
5890            >,
5891            offset: usize,
5892            depth: fidl::encoding::Depth,
5893        ) -> fidl::Result<()> {
5894            encoder.debug_check_bounds::<EchoEchoArraysRequest>(offset);
5895            // Zero out padding regions. There's no need to apply masks
5896            // because the unmasked parts will be overwritten by fields.
5897            // Write the fields.
5898            self.0.encode(encoder, offset + 0, depth)?;
5899            self.1.encode(encoder, offset + 680, depth)?;
5900            Ok(())
5901        }
5902    }
5903
5904    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
5905        for EchoEchoArraysRequest
5906    {
5907        #[inline(always)]
5908        fn new_empty() -> Self {
5909            Self {
5910                value: fidl::new_empty!(
5911                    ArraysStruct,
5912                    fidl::encoding::DefaultFuchsiaResourceDialect
5913                ),
5914                forward_to_server: fidl::new_empty!(
5915                    fidl::encoding::UnboundedString,
5916                    fidl::encoding::DefaultFuchsiaResourceDialect
5917                ),
5918            }
5919        }
5920
5921        #[inline]
5922        unsafe fn decode(
5923            &mut self,
5924            decoder: &mut fidl::encoding::Decoder<
5925                '_,
5926                fidl::encoding::DefaultFuchsiaResourceDialect,
5927            >,
5928            offset: usize,
5929            _depth: fidl::encoding::Depth,
5930        ) -> fidl::Result<()> {
5931            decoder.debug_check_bounds::<Self>(offset);
5932            // Verify that padding bytes are zero.
5933            fidl::decode!(
5934                ArraysStruct,
5935                fidl::encoding::DefaultFuchsiaResourceDialect,
5936                &mut self.value,
5937                decoder,
5938                offset + 0,
5939                _depth
5940            )?;
5941            fidl::decode!(
5942                fidl::encoding::UnboundedString,
5943                fidl::encoding::DefaultFuchsiaResourceDialect,
5944                &mut self.forward_to_server,
5945                decoder,
5946                offset + 680,
5947                _depth
5948            )?;
5949            Ok(())
5950        }
5951    }
5952
5953    impl fidl::encoding::ResourceTypeMarker for EchoEchoArraysResponse {
5954        type Borrowed<'a> = &'a mut Self;
5955        fn take_or_borrow<'a>(
5956            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
5957        ) -> Self::Borrowed<'a> {
5958            value
5959        }
5960    }
5961
5962    unsafe impl fidl::encoding::TypeMarker for EchoEchoArraysResponse {
5963        type Owned = Self;
5964
5965        #[inline(always)]
5966        fn inline_align(_context: fidl::encoding::Context) -> usize {
5967            8
5968        }
5969
5970        #[inline(always)]
5971        fn inline_size(_context: fidl::encoding::Context) -> usize {
5972            680
5973        }
5974    }
5975
5976    unsafe impl
5977        fidl::encoding::Encode<
5978            EchoEchoArraysResponse,
5979            fidl::encoding::DefaultFuchsiaResourceDialect,
5980        > for &mut EchoEchoArraysResponse
5981    {
5982        #[inline]
5983        unsafe fn encode(
5984            self,
5985            encoder: &mut fidl::encoding::Encoder<
5986                '_,
5987                fidl::encoding::DefaultFuchsiaResourceDialect,
5988            >,
5989            offset: usize,
5990            _depth: fidl::encoding::Depth,
5991        ) -> fidl::Result<()> {
5992            encoder.debug_check_bounds::<EchoEchoArraysResponse>(offset);
5993            // Delegate to tuple encoding.
5994            fidl::encoding::Encode::<
5995                EchoEchoArraysResponse,
5996                fidl::encoding::DefaultFuchsiaResourceDialect,
5997            >::encode(
5998                (<ArraysStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
5999                    &mut self.value,
6000                ),),
6001                encoder,
6002                offset,
6003                _depth,
6004            )
6005        }
6006    }
6007    unsafe impl<
6008        T0: fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
6009    >
6010        fidl::encoding::Encode<
6011            EchoEchoArraysResponse,
6012            fidl::encoding::DefaultFuchsiaResourceDialect,
6013        > for (T0,)
6014    {
6015        #[inline]
6016        unsafe fn encode(
6017            self,
6018            encoder: &mut fidl::encoding::Encoder<
6019                '_,
6020                fidl::encoding::DefaultFuchsiaResourceDialect,
6021            >,
6022            offset: usize,
6023            depth: fidl::encoding::Depth,
6024        ) -> fidl::Result<()> {
6025            encoder.debug_check_bounds::<EchoEchoArraysResponse>(offset);
6026            // Zero out padding regions. There's no need to apply masks
6027            // because the unmasked parts will be overwritten by fields.
6028            // Write the fields.
6029            self.0.encode(encoder, offset + 0, depth)?;
6030            Ok(())
6031        }
6032    }
6033
6034    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6035        for EchoEchoArraysResponse
6036    {
6037        #[inline(always)]
6038        fn new_empty() -> Self {
6039            Self {
6040                value: fidl::new_empty!(
6041                    ArraysStruct,
6042                    fidl::encoding::DefaultFuchsiaResourceDialect
6043                ),
6044            }
6045        }
6046
6047        #[inline]
6048        unsafe fn decode(
6049            &mut self,
6050            decoder: &mut fidl::encoding::Decoder<
6051                '_,
6052                fidl::encoding::DefaultFuchsiaResourceDialect,
6053            >,
6054            offset: usize,
6055            _depth: fidl::encoding::Depth,
6056        ) -> fidl::Result<()> {
6057            decoder.debug_check_bounds::<Self>(offset);
6058            // Verify that padding bytes are zero.
6059            fidl::decode!(
6060                ArraysStruct,
6061                fidl::encoding::DefaultFuchsiaResourceDialect,
6062                &mut self.value,
6063                decoder,
6064                offset + 0,
6065                _depth
6066            )?;
6067            Ok(())
6068        }
6069    }
6070
6071    impl fidl::encoding::ResourceTypeMarker for EchoEchoArraysWithErrorRequest {
6072        type Borrowed<'a> = &'a mut Self;
6073        fn take_or_borrow<'a>(
6074            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6075        ) -> Self::Borrowed<'a> {
6076            value
6077        }
6078    }
6079
6080    unsafe impl fidl::encoding::TypeMarker for EchoEchoArraysWithErrorRequest {
6081        type Owned = Self;
6082
6083        #[inline(always)]
6084        fn inline_align(_context: fidl::encoding::Context) -> usize {
6085            8
6086        }
6087
6088        #[inline(always)]
6089        fn inline_size(_context: fidl::encoding::Context) -> usize {
6090            712
6091        }
6092    }
6093
6094    unsafe impl
6095        fidl::encoding::Encode<
6096            EchoEchoArraysWithErrorRequest,
6097            fidl::encoding::DefaultFuchsiaResourceDialect,
6098        > for &mut EchoEchoArraysWithErrorRequest
6099    {
6100        #[inline]
6101        unsafe fn encode(
6102            self,
6103            encoder: &mut fidl::encoding::Encoder<
6104                '_,
6105                fidl::encoding::DefaultFuchsiaResourceDialect,
6106            >,
6107            offset: usize,
6108            _depth: fidl::encoding::Depth,
6109        ) -> fidl::Result<()> {
6110            encoder.debug_check_bounds::<EchoEchoArraysWithErrorRequest>(offset);
6111            // Delegate to tuple encoding.
6112            fidl::encoding::Encode::<
6113                EchoEchoArraysWithErrorRequest,
6114                fidl::encoding::DefaultFuchsiaResourceDialect,
6115            >::encode(
6116                (
6117                    <ArraysStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
6118                        &mut self.value,
6119                    ),
6120                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
6121                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
6122                        &self.forward_to_server,
6123                    ),
6124                    <RespondWith as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
6125                ),
6126                encoder,
6127                offset,
6128                _depth,
6129            )
6130        }
6131    }
6132    unsafe impl<
6133        T0: fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
6134        T1: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
6135        T2: fidl::encoding::Encode<
6136                fidl::encoding::UnboundedString,
6137                fidl::encoding::DefaultFuchsiaResourceDialect,
6138            >,
6139        T3: fidl::encoding::Encode<RespondWith, fidl::encoding::DefaultFuchsiaResourceDialect>,
6140    >
6141        fidl::encoding::Encode<
6142            EchoEchoArraysWithErrorRequest,
6143            fidl::encoding::DefaultFuchsiaResourceDialect,
6144        > for (T0, T1, T2, T3)
6145    {
6146        #[inline]
6147        unsafe fn encode(
6148            self,
6149            encoder: &mut fidl::encoding::Encoder<
6150                '_,
6151                fidl::encoding::DefaultFuchsiaResourceDialect,
6152            >,
6153            offset: usize,
6154            depth: fidl::encoding::Depth,
6155        ) -> fidl::Result<()> {
6156            encoder.debug_check_bounds::<EchoEchoArraysWithErrorRequest>(offset);
6157            // Zero out padding regions. There's no need to apply masks
6158            // because the unmasked parts will be overwritten by fields.
6159            unsafe {
6160                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(680);
6161                (ptr as *mut u64).write_unaligned(0);
6162            }
6163            unsafe {
6164                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(704);
6165                (ptr as *mut u64).write_unaligned(0);
6166            }
6167            // Write the fields.
6168            self.0.encode(encoder, offset + 0, depth)?;
6169            self.1.encode(encoder, offset + 680, depth)?;
6170            self.2.encode(encoder, offset + 688, depth)?;
6171            self.3.encode(encoder, offset + 704, depth)?;
6172            Ok(())
6173        }
6174    }
6175
6176    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6177        for EchoEchoArraysWithErrorRequest
6178    {
6179        #[inline(always)]
6180        fn new_empty() -> Self {
6181            Self {
6182                value: fidl::new_empty!(
6183                    ArraysStruct,
6184                    fidl::encoding::DefaultFuchsiaResourceDialect
6185                ),
6186                result_err: fidl::new_empty!(
6187                    DefaultEnum,
6188                    fidl::encoding::DefaultFuchsiaResourceDialect
6189                ),
6190                forward_to_server: fidl::new_empty!(
6191                    fidl::encoding::UnboundedString,
6192                    fidl::encoding::DefaultFuchsiaResourceDialect
6193                ),
6194                result_variant: fidl::new_empty!(
6195                    RespondWith,
6196                    fidl::encoding::DefaultFuchsiaResourceDialect
6197                ),
6198            }
6199        }
6200
6201        #[inline]
6202        unsafe fn decode(
6203            &mut self,
6204            decoder: &mut fidl::encoding::Decoder<
6205                '_,
6206                fidl::encoding::DefaultFuchsiaResourceDialect,
6207            >,
6208            offset: usize,
6209            _depth: fidl::encoding::Depth,
6210        ) -> fidl::Result<()> {
6211            decoder.debug_check_bounds::<Self>(offset);
6212            // Verify that padding bytes are zero.
6213            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(680) };
6214            let padval = unsafe { (ptr as *const u64).read_unaligned() };
6215            let mask = 0xffffffff00000000u64;
6216            let maskedval = padval & mask;
6217            if maskedval != 0 {
6218                return Err(fidl::Error::NonZeroPadding {
6219                    padding_start: offset + 680 + ((mask as u64).trailing_zeros() / 8) as usize,
6220                });
6221            }
6222            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(704) };
6223            let padval = unsafe { (ptr as *const u64).read_unaligned() };
6224            let mask = 0xffffffff00000000u64;
6225            let maskedval = padval & mask;
6226            if maskedval != 0 {
6227                return Err(fidl::Error::NonZeroPadding {
6228                    padding_start: offset + 704 + ((mask as u64).trailing_zeros() / 8) as usize,
6229                });
6230            }
6231            fidl::decode!(
6232                ArraysStruct,
6233                fidl::encoding::DefaultFuchsiaResourceDialect,
6234                &mut self.value,
6235                decoder,
6236                offset + 0,
6237                _depth
6238            )?;
6239            fidl::decode!(
6240                DefaultEnum,
6241                fidl::encoding::DefaultFuchsiaResourceDialect,
6242                &mut self.result_err,
6243                decoder,
6244                offset + 680,
6245                _depth
6246            )?;
6247            fidl::decode!(
6248                fidl::encoding::UnboundedString,
6249                fidl::encoding::DefaultFuchsiaResourceDialect,
6250                &mut self.forward_to_server,
6251                decoder,
6252                offset + 688,
6253                _depth
6254            )?;
6255            fidl::decode!(
6256                RespondWith,
6257                fidl::encoding::DefaultFuchsiaResourceDialect,
6258                &mut self.result_variant,
6259                decoder,
6260                offset + 704,
6261                _depth
6262            )?;
6263            Ok(())
6264        }
6265    }
6266
6267    impl fidl::encoding::ResourceTypeMarker for EchoEchoEventRequest {
6268        type Borrowed<'a> = &'a mut Self;
6269        fn take_or_borrow<'a>(
6270            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6271        ) -> Self::Borrowed<'a> {
6272            value
6273        }
6274    }
6275
6276    unsafe impl fidl::encoding::TypeMarker for EchoEchoEventRequest {
6277        type Owned = Self;
6278
6279        #[inline(always)]
6280        fn inline_align(_context: fidl::encoding::Context) -> usize {
6281            8
6282        }
6283
6284        #[inline(always)]
6285        fn inline_size(_context: fidl::encoding::Context) -> usize {
6286            2912
6287        }
6288    }
6289
6290    unsafe impl
6291        fidl::encoding::Encode<EchoEchoEventRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
6292        for &mut EchoEchoEventRequest
6293    {
6294        #[inline]
6295        unsafe fn encode(
6296            self,
6297            encoder: &mut fidl::encoding::Encoder<
6298                '_,
6299                fidl::encoding::DefaultFuchsiaResourceDialect,
6300            >,
6301            offset: usize,
6302            _depth: fidl::encoding::Depth,
6303        ) -> fidl::Result<()> {
6304            encoder.debug_check_bounds::<EchoEchoEventRequest>(offset);
6305            // Delegate to tuple encoding.
6306            fidl::encoding::Encode::<
6307                EchoEchoEventRequest,
6308                fidl::encoding::DefaultFuchsiaResourceDialect,
6309            >::encode(
6310                (<Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),),
6311                encoder,
6312                offset,
6313                _depth,
6314            )
6315        }
6316    }
6317    unsafe impl<T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>>
6318        fidl::encoding::Encode<EchoEchoEventRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
6319        for (T0,)
6320    {
6321        #[inline]
6322        unsafe fn encode(
6323            self,
6324            encoder: &mut fidl::encoding::Encoder<
6325                '_,
6326                fidl::encoding::DefaultFuchsiaResourceDialect,
6327            >,
6328            offset: usize,
6329            depth: fidl::encoding::Depth,
6330        ) -> fidl::Result<()> {
6331            encoder.debug_check_bounds::<EchoEchoEventRequest>(offset);
6332            // Zero out padding regions. There's no need to apply masks
6333            // because the unmasked parts will be overwritten by fields.
6334            // Write the fields.
6335            self.0.encode(encoder, offset + 0, depth)?;
6336            Ok(())
6337        }
6338    }
6339
6340    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6341        for EchoEchoEventRequest
6342    {
6343        #[inline(always)]
6344        fn new_empty() -> Self {
6345            Self { value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect) }
6346        }
6347
6348        #[inline]
6349        unsafe fn decode(
6350            &mut self,
6351            decoder: &mut fidl::encoding::Decoder<
6352                '_,
6353                fidl::encoding::DefaultFuchsiaResourceDialect,
6354            >,
6355            offset: usize,
6356            _depth: fidl::encoding::Depth,
6357        ) -> fidl::Result<()> {
6358            decoder.debug_check_bounds::<Self>(offset);
6359            // Verify that padding bytes are zero.
6360            fidl::decode!(
6361                Struct,
6362                fidl::encoding::DefaultFuchsiaResourceDialect,
6363                &mut self.value,
6364                decoder,
6365                offset + 0,
6366                _depth
6367            )?;
6368            Ok(())
6369        }
6370    }
6371
6372    impl fidl::encoding::ResourceTypeMarker for EchoEchoStructNoRetValRequest {
6373        type Borrowed<'a> = &'a mut Self;
6374        fn take_or_borrow<'a>(
6375            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6376        ) -> Self::Borrowed<'a> {
6377            value
6378        }
6379    }
6380
6381    unsafe impl fidl::encoding::TypeMarker for EchoEchoStructNoRetValRequest {
6382        type Owned = Self;
6383
6384        #[inline(always)]
6385        fn inline_align(_context: fidl::encoding::Context) -> usize {
6386            8
6387        }
6388
6389        #[inline(always)]
6390        fn inline_size(_context: fidl::encoding::Context) -> usize {
6391            2928
6392        }
6393    }
6394
6395    unsafe impl
6396        fidl::encoding::Encode<
6397            EchoEchoStructNoRetValRequest,
6398            fidl::encoding::DefaultFuchsiaResourceDialect,
6399        > for &mut EchoEchoStructNoRetValRequest
6400    {
6401        #[inline]
6402        unsafe fn encode(
6403            self,
6404            encoder: &mut fidl::encoding::Encoder<
6405                '_,
6406                fidl::encoding::DefaultFuchsiaResourceDialect,
6407            >,
6408            offset: usize,
6409            _depth: fidl::encoding::Depth,
6410        ) -> fidl::Result<()> {
6411            encoder.debug_check_bounds::<EchoEchoStructNoRetValRequest>(offset);
6412            // Delegate to tuple encoding.
6413            fidl::encoding::Encode::<
6414                EchoEchoStructNoRetValRequest,
6415                fidl::encoding::DefaultFuchsiaResourceDialect,
6416            >::encode(
6417                (
6418                    <Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
6419                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
6420                        &self.forward_to_server,
6421                    ),
6422                ),
6423                encoder,
6424                offset,
6425                _depth,
6426            )
6427        }
6428    }
6429    unsafe impl<
6430        T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>,
6431        T1: fidl::encoding::Encode<
6432                fidl::encoding::UnboundedString,
6433                fidl::encoding::DefaultFuchsiaResourceDialect,
6434            >,
6435    >
6436        fidl::encoding::Encode<
6437            EchoEchoStructNoRetValRequest,
6438            fidl::encoding::DefaultFuchsiaResourceDialect,
6439        > for (T0, T1)
6440    {
6441        #[inline]
6442        unsafe fn encode(
6443            self,
6444            encoder: &mut fidl::encoding::Encoder<
6445                '_,
6446                fidl::encoding::DefaultFuchsiaResourceDialect,
6447            >,
6448            offset: usize,
6449            depth: fidl::encoding::Depth,
6450        ) -> fidl::Result<()> {
6451            encoder.debug_check_bounds::<EchoEchoStructNoRetValRequest>(offset);
6452            // Zero out padding regions. There's no need to apply masks
6453            // because the unmasked parts will be overwritten by fields.
6454            // Write the fields.
6455            self.0.encode(encoder, offset + 0, depth)?;
6456            self.1.encode(encoder, offset + 2912, depth)?;
6457            Ok(())
6458        }
6459    }
6460
6461    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6462        for EchoEchoStructNoRetValRequest
6463    {
6464        #[inline(always)]
6465        fn new_empty() -> Self {
6466            Self {
6467                value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect),
6468                forward_to_server: fidl::new_empty!(
6469                    fidl::encoding::UnboundedString,
6470                    fidl::encoding::DefaultFuchsiaResourceDialect
6471                ),
6472            }
6473        }
6474
6475        #[inline]
6476        unsafe fn decode(
6477            &mut self,
6478            decoder: &mut fidl::encoding::Decoder<
6479                '_,
6480                fidl::encoding::DefaultFuchsiaResourceDialect,
6481            >,
6482            offset: usize,
6483            _depth: fidl::encoding::Depth,
6484        ) -> fidl::Result<()> {
6485            decoder.debug_check_bounds::<Self>(offset);
6486            // Verify that padding bytes are zero.
6487            fidl::decode!(
6488                Struct,
6489                fidl::encoding::DefaultFuchsiaResourceDialect,
6490                &mut self.value,
6491                decoder,
6492                offset + 0,
6493                _depth
6494            )?;
6495            fidl::decode!(
6496                fidl::encoding::UnboundedString,
6497                fidl::encoding::DefaultFuchsiaResourceDialect,
6498                &mut self.forward_to_server,
6499                decoder,
6500                offset + 2912,
6501                _depth
6502            )?;
6503            Ok(())
6504        }
6505    }
6506
6507    impl fidl::encoding::ResourceTypeMarker for EchoEchoStructRequest {
6508        type Borrowed<'a> = &'a mut Self;
6509        fn take_or_borrow<'a>(
6510            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6511        ) -> Self::Borrowed<'a> {
6512            value
6513        }
6514    }
6515
6516    unsafe impl fidl::encoding::TypeMarker for EchoEchoStructRequest {
6517        type Owned = Self;
6518
6519        #[inline(always)]
6520        fn inline_align(_context: fidl::encoding::Context) -> usize {
6521            8
6522        }
6523
6524        #[inline(always)]
6525        fn inline_size(_context: fidl::encoding::Context) -> usize {
6526            2928
6527        }
6528    }
6529
6530    unsafe impl
6531        fidl::encoding::Encode<EchoEchoStructRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
6532        for &mut EchoEchoStructRequest
6533    {
6534        #[inline]
6535        unsafe fn encode(
6536            self,
6537            encoder: &mut fidl::encoding::Encoder<
6538                '_,
6539                fidl::encoding::DefaultFuchsiaResourceDialect,
6540            >,
6541            offset: usize,
6542            _depth: fidl::encoding::Depth,
6543        ) -> fidl::Result<()> {
6544            encoder.debug_check_bounds::<EchoEchoStructRequest>(offset);
6545            // Delegate to tuple encoding.
6546            fidl::encoding::Encode::<
6547                EchoEchoStructRequest,
6548                fidl::encoding::DefaultFuchsiaResourceDialect,
6549            >::encode(
6550                (
6551                    <Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
6552                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
6553                        &self.forward_to_server,
6554                    ),
6555                ),
6556                encoder,
6557                offset,
6558                _depth,
6559            )
6560        }
6561    }
6562    unsafe impl<
6563        T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>,
6564        T1: fidl::encoding::Encode<
6565                fidl::encoding::UnboundedString,
6566                fidl::encoding::DefaultFuchsiaResourceDialect,
6567            >,
6568    >
6569        fidl::encoding::Encode<EchoEchoStructRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
6570        for (T0, T1)
6571    {
6572        #[inline]
6573        unsafe fn encode(
6574            self,
6575            encoder: &mut fidl::encoding::Encoder<
6576                '_,
6577                fidl::encoding::DefaultFuchsiaResourceDialect,
6578            >,
6579            offset: usize,
6580            depth: fidl::encoding::Depth,
6581        ) -> fidl::Result<()> {
6582            encoder.debug_check_bounds::<EchoEchoStructRequest>(offset);
6583            // Zero out padding regions. There's no need to apply masks
6584            // because the unmasked parts will be overwritten by fields.
6585            // Write the fields.
6586            self.0.encode(encoder, offset + 0, depth)?;
6587            self.1.encode(encoder, offset + 2912, depth)?;
6588            Ok(())
6589        }
6590    }
6591
6592    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6593        for EchoEchoStructRequest
6594    {
6595        #[inline(always)]
6596        fn new_empty() -> Self {
6597            Self {
6598                value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect),
6599                forward_to_server: fidl::new_empty!(
6600                    fidl::encoding::UnboundedString,
6601                    fidl::encoding::DefaultFuchsiaResourceDialect
6602                ),
6603            }
6604        }
6605
6606        #[inline]
6607        unsafe fn decode(
6608            &mut self,
6609            decoder: &mut fidl::encoding::Decoder<
6610                '_,
6611                fidl::encoding::DefaultFuchsiaResourceDialect,
6612            >,
6613            offset: usize,
6614            _depth: fidl::encoding::Depth,
6615        ) -> fidl::Result<()> {
6616            decoder.debug_check_bounds::<Self>(offset);
6617            // Verify that padding bytes are zero.
6618            fidl::decode!(
6619                Struct,
6620                fidl::encoding::DefaultFuchsiaResourceDialect,
6621                &mut self.value,
6622                decoder,
6623                offset + 0,
6624                _depth
6625            )?;
6626            fidl::decode!(
6627                fidl::encoding::UnboundedString,
6628                fidl::encoding::DefaultFuchsiaResourceDialect,
6629                &mut self.forward_to_server,
6630                decoder,
6631                offset + 2912,
6632                _depth
6633            )?;
6634            Ok(())
6635        }
6636    }
6637
6638    impl fidl::encoding::ResourceTypeMarker for EchoEchoStructResponse {
6639        type Borrowed<'a> = &'a mut Self;
6640        fn take_or_borrow<'a>(
6641            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6642        ) -> Self::Borrowed<'a> {
6643            value
6644        }
6645    }
6646
6647    unsafe impl fidl::encoding::TypeMarker for EchoEchoStructResponse {
6648        type Owned = Self;
6649
6650        #[inline(always)]
6651        fn inline_align(_context: fidl::encoding::Context) -> usize {
6652            8
6653        }
6654
6655        #[inline(always)]
6656        fn inline_size(_context: fidl::encoding::Context) -> usize {
6657            2912
6658        }
6659    }
6660
6661    unsafe impl
6662        fidl::encoding::Encode<
6663            EchoEchoStructResponse,
6664            fidl::encoding::DefaultFuchsiaResourceDialect,
6665        > for &mut EchoEchoStructResponse
6666    {
6667        #[inline]
6668        unsafe fn encode(
6669            self,
6670            encoder: &mut fidl::encoding::Encoder<
6671                '_,
6672                fidl::encoding::DefaultFuchsiaResourceDialect,
6673            >,
6674            offset: usize,
6675            _depth: fidl::encoding::Depth,
6676        ) -> fidl::Result<()> {
6677            encoder.debug_check_bounds::<EchoEchoStructResponse>(offset);
6678            // Delegate to tuple encoding.
6679            fidl::encoding::Encode::<
6680                EchoEchoStructResponse,
6681                fidl::encoding::DefaultFuchsiaResourceDialect,
6682            >::encode(
6683                (<Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),),
6684                encoder,
6685                offset,
6686                _depth,
6687            )
6688        }
6689    }
6690    unsafe impl<T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>>
6691        fidl::encoding::Encode<
6692            EchoEchoStructResponse,
6693            fidl::encoding::DefaultFuchsiaResourceDialect,
6694        > for (T0,)
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            // Zero out padding regions. There's no need to apply masks
6708            // because the unmasked parts will be overwritten by fields.
6709            // Write the fields.
6710            self.0.encode(encoder, offset + 0, depth)?;
6711            Ok(())
6712        }
6713    }
6714
6715    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6716        for EchoEchoStructResponse
6717    {
6718        #[inline(always)]
6719        fn new_empty() -> Self {
6720            Self { value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect) }
6721        }
6722
6723        #[inline]
6724        unsafe fn decode(
6725            &mut self,
6726            decoder: &mut fidl::encoding::Decoder<
6727                '_,
6728                fidl::encoding::DefaultFuchsiaResourceDialect,
6729            >,
6730            offset: usize,
6731            _depth: fidl::encoding::Depth,
6732        ) -> fidl::Result<()> {
6733            decoder.debug_check_bounds::<Self>(offset);
6734            // Verify that padding bytes are zero.
6735            fidl::decode!(
6736                Struct,
6737                fidl::encoding::DefaultFuchsiaResourceDialect,
6738                &mut self.value,
6739                decoder,
6740                offset + 0,
6741                _depth
6742            )?;
6743            Ok(())
6744        }
6745    }
6746
6747    impl fidl::encoding::ResourceTypeMarker for EchoEchoStructWithErrorRequest {
6748        type Borrowed<'a> = &'a mut Self;
6749        fn take_or_borrow<'a>(
6750            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6751        ) -> Self::Borrowed<'a> {
6752            value
6753        }
6754    }
6755
6756    unsafe impl fidl::encoding::TypeMarker for EchoEchoStructWithErrorRequest {
6757        type Owned = Self;
6758
6759        #[inline(always)]
6760        fn inline_align(_context: fidl::encoding::Context) -> usize {
6761            8
6762        }
6763
6764        #[inline(always)]
6765        fn inline_size(_context: fidl::encoding::Context) -> usize {
6766            2944
6767        }
6768    }
6769
6770    unsafe impl
6771        fidl::encoding::Encode<
6772            EchoEchoStructWithErrorRequest,
6773            fidl::encoding::DefaultFuchsiaResourceDialect,
6774        > for &mut EchoEchoStructWithErrorRequest
6775    {
6776        #[inline]
6777        unsafe fn encode(
6778            self,
6779            encoder: &mut fidl::encoding::Encoder<
6780                '_,
6781                fidl::encoding::DefaultFuchsiaResourceDialect,
6782            >,
6783            offset: usize,
6784            _depth: fidl::encoding::Depth,
6785        ) -> fidl::Result<()> {
6786            encoder.debug_check_bounds::<EchoEchoStructWithErrorRequest>(offset);
6787            // Delegate to tuple encoding.
6788            fidl::encoding::Encode::<
6789                EchoEchoStructWithErrorRequest,
6790                fidl::encoding::DefaultFuchsiaResourceDialect,
6791            >::encode(
6792                (
6793                    <Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
6794                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
6795                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
6796                        &self.forward_to_server,
6797                    ),
6798                    <RespondWith as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
6799                ),
6800                encoder,
6801                offset,
6802                _depth,
6803            )
6804        }
6805    }
6806    unsafe impl<
6807        T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>,
6808        T1: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
6809        T2: fidl::encoding::Encode<
6810                fidl::encoding::UnboundedString,
6811                fidl::encoding::DefaultFuchsiaResourceDialect,
6812            >,
6813        T3: fidl::encoding::Encode<RespondWith, fidl::encoding::DefaultFuchsiaResourceDialect>,
6814    >
6815        fidl::encoding::Encode<
6816            EchoEchoStructWithErrorRequest,
6817            fidl::encoding::DefaultFuchsiaResourceDialect,
6818        > for (T0, T1, T2, T3)
6819    {
6820        #[inline]
6821        unsafe fn encode(
6822            self,
6823            encoder: &mut fidl::encoding::Encoder<
6824                '_,
6825                fidl::encoding::DefaultFuchsiaResourceDialect,
6826            >,
6827            offset: usize,
6828            depth: fidl::encoding::Depth,
6829        ) -> fidl::Result<()> {
6830            encoder.debug_check_bounds::<EchoEchoStructWithErrorRequest>(offset);
6831            // Zero out padding regions. There's no need to apply masks
6832            // because the unmasked parts will be overwritten by fields.
6833            unsafe {
6834                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2912);
6835                (ptr as *mut u64).write_unaligned(0);
6836            }
6837            unsafe {
6838                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2936);
6839                (ptr as *mut u64).write_unaligned(0);
6840            }
6841            // Write the fields.
6842            self.0.encode(encoder, offset + 0, depth)?;
6843            self.1.encode(encoder, offset + 2912, depth)?;
6844            self.2.encode(encoder, offset + 2920, depth)?;
6845            self.3.encode(encoder, offset + 2936, depth)?;
6846            Ok(())
6847        }
6848    }
6849
6850    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6851        for EchoEchoStructWithErrorRequest
6852    {
6853        #[inline(always)]
6854        fn new_empty() -> Self {
6855            Self {
6856                value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect),
6857                result_err: fidl::new_empty!(
6858                    DefaultEnum,
6859                    fidl::encoding::DefaultFuchsiaResourceDialect
6860                ),
6861                forward_to_server: fidl::new_empty!(
6862                    fidl::encoding::UnboundedString,
6863                    fidl::encoding::DefaultFuchsiaResourceDialect
6864                ),
6865                result_variant: fidl::new_empty!(
6866                    RespondWith,
6867                    fidl::encoding::DefaultFuchsiaResourceDialect
6868                ),
6869            }
6870        }
6871
6872        #[inline]
6873        unsafe fn decode(
6874            &mut self,
6875            decoder: &mut fidl::encoding::Decoder<
6876                '_,
6877                fidl::encoding::DefaultFuchsiaResourceDialect,
6878            >,
6879            offset: usize,
6880            _depth: fidl::encoding::Depth,
6881        ) -> fidl::Result<()> {
6882            decoder.debug_check_bounds::<Self>(offset);
6883            // Verify that padding bytes are zero.
6884            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2912) };
6885            let padval = unsafe { (ptr as *const u64).read_unaligned() };
6886            let mask = 0xffffffff00000000u64;
6887            let maskedval = padval & mask;
6888            if maskedval != 0 {
6889                return Err(fidl::Error::NonZeroPadding {
6890                    padding_start: offset + 2912 + ((mask as u64).trailing_zeros() / 8) as usize,
6891                });
6892            }
6893            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2936) };
6894            let padval = unsafe { (ptr as *const u64).read_unaligned() };
6895            let mask = 0xffffffff00000000u64;
6896            let maskedval = padval & mask;
6897            if maskedval != 0 {
6898                return Err(fidl::Error::NonZeroPadding {
6899                    padding_start: offset + 2936 + ((mask as u64).trailing_zeros() / 8) as usize,
6900                });
6901            }
6902            fidl::decode!(
6903                Struct,
6904                fidl::encoding::DefaultFuchsiaResourceDialect,
6905                &mut self.value,
6906                decoder,
6907                offset + 0,
6908                _depth
6909            )?;
6910            fidl::decode!(
6911                DefaultEnum,
6912                fidl::encoding::DefaultFuchsiaResourceDialect,
6913                &mut self.result_err,
6914                decoder,
6915                offset + 2912,
6916                _depth
6917            )?;
6918            fidl::decode!(
6919                fidl::encoding::UnboundedString,
6920                fidl::encoding::DefaultFuchsiaResourceDialect,
6921                &mut self.forward_to_server,
6922                decoder,
6923                offset + 2920,
6924                _depth
6925            )?;
6926            fidl::decode!(
6927                RespondWith,
6928                fidl::encoding::DefaultFuchsiaResourceDialect,
6929                &mut self.result_variant,
6930                decoder,
6931                offset + 2936,
6932                _depth
6933            )?;
6934            Ok(())
6935        }
6936    }
6937
6938    impl fidl::encoding::ResourceTypeMarker for EchoEchoTableRequest {
6939        type Borrowed<'a> = &'a mut Self;
6940        fn take_or_borrow<'a>(
6941            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6942        ) -> Self::Borrowed<'a> {
6943            value
6944        }
6945    }
6946
6947    unsafe impl fidl::encoding::TypeMarker for EchoEchoTableRequest {
6948        type Owned = Self;
6949
6950        #[inline(always)]
6951        fn inline_align(_context: fidl::encoding::Context) -> usize {
6952            8
6953        }
6954
6955        #[inline(always)]
6956        fn inline_size(_context: fidl::encoding::Context) -> usize {
6957            32
6958        }
6959    }
6960
6961    unsafe impl
6962        fidl::encoding::Encode<EchoEchoTableRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
6963        for &mut EchoEchoTableRequest
6964    {
6965        #[inline]
6966        unsafe fn encode(
6967            self,
6968            encoder: &mut fidl::encoding::Encoder<
6969                '_,
6970                fidl::encoding::DefaultFuchsiaResourceDialect,
6971            >,
6972            offset: usize,
6973            _depth: fidl::encoding::Depth,
6974        ) -> fidl::Result<()> {
6975            encoder.debug_check_bounds::<EchoEchoTableRequest>(offset);
6976            // Delegate to tuple encoding.
6977            fidl::encoding::Encode::<
6978                EchoEchoTableRequest,
6979                fidl::encoding::DefaultFuchsiaResourceDialect,
6980            >::encode(
6981                (
6982                    <AllTypesTable as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
6983                        &mut self.value,
6984                    ),
6985                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
6986                        &self.forward_to_server,
6987                    ),
6988                ),
6989                encoder,
6990                offset,
6991                _depth,
6992            )
6993        }
6994    }
6995    unsafe impl<
6996        T0: fidl::encoding::Encode<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>,
6997        T1: fidl::encoding::Encode<
6998                fidl::encoding::UnboundedString,
6999                fidl::encoding::DefaultFuchsiaResourceDialect,
7000            >,
7001    >
7002        fidl::encoding::Encode<EchoEchoTableRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
7003        for (T0, T1)
7004    {
7005        #[inline]
7006        unsafe fn encode(
7007            self,
7008            encoder: &mut fidl::encoding::Encoder<
7009                '_,
7010                fidl::encoding::DefaultFuchsiaResourceDialect,
7011            >,
7012            offset: usize,
7013            depth: fidl::encoding::Depth,
7014        ) -> fidl::Result<()> {
7015            encoder.debug_check_bounds::<EchoEchoTableRequest>(offset);
7016            // Zero out padding regions. There's no need to apply masks
7017            // because the unmasked parts will be overwritten by fields.
7018            // Write the fields.
7019            self.0.encode(encoder, offset + 0, depth)?;
7020            self.1.encode(encoder, offset + 16, depth)?;
7021            Ok(())
7022        }
7023    }
7024
7025    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7026        for EchoEchoTableRequest
7027    {
7028        #[inline(always)]
7029        fn new_empty() -> Self {
7030            Self {
7031                value: fidl::new_empty!(
7032                    AllTypesTable,
7033                    fidl::encoding::DefaultFuchsiaResourceDialect
7034                ),
7035                forward_to_server: fidl::new_empty!(
7036                    fidl::encoding::UnboundedString,
7037                    fidl::encoding::DefaultFuchsiaResourceDialect
7038                ),
7039            }
7040        }
7041
7042        #[inline]
7043        unsafe fn decode(
7044            &mut self,
7045            decoder: &mut fidl::encoding::Decoder<
7046                '_,
7047                fidl::encoding::DefaultFuchsiaResourceDialect,
7048            >,
7049            offset: usize,
7050            _depth: fidl::encoding::Depth,
7051        ) -> fidl::Result<()> {
7052            decoder.debug_check_bounds::<Self>(offset);
7053            // Verify that padding bytes are zero.
7054            fidl::decode!(
7055                AllTypesTable,
7056                fidl::encoding::DefaultFuchsiaResourceDialect,
7057                &mut self.value,
7058                decoder,
7059                offset + 0,
7060                _depth
7061            )?;
7062            fidl::decode!(
7063                fidl::encoding::UnboundedString,
7064                fidl::encoding::DefaultFuchsiaResourceDialect,
7065                &mut self.forward_to_server,
7066                decoder,
7067                offset + 16,
7068                _depth
7069            )?;
7070            Ok(())
7071        }
7072    }
7073
7074    impl fidl::encoding::ResourceTypeMarker for EchoEchoTableResponse {
7075        type Borrowed<'a> = &'a mut Self;
7076        fn take_or_borrow<'a>(
7077            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7078        ) -> Self::Borrowed<'a> {
7079            value
7080        }
7081    }
7082
7083    unsafe impl fidl::encoding::TypeMarker for EchoEchoTableResponse {
7084        type Owned = Self;
7085
7086        #[inline(always)]
7087        fn inline_align(_context: fidl::encoding::Context) -> usize {
7088            8
7089        }
7090
7091        #[inline(always)]
7092        fn inline_size(_context: fidl::encoding::Context) -> usize {
7093            16
7094        }
7095    }
7096
7097    unsafe impl
7098        fidl::encoding::Encode<EchoEchoTableResponse, fidl::encoding::DefaultFuchsiaResourceDialect>
7099        for &mut EchoEchoTableResponse
7100    {
7101        #[inline]
7102        unsafe fn encode(
7103            self,
7104            encoder: &mut fidl::encoding::Encoder<
7105                '_,
7106                fidl::encoding::DefaultFuchsiaResourceDialect,
7107            >,
7108            offset: usize,
7109            _depth: fidl::encoding::Depth,
7110        ) -> fidl::Result<()> {
7111            encoder.debug_check_bounds::<EchoEchoTableResponse>(offset);
7112            // Delegate to tuple encoding.
7113            fidl::encoding::Encode::<
7114                EchoEchoTableResponse,
7115                fidl::encoding::DefaultFuchsiaResourceDialect,
7116            >::encode(
7117                (<AllTypesTable as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7118                    &mut self.value,
7119                ),),
7120                encoder,
7121                offset,
7122                _depth,
7123            )
7124        }
7125    }
7126    unsafe impl<
7127        T0: fidl::encoding::Encode<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>,
7128    >
7129        fidl::encoding::Encode<EchoEchoTableResponse, fidl::encoding::DefaultFuchsiaResourceDialect>
7130        for (T0,)
7131    {
7132        #[inline]
7133        unsafe fn encode(
7134            self,
7135            encoder: &mut fidl::encoding::Encoder<
7136                '_,
7137                fidl::encoding::DefaultFuchsiaResourceDialect,
7138            >,
7139            offset: usize,
7140            depth: fidl::encoding::Depth,
7141        ) -> fidl::Result<()> {
7142            encoder.debug_check_bounds::<EchoEchoTableResponse>(offset);
7143            // Zero out padding regions. There's no need to apply masks
7144            // because the unmasked parts will be overwritten by fields.
7145            // Write the fields.
7146            self.0.encode(encoder, offset + 0, depth)?;
7147            Ok(())
7148        }
7149    }
7150
7151    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7152        for EchoEchoTableResponse
7153    {
7154        #[inline(always)]
7155        fn new_empty() -> Self {
7156            Self {
7157                value: fidl::new_empty!(
7158                    AllTypesTable,
7159                    fidl::encoding::DefaultFuchsiaResourceDialect
7160                ),
7161            }
7162        }
7163
7164        #[inline]
7165        unsafe fn decode(
7166            &mut self,
7167            decoder: &mut fidl::encoding::Decoder<
7168                '_,
7169                fidl::encoding::DefaultFuchsiaResourceDialect,
7170            >,
7171            offset: usize,
7172            _depth: fidl::encoding::Depth,
7173        ) -> fidl::Result<()> {
7174            decoder.debug_check_bounds::<Self>(offset);
7175            // Verify that padding bytes are zero.
7176            fidl::decode!(
7177                AllTypesTable,
7178                fidl::encoding::DefaultFuchsiaResourceDialect,
7179                &mut self.value,
7180                decoder,
7181                offset + 0,
7182                _depth
7183            )?;
7184            Ok(())
7185        }
7186    }
7187
7188    impl fidl::encoding::ResourceTypeMarker for EchoEchoTableWithErrorRequest {
7189        type Borrowed<'a> = &'a mut Self;
7190        fn take_or_borrow<'a>(
7191            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7192        ) -> Self::Borrowed<'a> {
7193            value
7194        }
7195    }
7196
7197    unsafe impl fidl::encoding::TypeMarker for EchoEchoTableWithErrorRequest {
7198        type Owned = Self;
7199
7200        #[inline(always)]
7201        fn inline_align(_context: fidl::encoding::Context) -> usize {
7202            8
7203        }
7204
7205        #[inline(always)]
7206        fn inline_size(_context: fidl::encoding::Context) -> usize {
7207            48
7208        }
7209    }
7210
7211    unsafe impl
7212        fidl::encoding::Encode<
7213            EchoEchoTableWithErrorRequest,
7214            fidl::encoding::DefaultFuchsiaResourceDialect,
7215        > for &mut EchoEchoTableWithErrorRequest
7216    {
7217        #[inline]
7218        unsafe fn encode(
7219            self,
7220            encoder: &mut fidl::encoding::Encoder<
7221                '_,
7222                fidl::encoding::DefaultFuchsiaResourceDialect,
7223            >,
7224            offset: usize,
7225            _depth: fidl::encoding::Depth,
7226        ) -> fidl::Result<()> {
7227            encoder.debug_check_bounds::<EchoEchoTableWithErrorRequest>(offset);
7228            // Delegate to tuple encoding.
7229            fidl::encoding::Encode::<
7230                EchoEchoTableWithErrorRequest,
7231                fidl::encoding::DefaultFuchsiaResourceDialect,
7232            >::encode(
7233                (
7234                    <AllTypesTable as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7235                        &mut self.value,
7236                    ),
7237                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
7238                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
7239                        &self.forward_to_server,
7240                    ),
7241                    <RespondWith as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
7242                ),
7243                encoder,
7244                offset,
7245                _depth,
7246            )
7247        }
7248    }
7249    unsafe impl<
7250        T0: fidl::encoding::Encode<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>,
7251        T1: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
7252        T2: fidl::encoding::Encode<
7253                fidl::encoding::UnboundedString,
7254                fidl::encoding::DefaultFuchsiaResourceDialect,
7255            >,
7256        T3: fidl::encoding::Encode<RespondWith, fidl::encoding::DefaultFuchsiaResourceDialect>,
7257    >
7258        fidl::encoding::Encode<
7259            EchoEchoTableWithErrorRequest,
7260            fidl::encoding::DefaultFuchsiaResourceDialect,
7261        > for (T0, T1, T2, T3)
7262    {
7263        #[inline]
7264        unsafe fn encode(
7265            self,
7266            encoder: &mut fidl::encoding::Encoder<
7267                '_,
7268                fidl::encoding::DefaultFuchsiaResourceDialect,
7269            >,
7270            offset: usize,
7271            depth: fidl::encoding::Depth,
7272        ) -> fidl::Result<()> {
7273            encoder.debug_check_bounds::<EchoEchoTableWithErrorRequest>(offset);
7274            // Zero out padding regions. There's no need to apply masks
7275            // because the unmasked parts will be overwritten by fields.
7276            unsafe {
7277                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
7278                (ptr as *mut u64).write_unaligned(0);
7279            }
7280            unsafe {
7281                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
7282                (ptr as *mut u64).write_unaligned(0);
7283            }
7284            // Write the fields.
7285            self.0.encode(encoder, offset + 0, depth)?;
7286            self.1.encode(encoder, offset + 16, depth)?;
7287            self.2.encode(encoder, offset + 24, depth)?;
7288            self.3.encode(encoder, offset + 40, depth)?;
7289            Ok(())
7290        }
7291    }
7292
7293    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7294        for EchoEchoTableWithErrorRequest
7295    {
7296        #[inline(always)]
7297        fn new_empty() -> Self {
7298            Self {
7299                value: fidl::new_empty!(
7300                    AllTypesTable,
7301                    fidl::encoding::DefaultFuchsiaResourceDialect
7302                ),
7303                result_err: fidl::new_empty!(
7304                    DefaultEnum,
7305                    fidl::encoding::DefaultFuchsiaResourceDialect
7306                ),
7307                forward_to_server: fidl::new_empty!(
7308                    fidl::encoding::UnboundedString,
7309                    fidl::encoding::DefaultFuchsiaResourceDialect
7310                ),
7311                result_variant: fidl::new_empty!(
7312                    RespondWith,
7313                    fidl::encoding::DefaultFuchsiaResourceDialect
7314                ),
7315            }
7316        }
7317
7318        #[inline]
7319        unsafe fn decode(
7320            &mut self,
7321            decoder: &mut fidl::encoding::Decoder<
7322                '_,
7323                fidl::encoding::DefaultFuchsiaResourceDialect,
7324            >,
7325            offset: usize,
7326            _depth: fidl::encoding::Depth,
7327        ) -> fidl::Result<()> {
7328            decoder.debug_check_bounds::<Self>(offset);
7329            // Verify that padding bytes are zero.
7330            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
7331            let padval = unsafe { (ptr as *const u64).read_unaligned() };
7332            let mask = 0xffffffff00000000u64;
7333            let maskedval = padval & mask;
7334            if maskedval != 0 {
7335                return Err(fidl::Error::NonZeroPadding {
7336                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
7337                });
7338            }
7339            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
7340            let padval = unsafe { (ptr as *const u64).read_unaligned() };
7341            let mask = 0xffffffff00000000u64;
7342            let maskedval = padval & mask;
7343            if maskedval != 0 {
7344                return Err(fidl::Error::NonZeroPadding {
7345                    padding_start: offset + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
7346                });
7347            }
7348            fidl::decode!(
7349                AllTypesTable,
7350                fidl::encoding::DefaultFuchsiaResourceDialect,
7351                &mut self.value,
7352                decoder,
7353                offset + 0,
7354                _depth
7355            )?;
7356            fidl::decode!(
7357                DefaultEnum,
7358                fidl::encoding::DefaultFuchsiaResourceDialect,
7359                &mut self.result_err,
7360                decoder,
7361                offset + 16,
7362                _depth
7363            )?;
7364            fidl::decode!(
7365                fidl::encoding::UnboundedString,
7366                fidl::encoding::DefaultFuchsiaResourceDialect,
7367                &mut self.forward_to_server,
7368                decoder,
7369                offset + 24,
7370                _depth
7371            )?;
7372            fidl::decode!(
7373                RespondWith,
7374                fidl::encoding::DefaultFuchsiaResourceDialect,
7375                &mut self.result_variant,
7376                decoder,
7377                offset + 40,
7378                _depth
7379            )?;
7380            Ok(())
7381        }
7382    }
7383
7384    impl fidl::encoding::ResourceTypeMarker for EchoEchoVectorsRequest {
7385        type Borrowed<'a> = &'a mut Self;
7386        fn take_or_borrow<'a>(
7387            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7388        ) -> Self::Borrowed<'a> {
7389            value
7390        }
7391    }
7392
7393    unsafe impl fidl::encoding::TypeMarker for EchoEchoVectorsRequest {
7394        type Owned = Self;
7395
7396        #[inline(always)]
7397        fn inline_align(_context: fidl::encoding::Context) -> usize {
7398            8
7399        }
7400
7401        #[inline(always)]
7402        fn inline_size(_context: fidl::encoding::Context) -> usize {
7403            432
7404        }
7405    }
7406
7407    unsafe impl
7408        fidl::encoding::Encode<
7409            EchoEchoVectorsRequest,
7410            fidl::encoding::DefaultFuchsiaResourceDialect,
7411        > for &mut EchoEchoVectorsRequest
7412    {
7413        #[inline]
7414        unsafe fn encode(
7415            self,
7416            encoder: &mut fidl::encoding::Encoder<
7417                '_,
7418                fidl::encoding::DefaultFuchsiaResourceDialect,
7419            >,
7420            offset: usize,
7421            _depth: fidl::encoding::Depth,
7422        ) -> fidl::Result<()> {
7423            encoder.debug_check_bounds::<EchoEchoVectorsRequest>(offset);
7424            // Delegate to tuple encoding.
7425            fidl::encoding::Encode::<
7426                EchoEchoVectorsRequest,
7427                fidl::encoding::DefaultFuchsiaResourceDialect,
7428            >::encode(
7429                (
7430                    <VectorsStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7431                        &mut self.value,
7432                    ),
7433                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
7434                        &self.forward_to_server,
7435                    ),
7436                ),
7437                encoder,
7438                offset,
7439                _depth,
7440            )
7441        }
7442    }
7443    unsafe impl<
7444        T0: fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
7445        T1: fidl::encoding::Encode<
7446                fidl::encoding::UnboundedString,
7447                fidl::encoding::DefaultFuchsiaResourceDialect,
7448            >,
7449    >
7450        fidl::encoding::Encode<
7451            EchoEchoVectorsRequest,
7452            fidl::encoding::DefaultFuchsiaResourceDialect,
7453        > for (T0, T1)
7454    {
7455        #[inline]
7456        unsafe fn encode(
7457            self,
7458            encoder: &mut fidl::encoding::Encoder<
7459                '_,
7460                fidl::encoding::DefaultFuchsiaResourceDialect,
7461            >,
7462            offset: usize,
7463            depth: fidl::encoding::Depth,
7464        ) -> fidl::Result<()> {
7465            encoder.debug_check_bounds::<EchoEchoVectorsRequest>(offset);
7466            // Zero out padding regions. There's no need to apply masks
7467            // because the unmasked parts will be overwritten by fields.
7468            // Write the fields.
7469            self.0.encode(encoder, offset + 0, depth)?;
7470            self.1.encode(encoder, offset + 416, depth)?;
7471            Ok(())
7472        }
7473    }
7474
7475    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7476        for EchoEchoVectorsRequest
7477    {
7478        #[inline(always)]
7479        fn new_empty() -> Self {
7480            Self {
7481                value: fidl::new_empty!(
7482                    VectorsStruct,
7483                    fidl::encoding::DefaultFuchsiaResourceDialect
7484                ),
7485                forward_to_server: fidl::new_empty!(
7486                    fidl::encoding::UnboundedString,
7487                    fidl::encoding::DefaultFuchsiaResourceDialect
7488                ),
7489            }
7490        }
7491
7492        #[inline]
7493        unsafe fn decode(
7494            &mut self,
7495            decoder: &mut fidl::encoding::Decoder<
7496                '_,
7497                fidl::encoding::DefaultFuchsiaResourceDialect,
7498            >,
7499            offset: usize,
7500            _depth: fidl::encoding::Depth,
7501        ) -> fidl::Result<()> {
7502            decoder.debug_check_bounds::<Self>(offset);
7503            // Verify that padding bytes are zero.
7504            fidl::decode!(
7505                VectorsStruct,
7506                fidl::encoding::DefaultFuchsiaResourceDialect,
7507                &mut self.value,
7508                decoder,
7509                offset + 0,
7510                _depth
7511            )?;
7512            fidl::decode!(
7513                fidl::encoding::UnboundedString,
7514                fidl::encoding::DefaultFuchsiaResourceDialect,
7515                &mut self.forward_to_server,
7516                decoder,
7517                offset + 416,
7518                _depth
7519            )?;
7520            Ok(())
7521        }
7522    }
7523
7524    impl fidl::encoding::ResourceTypeMarker for EchoEchoVectorsResponse {
7525        type Borrowed<'a> = &'a mut Self;
7526        fn take_or_borrow<'a>(
7527            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7528        ) -> Self::Borrowed<'a> {
7529            value
7530        }
7531    }
7532
7533    unsafe impl fidl::encoding::TypeMarker for EchoEchoVectorsResponse {
7534        type Owned = Self;
7535
7536        #[inline(always)]
7537        fn inline_align(_context: fidl::encoding::Context) -> usize {
7538            8
7539        }
7540
7541        #[inline(always)]
7542        fn inline_size(_context: fidl::encoding::Context) -> usize {
7543            416
7544        }
7545    }
7546
7547    unsafe impl
7548        fidl::encoding::Encode<
7549            EchoEchoVectorsResponse,
7550            fidl::encoding::DefaultFuchsiaResourceDialect,
7551        > for &mut EchoEchoVectorsResponse
7552    {
7553        #[inline]
7554        unsafe fn encode(
7555            self,
7556            encoder: &mut fidl::encoding::Encoder<
7557                '_,
7558                fidl::encoding::DefaultFuchsiaResourceDialect,
7559            >,
7560            offset: usize,
7561            _depth: fidl::encoding::Depth,
7562        ) -> fidl::Result<()> {
7563            encoder.debug_check_bounds::<EchoEchoVectorsResponse>(offset);
7564            // Delegate to tuple encoding.
7565            fidl::encoding::Encode::<
7566                EchoEchoVectorsResponse,
7567                fidl::encoding::DefaultFuchsiaResourceDialect,
7568            >::encode(
7569                (<VectorsStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7570                    &mut self.value,
7571                ),),
7572                encoder,
7573                offset,
7574                _depth,
7575            )
7576        }
7577    }
7578    unsafe impl<
7579        T0: fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
7580    >
7581        fidl::encoding::Encode<
7582            EchoEchoVectorsResponse,
7583            fidl::encoding::DefaultFuchsiaResourceDialect,
7584        > for (T0,)
7585    {
7586        #[inline]
7587        unsafe fn encode(
7588            self,
7589            encoder: &mut fidl::encoding::Encoder<
7590                '_,
7591                fidl::encoding::DefaultFuchsiaResourceDialect,
7592            >,
7593            offset: usize,
7594            depth: fidl::encoding::Depth,
7595        ) -> fidl::Result<()> {
7596            encoder.debug_check_bounds::<EchoEchoVectorsResponse>(offset);
7597            // Zero out padding regions. There's no need to apply masks
7598            // because the unmasked parts will be overwritten by fields.
7599            // Write the fields.
7600            self.0.encode(encoder, offset + 0, depth)?;
7601            Ok(())
7602        }
7603    }
7604
7605    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7606        for EchoEchoVectorsResponse
7607    {
7608        #[inline(always)]
7609        fn new_empty() -> Self {
7610            Self {
7611                value: fidl::new_empty!(
7612                    VectorsStruct,
7613                    fidl::encoding::DefaultFuchsiaResourceDialect
7614                ),
7615            }
7616        }
7617
7618        #[inline]
7619        unsafe fn decode(
7620            &mut self,
7621            decoder: &mut fidl::encoding::Decoder<
7622                '_,
7623                fidl::encoding::DefaultFuchsiaResourceDialect,
7624            >,
7625            offset: usize,
7626            _depth: fidl::encoding::Depth,
7627        ) -> fidl::Result<()> {
7628            decoder.debug_check_bounds::<Self>(offset);
7629            // Verify that padding bytes are zero.
7630            fidl::decode!(
7631                VectorsStruct,
7632                fidl::encoding::DefaultFuchsiaResourceDialect,
7633                &mut self.value,
7634                decoder,
7635                offset + 0,
7636                _depth
7637            )?;
7638            Ok(())
7639        }
7640    }
7641
7642    impl fidl::encoding::ResourceTypeMarker for EchoEchoVectorsWithErrorRequest {
7643        type Borrowed<'a> = &'a mut Self;
7644        fn take_or_borrow<'a>(
7645            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7646        ) -> Self::Borrowed<'a> {
7647            value
7648        }
7649    }
7650
7651    unsafe impl fidl::encoding::TypeMarker for EchoEchoVectorsWithErrorRequest {
7652        type Owned = Self;
7653
7654        #[inline(always)]
7655        fn inline_align(_context: fidl::encoding::Context) -> usize {
7656            8
7657        }
7658
7659        #[inline(always)]
7660        fn inline_size(_context: fidl::encoding::Context) -> usize {
7661            448
7662        }
7663    }
7664
7665    unsafe impl
7666        fidl::encoding::Encode<
7667            EchoEchoVectorsWithErrorRequest,
7668            fidl::encoding::DefaultFuchsiaResourceDialect,
7669        > for &mut EchoEchoVectorsWithErrorRequest
7670    {
7671        #[inline]
7672        unsafe fn encode(
7673            self,
7674            encoder: &mut fidl::encoding::Encoder<
7675                '_,
7676                fidl::encoding::DefaultFuchsiaResourceDialect,
7677            >,
7678            offset: usize,
7679            _depth: fidl::encoding::Depth,
7680        ) -> fidl::Result<()> {
7681            encoder.debug_check_bounds::<EchoEchoVectorsWithErrorRequest>(offset);
7682            // Delegate to tuple encoding.
7683            fidl::encoding::Encode::<
7684                EchoEchoVectorsWithErrorRequest,
7685                fidl::encoding::DefaultFuchsiaResourceDialect,
7686            >::encode(
7687                (
7688                    <VectorsStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7689                        &mut self.value,
7690                    ),
7691                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
7692                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
7693                        &self.forward_to_server,
7694                    ),
7695                    <RespondWith as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
7696                ),
7697                encoder,
7698                offset,
7699                _depth,
7700            )
7701        }
7702    }
7703    unsafe impl<
7704        T0: fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
7705        T1: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
7706        T2: fidl::encoding::Encode<
7707                fidl::encoding::UnboundedString,
7708                fidl::encoding::DefaultFuchsiaResourceDialect,
7709            >,
7710        T3: fidl::encoding::Encode<RespondWith, fidl::encoding::DefaultFuchsiaResourceDialect>,
7711    >
7712        fidl::encoding::Encode<
7713            EchoEchoVectorsWithErrorRequest,
7714            fidl::encoding::DefaultFuchsiaResourceDialect,
7715        > for (T0, T1, T2, T3)
7716    {
7717        #[inline]
7718        unsafe fn encode(
7719            self,
7720            encoder: &mut fidl::encoding::Encoder<
7721                '_,
7722                fidl::encoding::DefaultFuchsiaResourceDialect,
7723            >,
7724            offset: usize,
7725            depth: fidl::encoding::Depth,
7726        ) -> fidl::Result<()> {
7727            encoder.debug_check_bounds::<EchoEchoVectorsWithErrorRequest>(offset);
7728            // Zero out padding regions. There's no need to apply masks
7729            // because the unmasked parts will be overwritten by fields.
7730            unsafe {
7731                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(416);
7732                (ptr as *mut u64).write_unaligned(0);
7733            }
7734            unsafe {
7735                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(440);
7736                (ptr as *mut u64).write_unaligned(0);
7737            }
7738            // Write the fields.
7739            self.0.encode(encoder, offset + 0, depth)?;
7740            self.1.encode(encoder, offset + 416, depth)?;
7741            self.2.encode(encoder, offset + 424, depth)?;
7742            self.3.encode(encoder, offset + 440, depth)?;
7743            Ok(())
7744        }
7745    }
7746
7747    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7748        for EchoEchoVectorsWithErrorRequest
7749    {
7750        #[inline(always)]
7751        fn new_empty() -> Self {
7752            Self {
7753                value: fidl::new_empty!(
7754                    VectorsStruct,
7755                    fidl::encoding::DefaultFuchsiaResourceDialect
7756                ),
7757                result_err: fidl::new_empty!(
7758                    DefaultEnum,
7759                    fidl::encoding::DefaultFuchsiaResourceDialect
7760                ),
7761                forward_to_server: fidl::new_empty!(
7762                    fidl::encoding::UnboundedString,
7763                    fidl::encoding::DefaultFuchsiaResourceDialect
7764                ),
7765                result_variant: fidl::new_empty!(
7766                    RespondWith,
7767                    fidl::encoding::DefaultFuchsiaResourceDialect
7768                ),
7769            }
7770        }
7771
7772        #[inline]
7773        unsafe fn decode(
7774            &mut self,
7775            decoder: &mut fidl::encoding::Decoder<
7776                '_,
7777                fidl::encoding::DefaultFuchsiaResourceDialect,
7778            >,
7779            offset: usize,
7780            _depth: fidl::encoding::Depth,
7781        ) -> fidl::Result<()> {
7782            decoder.debug_check_bounds::<Self>(offset);
7783            // Verify that padding bytes are zero.
7784            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(416) };
7785            let padval = unsafe { (ptr as *const u64).read_unaligned() };
7786            let mask = 0xffffffff00000000u64;
7787            let maskedval = padval & mask;
7788            if maskedval != 0 {
7789                return Err(fidl::Error::NonZeroPadding {
7790                    padding_start: offset + 416 + ((mask as u64).trailing_zeros() / 8) as usize,
7791                });
7792            }
7793            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(440) };
7794            let padval = unsafe { (ptr as *const u64).read_unaligned() };
7795            let mask = 0xffffffff00000000u64;
7796            let maskedval = padval & mask;
7797            if maskedval != 0 {
7798                return Err(fidl::Error::NonZeroPadding {
7799                    padding_start: offset + 440 + ((mask as u64).trailing_zeros() / 8) as usize,
7800                });
7801            }
7802            fidl::decode!(
7803                VectorsStruct,
7804                fidl::encoding::DefaultFuchsiaResourceDialect,
7805                &mut self.value,
7806                decoder,
7807                offset + 0,
7808                _depth
7809            )?;
7810            fidl::decode!(
7811                DefaultEnum,
7812                fidl::encoding::DefaultFuchsiaResourceDialect,
7813                &mut self.result_err,
7814                decoder,
7815                offset + 416,
7816                _depth
7817            )?;
7818            fidl::decode!(
7819                fidl::encoding::UnboundedString,
7820                fidl::encoding::DefaultFuchsiaResourceDialect,
7821                &mut self.forward_to_server,
7822                decoder,
7823                offset + 424,
7824                _depth
7825            )?;
7826            fidl::decode!(
7827                RespondWith,
7828                fidl::encoding::DefaultFuchsiaResourceDialect,
7829                &mut self.result_variant,
7830                decoder,
7831                offset + 440,
7832                _depth
7833            )?;
7834            Ok(())
7835        }
7836    }
7837
7838    impl fidl::encoding::ResourceTypeMarker for EchoEchoXunionsRequest {
7839        type Borrowed<'a> = &'a mut Self;
7840        fn take_or_borrow<'a>(
7841            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7842        ) -> Self::Borrowed<'a> {
7843            value
7844        }
7845    }
7846
7847    unsafe impl fidl::encoding::TypeMarker for EchoEchoXunionsRequest {
7848        type Owned = Self;
7849
7850        #[inline(always)]
7851        fn inline_align(_context: fidl::encoding::Context) -> usize {
7852            8
7853        }
7854
7855        #[inline(always)]
7856        fn inline_size(_context: fidl::encoding::Context) -> usize {
7857            32
7858        }
7859    }
7860
7861    unsafe impl
7862        fidl::encoding::Encode<
7863            EchoEchoXunionsRequest,
7864            fidl::encoding::DefaultFuchsiaResourceDialect,
7865        > for &mut EchoEchoXunionsRequest
7866    {
7867        #[inline]
7868        unsafe fn encode(
7869            self,
7870            encoder: &mut fidl::encoding::Encoder<
7871                '_,
7872                fidl::encoding::DefaultFuchsiaResourceDialect,
7873            >,
7874            offset: usize,
7875            _depth: fidl::encoding::Depth,
7876        ) -> fidl::Result<()> {
7877            encoder.debug_check_bounds::<EchoEchoXunionsRequest>(offset);
7878            // Delegate to tuple encoding.
7879            fidl::encoding::Encode::<EchoEchoXunionsRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
7880                (
7881                    <fidl::encoding::UnboundedVector<AllTypesXunion> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
7882                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(&self.forward_to_server),
7883                ),
7884                encoder, offset, _depth
7885            )
7886        }
7887    }
7888    unsafe impl<
7889        T0: fidl::encoding::Encode<
7890                fidl::encoding::UnboundedVector<AllTypesXunion>,
7891                fidl::encoding::DefaultFuchsiaResourceDialect,
7892            >,
7893        T1: fidl::encoding::Encode<
7894                fidl::encoding::UnboundedString,
7895                fidl::encoding::DefaultFuchsiaResourceDialect,
7896            >,
7897    >
7898        fidl::encoding::Encode<
7899            EchoEchoXunionsRequest,
7900            fidl::encoding::DefaultFuchsiaResourceDialect,
7901        > for (T0, T1)
7902    {
7903        #[inline]
7904        unsafe fn encode(
7905            self,
7906            encoder: &mut fidl::encoding::Encoder<
7907                '_,
7908                fidl::encoding::DefaultFuchsiaResourceDialect,
7909            >,
7910            offset: usize,
7911            depth: fidl::encoding::Depth,
7912        ) -> fidl::Result<()> {
7913            encoder.debug_check_bounds::<EchoEchoXunionsRequest>(offset);
7914            // Zero out padding regions. There's no need to apply masks
7915            // because the unmasked parts will be overwritten by fields.
7916            // Write the fields.
7917            self.0.encode(encoder, offset + 0, depth)?;
7918            self.1.encode(encoder, offset + 16, depth)?;
7919            Ok(())
7920        }
7921    }
7922
7923    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7924        for EchoEchoXunionsRequest
7925    {
7926        #[inline(always)]
7927        fn new_empty() -> Self {
7928            Self {
7929                value: fidl::new_empty!(
7930                    fidl::encoding::UnboundedVector<AllTypesXunion>,
7931                    fidl::encoding::DefaultFuchsiaResourceDialect
7932                ),
7933                forward_to_server: fidl::new_empty!(
7934                    fidl::encoding::UnboundedString,
7935                    fidl::encoding::DefaultFuchsiaResourceDialect
7936                ),
7937            }
7938        }
7939
7940        #[inline]
7941        unsafe fn decode(
7942            &mut self,
7943            decoder: &mut fidl::encoding::Decoder<
7944                '_,
7945                fidl::encoding::DefaultFuchsiaResourceDialect,
7946            >,
7947            offset: usize,
7948            _depth: fidl::encoding::Depth,
7949        ) -> fidl::Result<()> {
7950            decoder.debug_check_bounds::<Self>(offset);
7951            // Verify that padding bytes are zero.
7952            fidl::decode!(
7953                fidl::encoding::UnboundedVector<AllTypesXunion>,
7954                fidl::encoding::DefaultFuchsiaResourceDialect,
7955                &mut self.value,
7956                decoder,
7957                offset + 0,
7958                _depth
7959            )?;
7960            fidl::decode!(
7961                fidl::encoding::UnboundedString,
7962                fidl::encoding::DefaultFuchsiaResourceDialect,
7963                &mut self.forward_to_server,
7964                decoder,
7965                offset + 16,
7966                _depth
7967            )?;
7968            Ok(())
7969        }
7970    }
7971
7972    impl fidl::encoding::ResourceTypeMarker for EchoEchoXunionsResponse {
7973        type Borrowed<'a> = &'a mut Self;
7974        fn take_or_borrow<'a>(
7975            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7976        ) -> Self::Borrowed<'a> {
7977            value
7978        }
7979    }
7980
7981    unsafe impl fidl::encoding::TypeMarker for EchoEchoXunionsResponse {
7982        type Owned = Self;
7983
7984        #[inline(always)]
7985        fn inline_align(_context: fidl::encoding::Context) -> usize {
7986            8
7987        }
7988
7989        #[inline(always)]
7990        fn inline_size(_context: fidl::encoding::Context) -> usize {
7991            16
7992        }
7993    }
7994
7995    unsafe impl
7996        fidl::encoding::Encode<
7997            EchoEchoXunionsResponse,
7998            fidl::encoding::DefaultFuchsiaResourceDialect,
7999        > for &mut EchoEchoXunionsResponse
8000    {
8001        #[inline]
8002        unsafe fn encode(
8003            self,
8004            encoder: &mut fidl::encoding::Encoder<
8005                '_,
8006                fidl::encoding::DefaultFuchsiaResourceDialect,
8007            >,
8008            offset: usize,
8009            _depth: fidl::encoding::Depth,
8010        ) -> fidl::Result<()> {
8011            encoder.debug_check_bounds::<EchoEchoXunionsResponse>(offset);
8012            // Delegate to tuple encoding.
8013            fidl::encoding::Encode::<EchoEchoXunionsResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
8014                (
8015                    <fidl::encoding::UnboundedVector<AllTypesXunion> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
8016                ),
8017                encoder, offset, _depth
8018            )
8019        }
8020    }
8021    unsafe impl<
8022        T0: fidl::encoding::Encode<
8023                fidl::encoding::UnboundedVector<AllTypesXunion>,
8024                fidl::encoding::DefaultFuchsiaResourceDialect,
8025            >,
8026    >
8027        fidl::encoding::Encode<
8028            EchoEchoXunionsResponse,
8029            fidl::encoding::DefaultFuchsiaResourceDialect,
8030        > for (T0,)
8031    {
8032        #[inline]
8033        unsafe fn encode(
8034            self,
8035            encoder: &mut fidl::encoding::Encoder<
8036                '_,
8037                fidl::encoding::DefaultFuchsiaResourceDialect,
8038            >,
8039            offset: usize,
8040            depth: fidl::encoding::Depth,
8041        ) -> fidl::Result<()> {
8042            encoder.debug_check_bounds::<EchoEchoXunionsResponse>(offset);
8043            // Zero out padding regions. There's no need to apply masks
8044            // because the unmasked parts will be overwritten by fields.
8045            // Write the fields.
8046            self.0.encode(encoder, offset + 0, depth)?;
8047            Ok(())
8048        }
8049    }
8050
8051    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8052        for EchoEchoXunionsResponse
8053    {
8054        #[inline(always)]
8055        fn new_empty() -> Self {
8056            Self {
8057                value: fidl::new_empty!(
8058                    fidl::encoding::UnboundedVector<AllTypesXunion>,
8059                    fidl::encoding::DefaultFuchsiaResourceDialect
8060                ),
8061            }
8062        }
8063
8064        #[inline]
8065        unsafe fn decode(
8066            &mut self,
8067            decoder: &mut fidl::encoding::Decoder<
8068                '_,
8069                fidl::encoding::DefaultFuchsiaResourceDialect,
8070            >,
8071            offset: usize,
8072            _depth: fidl::encoding::Depth,
8073        ) -> fidl::Result<()> {
8074            decoder.debug_check_bounds::<Self>(offset);
8075            // Verify that padding bytes are zero.
8076            fidl::decode!(
8077                fidl::encoding::UnboundedVector<AllTypesXunion>,
8078                fidl::encoding::DefaultFuchsiaResourceDialect,
8079                &mut self.value,
8080                decoder,
8081                offset + 0,
8082                _depth
8083            )?;
8084            Ok(())
8085        }
8086    }
8087
8088    impl fidl::encoding::ResourceTypeMarker for EchoEchoXunionsWithErrorRequest {
8089        type Borrowed<'a> = &'a mut Self;
8090        fn take_or_borrow<'a>(
8091            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8092        ) -> Self::Borrowed<'a> {
8093            value
8094        }
8095    }
8096
8097    unsafe impl fidl::encoding::TypeMarker for EchoEchoXunionsWithErrorRequest {
8098        type Owned = Self;
8099
8100        #[inline(always)]
8101        fn inline_align(_context: fidl::encoding::Context) -> usize {
8102            8
8103        }
8104
8105        #[inline(always)]
8106        fn inline_size(_context: fidl::encoding::Context) -> usize {
8107            48
8108        }
8109    }
8110
8111    unsafe impl
8112        fidl::encoding::Encode<
8113            EchoEchoXunionsWithErrorRequest,
8114            fidl::encoding::DefaultFuchsiaResourceDialect,
8115        > for &mut EchoEchoXunionsWithErrorRequest
8116    {
8117        #[inline]
8118        unsafe fn encode(
8119            self,
8120            encoder: &mut fidl::encoding::Encoder<
8121                '_,
8122                fidl::encoding::DefaultFuchsiaResourceDialect,
8123            >,
8124            offset: usize,
8125            _depth: fidl::encoding::Depth,
8126        ) -> fidl::Result<()> {
8127            encoder.debug_check_bounds::<EchoEchoXunionsWithErrorRequest>(offset);
8128            // Delegate to tuple encoding.
8129            fidl::encoding::Encode::<EchoEchoXunionsWithErrorRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
8130                (
8131                    <fidl::encoding::UnboundedVector<AllTypesXunion> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
8132                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
8133                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(&self.forward_to_server),
8134                    <RespondWith as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
8135                ),
8136                encoder, offset, _depth
8137            )
8138        }
8139    }
8140    unsafe impl<
8141        T0: fidl::encoding::Encode<
8142                fidl::encoding::UnboundedVector<AllTypesXunion>,
8143                fidl::encoding::DefaultFuchsiaResourceDialect,
8144            >,
8145        T1: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8146        T2: fidl::encoding::Encode<
8147                fidl::encoding::UnboundedString,
8148                fidl::encoding::DefaultFuchsiaResourceDialect,
8149            >,
8150        T3: fidl::encoding::Encode<RespondWith, fidl::encoding::DefaultFuchsiaResourceDialect>,
8151    >
8152        fidl::encoding::Encode<
8153            EchoEchoXunionsWithErrorRequest,
8154            fidl::encoding::DefaultFuchsiaResourceDialect,
8155        > for (T0, T1, T2, T3)
8156    {
8157        #[inline]
8158        unsafe fn encode(
8159            self,
8160            encoder: &mut fidl::encoding::Encoder<
8161                '_,
8162                fidl::encoding::DefaultFuchsiaResourceDialect,
8163            >,
8164            offset: usize,
8165            depth: fidl::encoding::Depth,
8166        ) -> fidl::Result<()> {
8167            encoder.debug_check_bounds::<EchoEchoXunionsWithErrorRequest>(offset);
8168            // Zero out padding regions. There's no need to apply masks
8169            // because the unmasked parts will be overwritten by fields.
8170            unsafe {
8171                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
8172                (ptr as *mut u64).write_unaligned(0);
8173            }
8174            unsafe {
8175                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
8176                (ptr as *mut u64).write_unaligned(0);
8177            }
8178            // Write the fields.
8179            self.0.encode(encoder, offset + 0, depth)?;
8180            self.1.encode(encoder, offset + 16, depth)?;
8181            self.2.encode(encoder, offset + 24, depth)?;
8182            self.3.encode(encoder, offset + 40, depth)?;
8183            Ok(())
8184        }
8185    }
8186
8187    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8188        for EchoEchoXunionsWithErrorRequest
8189    {
8190        #[inline(always)]
8191        fn new_empty() -> Self {
8192            Self {
8193                value: fidl::new_empty!(
8194                    fidl::encoding::UnboundedVector<AllTypesXunion>,
8195                    fidl::encoding::DefaultFuchsiaResourceDialect
8196                ),
8197                result_err: fidl::new_empty!(
8198                    DefaultEnum,
8199                    fidl::encoding::DefaultFuchsiaResourceDialect
8200                ),
8201                forward_to_server: fidl::new_empty!(
8202                    fidl::encoding::UnboundedString,
8203                    fidl::encoding::DefaultFuchsiaResourceDialect
8204                ),
8205                result_variant: fidl::new_empty!(
8206                    RespondWith,
8207                    fidl::encoding::DefaultFuchsiaResourceDialect
8208                ),
8209            }
8210        }
8211
8212        #[inline]
8213        unsafe fn decode(
8214            &mut self,
8215            decoder: &mut fidl::encoding::Decoder<
8216                '_,
8217                fidl::encoding::DefaultFuchsiaResourceDialect,
8218            >,
8219            offset: usize,
8220            _depth: fidl::encoding::Depth,
8221        ) -> fidl::Result<()> {
8222            decoder.debug_check_bounds::<Self>(offset);
8223            // Verify that padding bytes are zero.
8224            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
8225            let padval = unsafe { (ptr as *const u64).read_unaligned() };
8226            let mask = 0xffffffff00000000u64;
8227            let maskedval = padval & mask;
8228            if maskedval != 0 {
8229                return Err(fidl::Error::NonZeroPadding {
8230                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
8231                });
8232            }
8233            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
8234            let padval = unsafe { (ptr as *const u64).read_unaligned() };
8235            let mask = 0xffffffff00000000u64;
8236            let maskedval = padval & mask;
8237            if maskedval != 0 {
8238                return Err(fidl::Error::NonZeroPadding {
8239                    padding_start: offset + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
8240                });
8241            }
8242            fidl::decode!(
8243                fidl::encoding::UnboundedVector<AllTypesXunion>,
8244                fidl::encoding::DefaultFuchsiaResourceDialect,
8245                &mut self.value,
8246                decoder,
8247                offset + 0,
8248                _depth
8249            )?;
8250            fidl::decode!(
8251                DefaultEnum,
8252                fidl::encoding::DefaultFuchsiaResourceDialect,
8253                &mut self.result_err,
8254                decoder,
8255                offset + 16,
8256                _depth
8257            )?;
8258            fidl::decode!(
8259                fidl::encoding::UnboundedString,
8260                fidl::encoding::DefaultFuchsiaResourceDialect,
8261                &mut self.forward_to_server,
8262                decoder,
8263                offset + 24,
8264                _depth
8265            )?;
8266            fidl::decode!(
8267                RespondWith,
8268                fidl::encoding::DefaultFuchsiaResourceDialect,
8269                &mut self.result_variant,
8270                decoder,
8271                offset + 40,
8272                _depth
8273            )?;
8274            Ok(())
8275        }
8276    }
8277
8278    impl fidl::encoding::ResourceTypeMarker for EchoEchoArraysWithErrorResponse {
8279        type Borrowed<'a> = &'a mut Self;
8280        fn take_or_borrow<'a>(
8281            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8282        ) -> Self::Borrowed<'a> {
8283            value
8284        }
8285    }
8286
8287    unsafe impl fidl::encoding::TypeMarker for EchoEchoArraysWithErrorResponse {
8288        type Owned = Self;
8289
8290        #[inline(always)]
8291        fn inline_align(_context: fidl::encoding::Context) -> usize {
8292            8
8293        }
8294
8295        #[inline(always)]
8296        fn inline_size(_context: fidl::encoding::Context) -> usize {
8297            680
8298        }
8299    }
8300
8301    unsafe impl
8302        fidl::encoding::Encode<
8303            EchoEchoArraysWithErrorResponse,
8304            fidl::encoding::DefaultFuchsiaResourceDialect,
8305        > for &mut EchoEchoArraysWithErrorResponse
8306    {
8307        #[inline]
8308        unsafe fn encode(
8309            self,
8310            encoder: &mut fidl::encoding::Encoder<
8311                '_,
8312                fidl::encoding::DefaultFuchsiaResourceDialect,
8313            >,
8314            offset: usize,
8315            _depth: fidl::encoding::Depth,
8316        ) -> fidl::Result<()> {
8317            encoder.debug_check_bounds::<EchoEchoArraysWithErrorResponse>(offset);
8318            // Delegate to tuple encoding.
8319            fidl::encoding::Encode::<
8320                EchoEchoArraysWithErrorResponse,
8321                fidl::encoding::DefaultFuchsiaResourceDialect,
8322            >::encode(
8323                (<ArraysStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8324                    &mut self.value,
8325                ),),
8326                encoder,
8327                offset,
8328                _depth,
8329            )
8330        }
8331    }
8332    unsafe impl<
8333        T0: fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
8334    >
8335        fidl::encoding::Encode<
8336            EchoEchoArraysWithErrorResponse,
8337            fidl::encoding::DefaultFuchsiaResourceDialect,
8338        > for (T0,)
8339    {
8340        #[inline]
8341        unsafe fn encode(
8342            self,
8343            encoder: &mut fidl::encoding::Encoder<
8344                '_,
8345                fidl::encoding::DefaultFuchsiaResourceDialect,
8346            >,
8347            offset: usize,
8348            depth: fidl::encoding::Depth,
8349        ) -> fidl::Result<()> {
8350            encoder.debug_check_bounds::<EchoEchoArraysWithErrorResponse>(offset);
8351            // Zero out padding regions. There's no need to apply masks
8352            // because the unmasked parts will be overwritten by fields.
8353            // Write the fields.
8354            self.0.encode(encoder, offset + 0, depth)?;
8355            Ok(())
8356        }
8357    }
8358
8359    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8360        for EchoEchoArraysWithErrorResponse
8361    {
8362        #[inline(always)]
8363        fn new_empty() -> Self {
8364            Self {
8365                value: fidl::new_empty!(
8366                    ArraysStruct,
8367                    fidl::encoding::DefaultFuchsiaResourceDialect
8368                ),
8369            }
8370        }
8371
8372        #[inline]
8373        unsafe fn decode(
8374            &mut self,
8375            decoder: &mut fidl::encoding::Decoder<
8376                '_,
8377                fidl::encoding::DefaultFuchsiaResourceDialect,
8378            >,
8379            offset: usize,
8380            _depth: fidl::encoding::Depth,
8381        ) -> fidl::Result<()> {
8382            decoder.debug_check_bounds::<Self>(offset);
8383            // Verify that padding bytes are zero.
8384            fidl::decode!(
8385                ArraysStruct,
8386                fidl::encoding::DefaultFuchsiaResourceDialect,
8387                &mut self.value,
8388                decoder,
8389                offset + 0,
8390                _depth
8391            )?;
8392            Ok(())
8393        }
8394    }
8395
8396    impl fidl::encoding::ResourceTypeMarker for EchoEchoStructWithErrorResponse {
8397        type Borrowed<'a> = &'a mut Self;
8398        fn take_or_borrow<'a>(
8399            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8400        ) -> Self::Borrowed<'a> {
8401            value
8402        }
8403    }
8404
8405    unsafe impl fidl::encoding::TypeMarker for EchoEchoStructWithErrorResponse {
8406        type Owned = Self;
8407
8408        #[inline(always)]
8409        fn inline_align(_context: fidl::encoding::Context) -> usize {
8410            8
8411        }
8412
8413        #[inline(always)]
8414        fn inline_size(_context: fidl::encoding::Context) -> usize {
8415            2912
8416        }
8417    }
8418
8419    unsafe impl
8420        fidl::encoding::Encode<
8421            EchoEchoStructWithErrorResponse,
8422            fidl::encoding::DefaultFuchsiaResourceDialect,
8423        > for &mut EchoEchoStructWithErrorResponse
8424    {
8425        #[inline]
8426        unsafe fn encode(
8427            self,
8428            encoder: &mut fidl::encoding::Encoder<
8429                '_,
8430                fidl::encoding::DefaultFuchsiaResourceDialect,
8431            >,
8432            offset: usize,
8433            _depth: fidl::encoding::Depth,
8434        ) -> fidl::Result<()> {
8435            encoder.debug_check_bounds::<EchoEchoStructWithErrorResponse>(offset);
8436            // Delegate to tuple encoding.
8437            fidl::encoding::Encode::<
8438                EchoEchoStructWithErrorResponse,
8439                fidl::encoding::DefaultFuchsiaResourceDialect,
8440            >::encode(
8441                (<Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),),
8442                encoder,
8443                offset,
8444                _depth,
8445            )
8446        }
8447    }
8448    unsafe impl<T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>>
8449        fidl::encoding::Encode<
8450            EchoEchoStructWithErrorResponse,
8451            fidl::encoding::DefaultFuchsiaResourceDialect,
8452        > for (T0,)
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            // Zero out padding regions. There's no need to apply masks
8466            // because the unmasked parts will be overwritten by fields.
8467            // Write the fields.
8468            self.0.encode(encoder, offset + 0, depth)?;
8469            Ok(())
8470        }
8471    }
8472
8473    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8474        for EchoEchoStructWithErrorResponse
8475    {
8476        #[inline(always)]
8477        fn new_empty() -> Self {
8478            Self { value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect) }
8479        }
8480
8481        #[inline]
8482        unsafe fn decode(
8483            &mut self,
8484            decoder: &mut fidl::encoding::Decoder<
8485                '_,
8486                fidl::encoding::DefaultFuchsiaResourceDialect,
8487            >,
8488            offset: usize,
8489            _depth: fidl::encoding::Depth,
8490        ) -> fidl::Result<()> {
8491            decoder.debug_check_bounds::<Self>(offset);
8492            // Verify that padding bytes are zero.
8493            fidl::decode!(
8494                Struct,
8495                fidl::encoding::DefaultFuchsiaResourceDialect,
8496                &mut self.value,
8497                decoder,
8498                offset + 0,
8499                _depth
8500            )?;
8501            Ok(())
8502        }
8503    }
8504
8505    impl fidl::encoding::ResourceTypeMarker for EchoEchoTableWithErrorResponse {
8506        type Borrowed<'a> = &'a mut Self;
8507        fn take_or_borrow<'a>(
8508            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8509        ) -> Self::Borrowed<'a> {
8510            value
8511        }
8512    }
8513
8514    unsafe impl fidl::encoding::TypeMarker for EchoEchoTableWithErrorResponse {
8515        type Owned = Self;
8516
8517        #[inline(always)]
8518        fn inline_align(_context: fidl::encoding::Context) -> usize {
8519            8
8520        }
8521
8522        #[inline(always)]
8523        fn inline_size(_context: fidl::encoding::Context) -> usize {
8524            16
8525        }
8526    }
8527
8528    unsafe impl
8529        fidl::encoding::Encode<
8530            EchoEchoTableWithErrorResponse,
8531            fidl::encoding::DefaultFuchsiaResourceDialect,
8532        > for &mut EchoEchoTableWithErrorResponse
8533    {
8534        #[inline]
8535        unsafe fn encode(
8536            self,
8537            encoder: &mut fidl::encoding::Encoder<
8538                '_,
8539                fidl::encoding::DefaultFuchsiaResourceDialect,
8540            >,
8541            offset: usize,
8542            _depth: fidl::encoding::Depth,
8543        ) -> fidl::Result<()> {
8544            encoder.debug_check_bounds::<EchoEchoTableWithErrorResponse>(offset);
8545            // Delegate to tuple encoding.
8546            fidl::encoding::Encode::<
8547                EchoEchoTableWithErrorResponse,
8548                fidl::encoding::DefaultFuchsiaResourceDialect,
8549            >::encode(
8550                (<AllTypesTable as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8551                    &mut self.value,
8552                ),),
8553                encoder,
8554                offset,
8555                _depth,
8556            )
8557        }
8558    }
8559    unsafe impl<
8560        T0: fidl::encoding::Encode<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>,
8561    >
8562        fidl::encoding::Encode<
8563            EchoEchoTableWithErrorResponse,
8564            fidl::encoding::DefaultFuchsiaResourceDialect,
8565        > for (T0,)
8566    {
8567        #[inline]
8568        unsafe fn encode(
8569            self,
8570            encoder: &mut fidl::encoding::Encoder<
8571                '_,
8572                fidl::encoding::DefaultFuchsiaResourceDialect,
8573            >,
8574            offset: usize,
8575            depth: fidl::encoding::Depth,
8576        ) -> fidl::Result<()> {
8577            encoder.debug_check_bounds::<EchoEchoTableWithErrorResponse>(offset);
8578            // Zero out padding regions. There's no need to apply masks
8579            // because the unmasked parts will be overwritten by fields.
8580            // Write the fields.
8581            self.0.encode(encoder, offset + 0, depth)?;
8582            Ok(())
8583        }
8584    }
8585
8586    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8587        for EchoEchoTableWithErrorResponse
8588    {
8589        #[inline(always)]
8590        fn new_empty() -> Self {
8591            Self {
8592                value: fidl::new_empty!(
8593                    AllTypesTable,
8594                    fidl::encoding::DefaultFuchsiaResourceDialect
8595                ),
8596            }
8597        }
8598
8599        #[inline]
8600        unsafe fn decode(
8601            &mut self,
8602            decoder: &mut fidl::encoding::Decoder<
8603                '_,
8604                fidl::encoding::DefaultFuchsiaResourceDialect,
8605            >,
8606            offset: usize,
8607            _depth: fidl::encoding::Depth,
8608        ) -> fidl::Result<()> {
8609            decoder.debug_check_bounds::<Self>(offset);
8610            // Verify that padding bytes are zero.
8611            fidl::decode!(
8612                AllTypesTable,
8613                fidl::encoding::DefaultFuchsiaResourceDialect,
8614                &mut self.value,
8615                decoder,
8616                offset + 0,
8617                _depth
8618            )?;
8619            Ok(())
8620        }
8621    }
8622
8623    impl fidl::encoding::ResourceTypeMarker for EchoEchoVectorsWithErrorResponse {
8624        type Borrowed<'a> = &'a mut Self;
8625        fn take_or_borrow<'a>(
8626            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8627        ) -> Self::Borrowed<'a> {
8628            value
8629        }
8630    }
8631
8632    unsafe impl fidl::encoding::TypeMarker for EchoEchoVectorsWithErrorResponse {
8633        type Owned = Self;
8634
8635        #[inline(always)]
8636        fn inline_align(_context: fidl::encoding::Context) -> usize {
8637            8
8638        }
8639
8640        #[inline(always)]
8641        fn inline_size(_context: fidl::encoding::Context) -> usize {
8642            416
8643        }
8644    }
8645
8646    unsafe impl
8647        fidl::encoding::Encode<
8648            EchoEchoVectorsWithErrorResponse,
8649            fidl::encoding::DefaultFuchsiaResourceDialect,
8650        > for &mut EchoEchoVectorsWithErrorResponse
8651    {
8652        #[inline]
8653        unsafe fn encode(
8654            self,
8655            encoder: &mut fidl::encoding::Encoder<
8656                '_,
8657                fidl::encoding::DefaultFuchsiaResourceDialect,
8658            >,
8659            offset: usize,
8660            _depth: fidl::encoding::Depth,
8661        ) -> fidl::Result<()> {
8662            encoder.debug_check_bounds::<EchoEchoVectorsWithErrorResponse>(offset);
8663            // Delegate to tuple encoding.
8664            fidl::encoding::Encode::<
8665                EchoEchoVectorsWithErrorResponse,
8666                fidl::encoding::DefaultFuchsiaResourceDialect,
8667            >::encode(
8668                (<VectorsStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8669                    &mut self.value,
8670                ),),
8671                encoder,
8672                offset,
8673                _depth,
8674            )
8675        }
8676    }
8677    unsafe impl<
8678        T0: fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
8679    >
8680        fidl::encoding::Encode<
8681            EchoEchoVectorsWithErrorResponse,
8682            fidl::encoding::DefaultFuchsiaResourceDialect,
8683        > for (T0,)
8684    {
8685        #[inline]
8686        unsafe fn encode(
8687            self,
8688            encoder: &mut fidl::encoding::Encoder<
8689                '_,
8690                fidl::encoding::DefaultFuchsiaResourceDialect,
8691            >,
8692            offset: usize,
8693            depth: fidl::encoding::Depth,
8694        ) -> fidl::Result<()> {
8695            encoder.debug_check_bounds::<EchoEchoVectorsWithErrorResponse>(offset);
8696            // Zero out padding regions. There's no need to apply masks
8697            // because the unmasked parts will be overwritten by fields.
8698            // Write the fields.
8699            self.0.encode(encoder, offset + 0, depth)?;
8700            Ok(())
8701        }
8702    }
8703
8704    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8705        for EchoEchoVectorsWithErrorResponse
8706    {
8707        #[inline(always)]
8708        fn new_empty() -> Self {
8709            Self {
8710                value: fidl::new_empty!(
8711                    VectorsStruct,
8712                    fidl::encoding::DefaultFuchsiaResourceDialect
8713                ),
8714            }
8715        }
8716
8717        #[inline]
8718        unsafe fn decode(
8719            &mut self,
8720            decoder: &mut fidl::encoding::Decoder<
8721                '_,
8722                fidl::encoding::DefaultFuchsiaResourceDialect,
8723            >,
8724            offset: usize,
8725            _depth: fidl::encoding::Depth,
8726        ) -> fidl::Result<()> {
8727            decoder.debug_check_bounds::<Self>(offset);
8728            // Verify that padding bytes are zero.
8729            fidl::decode!(
8730                VectorsStruct,
8731                fidl::encoding::DefaultFuchsiaResourceDialect,
8732                &mut self.value,
8733                decoder,
8734                offset + 0,
8735                _depth
8736            )?;
8737            Ok(())
8738        }
8739    }
8740
8741    impl fidl::encoding::ResourceTypeMarker for EchoEchoXunionsWithErrorResponse {
8742        type Borrowed<'a> = &'a mut Self;
8743        fn take_or_borrow<'a>(
8744            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8745        ) -> Self::Borrowed<'a> {
8746            value
8747        }
8748    }
8749
8750    unsafe impl fidl::encoding::TypeMarker for EchoEchoXunionsWithErrorResponse {
8751        type Owned = Self;
8752
8753        #[inline(always)]
8754        fn inline_align(_context: fidl::encoding::Context) -> usize {
8755            8
8756        }
8757
8758        #[inline(always)]
8759        fn inline_size(_context: fidl::encoding::Context) -> usize {
8760            16
8761        }
8762    }
8763
8764    unsafe impl
8765        fidl::encoding::Encode<
8766            EchoEchoXunionsWithErrorResponse,
8767            fidl::encoding::DefaultFuchsiaResourceDialect,
8768        > for &mut EchoEchoXunionsWithErrorResponse
8769    {
8770        #[inline]
8771        unsafe fn encode(
8772            self,
8773            encoder: &mut fidl::encoding::Encoder<
8774                '_,
8775                fidl::encoding::DefaultFuchsiaResourceDialect,
8776            >,
8777            offset: usize,
8778            _depth: fidl::encoding::Depth,
8779        ) -> fidl::Result<()> {
8780            encoder.debug_check_bounds::<EchoEchoXunionsWithErrorResponse>(offset);
8781            // Delegate to tuple encoding.
8782            fidl::encoding::Encode::<EchoEchoXunionsWithErrorResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
8783                (
8784                    <fidl::encoding::UnboundedVector<AllTypesXunion> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
8785                ),
8786                encoder, offset, _depth
8787            )
8788        }
8789    }
8790    unsafe impl<
8791        T0: fidl::encoding::Encode<
8792                fidl::encoding::UnboundedVector<AllTypesXunion>,
8793                fidl::encoding::DefaultFuchsiaResourceDialect,
8794            >,
8795    >
8796        fidl::encoding::Encode<
8797            EchoEchoXunionsWithErrorResponse,
8798            fidl::encoding::DefaultFuchsiaResourceDialect,
8799        > for (T0,)
8800    {
8801        #[inline]
8802        unsafe fn encode(
8803            self,
8804            encoder: &mut fidl::encoding::Encoder<
8805                '_,
8806                fidl::encoding::DefaultFuchsiaResourceDialect,
8807            >,
8808            offset: usize,
8809            depth: fidl::encoding::Depth,
8810        ) -> fidl::Result<()> {
8811            encoder.debug_check_bounds::<EchoEchoXunionsWithErrorResponse>(offset);
8812            // Zero out padding regions. There's no need to apply masks
8813            // because the unmasked parts will be overwritten by fields.
8814            // Write the fields.
8815            self.0.encode(encoder, offset + 0, depth)?;
8816            Ok(())
8817        }
8818    }
8819
8820    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8821        for EchoEchoXunionsWithErrorResponse
8822    {
8823        #[inline(always)]
8824        fn new_empty() -> Self {
8825            Self {
8826                value: fidl::new_empty!(
8827                    fidl::encoding::UnboundedVector<AllTypesXunion>,
8828                    fidl::encoding::DefaultFuchsiaResourceDialect
8829                ),
8830            }
8831        }
8832
8833        #[inline]
8834        unsafe fn decode(
8835            &mut self,
8836            decoder: &mut fidl::encoding::Decoder<
8837                '_,
8838                fidl::encoding::DefaultFuchsiaResourceDialect,
8839            >,
8840            offset: usize,
8841            _depth: fidl::encoding::Depth,
8842        ) -> fidl::Result<()> {
8843            decoder.debug_check_bounds::<Self>(offset);
8844            // Verify that padding bytes are zero.
8845            fidl::decode!(
8846                fidl::encoding::UnboundedVector<AllTypesXunion>,
8847                fidl::encoding::DefaultFuchsiaResourceDialect,
8848                &mut self.value,
8849                decoder,
8850                offset + 0,
8851                _depth
8852            )?;
8853            Ok(())
8854        }
8855    }
8856
8857    impl fidl::encoding::ResourceTypeMarker for Struct {
8858        type Borrowed<'a> = &'a mut Self;
8859        fn take_or_borrow<'a>(
8860            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8861        ) -> Self::Borrowed<'a> {
8862            value
8863        }
8864    }
8865
8866    unsafe impl fidl::encoding::TypeMarker for Struct {
8867        type Owned = Self;
8868
8869        #[inline(always)]
8870        fn inline_align(_context: fidl::encoding::Context) -> usize {
8871            8
8872        }
8873
8874        #[inline(always)]
8875        fn inline_size(_context: fidl::encoding::Context) -> usize {
8876            2912
8877        }
8878    }
8879
8880    unsafe impl fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>
8881        for &mut Struct
8882    {
8883        #[inline]
8884        unsafe fn encode(
8885            self,
8886            encoder: &mut fidl::encoding::Encoder<
8887                '_,
8888                fidl::encoding::DefaultFuchsiaResourceDialect,
8889            >,
8890            offset: usize,
8891            _depth: fidl::encoding::Depth,
8892        ) -> fidl::Result<()> {
8893            encoder.debug_check_bounds::<Struct>(offset);
8894            // Delegate to tuple encoding.
8895            fidl::encoding::Encode::<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
8896                (
8897                    <PrimitiveTypes as fidl::encoding::ValueTypeMarker>::borrow(
8898                        &self.primitive_types,
8899                    ),
8900                    <DefaultValues as fidl::encoding::ValueTypeMarker>::borrow(
8901                        &self.default_values,
8902                    ),
8903                    <Arrays as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8904                        &mut self.arrays,
8905                    ),
8906                    <Arrays2d as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8907                        &mut self.arrays_2d,
8908                    ),
8909                    <Vectors as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8910                        &mut self.vectors,
8911                    ),
8912                    <Handles as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8913                        &mut self.handles,
8914                    ),
8915                    <Strings as fidl::encoding::ValueTypeMarker>::borrow(&self.strings),
8916                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.default_enum),
8917                    <I8Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_enum),
8918                    <I16Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_enum),
8919                    <I32Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_enum),
8920                    <I64Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_enum),
8921                    <U8Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_enum),
8922                    <U16Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_enum),
8923                    <U32Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_enum),
8924                    <U64Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_enum),
8925                    <DefaultBits as fidl::encoding::ValueTypeMarker>::borrow(&self.default_bits),
8926                    <U8Bits as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_bits),
8927                    <U16Bits as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_bits),
8928                    <U32Bits as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_bits),
8929                    <U64Bits as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_bits),
8930                    <Structs as fidl::encoding::ValueTypeMarker>::borrow(&self.structs),
8931                    <Unions as fidl::encoding::ValueTypeMarker>::borrow(&self.unions),
8932                    <ThisIsATable as fidl::encoding::ValueTypeMarker>::borrow(&self.table),
8933                    <ThisIsAXunion as fidl::encoding::ValueTypeMarker>::borrow(&self.xunion),
8934                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.b),
8935                ),
8936                encoder,
8937                offset,
8938                _depth,
8939            )
8940        }
8941    }
8942    unsafe impl<
8943        T0: fidl::encoding::Encode<PrimitiveTypes, fidl::encoding::DefaultFuchsiaResourceDialect>,
8944        T1: fidl::encoding::Encode<DefaultValues, fidl::encoding::DefaultFuchsiaResourceDialect>,
8945        T2: fidl::encoding::Encode<Arrays, fidl::encoding::DefaultFuchsiaResourceDialect>,
8946        T3: fidl::encoding::Encode<Arrays2d, fidl::encoding::DefaultFuchsiaResourceDialect>,
8947        T4: fidl::encoding::Encode<Vectors, fidl::encoding::DefaultFuchsiaResourceDialect>,
8948        T5: fidl::encoding::Encode<Handles, fidl::encoding::DefaultFuchsiaResourceDialect>,
8949        T6: fidl::encoding::Encode<Strings, fidl::encoding::DefaultFuchsiaResourceDialect>,
8950        T7: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8951        T8: fidl::encoding::Encode<I8Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8952        T9: fidl::encoding::Encode<I16Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8953        T10: fidl::encoding::Encode<I32Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8954        T11: fidl::encoding::Encode<I64Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8955        T12: fidl::encoding::Encode<U8Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8956        T13: fidl::encoding::Encode<U16Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8957        T14: fidl::encoding::Encode<U32Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8958        T15: fidl::encoding::Encode<U64Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8959        T16: fidl::encoding::Encode<DefaultBits, fidl::encoding::DefaultFuchsiaResourceDialect>,
8960        T17: fidl::encoding::Encode<U8Bits, fidl::encoding::DefaultFuchsiaResourceDialect>,
8961        T18: fidl::encoding::Encode<U16Bits, fidl::encoding::DefaultFuchsiaResourceDialect>,
8962        T19: fidl::encoding::Encode<U32Bits, fidl::encoding::DefaultFuchsiaResourceDialect>,
8963        T20: fidl::encoding::Encode<U64Bits, fidl::encoding::DefaultFuchsiaResourceDialect>,
8964        T21: fidl::encoding::Encode<Structs, fidl::encoding::DefaultFuchsiaResourceDialect>,
8965        T22: fidl::encoding::Encode<Unions, fidl::encoding::DefaultFuchsiaResourceDialect>,
8966        T23: fidl::encoding::Encode<ThisIsATable, fidl::encoding::DefaultFuchsiaResourceDialect>,
8967        T24: fidl::encoding::Encode<ThisIsAXunion, fidl::encoding::DefaultFuchsiaResourceDialect>,
8968        T25: fidl::encoding::Encode<bool, fidl::encoding::DefaultFuchsiaResourceDialect>,
8969    > fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>
8970        for (
8971            T0,
8972            T1,
8973            T2,
8974            T3,
8975            T4,
8976            T5,
8977            T6,
8978            T7,
8979            T8,
8980            T9,
8981            T10,
8982            T11,
8983            T12,
8984            T13,
8985            T14,
8986            T15,
8987            T16,
8988            T17,
8989            T18,
8990            T19,
8991            T20,
8992            T21,
8993            T22,
8994            T23,
8995            T24,
8996            T25,
8997        )
8998    {
8999        #[inline]
9000        unsafe fn encode(
9001            self,
9002            encoder: &mut fidl::encoding::Encoder<
9003                '_,
9004                fidl::encoding::DefaultFuchsiaResourceDialect,
9005            >,
9006            offset: usize,
9007            depth: fidl::encoding::Depth,
9008        ) -> fidl::Result<()> {
9009            encoder.debug_check_bounds::<Struct>(offset);
9010            // Zero out padding regions. There's no need to apply masks
9011            // because the unmasked parts will be overwritten by fields.
9012            unsafe {
9013                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2640);
9014                (ptr as *mut u64).write_unaligned(0);
9015            }
9016            unsafe {
9017                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2744);
9018                (ptr as *mut u64).write_unaligned(0);
9019            }
9020            unsafe {
9021                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2752);
9022                (ptr as *mut u64).write_unaligned(0);
9023            }
9024            unsafe {
9025                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2768);
9026                (ptr as *mut u64).write_unaligned(0);
9027            }
9028            unsafe {
9029                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2784);
9030                (ptr as *mut u64).write_unaligned(0);
9031            }
9032            unsafe {
9033                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2792);
9034                (ptr as *mut u64).write_unaligned(0);
9035            }
9036            unsafe {
9037                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2904);
9038                (ptr as *mut u64).write_unaligned(0);
9039            }
9040            // Write the fields.
9041            self.0.encode(encoder, offset + 0, depth)?;
9042            self.1.encode(encoder, offset + 48, depth)?;
9043            self.2.encode(encoder, offset + 120, depth)?;
9044            self.3.encode(encoder, offset + 328, depth)?;
9045            self.4.encode(encoder, offset + 616, depth)?;
9046            self.5.encode(encoder, offset + 2536, depth)?;
9047            self.6.encode(encoder, offset + 2648, depth)?;
9048            self.7.encode(encoder, offset + 2744, depth)?;
9049            self.8.encode(encoder, offset + 2748, depth)?;
9050            self.9.encode(encoder, offset + 2750, depth)?;
9051            self.10.encode(encoder, offset + 2752, depth)?;
9052            self.11.encode(encoder, offset + 2760, depth)?;
9053            self.12.encode(encoder, offset + 2768, depth)?;
9054            self.13.encode(encoder, offset + 2770, depth)?;
9055            self.14.encode(encoder, offset + 2772, depth)?;
9056            self.15.encode(encoder, offset + 2776, depth)?;
9057            self.16.encode(encoder, offset + 2784, depth)?;
9058            self.17.encode(encoder, offset + 2788, depth)?;
9059            self.18.encode(encoder, offset + 2790, depth)?;
9060            self.19.encode(encoder, offset + 2792, depth)?;
9061            self.20.encode(encoder, offset + 2800, depth)?;
9062            self.21.encode(encoder, offset + 2808, depth)?;
9063            self.22.encode(encoder, offset + 2840, depth)?;
9064            self.23.encode(encoder, offset + 2872, depth)?;
9065            self.24.encode(encoder, offset + 2888, depth)?;
9066            self.25.encode(encoder, offset + 2904, depth)?;
9067            Ok(())
9068        }
9069    }
9070
9071    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Struct {
9072        #[inline(always)]
9073        fn new_empty() -> Self {
9074            Self {
9075                primitive_types: fidl::new_empty!(
9076                    PrimitiveTypes,
9077                    fidl::encoding::DefaultFuchsiaResourceDialect
9078                ),
9079                default_values: fidl::new_empty!(
9080                    DefaultValues,
9081                    fidl::encoding::DefaultFuchsiaResourceDialect
9082                ),
9083                arrays: fidl::new_empty!(Arrays, fidl::encoding::DefaultFuchsiaResourceDialect),
9084                arrays_2d: fidl::new_empty!(
9085                    Arrays2d,
9086                    fidl::encoding::DefaultFuchsiaResourceDialect
9087                ),
9088                vectors: fidl::new_empty!(Vectors, fidl::encoding::DefaultFuchsiaResourceDialect),
9089                handles: fidl::new_empty!(Handles, fidl::encoding::DefaultFuchsiaResourceDialect),
9090                strings: fidl::new_empty!(Strings, fidl::encoding::DefaultFuchsiaResourceDialect),
9091                default_enum: fidl::new_empty!(
9092                    DefaultEnum,
9093                    fidl::encoding::DefaultFuchsiaResourceDialect
9094                ),
9095                i8_enum: fidl::new_empty!(I8Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9096                i16_enum: fidl::new_empty!(I16Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9097                i32_enum: fidl::new_empty!(I32Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9098                i64_enum: fidl::new_empty!(I64Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9099                u8_enum: fidl::new_empty!(U8Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9100                u16_enum: fidl::new_empty!(U16Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9101                u32_enum: fidl::new_empty!(U32Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9102                u64_enum: fidl::new_empty!(U64Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9103                default_bits: fidl::new_empty!(
9104                    DefaultBits,
9105                    fidl::encoding::DefaultFuchsiaResourceDialect
9106                ),
9107                u8_bits: fidl::new_empty!(U8Bits, fidl::encoding::DefaultFuchsiaResourceDialect),
9108                u16_bits: fidl::new_empty!(U16Bits, fidl::encoding::DefaultFuchsiaResourceDialect),
9109                u32_bits: fidl::new_empty!(U32Bits, fidl::encoding::DefaultFuchsiaResourceDialect),
9110                u64_bits: fidl::new_empty!(U64Bits, fidl::encoding::DefaultFuchsiaResourceDialect),
9111                structs: fidl::new_empty!(Structs, fidl::encoding::DefaultFuchsiaResourceDialect),
9112                unions: fidl::new_empty!(Unions, fidl::encoding::DefaultFuchsiaResourceDialect),
9113                table: fidl::new_empty!(
9114                    ThisIsATable,
9115                    fidl::encoding::DefaultFuchsiaResourceDialect
9116                ),
9117                xunion: fidl::new_empty!(
9118                    ThisIsAXunion,
9119                    fidl::encoding::DefaultFuchsiaResourceDialect
9120                ),
9121                b: fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect),
9122            }
9123        }
9124
9125        #[inline]
9126        unsafe fn decode(
9127            &mut self,
9128            decoder: &mut fidl::encoding::Decoder<
9129                '_,
9130                fidl::encoding::DefaultFuchsiaResourceDialect,
9131            >,
9132            offset: usize,
9133            _depth: fidl::encoding::Depth,
9134        ) -> fidl::Result<()> {
9135            decoder.debug_check_bounds::<Self>(offset);
9136            // Verify that padding bytes are zero.
9137            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2640) };
9138            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9139            let mask = 0xffffffff00000000u64;
9140            let maskedval = padval & mask;
9141            if maskedval != 0 {
9142                return Err(fidl::Error::NonZeroPadding {
9143                    padding_start: offset + 2640 + ((mask as u64).trailing_zeros() / 8) as usize,
9144                });
9145            }
9146            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2744) };
9147            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9148            let mask = 0xff0000000000u64;
9149            let maskedval = padval & mask;
9150            if maskedval != 0 {
9151                return Err(fidl::Error::NonZeroPadding {
9152                    padding_start: offset + 2744 + ((mask as u64).trailing_zeros() / 8) as usize,
9153                });
9154            }
9155            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2752) };
9156            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9157            let mask = 0xffffffff00000000u64;
9158            let maskedval = padval & mask;
9159            if maskedval != 0 {
9160                return Err(fidl::Error::NonZeroPadding {
9161                    padding_start: offset + 2752 + ((mask as u64).trailing_zeros() / 8) as usize,
9162                });
9163            }
9164            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2768) };
9165            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9166            let mask = 0xff00u64;
9167            let maskedval = padval & mask;
9168            if maskedval != 0 {
9169                return Err(fidl::Error::NonZeroPadding {
9170                    padding_start: offset + 2768 + ((mask as u64).trailing_zeros() / 8) as usize,
9171                });
9172            }
9173            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2784) };
9174            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9175            let mask = 0xff0000000000u64;
9176            let maskedval = padval & mask;
9177            if maskedval != 0 {
9178                return Err(fidl::Error::NonZeroPadding {
9179                    padding_start: offset + 2784 + ((mask as u64).trailing_zeros() / 8) as usize,
9180                });
9181            }
9182            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2792) };
9183            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9184            let mask = 0xffffffff00000000u64;
9185            let maskedval = padval & mask;
9186            if maskedval != 0 {
9187                return Err(fidl::Error::NonZeroPadding {
9188                    padding_start: offset + 2792 + ((mask as u64).trailing_zeros() / 8) as usize,
9189                });
9190            }
9191            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2904) };
9192            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9193            let mask = 0xffffffffffffff00u64;
9194            let maskedval = padval & mask;
9195            if maskedval != 0 {
9196                return Err(fidl::Error::NonZeroPadding {
9197                    padding_start: offset + 2904 + ((mask as u64).trailing_zeros() / 8) as usize,
9198                });
9199            }
9200            fidl::decode!(
9201                PrimitiveTypes,
9202                fidl::encoding::DefaultFuchsiaResourceDialect,
9203                &mut self.primitive_types,
9204                decoder,
9205                offset + 0,
9206                _depth
9207            )?;
9208            fidl::decode!(
9209                DefaultValues,
9210                fidl::encoding::DefaultFuchsiaResourceDialect,
9211                &mut self.default_values,
9212                decoder,
9213                offset + 48,
9214                _depth
9215            )?;
9216            fidl::decode!(
9217                Arrays,
9218                fidl::encoding::DefaultFuchsiaResourceDialect,
9219                &mut self.arrays,
9220                decoder,
9221                offset + 120,
9222                _depth
9223            )?;
9224            fidl::decode!(
9225                Arrays2d,
9226                fidl::encoding::DefaultFuchsiaResourceDialect,
9227                &mut self.arrays_2d,
9228                decoder,
9229                offset + 328,
9230                _depth
9231            )?;
9232            fidl::decode!(
9233                Vectors,
9234                fidl::encoding::DefaultFuchsiaResourceDialect,
9235                &mut self.vectors,
9236                decoder,
9237                offset + 616,
9238                _depth
9239            )?;
9240            fidl::decode!(
9241                Handles,
9242                fidl::encoding::DefaultFuchsiaResourceDialect,
9243                &mut self.handles,
9244                decoder,
9245                offset + 2536,
9246                _depth
9247            )?;
9248            fidl::decode!(
9249                Strings,
9250                fidl::encoding::DefaultFuchsiaResourceDialect,
9251                &mut self.strings,
9252                decoder,
9253                offset + 2648,
9254                _depth
9255            )?;
9256            fidl::decode!(
9257                DefaultEnum,
9258                fidl::encoding::DefaultFuchsiaResourceDialect,
9259                &mut self.default_enum,
9260                decoder,
9261                offset + 2744,
9262                _depth
9263            )?;
9264            fidl::decode!(
9265                I8Enum,
9266                fidl::encoding::DefaultFuchsiaResourceDialect,
9267                &mut self.i8_enum,
9268                decoder,
9269                offset + 2748,
9270                _depth
9271            )?;
9272            fidl::decode!(
9273                I16Enum,
9274                fidl::encoding::DefaultFuchsiaResourceDialect,
9275                &mut self.i16_enum,
9276                decoder,
9277                offset + 2750,
9278                _depth
9279            )?;
9280            fidl::decode!(
9281                I32Enum,
9282                fidl::encoding::DefaultFuchsiaResourceDialect,
9283                &mut self.i32_enum,
9284                decoder,
9285                offset + 2752,
9286                _depth
9287            )?;
9288            fidl::decode!(
9289                I64Enum,
9290                fidl::encoding::DefaultFuchsiaResourceDialect,
9291                &mut self.i64_enum,
9292                decoder,
9293                offset + 2760,
9294                _depth
9295            )?;
9296            fidl::decode!(
9297                U8Enum,
9298                fidl::encoding::DefaultFuchsiaResourceDialect,
9299                &mut self.u8_enum,
9300                decoder,
9301                offset + 2768,
9302                _depth
9303            )?;
9304            fidl::decode!(
9305                U16Enum,
9306                fidl::encoding::DefaultFuchsiaResourceDialect,
9307                &mut self.u16_enum,
9308                decoder,
9309                offset + 2770,
9310                _depth
9311            )?;
9312            fidl::decode!(
9313                U32Enum,
9314                fidl::encoding::DefaultFuchsiaResourceDialect,
9315                &mut self.u32_enum,
9316                decoder,
9317                offset + 2772,
9318                _depth
9319            )?;
9320            fidl::decode!(
9321                U64Enum,
9322                fidl::encoding::DefaultFuchsiaResourceDialect,
9323                &mut self.u64_enum,
9324                decoder,
9325                offset + 2776,
9326                _depth
9327            )?;
9328            fidl::decode!(
9329                DefaultBits,
9330                fidl::encoding::DefaultFuchsiaResourceDialect,
9331                &mut self.default_bits,
9332                decoder,
9333                offset + 2784,
9334                _depth
9335            )?;
9336            fidl::decode!(
9337                U8Bits,
9338                fidl::encoding::DefaultFuchsiaResourceDialect,
9339                &mut self.u8_bits,
9340                decoder,
9341                offset + 2788,
9342                _depth
9343            )?;
9344            fidl::decode!(
9345                U16Bits,
9346                fidl::encoding::DefaultFuchsiaResourceDialect,
9347                &mut self.u16_bits,
9348                decoder,
9349                offset + 2790,
9350                _depth
9351            )?;
9352            fidl::decode!(
9353                U32Bits,
9354                fidl::encoding::DefaultFuchsiaResourceDialect,
9355                &mut self.u32_bits,
9356                decoder,
9357                offset + 2792,
9358                _depth
9359            )?;
9360            fidl::decode!(
9361                U64Bits,
9362                fidl::encoding::DefaultFuchsiaResourceDialect,
9363                &mut self.u64_bits,
9364                decoder,
9365                offset + 2800,
9366                _depth
9367            )?;
9368            fidl::decode!(
9369                Structs,
9370                fidl::encoding::DefaultFuchsiaResourceDialect,
9371                &mut self.structs,
9372                decoder,
9373                offset + 2808,
9374                _depth
9375            )?;
9376            fidl::decode!(
9377                Unions,
9378                fidl::encoding::DefaultFuchsiaResourceDialect,
9379                &mut self.unions,
9380                decoder,
9381                offset + 2840,
9382                _depth
9383            )?;
9384            fidl::decode!(
9385                ThisIsATable,
9386                fidl::encoding::DefaultFuchsiaResourceDialect,
9387                &mut self.table,
9388                decoder,
9389                offset + 2872,
9390                _depth
9391            )?;
9392            fidl::decode!(
9393                ThisIsAXunion,
9394                fidl::encoding::DefaultFuchsiaResourceDialect,
9395                &mut self.xunion,
9396                decoder,
9397                offset + 2888,
9398                _depth
9399            )?;
9400            fidl::decode!(
9401                bool,
9402                fidl::encoding::DefaultFuchsiaResourceDialect,
9403                &mut self.b,
9404                decoder,
9405                offset + 2904,
9406                _depth
9407            )?;
9408            Ok(())
9409        }
9410    }
9411
9412    impl fidl::encoding::ResourceTypeMarker for VectorsStruct {
9413        type Borrowed<'a> = &'a mut Self;
9414        fn take_or_borrow<'a>(
9415            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
9416        ) -> Self::Borrowed<'a> {
9417            value
9418        }
9419    }
9420
9421    unsafe impl fidl::encoding::TypeMarker for VectorsStruct {
9422        type Owned = Self;
9423
9424        #[inline(always)]
9425        fn inline_align(_context: fidl::encoding::Context) -> usize {
9426            8
9427        }
9428
9429        #[inline(always)]
9430        fn inline_size(_context: fidl::encoding::Context) -> usize {
9431            416
9432        }
9433    }
9434
9435    unsafe impl fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
9436        for &mut VectorsStruct
9437    {
9438        #[inline]
9439        unsafe fn encode(
9440            self,
9441            encoder: &mut fidl::encoding::Encoder<
9442                '_,
9443                fidl::encoding::DefaultFuchsiaResourceDialect,
9444            >,
9445            offset: usize,
9446            _depth: fidl::encoding::Depth,
9447        ) -> fidl::Result<()> {
9448            encoder.debug_check_bounds::<VectorsStruct>(offset);
9449            // Delegate to tuple encoding.
9450            fidl::encoding::Encode::<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
9451                (
9452                    <fidl::encoding::Vector<bool, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.bools),
9453                    <fidl::encoding::Vector<i8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int8s),
9454                    <fidl::encoding::Vector<i16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int16s),
9455                    <fidl::encoding::Vector<i32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int32s),
9456                    <fidl::encoding::Vector<i64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int64s),
9457                    <fidl::encoding::Vector<u8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint8s),
9458                    <fidl::encoding::Vector<u16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint16s),
9459                    <fidl::encoding::Vector<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint32s),
9460                    <fidl::encoding::Vector<u64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint64s),
9461                    <fidl::encoding::Vector<f32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.float32s),
9462                    <fidl::encoding::Vector<f64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.float64s),
9463                    <fidl::encoding::Vector<DefaultEnum, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.enums),
9464                    <fidl::encoding::Vector<DefaultBits, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.bits),
9465                    <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),
9466                    <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),
9467                    <fidl::encoding::Vector<fidl::encoding::UnboundedString, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.strings),
9468                    <fidl::encoding::Vector<fidl::encoding::Optional<fidl::encoding::UnboundedString>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_strings),
9469                    <fidl::encoding::Vector<ThisIsAStruct, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.structs),
9470                    <fidl::encoding::Vector<fidl::encoding::Boxed<ThisIsAStruct>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_structs),
9471                    <fidl::encoding::Vector<ThisIsAUnion, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.unions),
9472                    <fidl::encoding::Vector<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_unions),
9473                    <fidl::encoding::Vector<fidl::encoding::Array<u32, 3>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.arrays),
9474                    <fidl::encoding::Vector<fidl::encoding::UnboundedVector<u32>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.vectors),
9475                    <fidl::encoding::Vector<fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_vectors),
9476                    <fidl::encoding::Vector<ThisIsATable, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.tables),
9477                    <fidl::encoding::Vector<ThisIsAXunion, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.xunions),
9478                ),
9479                encoder, offset, _depth
9480            )
9481        }
9482    }
9483    unsafe impl<
9484        T0: fidl::encoding::Encode<
9485                fidl::encoding::Vector<bool, 3>,
9486                fidl::encoding::DefaultFuchsiaResourceDialect,
9487            >,
9488        T1: fidl::encoding::Encode<
9489                fidl::encoding::Vector<i8, 3>,
9490                fidl::encoding::DefaultFuchsiaResourceDialect,
9491            >,
9492        T2: fidl::encoding::Encode<
9493                fidl::encoding::Vector<i16, 3>,
9494                fidl::encoding::DefaultFuchsiaResourceDialect,
9495            >,
9496        T3: fidl::encoding::Encode<
9497                fidl::encoding::Vector<i32, 3>,
9498                fidl::encoding::DefaultFuchsiaResourceDialect,
9499            >,
9500        T4: fidl::encoding::Encode<
9501                fidl::encoding::Vector<i64, 3>,
9502                fidl::encoding::DefaultFuchsiaResourceDialect,
9503            >,
9504        T5: fidl::encoding::Encode<
9505                fidl::encoding::Vector<u8, 3>,
9506                fidl::encoding::DefaultFuchsiaResourceDialect,
9507            >,
9508        T6: fidl::encoding::Encode<
9509                fidl::encoding::Vector<u16, 3>,
9510                fidl::encoding::DefaultFuchsiaResourceDialect,
9511            >,
9512        T7: fidl::encoding::Encode<
9513                fidl::encoding::Vector<u32, 3>,
9514                fidl::encoding::DefaultFuchsiaResourceDialect,
9515            >,
9516        T8: fidl::encoding::Encode<
9517                fidl::encoding::Vector<u64, 3>,
9518                fidl::encoding::DefaultFuchsiaResourceDialect,
9519            >,
9520        T9: fidl::encoding::Encode<
9521                fidl::encoding::Vector<f32, 3>,
9522                fidl::encoding::DefaultFuchsiaResourceDialect,
9523            >,
9524        T10: fidl::encoding::Encode<
9525                fidl::encoding::Vector<f64, 3>,
9526                fidl::encoding::DefaultFuchsiaResourceDialect,
9527            >,
9528        T11: fidl::encoding::Encode<
9529                fidl::encoding::Vector<DefaultEnum, 3>,
9530                fidl::encoding::DefaultFuchsiaResourceDialect,
9531            >,
9532        T12: fidl::encoding::Encode<
9533                fidl::encoding::Vector<DefaultBits, 3>,
9534                fidl::encoding::DefaultFuchsiaResourceDialect,
9535            >,
9536        T13: fidl::encoding::Encode<
9537                fidl::encoding::Vector<
9538                    fidl::encoding::HandleType<
9539                        fidl::NullableHandle,
9540                        { fidl::ObjectType::NONE.into_raw() },
9541                        2147483648,
9542                    >,
9543                    3,
9544                >,
9545                fidl::encoding::DefaultFuchsiaResourceDialect,
9546            >,
9547        T14: fidl::encoding::Encode<
9548                fidl::encoding::Vector<
9549                    fidl::encoding::Optional<
9550                        fidl::encoding::HandleType<
9551                            fidl::NullableHandle,
9552                            { fidl::ObjectType::NONE.into_raw() },
9553                            2147483648,
9554                        >,
9555                    >,
9556                    3,
9557                >,
9558                fidl::encoding::DefaultFuchsiaResourceDialect,
9559            >,
9560        T15: fidl::encoding::Encode<
9561                fidl::encoding::Vector<fidl::encoding::UnboundedString, 3>,
9562                fidl::encoding::DefaultFuchsiaResourceDialect,
9563            >,
9564        T16: fidl::encoding::Encode<
9565                fidl::encoding::Vector<
9566                    fidl::encoding::Optional<fidl::encoding::UnboundedString>,
9567                    3,
9568                >,
9569                fidl::encoding::DefaultFuchsiaResourceDialect,
9570            >,
9571        T17: fidl::encoding::Encode<
9572                fidl::encoding::Vector<ThisIsAStruct, 3>,
9573                fidl::encoding::DefaultFuchsiaResourceDialect,
9574            >,
9575        T18: fidl::encoding::Encode<
9576                fidl::encoding::Vector<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
9577                fidl::encoding::DefaultFuchsiaResourceDialect,
9578            >,
9579        T19: fidl::encoding::Encode<
9580                fidl::encoding::Vector<ThisIsAUnion, 3>,
9581                fidl::encoding::DefaultFuchsiaResourceDialect,
9582            >,
9583        T20: fidl::encoding::Encode<
9584                fidl::encoding::Vector<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
9585                fidl::encoding::DefaultFuchsiaResourceDialect,
9586            >,
9587        T21: fidl::encoding::Encode<
9588                fidl::encoding::Vector<fidl::encoding::Array<u32, 3>, 3>,
9589                fidl::encoding::DefaultFuchsiaResourceDialect,
9590            >,
9591        T22: fidl::encoding::Encode<
9592                fidl::encoding::Vector<fidl::encoding::UnboundedVector<u32>, 3>,
9593                fidl::encoding::DefaultFuchsiaResourceDialect,
9594            >,
9595        T23: fidl::encoding::Encode<
9596                fidl::encoding::Vector<
9597                    fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
9598                    3,
9599                >,
9600                fidl::encoding::DefaultFuchsiaResourceDialect,
9601            >,
9602        T24: fidl::encoding::Encode<
9603                fidl::encoding::Vector<ThisIsATable, 3>,
9604                fidl::encoding::DefaultFuchsiaResourceDialect,
9605            >,
9606        T25: fidl::encoding::Encode<
9607                fidl::encoding::Vector<ThisIsAXunion, 3>,
9608                fidl::encoding::DefaultFuchsiaResourceDialect,
9609            >,
9610    > fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
9611        for (
9612            T0,
9613            T1,
9614            T2,
9615            T3,
9616            T4,
9617            T5,
9618            T6,
9619            T7,
9620            T8,
9621            T9,
9622            T10,
9623            T11,
9624            T12,
9625            T13,
9626            T14,
9627            T15,
9628            T16,
9629            T17,
9630            T18,
9631            T19,
9632            T20,
9633            T21,
9634            T22,
9635            T23,
9636            T24,
9637            T25,
9638        )
9639    {
9640        #[inline]
9641        unsafe fn encode(
9642            self,
9643            encoder: &mut fidl::encoding::Encoder<
9644                '_,
9645                fidl::encoding::DefaultFuchsiaResourceDialect,
9646            >,
9647            offset: usize,
9648            depth: fidl::encoding::Depth,
9649        ) -> fidl::Result<()> {
9650            encoder.debug_check_bounds::<VectorsStruct>(offset);
9651            // Zero out padding regions. There's no need to apply masks
9652            // because the unmasked parts will be overwritten by fields.
9653            // Write the fields.
9654            self.0.encode(encoder, offset + 0, depth)?;
9655            self.1.encode(encoder, offset + 16, depth)?;
9656            self.2.encode(encoder, offset + 32, depth)?;
9657            self.3.encode(encoder, offset + 48, depth)?;
9658            self.4.encode(encoder, offset + 64, depth)?;
9659            self.5.encode(encoder, offset + 80, depth)?;
9660            self.6.encode(encoder, offset + 96, depth)?;
9661            self.7.encode(encoder, offset + 112, depth)?;
9662            self.8.encode(encoder, offset + 128, depth)?;
9663            self.9.encode(encoder, offset + 144, depth)?;
9664            self.10.encode(encoder, offset + 160, depth)?;
9665            self.11.encode(encoder, offset + 176, depth)?;
9666            self.12.encode(encoder, offset + 192, depth)?;
9667            self.13.encode(encoder, offset + 208, depth)?;
9668            self.14.encode(encoder, offset + 224, depth)?;
9669            self.15.encode(encoder, offset + 240, depth)?;
9670            self.16.encode(encoder, offset + 256, depth)?;
9671            self.17.encode(encoder, offset + 272, depth)?;
9672            self.18.encode(encoder, offset + 288, depth)?;
9673            self.19.encode(encoder, offset + 304, depth)?;
9674            self.20.encode(encoder, offset + 320, depth)?;
9675            self.21.encode(encoder, offset + 336, depth)?;
9676            self.22.encode(encoder, offset + 352, depth)?;
9677            self.23.encode(encoder, offset + 368, depth)?;
9678            self.24.encode(encoder, offset + 384, depth)?;
9679            self.25.encode(encoder, offset + 400, depth)?;
9680            Ok(())
9681        }
9682    }
9683
9684    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for VectorsStruct {
9685        #[inline(always)]
9686        fn new_empty() -> Self {
9687            Self {
9688                bools: fidl::new_empty!(fidl::encoding::Vector<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9689                int8s: fidl::new_empty!(fidl::encoding::Vector<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9690                int16s: fidl::new_empty!(fidl::encoding::Vector<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9691                int32s: fidl::new_empty!(fidl::encoding::Vector<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9692                int64s: fidl::new_empty!(fidl::encoding::Vector<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9693                uint8s: fidl::new_empty!(fidl::encoding::Vector<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9694                uint16s: fidl::new_empty!(fidl::encoding::Vector<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9695                uint32s: fidl::new_empty!(fidl::encoding::Vector<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9696                uint64s: fidl::new_empty!(fidl::encoding::Vector<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9697                float32s: fidl::new_empty!(fidl::encoding::Vector<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9698                float64s: fidl::new_empty!(fidl::encoding::Vector<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9699                enums: fidl::new_empty!(fidl::encoding::Vector<DefaultEnum, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9700                bits: fidl::new_empty!(fidl::encoding::Vector<DefaultBits, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9701                handles: fidl::new_empty!(
9702                    fidl::encoding::Vector<
9703                        fidl::encoding::HandleType<
9704                            fidl::NullableHandle,
9705                            { fidl::ObjectType::NONE.into_raw() },
9706                            2147483648,
9707                        >,
9708                        3,
9709                    >,
9710                    fidl::encoding::DefaultFuchsiaResourceDialect
9711                ),
9712                nullable_handles: fidl::new_empty!(
9713                    fidl::encoding::Vector<
9714                        fidl::encoding::Optional<
9715                            fidl::encoding::HandleType<
9716                                fidl::NullableHandle,
9717                                { fidl::ObjectType::NONE.into_raw() },
9718                                2147483648,
9719                            >,
9720                        >,
9721                        3,
9722                    >,
9723                    fidl::encoding::DefaultFuchsiaResourceDialect
9724                ),
9725                strings: fidl::new_empty!(fidl::encoding::Vector<fidl::encoding::UnboundedString, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9726                nullable_strings: fidl::new_empty!(
9727                    fidl::encoding::Vector<
9728                        fidl::encoding::Optional<fidl::encoding::UnboundedString>,
9729                        3,
9730                    >,
9731                    fidl::encoding::DefaultFuchsiaResourceDialect
9732                ),
9733                structs: fidl::new_empty!(fidl::encoding::Vector<ThisIsAStruct, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9734                nullable_structs: fidl::new_empty!(
9735                    fidl::encoding::Vector<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
9736                    fidl::encoding::DefaultFuchsiaResourceDialect
9737                ),
9738                unions: fidl::new_empty!(fidl::encoding::Vector<ThisIsAUnion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9739                nullable_unions: fidl::new_empty!(
9740                    fidl::encoding::Vector<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
9741                    fidl::encoding::DefaultFuchsiaResourceDialect
9742                ),
9743                arrays: fidl::new_empty!(
9744                    fidl::encoding::Vector<fidl::encoding::Array<u32, 3>, 3>,
9745                    fidl::encoding::DefaultFuchsiaResourceDialect
9746                ),
9747                vectors: fidl::new_empty!(
9748                    fidl::encoding::Vector<fidl::encoding::UnboundedVector<u32>, 3>,
9749                    fidl::encoding::DefaultFuchsiaResourceDialect
9750                ),
9751                nullable_vectors: fidl::new_empty!(
9752                    fidl::encoding::Vector<
9753                        fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
9754                        3,
9755                    >,
9756                    fidl::encoding::DefaultFuchsiaResourceDialect
9757                ),
9758                tables: fidl::new_empty!(fidl::encoding::Vector<ThisIsATable, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9759                xunions: fidl::new_empty!(fidl::encoding::Vector<ThisIsAXunion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9760            }
9761        }
9762
9763        #[inline]
9764        unsafe fn decode(
9765            &mut self,
9766            decoder: &mut fidl::encoding::Decoder<
9767                '_,
9768                fidl::encoding::DefaultFuchsiaResourceDialect,
9769            >,
9770            offset: usize,
9771            _depth: fidl::encoding::Depth,
9772        ) -> fidl::Result<()> {
9773            decoder.debug_check_bounds::<Self>(offset);
9774            // Verify that padding bytes are zero.
9775            fidl::decode!(fidl::encoding::Vector<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.bools, decoder, offset + 0, _depth)?;
9776            fidl::decode!(fidl::encoding::Vector<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int8s, decoder, offset + 16, _depth)?;
9777            fidl::decode!(fidl::encoding::Vector<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int16s, decoder, offset + 32, _depth)?;
9778            fidl::decode!(fidl::encoding::Vector<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int32s, decoder, offset + 48, _depth)?;
9779            fidl::decode!(fidl::encoding::Vector<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int64s, decoder, offset + 64, _depth)?;
9780            fidl::decode!(fidl::encoding::Vector<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint8s, decoder, offset + 80, _depth)?;
9781            fidl::decode!(fidl::encoding::Vector<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint16s, decoder, offset + 96, _depth)?;
9782            fidl::decode!(fidl::encoding::Vector<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint32s, decoder, offset + 112, _depth)?;
9783            fidl::decode!(fidl::encoding::Vector<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint64s, decoder, offset + 128, _depth)?;
9784            fidl::decode!(fidl::encoding::Vector<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.float32s, decoder, offset + 144, _depth)?;
9785            fidl::decode!(fidl::encoding::Vector<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.float64s, decoder, offset + 160, _depth)?;
9786            fidl::decode!(fidl::encoding::Vector<DefaultEnum, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.enums, decoder, offset + 176, _depth)?;
9787            fidl::decode!(fidl::encoding::Vector<DefaultBits, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.bits, decoder, offset + 192, _depth)?;
9788            fidl::decode!(
9789                fidl::encoding::Vector<
9790                    fidl::encoding::HandleType<
9791                        fidl::NullableHandle,
9792                        { fidl::ObjectType::NONE.into_raw() },
9793                        2147483648,
9794                    >,
9795                    3,
9796                >,
9797                fidl::encoding::DefaultFuchsiaResourceDialect,
9798                &mut self.handles,
9799                decoder,
9800                offset + 208,
9801                _depth
9802            )?;
9803            fidl::decode!(
9804                fidl::encoding::Vector<
9805                    fidl::encoding::Optional<
9806                        fidl::encoding::HandleType<
9807                            fidl::NullableHandle,
9808                            { fidl::ObjectType::NONE.into_raw() },
9809                            2147483648,
9810                        >,
9811                    >,
9812                    3,
9813                >,
9814                fidl::encoding::DefaultFuchsiaResourceDialect,
9815                &mut self.nullable_handles,
9816                decoder,
9817                offset + 224,
9818                _depth
9819            )?;
9820            fidl::decode!(fidl::encoding::Vector<fidl::encoding::UnboundedString, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.strings, decoder, offset + 240, _depth)?;
9821            fidl::decode!(
9822                fidl::encoding::Vector<
9823                    fidl::encoding::Optional<fidl::encoding::UnboundedString>,
9824                    3,
9825                >,
9826                fidl::encoding::DefaultFuchsiaResourceDialect,
9827                &mut self.nullable_strings,
9828                decoder,
9829                offset + 256,
9830                _depth
9831            )?;
9832            fidl::decode!(fidl::encoding::Vector<ThisIsAStruct, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.structs, decoder, offset + 272, _depth)?;
9833            fidl::decode!(
9834                fidl::encoding::Vector<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
9835                fidl::encoding::DefaultFuchsiaResourceDialect,
9836                &mut self.nullable_structs,
9837                decoder,
9838                offset + 288,
9839                _depth
9840            )?;
9841            fidl::decode!(fidl::encoding::Vector<ThisIsAUnion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.unions, decoder, offset + 304, _depth)?;
9842            fidl::decode!(
9843                fidl::encoding::Vector<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
9844                fidl::encoding::DefaultFuchsiaResourceDialect,
9845                &mut self.nullable_unions,
9846                decoder,
9847                offset + 320,
9848                _depth
9849            )?;
9850            fidl::decode!(
9851                fidl::encoding::Vector<fidl::encoding::Array<u32, 3>, 3>,
9852                fidl::encoding::DefaultFuchsiaResourceDialect,
9853                &mut self.arrays,
9854                decoder,
9855                offset + 336,
9856                _depth
9857            )?;
9858            fidl::decode!(
9859                fidl::encoding::Vector<fidl::encoding::UnboundedVector<u32>, 3>,
9860                fidl::encoding::DefaultFuchsiaResourceDialect,
9861                &mut self.vectors,
9862                decoder,
9863                offset + 352,
9864                _depth
9865            )?;
9866            fidl::decode!(
9867                fidl::encoding::Vector<
9868                    fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
9869                    3,
9870                >,
9871                fidl::encoding::DefaultFuchsiaResourceDialect,
9872                &mut self.nullable_vectors,
9873                decoder,
9874                offset + 368,
9875                _depth
9876            )?;
9877            fidl::decode!(fidl::encoding::Vector<ThisIsATable, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.tables, decoder, offset + 384, _depth)?;
9878            fidl::decode!(fidl::encoding::Vector<ThisIsAXunion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.xunions, decoder, offset + 400, _depth)?;
9879            Ok(())
9880        }
9881    }
9882
9883    impl fidl::encoding::ResourceTypeMarker for Arrays {
9884        type Borrowed<'a> = &'a mut Self;
9885        fn take_or_borrow<'a>(
9886            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
9887        ) -> Self::Borrowed<'a> {
9888            value
9889        }
9890    }
9891
9892    unsafe impl fidl::encoding::TypeMarker for Arrays {
9893        type Owned = Self;
9894
9895        #[inline(always)]
9896        fn inline_align(_context: fidl::encoding::Context) -> usize {
9897            8
9898        }
9899
9900        #[inline(always)]
9901        fn inline_size(_context: fidl::encoding::Context) -> usize {
9902            208
9903        }
9904    }
9905
9906    unsafe impl fidl::encoding::Encode<Arrays, fidl::encoding::DefaultFuchsiaResourceDialect>
9907        for &mut Arrays
9908    {
9909        #[inline]
9910        unsafe fn encode(
9911            self,
9912            encoder: &mut fidl::encoding::Encoder<
9913                '_,
9914                fidl::encoding::DefaultFuchsiaResourceDialect,
9915            >,
9916            offset: usize,
9917            _depth: fidl::encoding::Depth,
9918        ) -> fidl::Result<()> {
9919            encoder.debug_check_bounds::<Arrays>(offset);
9920            // Delegate to tuple encoding.
9921            fidl::encoding::Encode::<Arrays, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
9922                (
9923                    <fidl::encoding::Array<bool, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9924                        &self.b_0,
9925                    ),
9926                    <fidl::encoding::Array<i8, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9927                        &self.i8_0,
9928                    ),
9929                    <fidl::encoding::Array<i16, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9930                        &self.i16_0,
9931                    ),
9932                    <fidl::encoding::Array<i32, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9933                        &self.i32_0,
9934                    ),
9935                    <fidl::encoding::Array<i64, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9936                        &self.i64_0,
9937                    ),
9938                    <fidl::encoding::Array<u8, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9939                        &self.u8_0,
9940                    ),
9941                    <fidl::encoding::Array<u16, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9942                        &self.u16_0,
9943                    ),
9944                    <fidl::encoding::Array<u32, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9945                        &self.u32_0,
9946                    ),
9947                    <fidl::encoding::Array<u64, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9948                        &self.u64_0,
9949                    ),
9950                    <fidl::encoding::Array<f32, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9951                        &self.f32_0,
9952                    ),
9953                    <fidl::encoding::Array<f64, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9954                        &self.f64_0,
9955                    ),
9956                    <fidl::encoding::Array<
9957                        fidl::encoding::HandleType<
9958                            fidl::NullableHandle,
9959                            { fidl::ObjectType::NONE.into_raw() },
9960                            2147483648,
9961                        >,
9962                        1,
9963                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
9964                        &mut self.handle_0
9965                    ),
9966                    <fidl::encoding::Array<bool, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9967                        &self.b_1,
9968                    ),
9969                    <fidl::encoding::Array<i8, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9970                        &self.i8_1,
9971                    ),
9972                    <fidl::encoding::Array<i16, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9973                        &self.i16_1,
9974                    ),
9975                    <fidl::encoding::Array<i32, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9976                        &self.i32_1,
9977                    ),
9978                    <fidl::encoding::Array<i64, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9979                        &self.i64_1,
9980                    ),
9981                    <fidl::encoding::Array<u8, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9982                        &self.u8_1,
9983                    ),
9984                    <fidl::encoding::Array<u16, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9985                        &self.u16_1,
9986                    ),
9987                    <fidl::encoding::Array<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9988                        &self.u32_1,
9989                    ),
9990                    <fidl::encoding::Array<u64, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9991                        &self.u64_1,
9992                    ),
9993                    <fidl::encoding::Array<f32, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9994                        &self.f32_1,
9995                    ),
9996                    <fidl::encoding::Array<f64, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9997                        &self.f64_1,
9998                    ),
9999                    <fidl::encoding::Array<
10000                        fidl::encoding::HandleType<
10001                            fidl::NullableHandle,
10002                            { fidl::ObjectType::NONE.into_raw() },
10003                            2147483648,
10004                        >,
10005                        3,
10006                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10007                        &mut self.handle_1
10008                    ),
10009                ),
10010                encoder,
10011                offset,
10012                _depth,
10013            )
10014        }
10015    }
10016    unsafe impl<
10017        T0: fidl::encoding::Encode<
10018                fidl::encoding::Array<bool, 1>,
10019                fidl::encoding::DefaultFuchsiaResourceDialect,
10020            >,
10021        T1: fidl::encoding::Encode<
10022                fidl::encoding::Array<i8, 1>,
10023                fidl::encoding::DefaultFuchsiaResourceDialect,
10024            >,
10025        T2: fidl::encoding::Encode<
10026                fidl::encoding::Array<i16, 1>,
10027                fidl::encoding::DefaultFuchsiaResourceDialect,
10028            >,
10029        T3: fidl::encoding::Encode<
10030                fidl::encoding::Array<i32, 1>,
10031                fidl::encoding::DefaultFuchsiaResourceDialect,
10032            >,
10033        T4: fidl::encoding::Encode<
10034                fidl::encoding::Array<i64, 1>,
10035                fidl::encoding::DefaultFuchsiaResourceDialect,
10036            >,
10037        T5: fidl::encoding::Encode<
10038                fidl::encoding::Array<u8, 1>,
10039                fidl::encoding::DefaultFuchsiaResourceDialect,
10040            >,
10041        T6: fidl::encoding::Encode<
10042                fidl::encoding::Array<u16, 1>,
10043                fidl::encoding::DefaultFuchsiaResourceDialect,
10044            >,
10045        T7: fidl::encoding::Encode<
10046                fidl::encoding::Array<u32, 1>,
10047                fidl::encoding::DefaultFuchsiaResourceDialect,
10048            >,
10049        T8: fidl::encoding::Encode<
10050                fidl::encoding::Array<u64, 1>,
10051                fidl::encoding::DefaultFuchsiaResourceDialect,
10052            >,
10053        T9: fidl::encoding::Encode<
10054                fidl::encoding::Array<f32, 1>,
10055                fidl::encoding::DefaultFuchsiaResourceDialect,
10056            >,
10057        T10: fidl::encoding::Encode<
10058                fidl::encoding::Array<f64, 1>,
10059                fidl::encoding::DefaultFuchsiaResourceDialect,
10060            >,
10061        T11: fidl::encoding::Encode<
10062                fidl::encoding::Array<
10063                    fidl::encoding::HandleType<
10064                        fidl::NullableHandle,
10065                        { fidl::ObjectType::NONE.into_raw() },
10066                        2147483648,
10067                    >,
10068                    1,
10069                >,
10070                fidl::encoding::DefaultFuchsiaResourceDialect,
10071            >,
10072        T12: fidl::encoding::Encode<
10073                fidl::encoding::Array<bool, 3>,
10074                fidl::encoding::DefaultFuchsiaResourceDialect,
10075            >,
10076        T13: fidl::encoding::Encode<
10077                fidl::encoding::Array<i8, 3>,
10078                fidl::encoding::DefaultFuchsiaResourceDialect,
10079            >,
10080        T14: fidl::encoding::Encode<
10081                fidl::encoding::Array<i16, 3>,
10082                fidl::encoding::DefaultFuchsiaResourceDialect,
10083            >,
10084        T15: fidl::encoding::Encode<
10085                fidl::encoding::Array<i32, 3>,
10086                fidl::encoding::DefaultFuchsiaResourceDialect,
10087            >,
10088        T16: fidl::encoding::Encode<
10089                fidl::encoding::Array<i64, 3>,
10090                fidl::encoding::DefaultFuchsiaResourceDialect,
10091            >,
10092        T17: fidl::encoding::Encode<
10093                fidl::encoding::Array<u8, 3>,
10094                fidl::encoding::DefaultFuchsiaResourceDialect,
10095            >,
10096        T18: fidl::encoding::Encode<
10097                fidl::encoding::Array<u16, 3>,
10098                fidl::encoding::DefaultFuchsiaResourceDialect,
10099            >,
10100        T19: fidl::encoding::Encode<
10101                fidl::encoding::Array<u32, 3>,
10102                fidl::encoding::DefaultFuchsiaResourceDialect,
10103            >,
10104        T20: fidl::encoding::Encode<
10105                fidl::encoding::Array<u64, 3>,
10106                fidl::encoding::DefaultFuchsiaResourceDialect,
10107            >,
10108        T21: fidl::encoding::Encode<
10109                fidl::encoding::Array<f32, 3>,
10110                fidl::encoding::DefaultFuchsiaResourceDialect,
10111            >,
10112        T22: fidl::encoding::Encode<
10113                fidl::encoding::Array<f64, 3>,
10114                fidl::encoding::DefaultFuchsiaResourceDialect,
10115            >,
10116        T23: fidl::encoding::Encode<
10117                fidl::encoding::Array<
10118                    fidl::encoding::HandleType<
10119                        fidl::NullableHandle,
10120                        { fidl::ObjectType::NONE.into_raw() },
10121                        2147483648,
10122                    >,
10123                    3,
10124                >,
10125                fidl::encoding::DefaultFuchsiaResourceDialect,
10126            >,
10127    > fidl::encoding::Encode<Arrays, fidl::encoding::DefaultFuchsiaResourceDialect>
10128        for (
10129            T0,
10130            T1,
10131            T2,
10132            T3,
10133            T4,
10134            T5,
10135            T6,
10136            T7,
10137            T8,
10138            T9,
10139            T10,
10140            T11,
10141            T12,
10142            T13,
10143            T14,
10144            T15,
10145            T16,
10146            T17,
10147            T18,
10148            T19,
10149            T20,
10150            T21,
10151            T22,
10152            T23,
10153        )
10154    {
10155        #[inline]
10156        unsafe fn encode(
10157            self,
10158            encoder: &mut fidl::encoding::Encoder<
10159                '_,
10160                fidl::encoding::DefaultFuchsiaResourceDialect,
10161            >,
10162            offset: usize,
10163            depth: fidl::encoding::Depth,
10164        ) -> fidl::Result<()> {
10165            encoder.debug_check_bounds::<Arrays>(offset);
10166            // Zero out padding regions. There's no need to apply masks
10167            // because the unmasked parts will be overwritten by fields.
10168            unsafe {
10169                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
10170                (ptr as *mut u64).write_unaligned(0);
10171            }
10172            unsafe {
10173                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
10174                (ptr as *mut u64).write_unaligned(0);
10175            }
10176            unsafe {
10177                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(72);
10178                (ptr as *mut u64).write_unaligned(0);
10179            }
10180            unsafe {
10181                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(104);
10182                (ptr as *mut u64).write_unaligned(0);
10183            }
10184            unsafe {
10185                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(112);
10186                (ptr as *mut u64).write_unaligned(0);
10187            }
10188            unsafe {
10189                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(160);
10190                (ptr as *mut u64).write_unaligned(0);
10191            }
10192            unsafe {
10193                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(200);
10194                (ptr as *mut u64).write_unaligned(0);
10195            }
10196            // Write the fields.
10197            self.0.encode(encoder, offset + 0, depth)?;
10198            self.1.encode(encoder, offset + 1, depth)?;
10199            self.2.encode(encoder, offset + 2, depth)?;
10200            self.3.encode(encoder, offset + 4, depth)?;
10201            self.4.encode(encoder, offset + 8, depth)?;
10202            self.5.encode(encoder, offset + 16, depth)?;
10203            self.6.encode(encoder, offset + 18, depth)?;
10204            self.7.encode(encoder, offset + 20, depth)?;
10205            self.8.encode(encoder, offset + 24, depth)?;
10206            self.9.encode(encoder, offset + 32, depth)?;
10207            self.10.encode(encoder, offset + 40, depth)?;
10208            self.11.encode(encoder, offset + 48, depth)?;
10209            self.12.encode(encoder, offset + 52, depth)?;
10210            self.13.encode(encoder, offset + 55, depth)?;
10211            self.14.encode(encoder, offset + 58, depth)?;
10212            self.15.encode(encoder, offset + 64, depth)?;
10213            self.16.encode(encoder, offset + 80, depth)?;
10214            self.17.encode(encoder, offset + 104, depth)?;
10215            self.18.encode(encoder, offset + 108, depth)?;
10216            self.19.encode(encoder, offset + 116, depth)?;
10217            self.20.encode(encoder, offset + 128, depth)?;
10218            self.21.encode(encoder, offset + 152, depth)?;
10219            self.22.encode(encoder, offset + 168, depth)?;
10220            self.23.encode(encoder, offset + 192, depth)?;
10221            Ok(())
10222        }
10223    }
10224
10225    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Arrays {
10226        #[inline(always)]
10227        fn new_empty() -> Self {
10228            Self {
10229                b_0: fidl::new_empty!(fidl::encoding::Array<bool, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10230                i8_0: fidl::new_empty!(fidl::encoding::Array<i8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10231                i16_0: fidl::new_empty!(fidl::encoding::Array<i16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10232                i32_0: fidl::new_empty!(fidl::encoding::Array<i32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10233                i64_0: fidl::new_empty!(fidl::encoding::Array<i64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10234                u8_0: fidl::new_empty!(fidl::encoding::Array<u8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10235                u16_0: fidl::new_empty!(fidl::encoding::Array<u16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10236                u32_0: fidl::new_empty!(fidl::encoding::Array<u32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10237                u64_0: fidl::new_empty!(fidl::encoding::Array<u64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10238                f32_0: fidl::new_empty!(fidl::encoding::Array<f32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10239                f64_0: fidl::new_empty!(fidl::encoding::Array<f64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10240                handle_0: fidl::new_empty!(
10241                    fidl::encoding::Array<
10242                        fidl::encoding::HandleType<
10243                            fidl::NullableHandle,
10244                            { fidl::ObjectType::NONE.into_raw() },
10245                            2147483648,
10246                        >,
10247                        1,
10248                    >,
10249                    fidl::encoding::DefaultFuchsiaResourceDialect
10250                ),
10251                b_1: fidl::new_empty!(fidl::encoding::Array<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10252                i8_1: fidl::new_empty!(fidl::encoding::Array<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10253                i16_1: fidl::new_empty!(fidl::encoding::Array<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10254                i32_1: fidl::new_empty!(fidl::encoding::Array<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10255                i64_1: fidl::new_empty!(fidl::encoding::Array<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10256                u8_1: fidl::new_empty!(fidl::encoding::Array<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10257                u16_1: fidl::new_empty!(fidl::encoding::Array<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10258                u32_1: fidl::new_empty!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10259                u64_1: fidl::new_empty!(fidl::encoding::Array<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10260                f32_1: fidl::new_empty!(fidl::encoding::Array<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10261                f64_1: fidl::new_empty!(fidl::encoding::Array<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10262                handle_1: fidl::new_empty!(
10263                    fidl::encoding::Array<
10264                        fidl::encoding::HandleType<
10265                            fidl::NullableHandle,
10266                            { fidl::ObjectType::NONE.into_raw() },
10267                            2147483648,
10268                        >,
10269                        3,
10270                    >,
10271                    fidl::encoding::DefaultFuchsiaResourceDialect
10272                ),
10273            }
10274        }
10275
10276        #[inline]
10277        unsafe fn decode(
10278            &mut self,
10279            decoder: &mut fidl::encoding::Decoder<
10280                '_,
10281                fidl::encoding::DefaultFuchsiaResourceDialect,
10282            >,
10283            offset: usize,
10284            _depth: fidl::encoding::Depth,
10285        ) -> fidl::Result<()> {
10286            decoder.debug_check_bounds::<Self>(offset);
10287            // Verify that padding bytes are zero.
10288            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
10289            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10290            let mask = 0xff00u64;
10291            let maskedval = padval & mask;
10292            if maskedval != 0 {
10293                return Err(fidl::Error::NonZeroPadding {
10294                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
10295                });
10296            }
10297            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
10298            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10299            let mask = 0xffffffff00000000u64;
10300            let maskedval = padval & mask;
10301            if maskedval != 0 {
10302                return Err(fidl::Error::NonZeroPadding {
10303                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
10304                });
10305            }
10306            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(72) };
10307            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10308            let mask = 0xffffffff00000000u64;
10309            let maskedval = padval & mask;
10310            if maskedval != 0 {
10311                return Err(fidl::Error::NonZeroPadding {
10312                    padding_start: offset + 72 + ((mask as u64).trailing_zeros() / 8) as usize,
10313                });
10314            }
10315            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(104) };
10316            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10317            let mask = 0xff000000u64;
10318            let maskedval = padval & mask;
10319            if maskedval != 0 {
10320                return Err(fidl::Error::NonZeroPadding {
10321                    padding_start: offset + 104 + ((mask as u64).trailing_zeros() / 8) as usize,
10322                });
10323            }
10324            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(112) };
10325            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10326            let mask = 0xffff0000u64;
10327            let maskedval = padval & mask;
10328            if maskedval != 0 {
10329                return Err(fidl::Error::NonZeroPadding {
10330                    padding_start: offset + 112 + ((mask as u64).trailing_zeros() / 8) as usize,
10331                });
10332            }
10333            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(160) };
10334            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10335            let mask = 0xffffffff00000000u64;
10336            let maskedval = padval & mask;
10337            if maskedval != 0 {
10338                return Err(fidl::Error::NonZeroPadding {
10339                    padding_start: offset + 160 + ((mask as u64).trailing_zeros() / 8) as usize,
10340                });
10341            }
10342            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(200) };
10343            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10344            let mask = 0xffffffff00000000u64;
10345            let maskedval = padval & mask;
10346            if maskedval != 0 {
10347                return Err(fidl::Error::NonZeroPadding {
10348                    padding_start: offset + 200 + ((mask as u64).trailing_zeros() / 8) as usize,
10349                });
10350            }
10351            fidl::decode!(fidl::encoding::Array<bool, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.b_0, decoder, offset + 0, _depth)?;
10352            fidl::decode!(fidl::encoding::Array<i8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i8_0, decoder, offset + 1, _depth)?;
10353            fidl::decode!(fidl::encoding::Array<i16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i16_0, decoder, offset + 2, _depth)?;
10354            fidl::decode!(fidl::encoding::Array<i32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i32_0, decoder, offset + 4, _depth)?;
10355            fidl::decode!(fidl::encoding::Array<i64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i64_0, decoder, offset + 8, _depth)?;
10356            fidl::decode!(fidl::encoding::Array<u8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u8_0, decoder, offset + 16, _depth)?;
10357            fidl::decode!(fidl::encoding::Array<u16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u16_0, decoder, offset + 18, _depth)?;
10358            fidl::decode!(fidl::encoding::Array<u32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u32_0, decoder, offset + 20, _depth)?;
10359            fidl::decode!(fidl::encoding::Array<u64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u64_0, decoder, offset + 24, _depth)?;
10360            fidl::decode!(fidl::encoding::Array<f32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f32_0, decoder, offset + 32, _depth)?;
10361            fidl::decode!(fidl::encoding::Array<f64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f64_0, decoder, offset + 40, _depth)?;
10362            fidl::decode!(
10363                fidl::encoding::Array<
10364                    fidl::encoding::HandleType<
10365                        fidl::NullableHandle,
10366                        { fidl::ObjectType::NONE.into_raw() },
10367                        2147483648,
10368                    >,
10369                    1,
10370                >,
10371                fidl::encoding::DefaultFuchsiaResourceDialect,
10372                &mut self.handle_0,
10373                decoder,
10374                offset + 48,
10375                _depth
10376            )?;
10377            fidl::decode!(fidl::encoding::Array<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.b_1, decoder, offset + 52, _depth)?;
10378            fidl::decode!(fidl::encoding::Array<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i8_1, decoder, offset + 55, _depth)?;
10379            fidl::decode!(fidl::encoding::Array<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i16_1, decoder, offset + 58, _depth)?;
10380            fidl::decode!(fidl::encoding::Array<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i32_1, decoder, offset + 64, _depth)?;
10381            fidl::decode!(fidl::encoding::Array<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i64_1, decoder, offset + 80, _depth)?;
10382            fidl::decode!(fidl::encoding::Array<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u8_1, decoder, offset + 104, _depth)?;
10383            fidl::decode!(fidl::encoding::Array<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u16_1, decoder, offset + 108, _depth)?;
10384            fidl::decode!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u32_1, decoder, offset + 116, _depth)?;
10385            fidl::decode!(fidl::encoding::Array<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u64_1, decoder, offset + 128, _depth)?;
10386            fidl::decode!(fidl::encoding::Array<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f32_1, decoder, offset + 152, _depth)?;
10387            fidl::decode!(fidl::encoding::Array<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f64_1, decoder, offset + 168, _depth)?;
10388            fidl::decode!(
10389                fidl::encoding::Array<
10390                    fidl::encoding::HandleType<
10391                        fidl::NullableHandle,
10392                        { fidl::ObjectType::NONE.into_raw() },
10393                        2147483648,
10394                    >,
10395                    3,
10396                >,
10397                fidl::encoding::DefaultFuchsiaResourceDialect,
10398                &mut self.handle_1,
10399                decoder,
10400                offset + 192,
10401                _depth
10402            )?;
10403            Ok(())
10404        }
10405    }
10406
10407    impl fidl::encoding::ResourceTypeMarker for Arrays2d {
10408        type Borrowed<'a> = &'a mut Self;
10409        fn take_or_borrow<'a>(
10410            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
10411        ) -> Self::Borrowed<'a> {
10412            value
10413        }
10414    }
10415
10416    unsafe impl fidl::encoding::TypeMarker for Arrays2d {
10417        type Owned = Self;
10418
10419        #[inline(always)]
10420        fn inline_align(_context: fidl::encoding::Context) -> usize {
10421            8
10422        }
10423
10424        #[inline(always)]
10425        fn inline_size(_context: fidl::encoding::Context) -> usize {
10426            288
10427        }
10428    }
10429
10430    unsafe impl fidl::encoding::Encode<Arrays2d, fidl::encoding::DefaultFuchsiaResourceDialect>
10431        for &mut Arrays2d
10432    {
10433        #[inline]
10434        unsafe fn encode(
10435            self,
10436            encoder: &mut fidl::encoding::Encoder<
10437                '_,
10438                fidl::encoding::DefaultFuchsiaResourceDialect,
10439            >,
10440            offset: usize,
10441            _depth: fidl::encoding::Depth,
10442        ) -> fidl::Result<()> {
10443            encoder.debug_check_bounds::<Arrays2d>(offset);
10444            // Delegate to tuple encoding.
10445            fidl::encoding::Encode::<Arrays2d, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
10446                (
10447                    <fidl::encoding::Array<fidl::encoding::Array<bool, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.b),
10448                    <fidl::encoding::Array<fidl::encoding::Array<i8, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8),
10449                    <fidl::encoding::Array<fidl::encoding::Array<i16, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16),
10450                    <fidl::encoding::Array<fidl::encoding::Array<i32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32),
10451                    <fidl::encoding::Array<fidl::encoding::Array<i64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64),
10452                    <fidl::encoding::Array<fidl::encoding::Array<u8, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8),
10453                    <fidl::encoding::Array<fidl::encoding::Array<u16, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16),
10454                    <fidl::encoding::Array<fidl::encoding::Array<u32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32),
10455                    <fidl::encoding::Array<fidl::encoding::Array<u64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64),
10456                    <fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32),
10457                    <fidl::encoding::Array<fidl::encoding::Array<f64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64),
10458                    <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),
10459                ),
10460                encoder, offset, _depth
10461            )
10462        }
10463    }
10464    unsafe impl<
10465        T0: fidl::encoding::Encode<
10466                fidl::encoding::Array<fidl::encoding::Array<bool, 2>, 3>,
10467                fidl::encoding::DefaultFuchsiaResourceDialect,
10468            >,
10469        T1: fidl::encoding::Encode<
10470                fidl::encoding::Array<fidl::encoding::Array<i8, 2>, 3>,
10471                fidl::encoding::DefaultFuchsiaResourceDialect,
10472            >,
10473        T2: fidl::encoding::Encode<
10474                fidl::encoding::Array<fidl::encoding::Array<i16, 2>, 3>,
10475                fidl::encoding::DefaultFuchsiaResourceDialect,
10476            >,
10477        T3: fidl::encoding::Encode<
10478                fidl::encoding::Array<fidl::encoding::Array<i32, 2>, 3>,
10479                fidl::encoding::DefaultFuchsiaResourceDialect,
10480            >,
10481        T4: fidl::encoding::Encode<
10482                fidl::encoding::Array<fidl::encoding::Array<i64, 2>, 3>,
10483                fidl::encoding::DefaultFuchsiaResourceDialect,
10484            >,
10485        T5: fidl::encoding::Encode<
10486                fidl::encoding::Array<fidl::encoding::Array<u8, 2>, 3>,
10487                fidl::encoding::DefaultFuchsiaResourceDialect,
10488            >,
10489        T6: fidl::encoding::Encode<
10490                fidl::encoding::Array<fidl::encoding::Array<u16, 2>, 3>,
10491                fidl::encoding::DefaultFuchsiaResourceDialect,
10492            >,
10493        T7: fidl::encoding::Encode<
10494                fidl::encoding::Array<fidl::encoding::Array<u32, 2>, 3>,
10495                fidl::encoding::DefaultFuchsiaResourceDialect,
10496            >,
10497        T8: fidl::encoding::Encode<
10498                fidl::encoding::Array<fidl::encoding::Array<u64, 2>, 3>,
10499                fidl::encoding::DefaultFuchsiaResourceDialect,
10500            >,
10501        T9: fidl::encoding::Encode<
10502                fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 3>,
10503                fidl::encoding::DefaultFuchsiaResourceDialect,
10504            >,
10505        T10: fidl::encoding::Encode<
10506                fidl::encoding::Array<fidl::encoding::Array<f64, 2>, 3>,
10507                fidl::encoding::DefaultFuchsiaResourceDialect,
10508            >,
10509        T11: fidl::encoding::Encode<
10510                fidl::encoding::Array<
10511                    fidl::encoding::Array<
10512                        fidl::encoding::HandleType<
10513                            fidl::NullableHandle,
10514                            { fidl::ObjectType::NONE.into_raw() },
10515                            2147483648,
10516                        >,
10517                        2,
10518                    >,
10519                    3,
10520                >,
10521                fidl::encoding::DefaultFuchsiaResourceDialect,
10522            >,
10523    > fidl::encoding::Encode<Arrays2d, fidl::encoding::DefaultFuchsiaResourceDialect>
10524        for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
10525    {
10526        #[inline]
10527        unsafe fn encode(
10528            self,
10529            encoder: &mut fidl::encoding::Encoder<
10530                '_,
10531                fidl::encoding::DefaultFuchsiaResourceDialect,
10532            >,
10533            offset: usize,
10534            depth: fidl::encoding::Depth,
10535        ) -> fidl::Result<()> {
10536            encoder.debug_check_bounds::<Arrays2d>(offset);
10537            // Zero out padding regions. There's no need to apply masks
10538            // because the unmasked parts will be overwritten by fields.
10539            unsafe {
10540                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(112);
10541                (ptr as *mut u64).write_unaligned(0);
10542            }
10543            unsafe {
10544                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(136);
10545                (ptr as *mut u64).write_unaligned(0);
10546            }
10547            // Write the fields.
10548            self.0.encode(encoder, offset + 0, depth)?;
10549            self.1.encode(encoder, offset + 6, depth)?;
10550            self.2.encode(encoder, offset + 12, depth)?;
10551            self.3.encode(encoder, offset + 24, depth)?;
10552            self.4.encode(encoder, offset + 48, depth)?;
10553            self.5.encode(encoder, offset + 96, depth)?;
10554            self.6.encode(encoder, offset + 102, depth)?;
10555            self.7.encode(encoder, offset + 116, depth)?;
10556            self.8.encode(encoder, offset + 144, depth)?;
10557            self.9.encode(encoder, offset + 192, depth)?;
10558            self.10.encode(encoder, offset + 216, depth)?;
10559            self.11.encode(encoder, offset + 264, depth)?;
10560            Ok(())
10561        }
10562    }
10563
10564    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Arrays2d {
10565        #[inline(always)]
10566        fn new_empty() -> Self {
10567            Self {
10568                b: fidl::new_empty!(
10569                    fidl::encoding::Array<fidl::encoding::Array<bool, 2>, 3>,
10570                    fidl::encoding::DefaultFuchsiaResourceDialect
10571                ),
10572                i8: fidl::new_empty!(
10573                    fidl::encoding::Array<fidl::encoding::Array<i8, 2>, 3>,
10574                    fidl::encoding::DefaultFuchsiaResourceDialect
10575                ),
10576                i16: fidl::new_empty!(
10577                    fidl::encoding::Array<fidl::encoding::Array<i16, 2>, 3>,
10578                    fidl::encoding::DefaultFuchsiaResourceDialect
10579                ),
10580                i32: fidl::new_empty!(
10581                    fidl::encoding::Array<fidl::encoding::Array<i32, 2>, 3>,
10582                    fidl::encoding::DefaultFuchsiaResourceDialect
10583                ),
10584                i64: fidl::new_empty!(
10585                    fidl::encoding::Array<fidl::encoding::Array<i64, 2>, 3>,
10586                    fidl::encoding::DefaultFuchsiaResourceDialect
10587                ),
10588                u8: fidl::new_empty!(
10589                    fidl::encoding::Array<fidl::encoding::Array<u8, 2>, 3>,
10590                    fidl::encoding::DefaultFuchsiaResourceDialect
10591                ),
10592                u16: fidl::new_empty!(
10593                    fidl::encoding::Array<fidl::encoding::Array<u16, 2>, 3>,
10594                    fidl::encoding::DefaultFuchsiaResourceDialect
10595                ),
10596                u32: fidl::new_empty!(
10597                    fidl::encoding::Array<fidl::encoding::Array<u32, 2>, 3>,
10598                    fidl::encoding::DefaultFuchsiaResourceDialect
10599                ),
10600                u64: fidl::new_empty!(
10601                    fidl::encoding::Array<fidl::encoding::Array<u64, 2>, 3>,
10602                    fidl::encoding::DefaultFuchsiaResourceDialect
10603                ),
10604                f32: fidl::new_empty!(
10605                    fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 3>,
10606                    fidl::encoding::DefaultFuchsiaResourceDialect
10607                ),
10608                f64: fidl::new_empty!(
10609                    fidl::encoding::Array<fidl::encoding::Array<f64, 2>, 3>,
10610                    fidl::encoding::DefaultFuchsiaResourceDialect
10611                ),
10612                handle_handle: fidl::new_empty!(
10613                    fidl::encoding::Array<
10614                        fidl::encoding::Array<
10615                            fidl::encoding::HandleType<
10616                                fidl::NullableHandle,
10617                                { fidl::ObjectType::NONE.into_raw() },
10618                                2147483648,
10619                            >,
10620                            2,
10621                        >,
10622                        3,
10623                    >,
10624                    fidl::encoding::DefaultFuchsiaResourceDialect
10625                ),
10626            }
10627        }
10628
10629        #[inline]
10630        unsafe fn decode(
10631            &mut self,
10632            decoder: &mut fidl::encoding::Decoder<
10633                '_,
10634                fidl::encoding::DefaultFuchsiaResourceDialect,
10635            >,
10636            offset: usize,
10637            _depth: fidl::encoding::Depth,
10638        ) -> fidl::Result<()> {
10639            decoder.debug_check_bounds::<Self>(offset);
10640            // Verify that padding bytes are zero.
10641            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(112) };
10642            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10643            let mask = 0xffff0000u64;
10644            let maskedval = padval & mask;
10645            if maskedval != 0 {
10646                return Err(fidl::Error::NonZeroPadding {
10647                    padding_start: offset + 112 + ((mask as u64).trailing_zeros() / 8) as usize,
10648                });
10649            }
10650            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(136) };
10651            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10652            let mask = 0xffffffff00000000u64;
10653            let maskedval = padval & mask;
10654            if maskedval != 0 {
10655                return Err(fidl::Error::NonZeroPadding {
10656                    padding_start: offset + 136 + ((mask as u64).trailing_zeros() / 8) as usize,
10657                });
10658            }
10659            fidl::decode!(
10660                fidl::encoding::Array<fidl::encoding::Array<bool, 2>, 3>,
10661                fidl::encoding::DefaultFuchsiaResourceDialect,
10662                &mut self.b,
10663                decoder,
10664                offset + 0,
10665                _depth
10666            )?;
10667            fidl::decode!(
10668                fidl::encoding::Array<fidl::encoding::Array<i8, 2>, 3>,
10669                fidl::encoding::DefaultFuchsiaResourceDialect,
10670                &mut self.i8,
10671                decoder,
10672                offset + 6,
10673                _depth
10674            )?;
10675            fidl::decode!(
10676                fidl::encoding::Array<fidl::encoding::Array<i16, 2>, 3>,
10677                fidl::encoding::DefaultFuchsiaResourceDialect,
10678                &mut self.i16,
10679                decoder,
10680                offset + 12,
10681                _depth
10682            )?;
10683            fidl::decode!(
10684                fidl::encoding::Array<fidl::encoding::Array<i32, 2>, 3>,
10685                fidl::encoding::DefaultFuchsiaResourceDialect,
10686                &mut self.i32,
10687                decoder,
10688                offset + 24,
10689                _depth
10690            )?;
10691            fidl::decode!(
10692                fidl::encoding::Array<fidl::encoding::Array<i64, 2>, 3>,
10693                fidl::encoding::DefaultFuchsiaResourceDialect,
10694                &mut self.i64,
10695                decoder,
10696                offset + 48,
10697                _depth
10698            )?;
10699            fidl::decode!(
10700                fidl::encoding::Array<fidl::encoding::Array<u8, 2>, 3>,
10701                fidl::encoding::DefaultFuchsiaResourceDialect,
10702                &mut self.u8,
10703                decoder,
10704                offset + 96,
10705                _depth
10706            )?;
10707            fidl::decode!(
10708                fidl::encoding::Array<fidl::encoding::Array<u16, 2>, 3>,
10709                fidl::encoding::DefaultFuchsiaResourceDialect,
10710                &mut self.u16,
10711                decoder,
10712                offset + 102,
10713                _depth
10714            )?;
10715            fidl::decode!(
10716                fidl::encoding::Array<fidl::encoding::Array<u32, 2>, 3>,
10717                fidl::encoding::DefaultFuchsiaResourceDialect,
10718                &mut self.u32,
10719                decoder,
10720                offset + 116,
10721                _depth
10722            )?;
10723            fidl::decode!(
10724                fidl::encoding::Array<fidl::encoding::Array<u64, 2>, 3>,
10725                fidl::encoding::DefaultFuchsiaResourceDialect,
10726                &mut self.u64,
10727                decoder,
10728                offset + 144,
10729                _depth
10730            )?;
10731            fidl::decode!(
10732                fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 3>,
10733                fidl::encoding::DefaultFuchsiaResourceDialect,
10734                &mut self.f32,
10735                decoder,
10736                offset + 192,
10737                _depth
10738            )?;
10739            fidl::decode!(
10740                fidl::encoding::Array<fidl::encoding::Array<f64, 2>, 3>,
10741                fidl::encoding::DefaultFuchsiaResourceDialect,
10742                &mut self.f64,
10743                decoder,
10744                offset + 216,
10745                _depth
10746            )?;
10747            fidl::decode!(
10748                fidl::encoding::Array<
10749                    fidl::encoding::Array<
10750                        fidl::encoding::HandleType<
10751                            fidl::NullableHandle,
10752                            { fidl::ObjectType::NONE.into_raw() },
10753                            2147483648,
10754                        >,
10755                        2,
10756                    >,
10757                    3,
10758                >,
10759                fidl::encoding::DefaultFuchsiaResourceDialect,
10760                &mut self.handle_handle,
10761                decoder,
10762                offset + 264,
10763                _depth
10764            )?;
10765            Ok(())
10766        }
10767    }
10768
10769    impl fidl::encoding::ResourceTypeMarker for Handles {
10770        type Borrowed<'a> = &'a mut Self;
10771        fn take_or_borrow<'a>(
10772            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
10773        ) -> Self::Borrowed<'a> {
10774            value
10775        }
10776    }
10777
10778    unsafe impl fidl::encoding::TypeMarker for Handles {
10779        type Owned = Self;
10780
10781        #[inline(always)]
10782        fn inline_align(_context: fidl::encoding::Context) -> usize {
10783            4
10784        }
10785
10786        #[inline(always)]
10787        fn inline_size(_context: fidl::encoding::Context) -> usize {
10788            108
10789        }
10790    }
10791
10792    unsafe impl fidl::encoding::Encode<Handles, fidl::encoding::DefaultFuchsiaResourceDialect>
10793        for &mut Handles
10794    {
10795        #[inline]
10796        unsafe fn encode(
10797            self,
10798            encoder: &mut fidl::encoding::Encoder<
10799                '_,
10800                fidl::encoding::DefaultFuchsiaResourceDialect,
10801            >,
10802            offset: usize,
10803            _depth: fidl::encoding::Depth,
10804        ) -> fidl::Result<()> {
10805            encoder.debug_check_bounds::<Handles>(offset);
10806            // Delegate to tuple encoding.
10807            fidl::encoding::Encode::<Handles, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
10808                (
10809                    <fidl::encoding::HandleType<
10810                        fidl::NullableHandle,
10811                        { fidl::ObjectType::NONE.into_raw() },
10812                        2147483648,
10813                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10814                        &mut self.handle_handle,
10815                    ),
10816                    <fidl::encoding::HandleType<
10817                        fidl::Process,
10818                        { fidl::ObjectType::PROCESS.into_raw() },
10819                        2147483648,
10820                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10821                        &mut self.process_handle,
10822                    ),
10823                    <fidl::encoding::HandleType<
10824                        fidl::Thread,
10825                        { fidl::ObjectType::THREAD.into_raw() },
10826                        2147483648,
10827                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10828                        &mut self.thread_handle,
10829                    ),
10830                    <fidl::encoding::HandleType<
10831                        fidl::Vmo,
10832                        { fidl::ObjectType::VMO.into_raw() },
10833                        2147483648,
10834                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10835                        &mut self.vmo_handle
10836                    ),
10837                    <fidl::encoding::HandleType<
10838                        fidl::Event,
10839                        { fidl::ObjectType::EVENT.into_raw() },
10840                        2147483648,
10841                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10842                        &mut self.event_handle,
10843                    ),
10844                    <fidl::encoding::HandleType<
10845                        fidl::Port,
10846                        { fidl::ObjectType::PORT.into_raw() },
10847                        2147483648,
10848                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10849                        &mut self.port_handle
10850                    ),
10851                    <fidl::encoding::HandleType<
10852                        fidl::Socket,
10853                        { fidl::ObjectType::SOCKET.into_raw() },
10854                        2147483648,
10855                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10856                        &mut self.socket_handle,
10857                    ),
10858                    <fidl::encoding::HandleType<
10859                        fidl::EventPair,
10860                        { fidl::ObjectType::EVENTPAIR.into_raw() },
10861                        2147483648,
10862                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10863                        &mut self.eventpair_handle,
10864                    ),
10865                    <fidl::encoding::HandleType<
10866                        fidl::Job,
10867                        { fidl::ObjectType::JOB.into_raw() },
10868                        2147483648,
10869                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10870                        &mut self.job_handle
10871                    ),
10872                    <fidl::encoding::HandleType<
10873                        fidl::Vmar,
10874                        { fidl::ObjectType::VMAR.into_raw() },
10875                        2147483648,
10876                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10877                        &mut self.vmar_handle
10878                    ),
10879                    <fidl::encoding::HandleType<
10880                        fidl::Fifo,
10881                        { fidl::ObjectType::FIFO.into_raw() },
10882                        2147483648,
10883                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10884                        &mut self.fifo_handle
10885                    ),
10886                    <fidl::encoding::HandleType<
10887                        fidl::Timer,
10888                        { fidl::ObjectType::TIMER.into_raw() },
10889                        2147483648,
10890                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10891                        &mut self.timer_handle,
10892                    ),
10893                    <fidl::encoding::Optional<
10894                        fidl::encoding::HandleType<
10895                            fidl::NullableHandle,
10896                            { fidl::ObjectType::NONE.into_raw() },
10897                            2147483648,
10898                        >,
10899                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10900                        &mut self.nullable_handle_handle,
10901                    ),
10902                    <fidl::encoding::Optional<
10903                        fidl::encoding::HandleType<
10904                            fidl::Process,
10905                            { fidl::ObjectType::PROCESS.into_raw() },
10906                            2147483648,
10907                        >,
10908                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10909                        &mut self.nullable_process_handle,
10910                    ),
10911                    <fidl::encoding::Optional<
10912                        fidl::encoding::HandleType<
10913                            fidl::Thread,
10914                            { fidl::ObjectType::THREAD.into_raw() },
10915                            2147483648,
10916                        >,
10917                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10918                        &mut self.nullable_thread_handle,
10919                    ),
10920                    <fidl::encoding::Optional<
10921                        fidl::encoding::HandleType<
10922                            fidl::Vmo,
10923                            { fidl::ObjectType::VMO.into_raw() },
10924                            2147483648,
10925                        >,
10926                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10927                        &mut self.nullable_vmo_handle,
10928                    ),
10929                    <fidl::encoding::Optional<
10930                        fidl::encoding::HandleType<
10931                            fidl::Channel,
10932                            { fidl::ObjectType::CHANNEL.into_raw() },
10933                            2147483648,
10934                        >,
10935                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10936                        &mut self.nullable_channel_handle,
10937                    ),
10938                    <fidl::encoding::Optional<
10939                        fidl::encoding::HandleType<
10940                            fidl::Event,
10941                            { fidl::ObjectType::EVENT.into_raw() },
10942                            2147483648,
10943                        >,
10944                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10945                        &mut self.nullable_event_handle,
10946                    ),
10947                    <fidl::encoding::Optional<
10948                        fidl::encoding::HandleType<
10949                            fidl::Port,
10950                            { fidl::ObjectType::PORT.into_raw() },
10951                            2147483648,
10952                        >,
10953                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10954                        &mut self.nullable_port_handle,
10955                    ),
10956                    <fidl::encoding::Optional<
10957                        fidl::encoding::HandleType<
10958                            fidl::Interrupt,
10959                            { fidl::ObjectType::INTERRUPT.into_raw() },
10960                            2147483648,
10961                        >,
10962                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10963                        &mut self.nullable_interrupt_handle,
10964                    ),
10965                    <fidl::encoding::Optional<
10966                        fidl::encoding::HandleType<
10967                            fidl::DebugLog,
10968                            { fidl::ObjectType::DEBUGLOG.into_raw() },
10969                            2147483648,
10970                        >,
10971                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10972                        &mut self.nullable_log_handle,
10973                    ),
10974                    <fidl::encoding::Optional<
10975                        fidl::encoding::HandleType<
10976                            fidl::Socket,
10977                            { fidl::ObjectType::SOCKET.into_raw() },
10978                            2147483648,
10979                        >,
10980                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10981                        &mut self.nullable_socket_handle,
10982                    ),
10983                    <fidl::encoding::Optional<
10984                        fidl::encoding::HandleType<
10985                            fidl::EventPair,
10986                            { fidl::ObjectType::EVENTPAIR.into_raw() },
10987                            2147483648,
10988                        >,
10989                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10990                        &mut self.nullable_eventpair_handle,
10991                    ),
10992                    <fidl::encoding::Optional<
10993                        fidl::encoding::HandleType<
10994                            fidl::Job,
10995                            { fidl::ObjectType::JOB.into_raw() },
10996                            2147483648,
10997                        >,
10998                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10999                        &mut self.nullable_job_handle,
11000                    ),
11001                    <fidl::encoding::Optional<
11002                        fidl::encoding::HandleType<
11003                            fidl::Vmar,
11004                            { fidl::ObjectType::VMAR.into_raw() },
11005                            2147483648,
11006                        >,
11007                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
11008                        &mut self.nullable_vmar_handle,
11009                    ),
11010                    <fidl::encoding::Optional<
11011                        fidl::encoding::HandleType<
11012                            fidl::Fifo,
11013                            { fidl::ObjectType::FIFO.into_raw() },
11014                            2147483648,
11015                        >,
11016                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
11017                        &mut self.nullable_fifo_handle,
11018                    ),
11019                    <fidl::encoding::Optional<
11020                        fidl::encoding::HandleType<
11021                            fidl::Timer,
11022                            { fidl::ObjectType::TIMER.into_raw() },
11023                            2147483648,
11024                        >,
11025                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
11026                        &mut self.nullable_timer_handle,
11027                    ),
11028                ),
11029                encoder,
11030                offset,
11031                _depth,
11032            )
11033        }
11034    }
11035    unsafe impl<
11036        T0: fidl::encoding::Encode<
11037                fidl::encoding::HandleType<
11038                    fidl::NullableHandle,
11039                    { fidl::ObjectType::NONE.into_raw() },
11040                    2147483648,
11041                >,
11042                fidl::encoding::DefaultFuchsiaResourceDialect,
11043            >,
11044        T1: fidl::encoding::Encode<
11045                fidl::encoding::HandleType<
11046                    fidl::Process,
11047                    { fidl::ObjectType::PROCESS.into_raw() },
11048                    2147483648,
11049                >,
11050                fidl::encoding::DefaultFuchsiaResourceDialect,
11051            >,
11052        T2: fidl::encoding::Encode<
11053                fidl::encoding::HandleType<
11054                    fidl::Thread,
11055                    { fidl::ObjectType::THREAD.into_raw() },
11056                    2147483648,
11057                >,
11058                fidl::encoding::DefaultFuchsiaResourceDialect,
11059            >,
11060        T3: fidl::encoding::Encode<
11061                fidl::encoding::HandleType<
11062                    fidl::Vmo,
11063                    { fidl::ObjectType::VMO.into_raw() },
11064                    2147483648,
11065                >,
11066                fidl::encoding::DefaultFuchsiaResourceDialect,
11067            >,
11068        T4: fidl::encoding::Encode<
11069                fidl::encoding::HandleType<
11070                    fidl::Event,
11071                    { fidl::ObjectType::EVENT.into_raw() },
11072                    2147483648,
11073                >,
11074                fidl::encoding::DefaultFuchsiaResourceDialect,
11075            >,
11076        T5: fidl::encoding::Encode<
11077                fidl::encoding::HandleType<
11078                    fidl::Port,
11079                    { fidl::ObjectType::PORT.into_raw() },
11080                    2147483648,
11081                >,
11082                fidl::encoding::DefaultFuchsiaResourceDialect,
11083            >,
11084        T6: fidl::encoding::Encode<
11085                fidl::encoding::HandleType<
11086                    fidl::Socket,
11087                    { fidl::ObjectType::SOCKET.into_raw() },
11088                    2147483648,
11089                >,
11090                fidl::encoding::DefaultFuchsiaResourceDialect,
11091            >,
11092        T7: fidl::encoding::Encode<
11093                fidl::encoding::HandleType<
11094                    fidl::EventPair,
11095                    { fidl::ObjectType::EVENTPAIR.into_raw() },
11096                    2147483648,
11097                >,
11098                fidl::encoding::DefaultFuchsiaResourceDialect,
11099            >,
11100        T8: fidl::encoding::Encode<
11101                fidl::encoding::HandleType<
11102                    fidl::Job,
11103                    { fidl::ObjectType::JOB.into_raw() },
11104                    2147483648,
11105                >,
11106                fidl::encoding::DefaultFuchsiaResourceDialect,
11107            >,
11108        T9: fidl::encoding::Encode<
11109                fidl::encoding::HandleType<
11110                    fidl::Vmar,
11111                    { fidl::ObjectType::VMAR.into_raw() },
11112                    2147483648,
11113                >,
11114                fidl::encoding::DefaultFuchsiaResourceDialect,
11115            >,
11116        T10: fidl::encoding::Encode<
11117                fidl::encoding::HandleType<
11118                    fidl::Fifo,
11119                    { fidl::ObjectType::FIFO.into_raw() },
11120                    2147483648,
11121                >,
11122                fidl::encoding::DefaultFuchsiaResourceDialect,
11123            >,
11124        T11: fidl::encoding::Encode<
11125                fidl::encoding::HandleType<
11126                    fidl::Timer,
11127                    { fidl::ObjectType::TIMER.into_raw() },
11128                    2147483648,
11129                >,
11130                fidl::encoding::DefaultFuchsiaResourceDialect,
11131            >,
11132        T12: fidl::encoding::Encode<
11133                fidl::encoding::Optional<
11134                    fidl::encoding::HandleType<
11135                        fidl::NullableHandle,
11136                        { fidl::ObjectType::NONE.into_raw() },
11137                        2147483648,
11138                    >,
11139                >,
11140                fidl::encoding::DefaultFuchsiaResourceDialect,
11141            >,
11142        T13: fidl::encoding::Encode<
11143                fidl::encoding::Optional<
11144                    fidl::encoding::HandleType<
11145                        fidl::Process,
11146                        { fidl::ObjectType::PROCESS.into_raw() },
11147                        2147483648,
11148                    >,
11149                >,
11150                fidl::encoding::DefaultFuchsiaResourceDialect,
11151            >,
11152        T14: fidl::encoding::Encode<
11153                fidl::encoding::Optional<
11154                    fidl::encoding::HandleType<
11155                        fidl::Thread,
11156                        { fidl::ObjectType::THREAD.into_raw() },
11157                        2147483648,
11158                    >,
11159                >,
11160                fidl::encoding::DefaultFuchsiaResourceDialect,
11161            >,
11162        T15: fidl::encoding::Encode<
11163                fidl::encoding::Optional<
11164                    fidl::encoding::HandleType<
11165                        fidl::Vmo,
11166                        { fidl::ObjectType::VMO.into_raw() },
11167                        2147483648,
11168                    >,
11169                >,
11170                fidl::encoding::DefaultFuchsiaResourceDialect,
11171            >,
11172        T16: fidl::encoding::Encode<
11173                fidl::encoding::Optional<
11174                    fidl::encoding::HandleType<
11175                        fidl::Channel,
11176                        { fidl::ObjectType::CHANNEL.into_raw() },
11177                        2147483648,
11178                    >,
11179                >,
11180                fidl::encoding::DefaultFuchsiaResourceDialect,
11181            >,
11182        T17: fidl::encoding::Encode<
11183                fidl::encoding::Optional<
11184                    fidl::encoding::HandleType<
11185                        fidl::Event,
11186                        { fidl::ObjectType::EVENT.into_raw() },
11187                        2147483648,
11188                    >,
11189                >,
11190                fidl::encoding::DefaultFuchsiaResourceDialect,
11191            >,
11192        T18: fidl::encoding::Encode<
11193                fidl::encoding::Optional<
11194                    fidl::encoding::HandleType<
11195                        fidl::Port,
11196                        { fidl::ObjectType::PORT.into_raw() },
11197                        2147483648,
11198                    >,
11199                >,
11200                fidl::encoding::DefaultFuchsiaResourceDialect,
11201            >,
11202        T19: fidl::encoding::Encode<
11203                fidl::encoding::Optional<
11204                    fidl::encoding::HandleType<
11205                        fidl::Interrupt,
11206                        { fidl::ObjectType::INTERRUPT.into_raw() },
11207                        2147483648,
11208                    >,
11209                >,
11210                fidl::encoding::DefaultFuchsiaResourceDialect,
11211            >,
11212        T20: fidl::encoding::Encode<
11213                fidl::encoding::Optional<
11214                    fidl::encoding::HandleType<
11215                        fidl::DebugLog,
11216                        { fidl::ObjectType::DEBUGLOG.into_raw() },
11217                        2147483648,
11218                    >,
11219                >,
11220                fidl::encoding::DefaultFuchsiaResourceDialect,
11221            >,
11222        T21: fidl::encoding::Encode<
11223                fidl::encoding::Optional<
11224                    fidl::encoding::HandleType<
11225                        fidl::Socket,
11226                        { fidl::ObjectType::SOCKET.into_raw() },
11227                        2147483648,
11228                    >,
11229                >,
11230                fidl::encoding::DefaultFuchsiaResourceDialect,
11231            >,
11232        T22: fidl::encoding::Encode<
11233                fidl::encoding::Optional<
11234                    fidl::encoding::HandleType<
11235                        fidl::EventPair,
11236                        { fidl::ObjectType::EVENTPAIR.into_raw() },
11237                        2147483648,
11238                    >,
11239                >,
11240                fidl::encoding::DefaultFuchsiaResourceDialect,
11241            >,
11242        T23: fidl::encoding::Encode<
11243                fidl::encoding::Optional<
11244                    fidl::encoding::HandleType<
11245                        fidl::Job,
11246                        { fidl::ObjectType::JOB.into_raw() },
11247                        2147483648,
11248                    >,
11249                >,
11250                fidl::encoding::DefaultFuchsiaResourceDialect,
11251            >,
11252        T24: fidl::encoding::Encode<
11253                fidl::encoding::Optional<
11254                    fidl::encoding::HandleType<
11255                        fidl::Vmar,
11256                        { fidl::ObjectType::VMAR.into_raw() },
11257                        2147483648,
11258                    >,
11259                >,
11260                fidl::encoding::DefaultFuchsiaResourceDialect,
11261            >,
11262        T25: fidl::encoding::Encode<
11263                fidl::encoding::Optional<
11264                    fidl::encoding::HandleType<
11265                        fidl::Fifo,
11266                        { fidl::ObjectType::FIFO.into_raw() },
11267                        2147483648,
11268                    >,
11269                >,
11270                fidl::encoding::DefaultFuchsiaResourceDialect,
11271            >,
11272        T26: fidl::encoding::Encode<
11273                fidl::encoding::Optional<
11274                    fidl::encoding::HandleType<
11275                        fidl::Timer,
11276                        { fidl::ObjectType::TIMER.into_raw() },
11277                        2147483648,
11278                    >,
11279                >,
11280                fidl::encoding::DefaultFuchsiaResourceDialect,
11281            >,
11282    > fidl::encoding::Encode<Handles, fidl::encoding::DefaultFuchsiaResourceDialect>
11283        for (
11284            T0,
11285            T1,
11286            T2,
11287            T3,
11288            T4,
11289            T5,
11290            T6,
11291            T7,
11292            T8,
11293            T9,
11294            T10,
11295            T11,
11296            T12,
11297            T13,
11298            T14,
11299            T15,
11300            T16,
11301            T17,
11302            T18,
11303            T19,
11304            T20,
11305            T21,
11306            T22,
11307            T23,
11308            T24,
11309            T25,
11310            T26,
11311        )
11312    {
11313        #[inline]
11314        unsafe fn encode(
11315            self,
11316            encoder: &mut fidl::encoding::Encoder<
11317                '_,
11318                fidl::encoding::DefaultFuchsiaResourceDialect,
11319            >,
11320            offset: usize,
11321            depth: fidl::encoding::Depth,
11322        ) -> fidl::Result<()> {
11323            encoder.debug_check_bounds::<Handles>(offset);
11324            // Zero out padding regions. There's no need to apply masks
11325            // because the unmasked parts will be overwritten by fields.
11326            // Write the fields.
11327            self.0.encode(encoder, offset + 0, depth)?;
11328            self.1.encode(encoder, offset + 4, depth)?;
11329            self.2.encode(encoder, offset + 8, depth)?;
11330            self.3.encode(encoder, offset + 12, depth)?;
11331            self.4.encode(encoder, offset + 16, depth)?;
11332            self.5.encode(encoder, offset + 20, depth)?;
11333            self.6.encode(encoder, offset + 24, depth)?;
11334            self.7.encode(encoder, offset + 28, depth)?;
11335            self.8.encode(encoder, offset + 32, depth)?;
11336            self.9.encode(encoder, offset + 36, depth)?;
11337            self.10.encode(encoder, offset + 40, depth)?;
11338            self.11.encode(encoder, offset + 44, depth)?;
11339            self.12.encode(encoder, offset + 48, depth)?;
11340            self.13.encode(encoder, offset + 52, depth)?;
11341            self.14.encode(encoder, offset + 56, depth)?;
11342            self.15.encode(encoder, offset + 60, depth)?;
11343            self.16.encode(encoder, offset + 64, depth)?;
11344            self.17.encode(encoder, offset + 68, depth)?;
11345            self.18.encode(encoder, offset + 72, depth)?;
11346            self.19.encode(encoder, offset + 76, depth)?;
11347            self.20.encode(encoder, offset + 80, depth)?;
11348            self.21.encode(encoder, offset + 84, depth)?;
11349            self.22.encode(encoder, offset + 88, depth)?;
11350            self.23.encode(encoder, offset + 92, depth)?;
11351            self.24.encode(encoder, offset + 96, depth)?;
11352            self.25.encode(encoder, offset + 100, depth)?;
11353            self.26.encode(encoder, offset + 104, depth)?;
11354            Ok(())
11355        }
11356    }
11357
11358    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Handles {
11359        #[inline(always)]
11360        fn new_empty() -> Self {
11361            Self {
11362                handle_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11363                process_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Process, { fidl::ObjectType::PROCESS.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11364                thread_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Thread, { fidl::ObjectType::THREAD.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11365                vmo_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11366                event_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11367                port_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Port, { fidl::ObjectType::PORT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11368                socket_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11369                eventpair_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11370                job_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Job, { fidl::ObjectType::JOB.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11371                vmar_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmar, { fidl::ObjectType::VMAR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11372                fifo_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Fifo, { fidl::ObjectType::FIFO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11373                timer_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Timer, { fidl::ObjectType::TIMER.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11374                nullable_handle_handle: fidl::new_empty!(
11375                    fidl::encoding::Optional<
11376                        fidl::encoding::HandleType<
11377                            fidl::NullableHandle,
11378                            { fidl::ObjectType::NONE.into_raw() },
11379                            2147483648,
11380                        >,
11381                    >,
11382                    fidl::encoding::DefaultFuchsiaResourceDialect
11383                ),
11384                nullable_process_handle: fidl::new_empty!(
11385                    fidl::encoding::Optional<
11386                        fidl::encoding::HandleType<
11387                            fidl::Process,
11388                            { fidl::ObjectType::PROCESS.into_raw() },
11389                            2147483648,
11390                        >,
11391                    >,
11392                    fidl::encoding::DefaultFuchsiaResourceDialect
11393                ),
11394                nullable_thread_handle: fidl::new_empty!(
11395                    fidl::encoding::Optional<
11396                        fidl::encoding::HandleType<
11397                            fidl::Thread,
11398                            { fidl::ObjectType::THREAD.into_raw() },
11399                            2147483648,
11400                        >,
11401                    >,
11402                    fidl::encoding::DefaultFuchsiaResourceDialect
11403                ),
11404                nullable_vmo_handle: fidl::new_empty!(
11405                    fidl::encoding::Optional<
11406                        fidl::encoding::HandleType<
11407                            fidl::Vmo,
11408                            { fidl::ObjectType::VMO.into_raw() },
11409                            2147483648,
11410                        >,
11411                    >,
11412                    fidl::encoding::DefaultFuchsiaResourceDialect
11413                ),
11414                nullable_channel_handle: fidl::new_empty!(
11415                    fidl::encoding::Optional<
11416                        fidl::encoding::HandleType<
11417                            fidl::Channel,
11418                            { fidl::ObjectType::CHANNEL.into_raw() },
11419                            2147483648,
11420                        >,
11421                    >,
11422                    fidl::encoding::DefaultFuchsiaResourceDialect
11423                ),
11424                nullable_event_handle: fidl::new_empty!(
11425                    fidl::encoding::Optional<
11426                        fidl::encoding::HandleType<
11427                            fidl::Event,
11428                            { fidl::ObjectType::EVENT.into_raw() },
11429                            2147483648,
11430                        >,
11431                    >,
11432                    fidl::encoding::DefaultFuchsiaResourceDialect
11433                ),
11434                nullable_port_handle: fidl::new_empty!(
11435                    fidl::encoding::Optional<
11436                        fidl::encoding::HandleType<
11437                            fidl::Port,
11438                            { fidl::ObjectType::PORT.into_raw() },
11439                            2147483648,
11440                        >,
11441                    >,
11442                    fidl::encoding::DefaultFuchsiaResourceDialect
11443                ),
11444                nullable_interrupt_handle: fidl::new_empty!(
11445                    fidl::encoding::Optional<
11446                        fidl::encoding::HandleType<
11447                            fidl::Interrupt,
11448                            { fidl::ObjectType::INTERRUPT.into_raw() },
11449                            2147483648,
11450                        >,
11451                    >,
11452                    fidl::encoding::DefaultFuchsiaResourceDialect
11453                ),
11454                nullable_log_handle: fidl::new_empty!(
11455                    fidl::encoding::Optional<
11456                        fidl::encoding::HandleType<
11457                            fidl::DebugLog,
11458                            { fidl::ObjectType::DEBUGLOG.into_raw() },
11459                            2147483648,
11460                        >,
11461                    >,
11462                    fidl::encoding::DefaultFuchsiaResourceDialect
11463                ),
11464                nullable_socket_handle: fidl::new_empty!(
11465                    fidl::encoding::Optional<
11466                        fidl::encoding::HandleType<
11467                            fidl::Socket,
11468                            { fidl::ObjectType::SOCKET.into_raw() },
11469                            2147483648,
11470                        >,
11471                    >,
11472                    fidl::encoding::DefaultFuchsiaResourceDialect
11473                ),
11474                nullable_eventpair_handle: fidl::new_empty!(
11475                    fidl::encoding::Optional<
11476                        fidl::encoding::HandleType<
11477                            fidl::EventPair,
11478                            { fidl::ObjectType::EVENTPAIR.into_raw() },
11479                            2147483648,
11480                        >,
11481                    >,
11482                    fidl::encoding::DefaultFuchsiaResourceDialect
11483                ),
11484                nullable_job_handle: fidl::new_empty!(
11485                    fidl::encoding::Optional<
11486                        fidl::encoding::HandleType<
11487                            fidl::Job,
11488                            { fidl::ObjectType::JOB.into_raw() },
11489                            2147483648,
11490                        >,
11491                    >,
11492                    fidl::encoding::DefaultFuchsiaResourceDialect
11493                ),
11494                nullable_vmar_handle: fidl::new_empty!(
11495                    fidl::encoding::Optional<
11496                        fidl::encoding::HandleType<
11497                            fidl::Vmar,
11498                            { fidl::ObjectType::VMAR.into_raw() },
11499                            2147483648,
11500                        >,
11501                    >,
11502                    fidl::encoding::DefaultFuchsiaResourceDialect
11503                ),
11504                nullable_fifo_handle: fidl::new_empty!(
11505                    fidl::encoding::Optional<
11506                        fidl::encoding::HandleType<
11507                            fidl::Fifo,
11508                            { fidl::ObjectType::FIFO.into_raw() },
11509                            2147483648,
11510                        >,
11511                    >,
11512                    fidl::encoding::DefaultFuchsiaResourceDialect
11513                ),
11514                nullable_timer_handle: fidl::new_empty!(
11515                    fidl::encoding::Optional<
11516                        fidl::encoding::HandleType<
11517                            fidl::Timer,
11518                            { fidl::ObjectType::TIMER.into_raw() },
11519                            2147483648,
11520                        >,
11521                    >,
11522                    fidl::encoding::DefaultFuchsiaResourceDialect
11523                ),
11524            }
11525        }
11526
11527        #[inline]
11528        unsafe fn decode(
11529            &mut self,
11530            decoder: &mut fidl::encoding::Decoder<
11531                '_,
11532                fidl::encoding::DefaultFuchsiaResourceDialect,
11533            >,
11534            offset: usize,
11535            _depth: fidl::encoding::Depth,
11536        ) -> fidl::Result<()> {
11537            decoder.debug_check_bounds::<Self>(offset);
11538            // Verify that padding bytes are zero.
11539            fidl::decode!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.handle_handle, decoder, offset + 0, _depth)?;
11540            fidl::decode!(fidl::encoding::HandleType<fidl::Process, { fidl::ObjectType::PROCESS.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.process_handle, decoder, offset + 4, _depth)?;
11541            fidl::decode!(fidl::encoding::HandleType<fidl::Thread, { fidl::ObjectType::THREAD.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.thread_handle, decoder, offset + 8, _depth)?;
11542            fidl::decode!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.vmo_handle, decoder, offset + 12, _depth)?;
11543            fidl::decode!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.event_handle, decoder, offset + 16, _depth)?;
11544            fidl::decode!(fidl::encoding::HandleType<fidl::Port, { fidl::ObjectType::PORT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.port_handle, decoder, offset + 20, _depth)?;
11545            fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.socket_handle, decoder, offset + 24, _depth)?;
11546            fidl::decode!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.eventpair_handle, decoder, offset + 28, _depth)?;
11547            fidl::decode!(fidl::encoding::HandleType<fidl::Job, { fidl::ObjectType::JOB.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.job_handle, decoder, offset + 32, _depth)?;
11548            fidl::decode!(fidl::encoding::HandleType<fidl::Vmar, { fidl::ObjectType::VMAR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.vmar_handle, decoder, offset + 36, _depth)?;
11549            fidl::decode!(fidl::encoding::HandleType<fidl::Fifo, { fidl::ObjectType::FIFO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.fifo_handle, decoder, offset + 40, _depth)?;
11550            fidl::decode!(fidl::encoding::HandleType<fidl::Timer, { fidl::ObjectType::TIMER.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.timer_handle, decoder, offset + 44, _depth)?;
11551            fidl::decode!(
11552                fidl::encoding::Optional<
11553                    fidl::encoding::HandleType<
11554                        fidl::NullableHandle,
11555                        { fidl::ObjectType::NONE.into_raw() },
11556                        2147483648,
11557                    >,
11558                >,
11559                fidl::encoding::DefaultFuchsiaResourceDialect,
11560                &mut self.nullable_handle_handle,
11561                decoder,
11562                offset + 48,
11563                _depth
11564            )?;
11565            fidl::decode!(
11566                fidl::encoding::Optional<
11567                    fidl::encoding::HandleType<
11568                        fidl::Process,
11569                        { fidl::ObjectType::PROCESS.into_raw() },
11570                        2147483648,
11571                    >,
11572                >,
11573                fidl::encoding::DefaultFuchsiaResourceDialect,
11574                &mut self.nullable_process_handle,
11575                decoder,
11576                offset + 52,
11577                _depth
11578            )?;
11579            fidl::decode!(
11580                fidl::encoding::Optional<
11581                    fidl::encoding::HandleType<
11582                        fidl::Thread,
11583                        { fidl::ObjectType::THREAD.into_raw() },
11584                        2147483648,
11585                    >,
11586                >,
11587                fidl::encoding::DefaultFuchsiaResourceDialect,
11588                &mut self.nullable_thread_handle,
11589                decoder,
11590                offset + 56,
11591                _depth
11592            )?;
11593            fidl::decode!(
11594                fidl::encoding::Optional<
11595                    fidl::encoding::HandleType<
11596                        fidl::Vmo,
11597                        { fidl::ObjectType::VMO.into_raw() },
11598                        2147483648,
11599                    >,
11600                >,
11601                fidl::encoding::DefaultFuchsiaResourceDialect,
11602                &mut self.nullable_vmo_handle,
11603                decoder,
11604                offset + 60,
11605                _depth
11606            )?;
11607            fidl::decode!(
11608                fidl::encoding::Optional<
11609                    fidl::encoding::HandleType<
11610                        fidl::Channel,
11611                        { fidl::ObjectType::CHANNEL.into_raw() },
11612                        2147483648,
11613                    >,
11614                >,
11615                fidl::encoding::DefaultFuchsiaResourceDialect,
11616                &mut self.nullable_channel_handle,
11617                decoder,
11618                offset + 64,
11619                _depth
11620            )?;
11621            fidl::decode!(
11622                fidl::encoding::Optional<
11623                    fidl::encoding::HandleType<
11624                        fidl::Event,
11625                        { fidl::ObjectType::EVENT.into_raw() },
11626                        2147483648,
11627                    >,
11628                >,
11629                fidl::encoding::DefaultFuchsiaResourceDialect,
11630                &mut self.nullable_event_handle,
11631                decoder,
11632                offset + 68,
11633                _depth
11634            )?;
11635            fidl::decode!(
11636                fidl::encoding::Optional<
11637                    fidl::encoding::HandleType<
11638                        fidl::Port,
11639                        { fidl::ObjectType::PORT.into_raw() },
11640                        2147483648,
11641                    >,
11642                >,
11643                fidl::encoding::DefaultFuchsiaResourceDialect,
11644                &mut self.nullable_port_handle,
11645                decoder,
11646                offset + 72,
11647                _depth
11648            )?;
11649            fidl::decode!(
11650                fidl::encoding::Optional<
11651                    fidl::encoding::HandleType<
11652                        fidl::Interrupt,
11653                        { fidl::ObjectType::INTERRUPT.into_raw() },
11654                        2147483648,
11655                    >,
11656                >,
11657                fidl::encoding::DefaultFuchsiaResourceDialect,
11658                &mut self.nullable_interrupt_handle,
11659                decoder,
11660                offset + 76,
11661                _depth
11662            )?;
11663            fidl::decode!(
11664                fidl::encoding::Optional<
11665                    fidl::encoding::HandleType<
11666                        fidl::DebugLog,
11667                        { fidl::ObjectType::DEBUGLOG.into_raw() },
11668                        2147483648,
11669                    >,
11670                >,
11671                fidl::encoding::DefaultFuchsiaResourceDialect,
11672                &mut self.nullable_log_handle,
11673                decoder,
11674                offset + 80,
11675                _depth
11676            )?;
11677            fidl::decode!(
11678                fidl::encoding::Optional<
11679                    fidl::encoding::HandleType<
11680                        fidl::Socket,
11681                        { fidl::ObjectType::SOCKET.into_raw() },
11682                        2147483648,
11683                    >,
11684                >,
11685                fidl::encoding::DefaultFuchsiaResourceDialect,
11686                &mut self.nullable_socket_handle,
11687                decoder,
11688                offset + 84,
11689                _depth
11690            )?;
11691            fidl::decode!(
11692                fidl::encoding::Optional<
11693                    fidl::encoding::HandleType<
11694                        fidl::EventPair,
11695                        { fidl::ObjectType::EVENTPAIR.into_raw() },
11696                        2147483648,
11697                    >,
11698                >,
11699                fidl::encoding::DefaultFuchsiaResourceDialect,
11700                &mut self.nullable_eventpair_handle,
11701                decoder,
11702                offset + 88,
11703                _depth
11704            )?;
11705            fidl::decode!(
11706                fidl::encoding::Optional<
11707                    fidl::encoding::HandleType<
11708                        fidl::Job,
11709                        { fidl::ObjectType::JOB.into_raw() },
11710                        2147483648,
11711                    >,
11712                >,
11713                fidl::encoding::DefaultFuchsiaResourceDialect,
11714                &mut self.nullable_job_handle,
11715                decoder,
11716                offset + 92,
11717                _depth
11718            )?;
11719            fidl::decode!(
11720                fidl::encoding::Optional<
11721                    fidl::encoding::HandleType<
11722                        fidl::Vmar,
11723                        { fidl::ObjectType::VMAR.into_raw() },
11724                        2147483648,
11725                    >,
11726                >,
11727                fidl::encoding::DefaultFuchsiaResourceDialect,
11728                &mut self.nullable_vmar_handle,
11729                decoder,
11730                offset + 96,
11731                _depth
11732            )?;
11733            fidl::decode!(
11734                fidl::encoding::Optional<
11735                    fidl::encoding::HandleType<
11736                        fidl::Fifo,
11737                        { fidl::ObjectType::FIFO.into_raw() },
11738                        2147483648,
11739                    >,
11740                >,
11741                fidl::encoding::DefaultFuchsiaResourceDialect,
11742                &mut self.nullable_fifo_handle,
11743                decoder,
11744                offset + 100,
11745                _depth
11746            )?;
11747            fidl::decode!(
11748                fidl::encoding::Optional<
11749                    fidl::encoding::HandleType<
11750                        fidl::Timer,
11751                        { fidl::ObjectType::TIMER.into_raw() },
11752                        2147483648,
11753                    >,
11754                >,
11755                fidl::encoding::DefaultFuchsiaResourceDialect,
11756                &mut self.nullable_timer_handle,
11757                decoder,
11758                offset + 104,
11759                _depth
11760            )?;
11761            Ok(())
11762        }
11763    }
11764
11765    impl fidl::encoding::ResourceTypeMarker for Vectors {
11766        type Borrowed<'a> = &'a mut Self;
11767        fn take_or_borrow<'a>(
11768            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
11769        ) -> Self::Borrowed<'a> {
11770            value
11771        }
11772    }
11773
11774    unsafe impl fidl::encoding::TypeMarker for Vectors {
11775        type Owned = Self;
11776
11777        #[inline(always)]
11778        fn inline_align(_context: fidl::encoding::Context) -> usize {
11779            8
11780        }
11781
11782        #[inline(always)]
11783        fn inline_size(_context: fidl::encoding::Context) -> usize {
11784            1920
11785        }
11786    }
11787
11788    unsafe impl fidl::encoding::Encode<Vectors, fidl::encoding::DefaultFuchsiaResourceDialect>
11789        for &mut Vectors
11790    {
11791        #[inline]
11792        unsafe fn encode(
11793            self,
11794            encoder: &mut fidl::encoding::Encoder<
11795                '_,
11796                fidl::encoding::DefaultFuchsiaResourceDialect,
11797            >,
11798            offset: usize,
11799            _depth: fidl::encoding::Depth,
11800        ) -> fidl::Result<()> {
11801            encoder.debug_check_bounds::<Vectors>(offset);
11802            // Delegate to tuple encoding.
11803            fidl::encoding::Encode::<Vectors, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
11804                (
11805                    <fidl::encoding::UnboundedVector<bool> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_0),
11806                    <fidl::encoding::UnboundedVector<i8> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_0),
11807                    <fidl::encoding::UnboundedVector<i16> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_0),
11808                    <fidl::encoding::UnboundedVector<i32> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_0),
11809                    <fidl::encoding::UnboundedVector<i64> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_0),
11810                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_0),
11811                    <fidl::encoding::UnboundedVector<u16> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_0),
11812                    <fidl::encoding::UnboundedVector<u32> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_0),
11813                    <fidl::encoding::UnboundedVector<u64> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_0),
11814                    <fidl::encoding::UnboundedVector<f32> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_0),
11815                    <fidl::encoding::UnboundedVector<f64> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_0),
11816                    <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),
11817                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_1),
11818                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_1),
11819                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_1),
11820                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_1),
11821                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_1),
11822                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_1),
11823                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_1),
11824                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_1),
11825                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_1),
11826                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_1),
11827                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_1),
11828                    <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),
11829                    <fidl::encoding::Vector<bool, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_sized_0),
11830                    <fidl::encoding::Vector<i8, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_sized_0),
11831                    <fidl::encoding::Vector<i16, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_sized_0),
11832                    <fidl::encoding::Vector<i32, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_sized_0),
11833                    <fidl::encoding::Vector<i64, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_sized_0),
11834                    <fidl::encoding::Vector<u8, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_sized_0),
11835                    <fidl::encoding::Vector<u16, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_sized_0),
11836                    <fidl::encoding::Vector<u32, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_sized_0),
11837                    <fidl::encoding::Vector<u64, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_sized_0),
11838                    <fidl::encoding::Vector<f32, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_sized_0),
11839                    <fidl::encoding::Vector<f64, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_sized_0),
11840                    <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),
11841                    <fidl::encoding::Vector<bool, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_sized_1),
11842                    <fidl::encoding::Vector<i8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_sized_1),
11843                    <fidl::encoding::Vector<i16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_sized_1),
11844                    <fidl::encoding::Vector<i32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_sized_1),
11845                    <fidl::encoding::Vector<i64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_sized_1),
11846                    <fidl::encoding::Vector<u8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_sized_1),
11847                    <fidl::encoding::Vector<u16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_sized_1),
11848                    <fidl::encoding::Vector<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_sized_1),
11849                    <fidl::encoding::Vector<u64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_sized_1),
11850                    <fidl::encoding::Vector<f32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_sized_1),
11851                    <fidl::encoding::Vector<f64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_sized_1),
11852                    <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),
11853                    <fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_sized_2),
11854                    <fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_sized_2),
11855                    <fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_sized_2),
11856                    <fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_sized_2),
11857                    <fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_sized_2),
11858                    <fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_sized_2),
11859                    <fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_sized_2),
11860                    <fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_sized_2),
11861                    <fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_sized_2),
11862                    <fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_sized_2),
11863                    <fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_sized_2),
11864                    <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),
11865                    <fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_nullable_0),
11866                    <fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_nullable_0),
11867                    <fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_nullable_0),
11868                    <fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_nullable_0),
11869                    <fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_nullable_0),
11870                    <fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_nullable_0),
11871                    <fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_nullable_0),
11872                    <fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_nullable_0),
11873                    <fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_nullable_0),
11874                    <fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_nullable_0),
11875                    <fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_nullable_0),
11876                    <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),
11877                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_nullable_1),
11878                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_nullable_1),
11879                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_nullable_1),
11880                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_nullable_1),
11881                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_nullable_1),
11882                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_nullable_1),
11883                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_nullable_1),
11884                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_nullable_1),
11885                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_nullable_1),
11886                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_nullable_1),
11887                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_nullable_1),
11888                    <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),
11889                    <fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_nullable_sized_0),
11890                    <fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_nullable_sized_0),
11891                    <fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_nullable_sized_0),
11892                    <fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_nullable_sized_0),
11893                    <fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_nullable_sized_0),
11894                    <fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_nullable_sized_0),
11895                    <fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_nullable_sized_0),
11896                    <fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_nullable_sized_0),
11897                    <fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_nullable_sized_0),
11898                    <fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_nullable_sized_0),
11899                    <fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_nullable_sized_0),
11900                    <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),
11901                    <fidl::encoding::Optional<fidl::encoding::Vector<bool, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_nullable_sized_1),
11902                    <fidl::encoding::Optional<fidl::encoding::Vector<i8, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_nullable_sized_1),
11903                    <fidl::encoding::Optional<fidl::encoding::Vector<i16, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_nullable_sized_1),
11904                    <fidl::encoding::Optional<fidl::encoding::Vector<i32, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_nullable_sized_1),
11905                    <fidl::encoding::Optional<fidl::encoding::Vector<i64, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_nullable_sized_1),
11906                    <fidl::encoding::Optional<fidl::encoding::Vector<u8, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_nullable_sized_1),
11907                    <fidl::encoding::Optional<fidl::encoding::Vector<u16, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_nullable_sized_1),
11908                    <fidl::encoding::Optional<fidl::encoding::Vector<u32, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_nullable_sized_1),
11909                    <fidl::encoding::Optional<fidl::encoding::Vector<u64, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_nullable_sized_1),
11910                    <fidl::encoding::Optional<fidl::encoding::Vector<f32, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_nullable_sized_1),
11911                    <fidl::encoding::Optional<fidl::encoding::Vector<f64, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_nullable_sized_1),
11912                    <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),
11913                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_nullable_sized_2),
11914                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_nullable_sized_2),
11915                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_nullable_sized_2),
11916                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_nullable_sized_2),
11917                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_nullable_sized_2),
11918                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_nullable_sized_2),
11919                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_nullable_sized_2),
11920                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_nullable_sized_2),
11921                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_nullable_sized_2),
11922                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_nullable_sized_2),
11923                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_nullable_sized_2),
11924                    <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),
11925                ),
11926                encoder, offset, _depth
11927            )
11928        }
11929    }
11930    unsafe impl<
11931        T0: fidl::encoding::Encode<
11932                fidl::encoding::UnboundedVector<bool>,
11933                fidl::encoding::DefaultFuchsiaResourceDialect,
11934            >,
11935        T1: fidl::encoding::Encode<
11936                fidl::encoding::UnboundedVector<i8>,
11937                fidl::encoding::DefaultFuchsiaResourceDialect,
11938            >,
11939        T2: fidl::encoding::Encode<
11940                fidl::encoding::UnboundedVector<i16>,
11941                fidl::encoding::DefaultFuchsiaResourceDialect,
11942            >,
11943        T3: fidl::encoding::Encode<
11944                fidl::encoding::UnboundedVector<i32>,
11945                fidl::encoding::DefaultFuchsiaResourceDialect,
11946            >,
11947        T4: fidl::encoding::Encode<
11948                fidl::encoding::UnboundedVector<i64>,
11949                fidl::encoding::DefaultFuchsiaResourceDialect,
11950            >,
11951        T5: fidl::encoding::Encode<
11952                fidl::encoding::UnboundedVector<u8>,
11953                fidl::encoding::DefaultFuchsiaResourceDialect,
11954            >,
11955        T6: fidl::encoding::Encode<
11956                fidl::encoding::UnboundedVector<u16>,
11957                fidl::encoding::DefaultFuchsiaResourceDialect,
11958            >,
11959        T7: fidl::encoding::Encode<
11960                fidl::encoding::UnboundedVector<u32>,
11961                fidl::encoding::DefaultFuchsiaResourceDialect,
11962            >,
11963        T8: fidl::encoding::Encode<
11964                fidl::encoding::UnboundedVector<u64>,
11965                fidl::encoding::DefaultFuchsiaResourceDialect,
11966            >,
11967        T9: fidl::encoding::Encode<
11968                fidl::encoding::UnboundedVector<f32>,
11969                fidl::encoding::DefaultFuchsiaResourceDialect,
11970            >,
11971        T10: fidl::encoding::Encode<
11972                fidl::encoding::UnboundedVector<f64>,
11973                fidl::encoding::DefaultFuchsiaResourceDialect,
11974            >,
11975        T11: fidl::encoding::Encode<
11976                fidl::encoding::UnboundedVector<
11977                    fidl::encoding::HandleType<
11978                        fidl::NullableHandle,
11979                        { fidl::ObjectType::NONE.into_raw() },
11980                        2147483648,
11981                    >,
11982                >,
11983                fidl::encoding::DefaultFuchsiaResourceDialect,
11984            >,
11985        T12: fidl::encoding::Encode<
11986                fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
11987                fidl::encoding::DefaultFuchsiaResourceDialect,
11988            >,
11989        T13: fidl::encoding::Encode<
11990                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
11991                fidl::encoding::DefaultFuchsiaResourceDialect,
11992            >,
11993        T14: fidl::encoding::Encode<
11994                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
11995                fidl::encoding::DefaultFuchsiaResourceDialect,
11996            >,
11997        T15: fidl::encoding::Encode<
11998                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
11999                fidl::encoding::DefaultFuchsiaResourceDialect,
12000            >,
12001        T16: fidl::encoding::Encode<
12002                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
12003                fidl::encoding::DefaultFuchsiaResourceDialect,
12004            >,
12005        T17: fidl::encoding::Encode<
12006                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
12007                fidl::encoding::DefaultFuchsiaResourceDialect,
12008            >,
12009        T18: fidl::encoding::Encode<
12010                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
12011                fidl::encoding::DefaultFuchsiaResourceDialect,
12012            >,
12013        T19: fidl::encoding::Encode<
12014                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
12015                fidl::encoding::DefaultFuchsiaResourceDialect,
12016            >,
12017        T20: fidl::encoding::Encode<
12018                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
12019                fidl::encoding::DefaultFuchsiaResourceDialect,
12020            >,
12021        T21: fidl::encoding::Encode<
12022                fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
12023                fidl::encoding::DefaultFuchsiaResourceDialect,
12024            >,
12025        T22: fidl::encoding::Encode<
12026                fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
12027                fidl::encoding::DefaultFuchsiaResourceDialect,
12028            >,
12029        T23: fidl::encoding::Encode<
12030                fidl::encoding::UnboundedVector<
12031                    fidl::encoding::Vector<
12032                        fidl::encoding::HandleType<
12033                            fidl::NullableHandle,
12034                            { fidl::ObjectType::NONE.into_raw() },
12035                            2147483648,
12036                        >,
12037                        2,
12038                    >,
12039                >,
12040                fidl::encoding::DefaultFuchsiaResourceDialect,
12041            >,
12042        T24: fidl::encoding::Encode<
12043                fidl::encoding::Vector<bool, 1>,
12044                fidl::encoding::DefaultFuchsiaResourceDialect,
12045            >,
12046        T25: fidl::encoding::Encode<
12047                fidl::encoding::Vector<i8, 1>,
12048                fidl::encoding::DefaultFuchsiaResourceDialect,
12049            >,
12050        T26: fidl::encoding::Encode<
12051                fidl::encoding::Vector<i16, 1>,
12052                fidl::encoding::DefaultFuchsiaResourceDialect,
12053            >,
12054        T27: fidl::encoding::Encode<
12055                fidl::encoding::Vector<i32, 1>,
12056                fidl::encoding::DefaultFuchsiaResourceDialect,
12057            >,
12058        T28: fidl::encoding::Encode<
12059                fidl::encoding::Vector<i64, 1>,
12060                fidl::encoding::DefaultFuchsiaResourceDialect,
12061            >,
12062        T29: fidl::encoding::Encode<
12063                fidl::encoding::Vector<u8, 1>,
12064                fidl::encoding::DefaultFuchsiaResourceDialect,
12065            >,
12066        T30: fidl::encoding::Encode<
12067                fidl::encoding::Vector<u16, 1>,
12068                fidl::encoding::DefaultFuchsiaResourceDialect,
12069            >,
12070        T31: fidl::encoding::Encode<
12071                fidl::encoding::Vector<u32, 1>,
12072                fidl::encoding::DefaultFuchsiaResourceDialect,
12073            >,
12074        T32: fidl::encoding::Encode<
12075                fidl::encoding::Vector<u64, 1>,
12076                fidl::encoding::DefaultFuchsiaResourceDialect,
12077            >,
12078        T33: fidl::encoding::Encode<
12079                fidl::encoding::Vector<f32, 1>,
12080                fidl::encoding::DefaultFuchsiaResourceDialect,
12081            >,
12082        T34: fidl::encoding::Encode<
12083                fidl::encoding::Vector<f64, 1>,
12084                fidl::encoding::DefaultFuchsiaResourceDialect,
12085            >,
12086        T35: fidl::encoding::Encode<
12087                fidl::encoding::Vector<
12088                    fidl::encoding::HandleType<
12089                        fidl::NullableHandle,
12090                        { fidl::ObjectType::NONE.into_raw() },
12091                        2147483648,
12092                    >,
12093                    1,
12094                >,
12095                fidl::encoding::DefaultFuchsiaResourceDialect,
12096            >,
12097        T36: fidl::encoding::Encode<
12098                fidl::encoding::Vector<bool, 3>,
12099                fidl::encoding::DefaultFuchsiaResourceDialect,
12100            >,
12101        T37: fidl::encoding::Encode<
12102                fidl::encoding::Vector<i8, 3>,
12103                fidl::encoding::DefaultFuchsiaResourceDialect,
12104            >,
12105        T38: fidl::encoding::Encode<
12106                fidl::encoding::Vector<i16, 3>,
12107                fidl::encoding::DefaultFuchsiaResourceDialect,
12108            >,
12109        T39: fidl::encoding::Encode<
12110                fidl::encoding::Vector<i32, 3>,
12111                fidl::encoding::DefaultFuchsiaResourceDialect,
12112            >,
12113        T40: fidl::encoding::Encode<
12114                fidl::encoding::Vector<i64, 3>,
12115                fidl::encoding::DefaultFuchsiaResourceDialect,
12116            >,
12117        T41: fidl::encoding::Encode<
12118                fidl::encoding::Vector<u8, 3>,
12119                fidl::encoding::DefaultFuchsiaResourceDialect,
12120            >,
12121        T42: fidl::encoding::Encode<
12122                fidl::encoding::Vector<u16, 3>,
12123                fidl::encoding::DefaultFuchsiaResourceDialect,
12124            >,
12125        T43: fidl::encoding::Encode<
12126                fidl::encoding::Vector<u32, 3>,
12127                fidl::encoding::DefaultFuchsiaResourceDialect,
12128            >,
12129        T44: fidl::encoding::Encode<
12130                fidl::encoding::Vector<u64, 3>,
12131                fidl::encoding::DefaultFuchsiaResourceDialect,
12132            >,
12133        T45: fidl::encoding::Encode<
12134                fidl::encoding::Vector<f32, 3>,
12135                fidl::encoding::DefaultFuchsiaResourceDialect,
12136            >,
12137        T46: fidl::encoding::Encode<
12138                fidl::encoding::Vector<f64, 3>,
12139                fidl::encoding::DefaultFuchsiaResourceDialect,
12140            >,
12141        T47: fidl::encoding::Encode<
12142                fidl::encoding::Vector<
12143                    fidl::encoding::HandleType<
12144                        fidl::NullableHandle,
12145                        { fidl::ObjectType::NONE.into_raw() },
12146                        2147483648,
12147                    >,
12148                    3,
12149                >,
12150                fidl::encoding::DefaultFuchsiaResourceDialect,
12151            >,
12152        T48: fidl::encoding::Encode<
12153                fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
12154                fidl::encoding::DefaultFuchsiaResourceDialect,
12155            >,
12156        T49: fidl::encoding::Encode<
12157                fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>,
12158                fidl::encoding::DefaultFuchsiaResourceDialect,
12159            >,
12160        T50: fidl::encoding::Encode<
12161                fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>,
12162                fidl::encoding::DefaultFuchsiaResourceDialect,
12163            >,
12164        T51: fidl::encoding::Encode<
12165                fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>,
12166                fidl::encoding::DefaultFuchsiaResourceDialect,
12167            >,
12168        T52: fidl::encoding::Encode<
12169                fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>,
12170                fidl::encoding::DefaultFuchsiaResourceDialect,
12171            >,
12172        T53: fidl::encoding::Encode<
12173                fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>,
12174                fidl::encoding::DefaultFuchsiaResourceDialect,
12175            >,
12176        T54: fidl::encoding::Encode<
12177                fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>,
12178                fidl::encoding::DefaultFuchsiaResourceDialect,
12179            >,
12180        T55: fidl::encoding::Encode<
12181                fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>,
12182                fidl::encoding::DefaultFuchsiaResourceDialect,
12183            >,
12184        T56: fidl::encoding::Encode<
12185                fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>,
12186                fidl::encoding::DefaultFuchsiaResourceDialect,
12187            >,
12188        T57: fidl::encoding::Encode<
12189                fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>,
12190                fidl::encoding::DefaultFuchsiaResourceDialect,
12191            >,
12192        T58: fidl::encoding::Encode<
12193                fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>,
12194                fidl::encoding::DefaultFuchsiaResourceDialect,
12195            >,
12196        T59: fidl::encoding::Encode<
12197                fidl::encoding::Vector<
12198                    fidl::encoding::Vector<
12199                        fidl::encoding::HandleType<
12200                            fidl::NullableHandle,
12201                            { fidl::ObjectType::NONE.into_raw() },
12202                            2147483648,
12203                        >,
12204                        2,
12205                    >,
12206                    3,
12207                >,
12208                fidl::encoding::DefaultFuchsiaResourceDialect,
12209            >,
12210        T60: fidl::encoding::Encode<
12211                fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
12212                fidl::encoding::DefaultFuchsiaResourceDialect,
12213            >,
12214        T61: fidl::encoding::Encode<
12215                fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
12216                fidl::encoding::DefaultFuchsiaResourceDialect,
12217            >,
12218        T62: fidl::encoding::Encode<
12219                fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
12220                fidl::encoding::DefaultFuchsiaResourceDialect,
12221            >,
12222        T63: fidl::encoding::Encode<
12223                fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
12224                fidl::encoding::DefaultFuchsiaResourceDialect,
12225            >,
12226        T64: fidl::encoding::Encode<
12227                fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
12228                fidl::encoding::DefaultFuchsiaResourceDialect,
12229            >,
12230        T65: fidl::encoding::Encode<
12231                fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
12232                fidl::encoding::DefaultFuchsiaResourceDialect,
12233            >,
12234        T66: fidl::encoding::Encode<
12235                fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
12236                fidl::encoding::DefaultFuchsiaResourceDialect,
12237            >,
12238        T67: fidl::encoding::Encode<
12239                fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
12240                fidl::encoding::DefaultFuchsiaResourceDialect,
12241            >,
12242        T68: fidl::encoding::Encode<
12243                fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
12244                fidl::encoding::DefaultFuchsiaResourceDialect,
12245            >,
12246        T69: fidl::encoding::Encode<
12247                fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
12248                fidl::encoding::DefaultFuchsiaResourceDialect,
12249            >,
12250        T70: fidl::encoding::Encode<
12251                fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
12252                fidl::encoding::DefaultFuchsiaResourceDialect,
12253            >,
12254        T71: fidl::encoding::Encode<
12255                fidl::encoding::Optional<
12256                    fidl::encoding::Vector<
12257                        fidl::encoding::HandleType<
12258                            fidl::NullableHandle,
12259                            { fidl::ObjectType::NONE.into_raw() },
12260                            2147483648,
12261                        >,
12262                        1,
12263                    >,
12264                >,
12265                fidl::encoding::DefaultFuchsiaResourceDialect,
12266            >,
12267        T72: fidl::encoding::Encode<
12268                fidl::encoding::Optional<
12269                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
12270                >,
12271                fidl::encoding::DefaultFuchsiaResourceDialect,
12272            >,
12273        T73: fidl::encoding::Encode<
12274                fidl::encoding::Optional<
12275                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
12276                >,
12277                fidl::encoding::DefaultFuchsiaResourceDialect,
12278            >,
12279        T74: fidl::encoding::Encode<
12280                fidl::encoding::Optional<
12281                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
12282                >,
12283                fidl::encoding::DefaultFuchsiaResourceDialect,
12284            >,
12285        T75: fidl::encoding::Encode<
12286                fidl::encoding::Optional<
12287                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
12288                >,
12289                fidl::encoding::DefaultFuchsiaResourceDialect,
12290            >,
12291        T76: fidl::encoding::Encode<
12292                fidl::encoding::Optional<
12293                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
12294                >,
12295                fidl::encoding::DefaultFuchsiaResourceDialect,
12296            >,
12297        T77: fidl::encoding::Encode<
12298                fidl::encoding::Optional<
12299                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
12300                >,
12301                fidl::encoding::DefaultFuchsiaResourceDialect,
12302            >,
12303        T78: fidl::encoding::Encode<
12304                fidl::encoding::Optional<
12305                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
12306                >,
12307                fidl::encoding::DefaultFuchsiaResourceDialect,
12308            >,
12309        T79: fidl::encoding::Encode<
12310                fidl::encoding::Optional<
12311                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
12312                >,
12313                fidl::encoding::DefaultFuchsiaResourceDialect,
12314            >,
12315        T80: fidl::encoding::Encode<
12316                fidl::encoding::Optional<
12317                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
12318                >,
12319                fidl::encoding::DefaultFuchsiaResourceDialect,
12320            >,
12321        T81: fidl::encoding::Encode<
12322                fidl::encoding::Optional<
12323                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
12324                >,
12325                fidl::encoding::DefaultFuchsiaResourceDialect,
12326            >,
12327        T82: fidl::encoding::Encode<
12328                fidl::encoding::Optional<
12329                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
12330                >,
12331                fidl::encoding::DefaultFuchsiaResourceDialect,
12332            >,
12333        T83: fidl::encoding::Encode<
12334                fidl::encoding::Optional<
12335                    fidl::encoding::UnboundedVector<
12336                        fidl::encoding::Vector<
12337                            fidl::encoding::HandleType<
12338                                fidl::NullableHandle,
12339                                { fidl::ObjectType::NONE.into_raw() },
12340                                2147483648,
12341                            >,
12342                            2,
12343                        >,
12344                    >,
12345                >,
12346                fidl::encoding::DefaultFuchsiaResourceDialect,
12347            >,
12348        T84: fidl::encoding::Encode<
12349                fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
12350                fidl::encoding::DefaultFuchsiaResourceDialect,
12351            >,
12352        T85: fidl::encoding::Encode<
12353                fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
12354                fidl::encoding::DefaultFuchsiaResourceDialect,
12355            >,
12356        T86: fidl::encoding::Encode<
12357                fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
12358                fidl::encoding::DefaultFuchsiaResourceDialect,
12359            >,
12360        T87: fidl::encoding::Encode<
12361                fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
12362                fidl::encoding::DefaultFuchsiaResourceDialect,
12363            >,
12364        T88: fidl::encoding::Encode<
12365                fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
12366                fidl::encoding::DefaultFuchsiaResourceDialect,
12367            >,
12368        T89: fidl::encoding::Encode<
12369                fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
12370                fidl::encoding::DefaultFuchsiaResourceDialect,
12371            >,
12372        T90: fidl::encoding::Encode<
12373                fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
12374                fidl::encoding::DefaultFuchsiaResourceDialect,
12375            >,
12376        T91: fidl::encoding::Encode<
12377                fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
12378                fidl::encoding::DefaultFuchsiaResourceDialect,
12379            >,
12380        T92: fidl::encoding::Encode<
12381                fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
12382                fidl::encoding::DefaultFuchsiaResourceDialect,
12383            >,
12384        T93: fidl::encoding::Encode<
12385                fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
12386                fidl::encoding::DefaultFuchsiaResourceDialect,
12387            >,
12388        T94: fidl::encoding::Encode<
12389                fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
12390                fidl::encoding::DefaultFuchsiaResourceDialect,
12391            >,
12392        T95: fidl::encoding::Encode<
12393                fidl::encoding::Optional<
12394                    fidl::encoding::Vector<
12395                        fidl::encoding::HandleType<
12396                            fidl::NullableHandle,
12397                            { fidl::ObjectType::NONE.into_raw() },
12398                            2147483648,
12399                        >,
12400                        1,
12401                    >,
12402                >,
12403                fidl::encoding::DefaultFuchsiaResourceDialect,
12404            >,
12405        T96: fidl::encoding::Encode<
12406                fidl::encoding::Optional<fidl::encoding::Vector<bool, 3>>,
12407                fidl::encoding::DefaultFuchsiaResourceDialect,
12408            >,
12409        T97: fidl::encoding::Encode<
12410                fidl::encoding::Optional<fidl::encoding::Vector<i8, 3>>,
12411                fidl::encoding::DefaultFuchsiaResourceDialect,
12412            >,
12413        T98: fidl::encoding::Encode<
12414                fidl::encoding::Optional<fidl::encoding::Vector<i16, 3>>,
12415                fidl::encoding::DefaultFuchsiaResourceDialect,
12416            >,
12417        T99: fidl::encoding::Encode<
12418                fidl::encoding::Optional<fidl::encoding::Vector<i32, 3>>,
12419                fidl::encoding::DefaultFuchsiaResourceDialect,
12420            >,
12421        T100: fidl::encoding::Encode<
12422                fidl::encoding::Optional<fidl::encoding::Vector<i64, 3>>,
12423                fidl::encoding::DefaultFuchsiaResourceDialect,
12424            >,
12425        T101: fidl::encoding::Encode<
12426                fidl::encoding::Optional<fidl::encoding::Vector<u8, 3>>,
12427                fidl::encoding::DefaultFuchsiaResourceDialect,
12428            >,
12429        T102: fidl::encoding::Encode<
12430                fidl::encoding::Optional<fidl::encoding::Vector<u16, 3>>,
12431                fidl::encoding::DefaultFuchsiaResourceDialect,
12432            >,
12433        T103: fidl::encoding::Encode<
12434                fidl::encoding::Optional<fidl::encoding::Vector<u32, 3>>,
12435                fidl::encoding::DefaultFuchsiaResourceDialect,
12436            >,
12437        T104: fidl::encoding::Encode<
12438                fidl::encoding::Optional<fidl::encoding::Vector<u64, 3>>,
12439                fidl::encoding::DefaultFuchsiaResourceDialect,
12440            >,
12441        T105: fidl::encoding::Encode<
12442                fidl::encoding::Optional<fidl::encoding::Vector<f32, 3>>,
12443                fidl::encoding::DefaultFuchsiaResourceDialect,
12444            >,
12445        T106: fidl::encoding::Encode<
12446                fidl::encoding::Optional<fidl::encoding::Vector<f64, 3>>,
12447                fidl::encoding::DefaultFuchsiaResourceDialect,
12448            >,
12449        T107: fidl::encoding::Encode<
12450                fidl::encoding::Optional<
12451                    fidl::encoding::Vector<
12452                        fidl::encoding::HandleType<
12453                            fidl::NullableHandle,
12454                            { fidl::ObjectType::NONE.into_raw() },
12455                            2147483648,
12456                        >,
12457                        3,
12458                    >,
12459                >,
12460                fidl::encoding::DefaultFuchsiaResourceDialect,
12461            >,
12462        T108: fidl::encoding::Encode<
12463                fidl::encoding::Optional<
12464                    fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
12465                >,
12466                fidl::encoding::DefaultFuchsiaResourceDialect,
12467            >,
12468        T109: fidl::encoding::Encode<
12469                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>>,
12470                fidl::encoding::DefaultFuchsiaResourceDialect,
12471            >,
12472        T110: fidl::encoding::Encode<
12473                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>>,
12474                fidl::encoding::DefaultFuchsiaResourceDialect,
12475            >,
12476        T111: fidl::encoding::Encode<
12477                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>>,
12478                fidl::encoding::DefaultFuchsiaResourceDialect,
12479            >,
12480        T112: fidl::encoding::Encode<
12481                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>>,
12482                fidl::encoding::DefaultFuchsiaResourceDialect,
12483            >,
12484        T113: fidl::encoding::Encode<
12485                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>>,
12486                fidl::encoding::DefaultFuchsiaResourceDialect,
12487            >,
12488        T114: fidl::encoding::Encode<
12489                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>>,
12490                fidl::encoding::DefaultFuchsiaResourceDialect,
12491            >,
12492        T115: fidl::encoding::Encode<
12493                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>>,
12494                fidl::encoding::DefaultFuchsiaResourceDialect,
12495            >,
12496        T116: fidl::encoding::Encode<
12497                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>>,
12498                fidl::encoding::DefaultFuchsiaResourceDialect,
12499            >,
12500        T117: fidl::encoding::Encode<
12501                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>>,
12502                fidl::encoding::DefaultFuchsiaResourceDialect,
12503            >,
12504        T118: fidl::encoding::Encode<
12505                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>>,
12506                fidl::encoding::DefaultFuchsiaResourceDialect,
12507            >,
12508        T119: fidl::encoding::Encode<
12509                fidl::encoding::Optional<
12510                    fidl::encoding::Vector<
12511                        fidl::encoding::Vector<
12512                            fidl::encoding::HandleType<
12513                                fidl::NullableHandle,
12514                                { fidl::ObjectType::NONE.into_raw() },
12515                                2147483648,
12516                            >,
12517                            2,
12518                        >,
12519                        3,
12520                    >,
12521                >,
12522                fidl::encoding::DefaultFuchsiaResourceDialect,
12523            >,
12524    > fidl::encoding::Encode<Vectors, fidl::encoding::DefaultFuchsiaResourceDialect>
12525        for (
12526            T0,
12527            T1,
12528            T2,
12529            T3,
12530            T4,
12531            T5,
12532            T6,
12533            T7,
12534            T8,
12535            T9,
12536            T10,
12537            T11,
12538            T12,
12539            T13,
12540            T14,
12541            T15,
12542            T16,
12543            T17,
12544            T18,
12545            T19,
12546            T20,
12547            T21,
12548            T22,
12549            T23,
12550            T24,
12551            T25,
12552            T26,
12553            T27,
12554            T28,
12555            T29,
12556            T30,
12557            T31,
12558            T32,
12559            T33,
12560            T34,
12561            T35,
12562            T36,
12563            T37,
12564            T38,
12565            T39,
12566            T40,
12567            T41,
12568            T42,
12569            T43,
12570            T44,
12571            T45,
12572            T46,
12573            T47,
12574            T48,
12575            T49,
12576            T50,
12577            T51,
12578            T52,
12579            T53,
12580            T54,
12581            T55,
12582            T56,
12583            T57,
12584            T58,
12585            T59,
12586            T60,
12587            T61,
12588            T62,
12589            T63,
12590            T64,
12591            T65,
12592            T66,
12593            T67,
12594            T68,
12595            T69,
12596            T70,
12597            T71,
12598            T72,
12599            T73,
12600            T74,
12601            T75,
12602            T76,
12603            T77,
12604            T78,
12605            T79,
12606            T80,
12607            T81,
12608            T82,
12609            T83,
12610            T84,
12611            T85,
12612            T86,
12613            T87,
12614            T88,
12615            T89,
12616            T90,
12617            T91,
12618            T92,
12619            T93,
12620            T94,
12621            T95,
12622            T96,
12623            T97,
12624            T98,
12625            T99,
12626            T100,
12627            T101,
12628            T102,
12629            T103,
12630            T104,
12631            T105,
12632            T106,
12633            T107,
12634            T108,
12635            T109,
12636            T110,
12637            T111,
12638            T112,
12639            T113,
12640            T114,
12641            T115,
12642            T116,
12643            T117,
12644            T118,
12645            T119,
12646        )
12647    {
12648        #[inline]
12649        unsafe fn encode(
12650            self,
12651            encoder: &mut fidl::encoding::Encoder<
12652                '_,
12653                fidl::encoding::DefaultFuchsiaResourceDialect,
12654            >,
12655            offset: usize,
12656            depth: fidl::encoding::Depth,
12657        ) -> fidl::Result<()> {
12658            encoder.debug_check_bounds::<Vectors>(offset);
12659            // Zero out padding regions. There's no need to apply masks
12660            // because the unmasked parts will be overwritten by fields.
12661            // Write the fields.
12662            self.0.encode(encoder, offset + 0, depth)?;
12663            self.1.encode(encoder, offset + 16, depth)?;
12664            self.2.encode(encoder, offset + 32, depth)?;
12665            self.3.encode(encoder, offset + 48, depth)?;
12666            self.4.encode(encoder, offset + 64, depth)?;
12667            self.5.encode(encoder, offset + 80, depth)?;
12668            self.6.encode(encoder, offset + 96, depth)?;
12669            self.7.encode(encoder, offset + 112, depth)?;
12670            self.8.encode(encoder, offset + 128, depth)?;
12671            self.9.encode(encoder, offset + 144, depth)?;
12672            self.10.encode(encoder, offset + 160, depth)?;
12673            self.11.encode(encoder, offset + 176, depth)?;
12674            self.12.encode(encoder, offset + 192, depth)?;
12675            self.13.encode(encoder, offset + 208, depth)?;
12676            self.14.encode(encoder, offset + 224, depth)?;
12677            self.15.encode(encoder, offset + 240, depth)?;
12678            self.16.encode(encoder, offset + 256, depth)?;
12679            self.17.encode(encoder, offset + 272, depth)?;
12680            self.18.encode(encoder, offset + 288, depth)?;
12681            self.19.encode(encoder, offset + 304, depth)?;
12682            self.20.encode(encoder, offset + 320, depth)?;
12683            self.21.encode(encoder, offset + 336, depth)?;
12684            self.22.encode(encoder, offset + 352, depth)?;
12685            self.23.encode(encoder, offset + 368, depth)?;
12686            self.24.encode(encoder, offset + 384, depth)?;
12687            self.25.encode(encoder, offset + 400, depth)?;
12688            self.26.encode(encoder, offset + 416, depth)?;
12689            self.27.encode(encoder, offset + 432, depth)?;
12690            self.28.encode(encoder, offset + 448, depth)?;
12691            self.29.encode(encoder, offset + 464, depth)?;
12692            self.30.encode(encoder, offset + 480, depth)?;
12693            self.31.encode(encoder, offset + 496, depth)?;
12694            self.32.encode(encoder, offset + 512, depth)?;
12695            self.33.encode(encoder, offset + 528, depth)?;
12696            self.34.encode(encoder, offset + 544, depth)?;
12697            self.35.encode(encoder, offset + 560, depth)?;
12698            self.36.encode(encoder, offset + 576, depth)?;
12699            self.37.encode(encoder, offset + 592, depth)?;
12700            self.38.encode(encoder, offset + 608, depth)?;
12701            self.39.encode(encoder, offset + 624, depth)?;
12702            self.40.encode(encoder, offset + 640, depth)?;
12703            self.41.encode(encoder, offset + 656, depth)?;
12704            self.42.encode(encoder, offset + 672, depth)?;
12705            self.43.encode(encoder, offset + 688, depth)?;
12706            self.44.encode(encoder, offset + 704, depth)?;
12707            self.45.encode(encoder, offset + 720, depth)?;
12708            self.46.encode(encoder, offset + 736, depth)?;
12709            self.47.encode(encoder, offset + 752, depth)?;
12710            self.48.encode(encoder, offset + 768, depth)?;
12711            self.49.encode(encoder, offset + 784, depth)?;
12712            self.50.encode(encoder, offset + 800, depth)?;
12713            self.51.encode(encoder, offset + 816, depth)?;
12714            self.52.encode(encoder, offset + 832, depth)?;
12715            self.53.encode(encoder, offset + 848, depth)?;
12716            self.54.encode(encoder, offset + 864, depth)?;
12717            self.55.encode(encoder, offset + 880, depth)?;
12718            self.56.encode(encoder, offset + 896, depth)?;
12719            self.57.encode(encoder, offset + 912, depth)?;
12720            self.58.encode(encoder, offset + 928, depth)?;
12721            self.59.encode(encoder, offset + 944, depth)?;
12722            self.60.encode(encoder, offset + 960, depth)?;
12723            self.61.encode(encoder, offset + 976, depth)?;
12724            self.62.encode(encoder, offset + 992, depth)?;
12725            self.63.encode(encoder, offset + 1008, depth)?;
12726            self.64.encode(encoder, offset + 1024, depth)?;
12727            self.65.encode(encoder, offset + 1040, depth)?;
12728            self.66.encode(encoder, offset + 1056, depth)?;
12729            self.67.encode(encoder, offset + 1072, depth)?;
12730            self.68.encode(encoder, offset + 1088, depth)?;
12731            self.69.encode(encoder, offset + 1104, depth)?;
12732            self.70.encode(encoder, offset + 1120, depth)?;
12733            self.71.encode(encoder, offset + 1136, depth)?;
12734            self.72.encode(encoder, offset + 1152, depth)?;
12735            self.73.encode(encoder, offset + 1168, depth)?;
12736            self.74.encode(encoder, offset + 1184, depth)?;
12737            self.75.encode(encoder, offset + 1200, depth)?;
12738            self.76.encode(encoder, offset + 1216, depth)?;
12739            self.77.encode(encoder, offset + 1232, depth)?;
12740            self.78.encode(encoder, offset + 1248, depth)?;
12741            self.79.encode(encoder, offset + 1264, depth)?;
12742            self.80.encode(encoder, offset + 1280, depth)?;
12743            self.81.encode(encoder, offset + 1296, depth)?;
12744            self.82.encode(encoder, offset + 1312, depth)?;
12745            self.83.encode(encoder, offset + 1328, depth)?;
12746            self.84.encode(encoder, offset + 1344, depth)?;
12747            self.85.encode(encoder, offset + 1360, depth)?;
12748            self.86.encode(encoder, offset + 1376, depth)?;
12749            self.87.encode(encoder, offset + 1392, depth)?;
12750            self.88.encode(encoder, offset + 1408, depth)?;
12751            self.89.encode(encoder, offset + 1424, depth)?;
12752            self.90.encode(encoder, offset + 1440, depth)?;
12753            self.91.encode(encoder, offset + 1456, depth)?;
12754            self.92.encode(encoder, offset + 1472, depth)?;
12755            self.93.encode(encoder, offset + 1488, depth)?;
12756            self.94.encode(encoder, offset + 1504, depth)?;
12757            self.95.encode(encoder, offset + 1520, depth)?;
12758            self.96.encode(encoder, offset + 1536, depth)?;
12759            self.97.encode(encoder, offset + 1552, depth)?;
12760            self.98.encode(encoder, offset + 1568, depth)?;
12761            self.99.encode(encoder, offset + 1584, depth)?;
12762            self.100.encode(encoder, offset + 1600, depth)?;
12763            self.101.encode(encoder, offset + 1616, depth)?;
12764            self.102.encode(encoder, offset + 1632, depth)?;
12765            self.103.encode(encoder, offset + 1648, depth)?;
12766            self.104.encode(encoder, offset + 1664, depth)?;
12767            self.105.encode(encoder, offset + 1680, depth)?;
12768            self.106.encode(encoder, offset + 1696, depth)?;
12769            self.107.encode(encoder, offset + 1712, depth)?;
12770            self.108.encode(encoder, offset + 1728, depth)?;
12771            self.109.encode(encoder, offset + 1744, depth)?;
12772            self.110.encode(encoder, offset + 1760, depth)?;
12773            self.111.encode(encoder, offset + 1776, depth)?;
12774            self.112.encode(encoder, offset + 1792, depth)?;
12775            self.113.encode(encoder, offset + 1808, depth)?;
12776            self.114.encode(encoder, offset + 1824, depth)?;
12777            self.115.encode(encoder, offset + 1840, depth)?;
12778            self.116.encode(encoder, offset + 1856, depth)?;
12779            self.117.encode(encoder, offset + 1872, depth)?;
12780            self.118.encode(encoder, offset + 1888, depth)?;
12781            self.119.encode(encoder, offset + 1904, depth)?;
12782            Ok(())
12783        }
12784    }
12785
12786    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Vectors {
12787        #[inline(always)]
12788        fn new_empty() -> Self {
12789            Self {
12790                b_0: fidl::new_empty!(
12791                    fidl::encoding::UnboundedVector<bool>,
12792                    fidl::encoding::DefaultFuchsiaResourceDialect
12793                ),
12794                i8_0: fidl::new_empty!(
12795                    fidl::encoding::UnboundedVector<i8>,
12796                    fidl::encoding::DefaultFuchsiaResourceDialect
12797                ),
12798                i16_0: fidl::new_empty!(
12799                    fidl::encoding::UnboundedVector<i16>,
12800                    fidl::encoding::DefaultFuchsiaResourceDialect
12801                ),
12802                i32_0: fidl::new_empty!(
12803                    fidl::encoding::UnboundedVector<i32>,
12804                    fidl::encoding::DefaultFuchsiaResourceDialect
12805                ),
12806                i64_0: fidl::new_empty!(
12807                    fidl::encoding::UnboundedVector<i64>,
12808                    fidl::encoding::DefaultFuchsiaResourceDialect
12809                ),
12810                u8_0: fidl::new_empty!(
12811                    fidl::encoding::UnboundedVector<u8>,
12812                    fidl::encoding::DefaultFuchsiaResourceDialect
12813                ),
12814                u16_0: fidl::new_empty!(
12815                    fidl::encoding::UnboundedVector<u16>,
12816                    fidl::encoding::DefaultFuchsiaResourceDialect
12817                ),
12818                u32_0: fidl::new_empty!(
12819                    fidl::encoding::UnboundedVector<u32>,
12820                    fidl::encoding::DefaultFuchsiaResourceDialect
12821                ),
12822                u64_0: fidl::new_empty!(
12823                    fidl::encoding::UnboundedVector<u64>,
12824                    fidl::encoding::DefaultFuchsiaResourceDialect
12825                ),
12826                f32_0: fidl::new_empty!(
12827                    fidl::encoding::UnboundedVector<f32>,
12828                    fidl::encoding::DefaultFuchsiaResourceDialect
12829                ),
12830                f64_0: fidl::new_empty!(
12831                    fidl::encoding::UnboundedVector<f64>,
12832                    fidl::encoding::DefaultFuchsiaResourceDialect
12833                ),
12834                handle_0: fidl::new_empty!(
12835                    fidl::encoding::UnboundedVector<
12836                        fidl::encoding::HandleType<
12837                            fidl::NullableHandle,
12838                            { fidl::ObjectType::NONE.into_raw() },
12839                            2147483648,
12840                        >,
12841                    >,
12842                    fidl::encoding::DefaultFuchsiaResourceDialect
12843                ),
12844                b_1: fidl::new_empty!(
12845                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
12846                    fidl::encoding::DefaultFuchsiaResourceDialect
12847                ),
12848                i8_1: fidl::new_empty!(
12849                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
12850                    fidl::encoding::DefaultFuchsiaResourceDialect
12851                ),
12852                i16_1: fidl::new_empty!(
12853                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
12854                    fidl::encoding::DefaultFuchsiaResourceDialect
12855                ),
12856                i32_1: fidl::new_empty!(
12857                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
12858                    fidl::encoding::DefaultFuchsiaResourceDialect
12859                ),
12860                i64_1: fidl::new_empty!(
12861                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
12862                    fidl::encoding::DefaultFuchsiaResourceDialect
12863                ),
12864                u8_1: fidl::new_empty!(
12865                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
12866                    fidl::encoding::DefaultFuchsiaResourceDialect
12867                ),
12868                u16_1: fidl::new_empty!(
12869                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
12870                    fidl::encoding::DefaultFuchsiaResourceDialect
12871                ),
12872                u32_1: fidl::new_empty!(
12873                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
12874                    fidl::encoding::DefaultFuchsiaResourceDialect
12875                ),
12876                u64_1: fidl::new_empty!(
12877                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
12878                    fidl::encoding::DefaultFuchsiaResourceDialect
12879                ),
12880                f32_1: fidl::new_empty!(
12881                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
12882                    fidl::encoding::DefaultFuchsiaResourceDialect
12883                ),
12884                f64_1: fidl::new_empty!(
12885                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
12886                    fidl::encoding::DefaultFuchsiaResourceDialect
12887                ),
12888                handle_1: fidl::new_empty!(
12889                    fidl::encoding::UnboundedVector<
12890                        fidl::encoding::Vector<
12891                            fidl::encoding::HandleType<
12892                                fidl::NullableHandle,
12893                                { fidl::ObjectType::NONE.into_raw() },
12894                                2147483648,
12895                            >,
12896                            2,
12897                        >,
12898                    >,
12899                    fidl::encoding::DefaultFuchsiaResourceDialect
12900                ),
12901                b_sized_0: fidl::new_empty!(fidl::encoding::Vector<bool, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12902                i8_sized_0: fidl::new_empty!(fidl::encoding::Vector<i8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12903                i16_sized_0: fidl::new_empty!(fidl::encoding::Vector<i16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12904                i32_sized_0: fidl::new_empty!(fidl::encoding::Vector<i32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12905                i64_sized_0: fidl::new_empty!(fidl::encoding::Vector<i64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12906                u8_sized_0: fidl::new_empty!(fidl::encoding::Vector<u8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12907                u16_sized_0: fidl::new_empty!(fidl::encoding::Vector<u16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12908                u32_sized_0: fidl::new_empty!(fidl::encoding::Vector<u32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12909                u64_sized_0: fidl::new_empty!(fidl::encoding::Vector<u64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12910                f32_sized_0: fidl::new_empty!(fidl::encoding::Vector<f32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12911                f64_sized_0: fidl::new_empty!(fidl::encoding::Vector<f64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12912                handle_sized_0: fidl::new_empty!(
12913                    fidl::encoding::Vector<
12914                        fidl::encoding::HandleType<
12915                            fidl::NullableHandle,
12916                            { fidl::ObjectType::NONE.into_raw() },
12917                            2147483648,
12918                        >,
12919                        1,
12920                    >,
12921                    fidl::encoding::DefaultFuchsiaResourceDialect
12922                ),
12923                b_sized_1: fidl::new_empty!(fidl::encoding::Vector<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12924                i8_sized_1: fidl::new_empty!(fidl::encoding::Vector<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12925                i16_sized_1: fidl::new_empty!(fidl::encoding::Vector<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12926                i32_sized_1: fidl::new_empty!(fidl::encoding::Vector<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12927                i64_sized_1: fidl::new_empty!(fidl::encoding::Vector<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12928                u8_sized_1: fidl::new_empty!(fidl::encoding::Vector<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12929                u16_sized_1: fidl::new_empty!(fidl::encoding::Vector<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12930                u32_sized_1: fidl::new_empty!(fidl::encoding::Vector<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12931                u64_sized_1: fidl::new_empty!(fidl::encoding::Vector<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12932                f32_sized_1: fidl::new_empty!(fidl::encoding::Vector<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12933                f64_sized_1: fidl::new_empty!(fidl::encoding::Vector<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12934                handle_sized_1: fidl::new_empty!(
12935                    fidl::encoding::Vector<
12936                        fidl::encoding::HandleType<
12937                            fidl::NullableHandle,
12938                            { fidl::ObjectType::NONE.into_raw() },
12939                            2147483648,
12940                        >,
12941                        3,
12942                    >,
12943                    fidl::encoding::DefaultFuchsiaResourceDialect
12944                ),
12945                b_sized_2: fidl::new_empty!(
12946                    fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
12947                    fidl::encoding::DefaultFuchsiaResourceDialect
12948                ),
12949                i8_sized_2: fidl::new_empty!(
12950                    fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>,
12951                    fidl::encoding::DefaultFuchsiaResourceDialect
12952                ),
12953                i16_sized_2: fidl::new_empty!(
12954                    fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>,
12955                    fidl::encoding::DefaultFuchsiaResourceDialect
12956                ),
12957                i32_sized_2: fidl::new_empty!(
12958                    fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>,
12959                    fidl::encoding::DefaultFuchsiaResourceDialect
12960                ),
12961                i64_sized_2: fidl::new_empty!(
12962                    fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>,
12963                    fidl::encoding::DefaultFuchsiaResourceDialect
12964                ),
12965                u8_sized_2: fidl::new_empty!(
12966                    fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>,
12967                    fidl::encoding::DefaultFuchsiaResourceDialect
12968                ),
12969                u16_sized_2: fidl::new_empty!(
12970                    fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>,
12971                    fidl::encoding::DefaultFuchsiaResourceDialect
12972                ),
12973                u32_sized_2: fidl::new_empty!(
12974                    fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>,
12975                    fidl::encoding::DefaultFuchsiaResourceDialect
12976                ),
12977                u64_sized_2: fidl::new_empty!(
12978                    fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>,
12979                    fidl::encoding::DefaultFuchsiaResourceDialect
12980                ),
12981                f32_sized_2: fidl::new_empty!(
12982                    fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>,
12983                    fidl::encoding::DefaultFuchsiaResourceDialect
12984                ),
12985                f64_sized_2: fidl::new_empty!(
12986                    fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>,
12987                    fidl::encoding::DefaultFuchsiaResourceDialect
12988                ),
12989                handle_sized_2: fidl::new_empty!(
12990                    fidl::encoding::Vector<
12991                        fidl::encoding::Vector<
12992                            fidl::encoding::HandleType<
12993                                fidl::NullableHandle,
12994                                { fidl::ObjectType::NONE.into_raw() },
12995                                2147483648,
12996                            >,
12997                            2,
12998                        >,
12999                        3,
13000                    >,
13001                    fidl::encoding::DefaultFuchsiaResourceDialect
13002                ),
13003                b_nullable_0: fidl::new_empty!(
13004                    fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
13005                    fidl::encoding::DefaultFuchsiaResourceDialect
13006                ),
13007                i8_nullable_0: fidl::new_empty!(
13008                    fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
13009                    fidl::encoding::DefaultFuchsiaResourceDialect
13010                ),
13011                i16_nullable_0: fidl::new_empty!(
13012                    fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
13013                    fidl::encoding::DefaultFuchsiaResourceDialect
13014                ),
13015                i32_nullable_0: fidl::new_empty!(
13016                    fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
13017                    fidl::encoding::DefaultFuchsiaResourceDialect
13018                ),
13019                i64_nullable_0: fidl::new_empty!(
13020                    fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
13021                    fidl::encoding::DefaultFuchsiaResourceDialect
13022                ),
13023                u8_nullable_0: fidl::new_empty!(
13024                    fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
13025                    fidl::encoding::DefaultFuchsiaResourceDialect
13026                ),
13027                u16_nullable_0: fidl::new_empty!(
13028                    fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
13029                    fidl::encoding::DefaultFuchsiaResourceDialect
13030                ),
13031                u32_nullable_0: fidl::new_empty!(
13032                    fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
13033                    fidl::encoding::DefaultFuchsiaResourceDialect
13034                ),
13035                u64_nullable_0: fidl::new_empty!(
13036                    fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
13037                    fidl::encoding::DefaultFuchsiaResourceDialect
13038                ),
13039                f32_nullable_0: fidl::new_empty!(
13040                    fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
13041                    fidl::encoding::DefaultFuchsiaResourceDialect
13042                ),
13043                f64_nullable_0: fidl::new_empty!(
13044                    fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
13045                    fidl::encoding::DefaultFuchsiaResourceDialect
13046                ),
13047                handle_nullable_0: fidl::new_empty!(
13048                    fidl::encoding::Optional<
13049                        fidl::encoding::Vector<
13050                            fidl::encoding::HandleType<
13051                                fidl::NullableHandle,
13052                                { fidl::ObjectType::NONE.into_raw() },
13053                                2147483648,
13054                            >,
13055                            1,
13056                        >,
13057                    >,
13058                    fidl::encoding::DefaultFuchsiaResourceDialect
13059                ),
13060                b_nullable_1: fidl::new_empty!(
13061                    fidl::encoding::Optional<
13062                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
13063                    >,
13064                    fidl::encoding::DefaultFuchsiaResourceDialect
13065                ),
13066                i8_nullable_1: fidl::new_empty!(
13067                    fidl::encoding::Optional<
13068                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
13069                    >,
13070                    fidl::encoding::DefaultFuchsiaResourceDialect
13071                ),
13072                i16_nullable_1: fidl::new_empty!(
13073                    fidl::encoding::Optional<
13074                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
13075                    >,
13076                    fidl::encoding::DefaultFuchsiaResourceDialect
13077                ),
13078                i32_nullable_1: fidl::new_empty!(
13079                    fidl::encoding::Optional<
13080                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
13081                    >,
13082                    fidl::encoding::DefaultFuchsiaResourceDialect
13083                ),
13084                i64_nullable_1: fidl::new_empty!(
13085                    fidl::encoding::Optional<
13086                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
13087                    >,
13088                    fidl::encoding::DefaultFuchsiaResourceDialect
13089                ),
13090                u8_nullable_1: fidl::new_empty!(
13091                    fidl::encoding::Optional<
13092                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
13093                    >,
13094                    fidl::encoding::DefaultFuchsiaResourceDialect
13095                ),
13096                u16_nullable_1: fidl::new_empty!(
13097                    fidl::encoding::Optional<
13098                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
13099                    >,
13100                    fidl::encoding::DefaultFuchsiaResourceDialect
13101                ),
13102                u32_nullable_1: fidl::new_empty!(
13103                    fidl::encoding::Optional<
13104                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
13105                    >,
13106                    fidl::encoding::DefaultFuchsiaResourceDialect
13107                ),
13108                u64_nullable_1: fidl::new_empty!(
13109                    fidl::encoding::Optional<
13110                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
13111                    >,
13112                    fidl::encoding::DefaultFuchsiaResourceDialect
13113                ),
13114                f32_nullable_1: fidl::new_empty!(
13115                    fidl::encoding::Optional<
13116                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
13117                    >,
13118                    fidl::encoding::DefaultFuchsiaResourceDialect
13119                ),
13120                f64_nullable_1: fidl::new_empty!(
13121                    fidl::encoding::Optional<
13122                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
13123                    >,
13124                    fidl::encoding::DefaultFuchsiaResourceDialect
13125                ),
13126                handle_nullable_1: fidl::new_empty!(
13127                    fidl::encoding::Optional<
13128                        fidl::encoding::UnboundedVector<
13129                            fidl::encoding::Vector<
13130                                fidl::encoding::HandleType<
13131                                    fidl::NullableHandle,
13132                                    { fidl::ObjectType::NONE.into_raw() },
13133                                    2147483648,
13134                                >,
13135                                2,
13136                            >,
13137                        >,
13138                    >,
13139                    fidl::encoding::DefaultFuchsiaResourceDialect
13140                ),
13141                b_nullable_sized_0: fidl::new_empty!(
13142                    fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
13143                    fidl::encoding::DefaultFuchsiaResourceDialect
13144                ),
13145                i8_nullable_sized_0: fidl::new_empty!(
13146                    fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
13147                    fidl::encoding::DefaultFuchsiaResourceDialect
13148                ),
13149                i16_nullable_sized_0: fidl::new_empty!(
13150                    fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
13151                    fidl::encoding::DefaultFuchsiaResourceDialect
13152                ),
13153                i32_nullable_sized_0: fidl::new_empty!(
13154                    fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
13155                    fidl::encoding::DefaultFuchsiaResourceDialect
13156                ),
13157                i64_nullable_sized_0: fidl::new_empty!(
13158                    fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
13159                    fidl::encoding::DefaultFuchsiaResourceDialect
13160                ),
13161                u8_nullable_sized_0: fidl::new_empty!(
13162                    fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
13163                    fidl::encoding::DefaultFuchsiaResourceDialect
13164                ),
13165                u16_nullable_sized_0: fidl::new_empty!(
13166                    fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
13167                    fidl::encoding::DefaultFuchsiaResourceDialect
13168                ),
13169                u32_nullable_sized_0: fidl::new_empty!(
13170                    fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
13171                    fidl::encoding::DefaultFuchsiaResourceDialect
13172                ),
13173                u64_nullable_sized_0: fidl::new_empty!(
13174                    fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
13175                    fidl::encoding::DefaultFuchsiaResourceDialect
13176                ),
13177                f32_nullable_sized_0: fidl::new_empty!(
13178                    fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
13179                    fidl::encoding::DefaultFuchsiaResourceDialect
13180                ),
13181                f64_nullable_sized_0: fidl::new_empty!(
13182                    fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
13183                    fidl::encoding::DefaultFuchsiaResourceDialect
13184                ),
13185                handle_nullable_sized_0: fidl::new_empty!(
13186                    fidl::encoding::Optional<
13187                        fidl::encoding::Vector<
13188                            fidl::encoding::HandleType<
13189                                fidl::NullableHandle,
13190                                { fidl::ObjectType::NONE.into_raw() },
13191                                2147483648,
13192                            >,
13193                            1,
13194                        >,
13195                    >,
13196                    fidl::encoding::DefaultFuchsiaResourceDialect
13197                ),
13198                b_nullable_sized_1: fidl::new_empty!(
13199                    fidl::encoding::Optional<fidl::encoding::Vector<bool, 3>>,
13200                    fidl::encoding::DefaultFuchsiaResourceDialect
13201                ),
13202                i8_nullable_sized_1: fidl::new_empty!(
13203                    fidl::encoding::Optional<fidl::encoding::Vector<i8, 3>>,
13204                    fidl::encoding::DefaultFuchsiaResourceDialect
13205                ),
13206                i16_nullable_sized_1: fidl::new_empty!(
13207                    fidl::encoding::Optional<fidl::encoding::Vector<i16, 3>>,
13208                    fidl::encoding::DefaultFuchsiaResourceDialect
13209                ),
13210                i32_nullable_sized_1: fidl::new_empty!(
13211                    fidl::encoding::Optional<fidl::encoding::Vector<i32, 3>>,
13212                    fidl::encoding::DefaultFuchsiaResourceDialect
13213                ),
13214                i64_nullable_sized_1: fidl::new_empty!(
13215                    fidl::encoding::Optional<fidl::encoding::Vector<i64, 3>>,
13216                    fidl::encoding::DefaultFuchsiaResourceDialect
13217                ),
13218                u8_nullable_sized_1: fidl::new_empty!(
13219                    fidl::encoding::Optional<fidl::encoding::Vector<u8, 3>>,
13220                    fidl::encoding::DefaultFuchsiaResourceDialect
13221                ),
13222                u16_nullable_sized_1: fidl::new_empty!(
13223                    fidl::encoding::Optional<fidl::encoding::Vector<u16, 3>>,
13224                    fidl::encoding::DefaultFuchsiaResourceDialect
13225                ),
13226                u32_nullable_sized_1: fidl::new_empty!(
13227                    fidl::encoding::Optional<fidl::encoding::Vector<u32, 3>>,
13228                    fidl::encoding::DefaultFuchsiaResourceDialect
13229                ),
13230                u64_nullable_sized_1: fidl::new_empty!(
13231                    fidl::encoding::Optional<fidl::encoding::Vector<u64, 3>>,
13232                    fidl::encoding::DefaultFuchsiaResourceDialect
13233                ),
13234                f32_nullable_sized_1: fidl::new_empty!(
13235                    fidl::encoding::Optional<fidl::encoding::Vector<f32, 3>>,
13236                    fidl::encoding::DefaultFuchsiaResourceDialect
13237                ),
13238                f64_nullable_sized_1: fidl::new_empty!(
13239                    fidl::encoding::Optional<fidl::encoding::Vector<f64, 3>>,
13240                    fidl::encoding::DefaultFuchsiaResourceDialect
13241                ),
13242                handle_nullable_sized_1: fidl::new_empty!(
13243                    fidl::encoding::Optional<
13244                        fidl::encoding::Vector<
13245                            fidl::encoding::HandleType<
13246                                fidl::NullableHandle,
13247                                { fidl::ObjectType::NONE.into_raw() },
13248                                2147483648,
13249                            >,
13250                            3,
13251                        >,
13252                    >,
13253                    fidl::encoding::DefaultFuchsiaResourceDialect
13254                ),
13255                b_nullable_sized_2: fidl::new_empty!(
13256                    fidl::encoding::Optional<
13257                        fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
13258                    >,
13259                    fidl::encoding::DefaultFuchsiaResourceDialect
13260                ),
13261                i8_nullable_sized_2: fidl::new_empty!(
13262                    fidl::encoding::Optional<
13263                        fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>,
13264                    >,
13265                    fidl::encoding::DefaultFuchsiaResourceDialect
13266                ),
13267                i16_nullable_sized_2: fidl::new_empty!(
13268                    fidl::encoding::Optional<
13269                        fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>,
13270                    >,
13271                    fidl::encoding::DefaultFuchsiaResourceDialect
13272                ),
13273                i32_nullable_sized_2: fidl::new_empty!(
13274                    fidl::encoding::Optional<
13275                        fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>,
13276                    >,
13277                    fidl::encoding::DefaultFuchsiaResourceDialect
13278                ),
13279                i64_nullable_sized_2: fidl::new_empty!(
13280                    fidl::encoding::Optional<
13281                        fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>,
13282                    >,
13283                    fidl::encoding::DefaultFuchsiaResourceDialect
13284                ),
13285                u8_nullable_sized_2: fidl::new_empty!(
13286                    fidl::encoding::Optional<
13287                        fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>,
13288                    >,
13289                    fidl::encoding::DefaultFuchsiaResourceDialect
13290                ),
13291                u16_nullable_sized_2: fidl::new_empty!(
13292                    fidl::encoding::Optional<
13293                        fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>,
13294                    >,
13295                    fidl::encoding::DefaultFuchsiaResourceDialect
13296                ),
13297                u32_nullable_sized_2: fidl::new_empty!(
13298                    fidl::encoding::Optional<
13299                        fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>,
13300                    >,
13301                    fidl::encoding::DefaultFuchsiaResourceDialect
13302                ),
13303                u64_nullable_sized_2: fidl::new_empty!(
13304                    fidl::encoding::Optional<
13305                        fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>,
13306                    >,
13307                    fidl::encoding::DefaultFuchsiaResourceDialect
13308                ),
13309                f32_nullable_sized_2: fidl::new_empty!(
13310                    fidl::encoding::Optional<
13311                        fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>,
13312                    >,
13313                    fidl::encoding::DefaultFuchsiaResourceDialect
13314                ),
13315                f64_nullable_sized_2: fidl::new_empty!(
13316                    fidl::encoding::Optional<
13317                        fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>,
13318                    >,
13319                    fidl::encoding::DefaultFuchsiaResourceDialect
13320                ),
13321                handle_nullable_sized_2: fidl::new_empty!(
13322                    fidl::encoding::Optional<
13323                        fidl::encoding::Vector<
13324                            fidl::encoding::Vector<
13325                                fidl::encoding::HandleType<
13326                                    fidl::NullableHandle,
13327                                    { fidl::ObjectType::NONE.into_raw() },
13328                                    2147483648,
13329                                >,
13330                                2,
13331                            >,
13332                            3,
13333                        >,
13334                    >,
13335                    fidl::encoding::DefaultFuchsiaResourceDialect
13336                ),
13337            }
13338        }
13339
13340        #[inline]
13341        unsafe fn decode(
13342            &mut self,
13343            decoder: &mut fidl::encoding::Decoder<
13344                '_,
13345                fidl::encoding::DefaultFuchsiaResourceDialect,
13346            >,
13347            offset: usize,
13348            _depth: fidl::encoding::Depth,
13349        ) -> fidl::Result<()> {
13350            decoder.debug_check_bounds::<Self>(offset);
13351            // Verify that padding bytes are zero.
13352            fidl::decode!(
13353                fidl::encoding::UnboundedVector<bool>,
13354                fidl::encoding::DefaultFuchsiaResourceDialect,
13355                &mut self.b_0,
13356                decoder,
13357                offset + 0,
13358                _depth
13359            )?;
13360            fidl::decode!(
13361                fidl::encoding::UnboundedVector<i8>,
13362                fidl::encoding::DefaultFuchsiaResourceDialect,
13363                &mut self.i8_0,
13364                decoder,
13365                offset + 16,
13366                _depth
13367            )?;
13368            fidl::decode!(
13369                fidl::encoding::UnboundedVector<i16>,
13370                fidl::encoding::DefaultFuchsiaResourceDialect,
13371                &mut self.i16_0,
13372                decoder,
13373                offset + 32,
13374                _depth
13375            )?;
13376            fidl::decode!(
13377                fidl::encoding::UnboundedVector<i32>,
13378                fidl::encoding::DefaultFuchsiaResourceDialect,
13379                &mut self.i32_0,
13380                decoder,
13381                offset + 48,
13382                _depth
13383            )?;
13384            fidl::decode!(
13385                fidl::encoding::UnboundedVector<i64>,
13386                fidl::encoding::DefaultFuchsiaResourceDialect,
13387                &mut self.i64_0,
13388                decoder,
13389                offset + 64,
13390                _depth
13391            )?;
13392            fidl::decode!(
13393                fidl::encoding::UnboundedVector<u8>,
13394                fidl::encoding::DefaultFuchsiaResourceDialect,
13395                &mut self.u8_0,
13396                decoder,
13397                offset + 80,
13398                _depth
13399            )?;
13400            fidl::decode!(
13401                fidl::encoding::UnboundedVector<u16>,
13402                fidl::encoding::DefaultFuchsiaResourceDialect,
13403                &mut self.u16_0,
13404                decoder,
13405                offset + 96,
13406                _depth
13407            )?;
13408            fidl::decode!(
13409                fidl::encoding::UnboundedVector<u32>,
13410                fidl::encoding::DefaultFuchsiaResourceDialect,
13411                &mut self.u32_0,
13412                decoder,
13413                offset + 112,
13414                _depth
13415            )?;
13416            fidl::decode!(
13417                fidl::encoding::UnboundedVector<u64>,
13418                fidl::encoding::DefaultFuchsiaResourceDialect,
13419                &mut self.u64_0,
13420                decoder,
13421                offset + 128,
13422                _depth
13423            )?;
13424            fidl::decode!(
13425                fidl::encoding::UnboundedVector<f32>,
13426                fidl::encoding::DefaultFuchsiaResourceDialect,
13427                &mut self.f32_0,
13428                decoder,
13429                offset + 144,
13430                _depth
13431            )?;
13432            fidl::decode!(
13433                fidl::encoding::UnboundedVector<f64>,
13434                fidl::encoding::DefaultFuchsiaResourceDialect,
13435                &mut self.f64_0,
13436                decoder,
13437                offset + 160,
13438                _depth
13439            )?;
13440            fidl::decode!(
13441                fidl::encoding::UnboundedVector<
13442                    fidl::encoding::HandleType<
13443                        fidl::NullableHandle,
13444                        { fidl::ObjectType::NONE.into_raw() },
13445                        2147483648,
13446                    >,
13447                >,
13448                fidl::encoding::DefaultFuchsiaResourceDialect,
13449                &mut self.handle_0,
13450                decoder,
13451                offset + 176,
13452                _depth
13453            )?;
13454            fidl::decode!(
13455                fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
13456                fidl::encoding::DefaultFuchsiaResourceDialect,
13457                &mut self.b_1,
13458                decoder,
13459                offset + 192,
13460                _depth
13461            )?;
13462            fidl::decode!(
13463                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
13464                fidl::encoding::DefaultFuchsiaResourceDialect,
13465                &mut self.i8_1,
13466                decoder,
13467                offset + 208,
13468                _depth
13469            )?;
13470            fidl::decode!(
13471                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
13472                fidl::encoding::DefaultFuchsiaResourceDialect,
13473                &mut self.i16_1,
13474                decoder,
13475                offset + 224,
13476                _depth
13477            )?;
13478            fidl::decode!(
13479                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
13480                fidl::encoding::DefaultFuchsiaResourceDialect,
13481                &mut self.i32_1,
13482                decoder,
13483                offset + 240,
13484                _depth
13485            )?;
13486            fidl::decode!(
13487                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
13488                fidl::encoding::DefaultFuchsiaResourceDialect,
13489                &mut self.i64_1,
13490                decoder,
13491                offset + 256,
13492                _depth
13493            )?;
13494            fidl::decode!(
13495                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
13496                fidl::encoding::DefaultFuchsiaResourceDialect,
13497                &mut self.u8_1,
13498                decoder,
13499                offset + 272,
13500                _depth
13501            )?;
13502            fidl::decode!(
13503                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
13504                fidl::encoding::DefaultFuchsiaResourceDialect,
13505                &mut self.u16_1,
13506                decoder,
13507                offset + 288,
13508                _depth
13509            )?;
13510            fidl::decode!(
13511                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
13512                fidl::encoding::DefaultFuchsiaResourceDialect,
13513                &mut self.u32_1,
13514                decoder,
13515                offset + 304,
13516                _depth
13517            )?;
13518            fidl::decode!(
13519                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
13520                fidl::encoding::DefaultFuchsiaResourceDialect,
13521                &mut self.u64_1,
13522                decoder,
13523                offset + 320,
13524                _depth
13525            )?;
13526            fidl::decode!(
13527                fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
13528                fidl::encoding::DefaultFuchsiaResourceDialect,
13529                &mut self.f32_1,
13530                decoder,
13531                offset + 336,
13532                _depth
13533            )?;
13534            fidl::decode!(
13535                fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
13536                fidl::encoding::DefaultFuchsiaResourceDialect,
13537                &mut self.f64_1,
13538                decoder,
13539                offset + 352,
13540                _depth
13541            )?;
13542            fidl::decode!(
13543                fidl::encoding::UnboundedVector<
13544                    fidl::encoding::Vector<
13545                        fidl::encoding::HandleType<
13546                            fidl::NullableHandle,
13547                            { fidl::ObjectType::NONE.into_raw() },
13548                            2147483648,
13549                        >,
13550                        2,
13551                    >,
13552                >,
13553                fidl::encoding::DefaultFuchsiaResourceDialect,
13554                &mut self.handle_1,
13555                decoder,
13556                offset + 368,
13557                _depth
13558            )?;
13559            fidl::decode!(fidl::encoding::Vector<bool, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.b_sized_0, decoder, offset + 384, _depth)?;
13560            fidl::decode!(fidl::encoding::Vector<i8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i8_sized_0, decoder, offset + 400, _depth)?;
13561            fidl::decode!(fidl::encoding::Vector<i16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i16_sized_0, decoder, offset + 416, _depth)?;
13562            fidl::decode!(fidl::encoding::Vector<i32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i32_sized_0, decoder, offset + 432, _depth)?;
13563            fidl::decode!(fidl::encoding::Vector<i64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i64_sized_0, decoder, offset + 448, _depth)?;
13564            fidl::decode!(fidl::encoding::Vector<u8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u8_sized_0, decoder, offset + 464, _depth)?;
13565            fidl::decode!(fidl::encoding::Vector<u16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u16_sized_0, decoder, offset + 480, _depth)?;
13566            fidl::decode!(fidl::encoding::Vector<u32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u32_sized_0, decoder, offset + 496, _depth)?;
13567            fidl::decode!(fidl::encoding::Vector<u64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u64_sized_0, decoder, offset + 512, _depth)?;
13568            fidl::decode!(fidl::encoding::Vector<f32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f32_sized_0, decoder, offset + 528, _depth)?;
13569            fidl::decode!(fidl::encoding::Vector<f64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f64_sized_0, decoder, offset + 544, _depth)?;
13570            fidl::decode!(
13571                fidl::encoding::Vector<
13572                    fidl::encoding::HandleType<
13573                        fidl::NullableHandle,
13574                        { fidl::ObjectType::NONE.into_raw() },
13575                        2147483648,
13576                    >,
13577                    1,
13578                >,
13579                fidl::encoding::DefaultFuchsiaResourceDialect,
13580                &mut self.handle_sized_0,
13581                decoder,
13582                offset + 560,
13583                _depth
13584            )?;
13585            fidl::decode!(fidl::encoding::Vector<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.b_sized_1, decoder, offset + 576, _depth)?;
13586            fidl::decode!(fidl::encoding::Vector<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i8_sized_1, decoder, offset + 592, _depth)?;
13587            fidl::decode!(fidl::encoding::Vector<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i16_sized_1, decoder, offset + 608, _depth)?;
13588            fidl::decode!(fidl::encoding::Vector<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i32_sized_1, decoder, offset + 624, _depth)?;
13589            fidl::decode!(fidl::encoding::Vector<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i64_sized_1, decoder, offset + 640, _depth)?;
13590            fidl::decode!(fidl::encoding::Vector<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u8_sized_1, decoder, offset + 656, _depth)?;
13591            fidl::decode!(fidl::encoding::Vector<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u16_sized_1, decoder, offset + 672, _depth)?;
13592            fidl::decode!(fidl::encoding::Vector<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u32_sized_1, decoder, offset + 688, _depth)?;
13593            fidl::decode!(fidl::encoding::Vector<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u64_sized_1, decoder, offset + 704, _depth)?;
13594            fidl::decode!(fidl::encoding::Vector<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f32_sized_1, decoder, offset + 720, _depth)?;
13595            fidl::decode!(fidl::encoding::Vector<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f64_sized_1, decoder, offset + 736, _depth)?;
13596            fidl::decode!(
13597                fidl::encoding::Vector<
13598                    fidl::encoding::HandleType<
13599                        fidl::NullableHandle,
13600                        { fidl::ObjectType::NONE.into_raw() },
13601                        2147483648,
13602                    >,
13603                    3,
13604                >,
13605                fidl::encoding::DefaultFuchsiaResourceDialect,
13606                &mut self.handle_sized_1,
13607                decoder,
13608                offset + 752,
13609                _depth
13610            )?;
13611            fidl::decode!(
13612                fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
13613                fidl::encoding::DefaultFuchsiaResourceDialect,
13614                &mut self.b_sized_2,
13615                decoder,
13616                offset + 768,
13617                _depth
13618            )?;
13619            fidl::decode!(
13620                fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>,
13621                fidl::encoding::DefaultFuchsiaResourceDialect,
13622                &mut self.i8_sized_2,
13623                decoder,
13624                offset + 784,
13625                _depth
13626            )?;
13627            fidl::decode!(
13628                fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>,
13629                fidl::encoding::DefaultFuchsiaResourceDialect,
13630                &mut self.i16_sized_2,
13631                decoder,
13632                offset + 800,
13633                _depth
13634            )?;
13635            fidl::decode!(
13636                fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>,
13637                fidl::encoding::DefaultFuchsiaResourceDialect,
13638                &mut self.i32_sized_2,
13639                decoder,
13640                offset + 816,
13641                _depth
13642            )?;
13643            fidl::decode!(
13644                fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>,
13645                fidl::encoding::DefaultFuchsiaResourceDialect,
13646                &mut self.i64_sized_2,
13647                decoder,
13648                offset + 832,
13649                _depth
13650            )?;
13651            fidl::decode!(
13652                fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>,
13653                fidl::encoding::DefaultFuchsiaResourceDialect,
13654                &mut self.u8_sized_2,
13655                decoder,
13656                offset + 848,
13657                _depth
13658            )?;
13659            fidl::decode!(
13660                fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>,
13661                fidl::encoding::DefaultFuchsiaResourceDialect,
13662                &mut self.u16_sized_2,
13663                decoder,
13664                offset + 864,
13665                _depth
13666            )?;
13667            fidl::decode!(
13668                fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>,
13669                fidl::encoding::DefaultFuchsiaResourceDialect,
13670                &mut self.u32_sized_2,
13671                decoder,
13672                offset + 880,
13673                _depth
13674            )?;
13675            fidl::decode!(
13676                fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>,
13677                fidl::encoding::DefaultFuchsiaResourceDialect,
13678                &mut self.u64_sized_2,
13679                decoder,
13680                offset + 896,
13681                _depth
13682            )?;
13683            fidl::decode!(
13684                fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>,
13685                fidl::encoding::DefaultFuchsiaResourceDialect,
13686                &mut self.f32_sized_2,
13687                decoder,
13688                offset + 912,
13689                _depth
13690            )?;
13691            fidl::decode!(
13692                fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>,
13693                fidl::encoding::DefaultFuchsiaResourceDialect,
13694                &mut self.f64_sized_2,
13695                decoder,
13696                offset + 928,
13697                _depth
13698            )?;
13699            fidl::decode!(
13700                fidl::encoding::Vector<
13701                    fidl::encoding::Vector<
13702                        fidl::encoding::HandleType<
13703                            fidl::NullableHandle,
13704                            { fidl::ObjectType::NONE.into_raw() },
13705                            2147483648,
13706                        >,
13707                        2,
13708                    >,
13709                    3,
13710                >,
13711                fidl::encoding::DefaultFuchsiaResourceDialect,
13712                &mut self.handle_sized_2,
13713                decoder,
13714                offset + 944,
13715                _depth
13716            )?;
13717            fidl::decode!(
13718                fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
13719                fidl::encoding::DefaultFuchsiaResourceDialect,
13720                &mut self.b_nullable_0,
13721                decoder,
13722                offset + 960,
13723                _depth
13724            )?;
13725            fidl::decode!(
13726                fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
13727                fidl::encoding::DefaultFuchsiaResourceDialect,
13728                &mut self.i8_nullable_0,
13729                decoder,
13730                offset + 976,
13731                _depth
13732            )?;
13733            fidl::decode!(
13734                fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
13735                fidl::encoding::DefaultFuchsiaResourceDialect,
13736                &mut self.i16_nullable_0,
13737                decoder,
13738                offset + 992,
13739                _depth
13740            )?;
13741            fidl::decode!(
13742                fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
13743                fidl::encoding::DefaultFuchsiaResourceDialect,
13744                &mut self.i32_nullable_0,
13745                decoder,
13746                offset + 1008,
13747                _depth
13748            )?;
13749            fidl::decode!(
13750                fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
13751                fidl::encoding::DefaultFuchsiaResourceDialect,
13752                &mut self.i64_nullable_0,
13753                decoder,
13754                offset + 1024,
13755                _depth
13756            )?;
13757            fidl::decode!(
13758                fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
13759                fidl::encoding::DefaultFuchsiaResourceDialect,
13760                &mut self.u8_nullable_0,
13761                decoder,
13762                offset + 1040,
13763                _depth
13764            )?;
13765            fidl::decode!(
13766                fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
13767                fidl::encoding::DefaultFuchsiaResourceDialect,
13768                &mut self.u16_nullable_0,
13769                decoder,
13770                offset + 1056,
13771                _depth
13772            )?;
13773            fidl::decode!(
13774                fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
13775                fidl::encoding::DefaultFuchsiaResourceDialect,
13776                &mut self.u32_nullable_0,
13777                decoder,
13778                offset + 1072,
13779                _depth
13780            )?;
13781            fidl::decode!(
13782                fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
13783                fidl::encoding::DefaultFuchsiaResourceDialect,
13784                &mut self.u64_nullable_0,
13785                decoder,
13786                offset + 1088,
13787                _depth
13788            )?;
13789            fidl::decode!(
13790                fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
13791                fidl::encoding::DefaultFuchsiaResourceDialect,
13792                &mut self.f32_nullable_0,
13793                decoder,
13794                offset + 1104,
13795                _depth
13796            )?;
13797            fidl::decode!(
13798                fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
13799                fidl::encoding::DefaultFuchsiaResourceDialect,
13800                &mut self.f64_nullable_0,
13801                decoder,
13802                offset + 1120,
13803                _depth
13804            )?;
13805            fidl::decode!(
13806                fidl::encoding::Optional<
13807                    fidl::encoding::Vector<
13808                        fidl::encoding::HandleType<
13809                            fidl::NullableHandle,
13810                            { fidl::ObjectType::NONE.into_raw() },
13811                            2147483648,
13812                        >,
13813                        1,
13814                    >,
13815                >,
13816                fidl::encoding::DefaultFuchsiaResourceDialect,
13817                &mut self.handle_nullable_0,
13818                decoder,
13819                offset + 1136,
13820                _depth
13821            )?;
13822            fidl::decode!(
13823                fidl::encoding::Optional<
13824                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
13825                >,
13826                fidl::encoding::DefaultFuchsiaResourceDialect,
13827                &mut self.b_nullable_1,
13828                decoder,
13829                offset + 1152,
13830                _depth
13831            )?;
13832            fidl::decode!(
13833                fidl::encoding::Optional<
13834                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
13835                >,
13836                fidl::encoding::DefaultFuchsiaResourceDialect,
13837                &mut self.i8_nullable_1,
13838                decoder,
13839                offset + 1168,
13840                _depth
13841            )?;
13842            fidl::decode!(
13843                fidl::encoding::Optional<
13844                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
13845                >,
13846                fidl::encoding::DefaultFuchsiaResourceDialect,
13847                &mut self.i16_nullable_1,
13848                decoder,
13849                offset + 1184,
13850                _depth
13851            )?;
13852            fidl::decode!(
13853                fidl::encoding::Optional<
13854                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
13855                >,
13856                fidl::encoding::DefaultFuchsiaResourceDialect,
13857                &mut self.i32_nullable_1,
13858                decoder,
13859                offset + 1200,
13860                _depth
13861            )?;
13862            fidl::decode!(
13863                fidl::encoding::Optional<
13864                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
13865                >,
13866                fidl::encoding::DefaultFuchsiaResourceDialect,
13867                &mut self.i64_nullable_1,
13868                decoder,
13869                offset + 1216,
13870                _depth
13871            )?;
13872            fidl::decode!(
13873                fidl::encoding::Optional<
13874                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
13875                >,
13876                fidl::encoding::DefaultFuchsiaResourceDialect,
13877                &mut self.u8_nullable_1,
13878                decoder,
13879                offset + 1232,
13880                _depth
13881            )?;
13882            fidl::decode!(
13883                fidl::encoding::Optional<
13884                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
13885                >,
13886                fidl::encoding::DefaultFuchsiaResourceDialect,
13887                &mut self.u16_nullable_1,
13888                decoder,
13889                offset + 1248,
13890                _depth
13891            )?;
13892            fidl::decode!(
13893                fidl::encoding::Optional<
13894                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
13895                >,
13896                fidl::encoding::DefaultFuchsiaResourceDialect,
13897                &mut self.u32_nullable_1,
13898                decoder,
13899                offset + 1264,
13900                _depth
13901            )?;
13902            fidl::decode!(
13903                fidl::encoding::Optional<
13904                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
13905                >,
13906                fidl::encoding::DefaultFuchsiaResourceDialect,
13907                &mut self.u64_nullable_1,
13908                decoder,
13909                offset + 1280,
13910                _depth
13911            )?;
13912            fidl::decode!(
13913                fidl::encoding::Optional<
13914                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
13915                >,
13916                fidl::encoding::DefaultFuchsiaResourceDialect,
13917                &mut self.f32_nullable_1,
13918                decoder,
13919                offset + 1296,
13920                _depth
13921            )?;
13922            fidl::decode!(
13923                fidl::encoding::Optional<
13924                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
13925                >,
13926                fidl::encoding::DefaultFuchsiaResourceDialect,
13927                &mut self.f64_nullable_1,
13928                decoder,
13929                offset + 1312,
13930                _depth
13931            )?;
13932            fidl::decode!(
13933                fidl::encoding::Optional<
13934                    fidl::encoding::UnboundedVector<
13935                        fidl::encoding::Vector<
13936                            fidl::encoding::HandleType<
13937                                fidl::NullableHandle,
13938                                { fidl::ObjectType::NONE.into_raw() },
13939                                2147483648,
13940                            >,
13941                            2,
13942                        >,
13943                    >,
13944                >,
13945                fidl::encoding::DefaultFuchsiaResourceDialect,
13946                &mut self.handle_nullable_1,
13947                decoder,
13948                offset + 1328,
13949                _depth
13950            )?;
13951            fidl::decode!(
13952                fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
13953                fidl::encoding::DefaultFuchsiaResourceDialect,
13954                &mut self.b_nullable_sized_0,
13955                decoder,
13956                offset + 1344,
13957                _depth
13958            )?;
13959            fidl::decode!(
13960                fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
13961                fidl::encoding::DefaultFuchsiaResourceDialect,
13962                &mut self.i8_nullable_sized_0,
13963                decoder,
13964                offset + 1360,
13965                _depth
13966            )?;
13967            fidl::decode!(
13968                fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
13969                fidl::encoding::DefaultFuchsiaResourceDialect,
13970                &mut self.i16_nullable_sized_0,
13971                decoder,
13972                offset + 1376,
13973                _depth
13974            )?;
13975            fidl::decode!(
13976                fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
13977                fidl::encoding::DefaultFuchsiaResourceDialect,
13978                &mut self.i32_nullable_sized_0,
13979                decoder,
13980                offset + 1392,
13981                _depth
13982            )?;
13983            fidl::decode!(
13984                fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
13985                fidl::encoding::DefaultFuchsiaResourceDialect,
13986                &mut self.i64_nullable_sized_0,
13987                decoder,
13988                offset + 1408,
13989                _depth
13990            )?;
13991            fidl::decode!(
13992                fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
13993                fidl::encoding::DefaultFuchsiaResourceDialect,
13994                &mut self.u8_nullable_sized_0,
13995                decoder,
13996                offset + 1424,
13997                _depth
13998            )?;
13999            fidl::decode!(
14000                fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
14001                fidl::encoding::DefaultFuchsiaResourceDialect,
14002                &mut self.u16_nullable_sized_0,
14003                decoder,
14004                offset + 1440,
14005                _depth
14006            )?;
14007            fidl::decode!(
14008                fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
14009                fidl::encoding::DefaultFuchsiaResourceDialect,
14010                &mut self.u32_nullable_sized_0,
14011                decoder,
14012                offset + 1456,
14013                _depth
14014            )?;
14015            fidl::decode!(
14016                fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
14017                fidl::encoding::DefaultFuchsiaResourceDialect,
14018                &mut self.u64_nullable_sized_0,
14019                decoder,
14020                offset + 1472,
14021                _depth
14022            )?;
14023            fidl::decode!(
14024                fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
14025                fidl::encoding::DefaultFuchsiaResourceDialect,
14026                &mut self.f32_nullable_sized_0,
14027                decoder,
14028                offset + 1488,
14029                _depth
14030            )?;
14031            fidl::decode!(
14032                fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
14033                fidl::encoding::DefaultFuchsiaResourceDialect,
14034                &mut self.f64_nullable_sized_0,
14035                decoder,
14036                offset + 1504,
14037                _depth
14038            )?;
14039            fidl::decode!(
14040                fidl::encoding::Optional<
14041                    fidl::encoding::Vector<
14042                        fidl::encoding::HandleType<
14043                            fidl::NullableHandle,
14044                            { fidl::ObjectType::NONE.into_raw() },
14045                            2147483648,
14046                        >,
14047                        1,
14048                    >,
14049                >,
14050                fidl::encoding::DefaultFuchsiaResourceDialect,
14051                &mut self.handle_nullable_sized_0,
14052                decoder,
14053                offset + 1520,
14054                _depth
14055            )?;
14056            fidl::decode!(
14057                fidl::encoding::Optional<fidl::encoding::Vector<bool, 3>>,
14058                fidl::encoding::DefaultFuchsiaResourceDialect,
14059                &mut self.b_nullable_sized_1,
14060                decoder,
14061                offset + 1536,
14062                _depth
14063            )?;
14064            fidl::decode!(
14065                fidl::encoding::Optional<fidl::encoding::Vector<i8, 3>>,
14066                fidl::encoding::DefaultFuchsiaResourceDialect,
14067                &mut self.i8_nullable_sized_1,
14068                decoder,
14069                offset + 1552,
14070                _depth
14071            )?;
14072            fidl::decode!(
14073                fidl::encoding::Optional<fidl::encoding::Vector<i16, 3>>,
14074                fidl::encoding::DefaultFuchsiaResourceDialect,
14075                &mut self.i16_nullable_sized_1,
14076                decoder,
14077                offset + 1568,
14078                _depth
14079            )?;
14080            fidl::decode!(
14081                fidl::encoding::Optional<fidl::encoding::Vector<i32, 3>>,
14082                fidl::encoding::DefaultFuchsiaResourceDialect,
14083                &mut self.i32_nullable_sized_1,
14084                decoder,
14085                offset + 1584,
14086                _depth
14087            )?;
14088            fidl::decode!(
14089                fidl::encoding::Optional<fidl::encoding::Vector<i64, 3>>,
14090                fidl::encoding::DefaultFuchsiaResourceDialect,
14091                &mut self.i64_nullable_sized_1,
14092                decoder,
14093                offset + 1600,
14094                _depth
14095            )?;
14096            fidl::decode!(
14097                fidl::encoding::Optional<fidl::encoding::Vector<u8, 3>>,
14098                fidl::encoding::DefaultFuchsiaResourceDialect,
14099                &mut self.u8_nullable_sized_1,
14100                decoder,
14101                offset + 1616,
14102                _depth
14103            )?;
14104            fidl::decode!(
14105                fidl::encoding::Optional<fidl::encoding::Vector<u16, 3>>,
14106                fidl::encoding::DefaultFuchsiaResourceDialect,
14107                &mut self.u16_nullable_sized_1,
14108                decoder,
14109                offset + 1632,
14110                _depth
14111            )?;
14112            fidl::decode!(
14113                fidl::encoding::Optional<fidl::encoding::Vector<u32, 3>>,
14114                fidl::encoding::DefaultFuchsiaResourceDialect,
14115                &mut self.u32_nullable_sized_1,
14116                decoder,
14117                offset + 1648,
14118                _depth
14119            )?;
14120            fidl::decode!(
14121                fidl::encoding::Optional<fidl::encoding::Vector<u64, 3>>,
14122                fidl::encoding::DefaultFuchsiaResourceDialect,
14123                &mut self.u64_nullable_sized_1,
14124                decoder,
14125                offset + 1664,
14126                _depth
14127            )?;
14128            fidl::decode!(
14129                fidl::encoding::Optional<fidl::encoding::Vector<f32, 3>>,
14130                fidl::encoding::DefaultFuchsiaResourceDialect,
14131                &mut self.f32_nullable_sized_1,
14132                decoder,
14133                offset + 1680,
14134                _depth
14135            )?;
14136            fidl::decode!(
14137                fidl::encoding::Optional<fidl::encoding::Vector<f64, 3>>,
14138                fidl::encoding::DefaultFuchsiaResourceDialect,
14139                &mut self.f64_nullable_sized_1,
14140                decoder,
14141                offset + 1696,
14142                _depth
14143            )?;
14144            fidl::decode!(
14145                fidl::encoding::Optional<
14146                    fidl::encoding::Vector<
14147                        fidl::encoding::HandleType<
14148                            fidl::NullableHandle,
14149                            { fidl::ObjectType::NONE.into_raw() },
14150                            2147483648,
14151                        >,
14152                        3,
14153                    >,
14154                >,
14155                fidl::encoding::DefaultFuchsiaResourceDialect,
14156                &mut self.handle_nullable_sized_1,
14157                decoder,
14158                offset + 1712,
14159                _depth
14160            )?;
14161            fidl::decode!(
14162                fidl::encoding::Optional<
14163                    fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
14164                >,
14165                fidl::encoding::DefaultFuchsiaResourceDialect,
14166                &mut self.b_nullable_sized_2,
14167                decoder,
14168                offset + 1728,
14169                _depth
14170            )?;
14171            fidl::decode!(
14172                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>>,
14173                fidl::encoding::DefaultFuchsiaResourceDialect,
14174                &mut self.i8_nullable_sized_2,
14175                decoder,
14176                offset + 1744,
14177                _depth
14178            )?;
14179            fidl::decode!(
14180                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>>,
14181                fidl::encoding::DefaultFuchsiaResourceDialect,
14182                &mut self.i16_nullable_sized_2,
14183                decoder,
14184                offset + 1760,
14185                _depth
14186            )?;
14187            fidl::decode!(
14188                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>>,
14189                fidl::encoding::DefaultFuchsiaResourceDialect,
14190                &mut self.i32_nullable_sized_2,
14191                decoder,
14192                offset + 1776,
14193                _depth
14194            )?;
14195            fidl::decode!(
14196                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>>,
14197                fidl::encoding::DefaultFuchsiaResourceDialect,
14198                &mut self.i64_nullable_sized_2,
14199                decoder,
14200                offset + 1792,
14201                _depth
14202            )?;
14203            fidl::decode!(
14204                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>>,
14205                fidl::encoding::DefaultFuchsiaResourceDialect,
14206                &mut self.u8_nullable_sized_2,
14207                decoder,
14208                offset + 1808,
14209                _depth
14210            )?;
14211            fidl::decode!(
14212                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>>,
14213                fidl::encoding::DefaultFuchsiaResourceDialect,
14214                &mut self.u16_nullable_sized_2,
14215                decoder,
14216                offset + 1824,
14217                _depth
14218            )?;
14219            fidl::decode!(
14220                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>>,
14221                fidl::encoding::DefaultFuchsiaResourceDialect,
14222                &mut self.u32_nullable_sized_2,
14223                decoder,
14224                offset + 1840,
14225                _depth
14226            )?;
14227            fidl::decode!(
14228                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>>,
14229                fidl::encoding::DefaultFuchsiaResourceDialect,
14230                &mut self.u64_nullable_sized_2,
14231                decoder,
14232                offset + 1856,
14233                _depth
14234            )?;
14235            fidl::decode!(
14236                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>>,
14237                fidl::encoding::DefaultFuchsiaResourceDialect,
14238                &mut self.f32_nullable_sized_2,
14239                decoder,
14240                offset + 1872,
14241                _depth
14242            )?;
14243            fidl::decode!(
14244                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>>,
14245                fidl::encoding::DefaultFuchsiaResourceDialect,
14246                &mut self.f64_nullable_sized_2,
14247                decoder,
14248                offset + 1888,
14249                _depth
14250            )?;
14251            fidl::decode!(
14252                fidl::encoding::Optional<
14253                    fidl::encoding::Vector<
14254                        fidl::encoding::Vector<
14255                            fidl::encoding::HandleType<
14256                                fidl::NullableHandle,
14257                                { fidl::ObjectType::NONE.into_raw() },
14258                                2147483648,
14259                            >,
14260                            2,
14261                        >,
14262                        3,
14263                    >,
14264                >,
14265                fidl::encoding::DefaultFuchsiaResourceDialect,
14266                &mut self.handle_nullable_sized_2,
14267                decoder,
14268                offset + 1904,
14269                _depth
14270            )?;
14271            Ok(())
14272        }
14273    }
14274
14275    impl AllTypesTable {
14276        #[inline(always)]
14277        fn max_ordinal_present(&self) -> u64 {
14278            if let Some(_) = self.xunion_member {
14279                return 21;
14280            }
14281            if let Some(_) = self.table_member {
14282                return 20;
14283            }
14284            if let Some(_) = self.vector_member {
14285                return 19;
14286            }
14287            if let Some(_) = self.array_member {
14288                return 18;
14289            }
14290            if let Some(_) = self.union_member {
14291                return 17;
14292            }
14293            if let Some(_) = self.struct_member {
14294                return 16;
14295            }
14296            if let Some(_) = self.string_member {
14297                return 15;
14298            }
14299            if let Some(_) = self.handle_member {
14300                return 14;
14301            }
14302            if let Some(_) = self.bits_member {
14303                return 13;
14304            }
14305            if let Some(_) = self.enum_member {
14306                return 12;
14307            }
14308            if let Some(_) = self.float64_member {
14309                return 11;
14310            }
14311            if let Some(_) = self.float32_member {
14312                return 10;
14313            }
14314            if let Some(_) = self.uint64_member {
14315                return 9;
14316            }
14317            if let Some(_) = self.uint32_member {
14318                return 8;
14319            }
14320            if let Some(_) = self.uint16_member {
14321                return 7;
14322            }
14323            if let Some(_) = self.uint8_member {
14324                return 6;
14325            }
14326            if let Some(_) = self.int64_member {
14327                return 5;
14328            }
14329            if let Some(_) = self.int32_member {
14330                return 4;
14331            }
14332            if let Some(_) = self.int16_member {
14333                return 3;
14334            }
14335            if let Some(_) = self.int8_member {
14336                return 2;
14337            }
14338            if let Some(_) = self.bool_member {
14339                return 1;
14340            }
14341            0
14342        }
14343    }
14344
14345    impl fidl::encoding::ResourceTypeMarker for AllTypesTable {
14346        type Borrowed<'a> = &'a mut Self;
14347        fn take_or_borrow<'a>(
14348            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
14349        ) -> Self::Borrowed<'a> {
14350            value
14351        }
14352    }
14353
14354    unsafe impl fidl::encoding::TypeMarker for AllTypesTable {
14355        type Owned = Self;
14356
14357        #[inline(always)]
14358        fn inline_align(_context: fidl::encoding::Context) -> usize {
14359            8
14360        }
14361
14362        #[inline(always)]
14363        fn inline_size(_context: fidl::encoding::Context) -> usize {
14364            16
14365        }
14366    }
14367
14368    unsafe impl fidl::encoding::Encode<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>
14369        for &mut AllTypesTable
14370    {
14371        unsafe fn encode(
14372            self,
14373            encoder: &mut fidl::encoding::Encoder<
14374                '_,
14375                fidl::encoding::DefaultFuchsiaResourceDialect,
14376            >,
14377            offset: usize,
14378            mut depth: fidl::encoding::Depth,
14379        ) -> fidl::Result<()> {
14380            encoder.debug_check_bounds::<AllTypesTable>(offset);
14381            // Vector header
14382            let max_ordinal: u64 = self.max_ordinal_present();
14383            encoder.write_num(max_ordinal, offset);
14384            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
14385            // Calling encoder.out_of_line_offset(0) is not allowed.
14386            if max_ordinal == 0 {
14387                return Ok(());
14388            }
14389            depth.increment()?;
14390            let envelope_size = 8;
14391            let bytes_len = max_ordinal as usize * envelope_size;
14392            #[allow(unused_variables)]
14393            let offset = encoder.out_of_line_offset(bytes_len);
14394            let mut _prev_end_offset: usize = 0;
14395            if 1 > max_ordinal {
14396                return Ok(());
14397            }
14398
14399            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14400            // are envelope_size bytes.
14401            let cur_offset: usize = (1 - 1) * envelope_size;
14402
14403            // Zero reserved fields.
14404            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14405
14406            // Safety:
14407            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14408            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14409            //   envelope_size bytes, there is always sufficient room.
14410            fidl::encoding::encode_in_envelope_optional::<
14411                bool,
14412                fidl::encoding::DefaultFuchsiaResourceDialect,
14413            >(
14414                self.bool_member.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
14415                encoder,
14416                offset + cur_offset,
14417                depth,
14418            )?;
14419
14420            _prev_end_offset = cur_offset + envelope_size;
14421            if 2 > max_ordinal {
14422                return Ok(());
14423            }
14424
14425            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14426            // are envelope_size bytes.
14427            let cur_offset: usize = (2 - 1) * envelope_size;
14428
14429            // Zero reserved fields.
14430            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14431
14432            // Safety:
14433            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14434            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14435            //   envelope_size bytes, there is always sufficient room.
14436            fidl::encoding::encode_in_envelope_optional::<
14437                i8,
14438                fidl::encoding::DefaultFuchsiaResourceDialect,
14439            >(
14440                self.int8_member.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
14441                encoder,
14442                offset + cur_offset,
14443                depth,
14444            )?;
14445
14446            _prev_end_offset = cur_offset + envelope_size;
14447            if 3 > max_ordinal {
14448                return Ok(());
14449            }
14450
14451            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14452            // are envelope_size bytes.
14453            let cur_offset: usize = (3 - 1) * envelope_size;
14454
14455            // Zero reserved fields.
14456            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14457
14458            // Safety:
14459            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14460            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14461            //   envelope_size bytes, there is always sufficient room.
14462            fidl::encoding::encode_in_envelope_optional::<
14463                i16,
14464                fidl::encoding::DefaultFuchsiaResourceDialect,
14465            >(
14466                self.int16_member.as_ref().map(<i16 as fidl::encoding::ValueTypeMarker>::borrow),
14467                encoder,
14468                offset + cur_offset,
14469                depth,
14470            )?;
14471
14472            _prev_end_offset = cur_offset + envelope_size;
14473            if 4 > max_ordinal {
14474                return Ok(());
14475            }
14476
14477            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14478            // are envelope_size bytes.
14479            let cur_offset: usize = (4 - 1) * envelope_size;
14480
14481            // Zero reserved fields.
14482            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14483
14484            // Safety:
14485            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14486            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14487            //   envelope_size bytes, there is always sufficient room.
14488            fidl::encoding::encode_in_envelope_optional::<
14489                i32,
14490                fidl::encoding::DefaultFuchsiaResourceDialect,
14491            >(
14492                self.int32_member.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
14493                encoder,
14494                offset + cur_offset,
14495                depth,
14496            )?;
14497
14498            _prev_end_offset = cur_offset + envelope_size;
14499            if 5 > max_ordinal {
14500                return Ok(());
14501            }
14502
14503            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14504            // are envelope_size bytes.
14505            let cur_offset: usize = (5 - 1) * envelope_size;
14506
14507            // Zero reserved fields.
14508            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14509
14510            // Safety:
14511            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14512            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14513            //   envelope_size bytes, there is always sufficient room.
14514            fidl::encoding::encode_in_envelope_optional::<
14515                i64,
14516                fidl::encoding::DefaultFuchsiaResourceDialect,
14517            >(
14518                self.int64_member.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
14519                encoder,
14520                offset + cur_offset,
14521                depth,
14522            )?;
14523
14524            _prev_end_offset = cur_offset + envelope_size;
14525            if 6 > max_ordinal {
14526                return Ok(());
14527            }
14528
14529            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14530            // are envelope_size bytes.
14531            let cur_offset: usize = (6 - 1) * envelope_size;
14532
14533            // Zero reserved fields.
14534            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14535
14536            // Safety:
14537            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14538            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14539            //   envelope_size bytes, there is always sufficient room.
14540            fidl::encoding::encode_in_envelope_optional::<
14541                u8,
14542                fidl::encoding::DefaultFuchsiaResourceDialect,
14543            >(
14544                self.uint8_member.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
14545                encoder,
14546                offset + cur_offset,
14547                depth,
14548            )?;
14549
14550            _prev_end_offset = cur_offset + envelope_size;
14551            if 7 > max_ordinal {
14552                return Ok(());
14553            }
14554
14555            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14556            // are envelope_size bytes.
14557            let cur_offset: usize = (7 - 1) * envelope_size;
14558
14559            // Zero reserved fields.
14560            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14561
14562            // Safety:
14563            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14564            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14565            //   envelope_size bytes, there is always sufficient room.
14566            fidl::encoding::encode_in_envelope_optional::<
14567                u16,
14568                fidl::encoding::DefaultFuchsiaResourceDialect,
14569            >(
14570                self.uint16_member.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
14571                encoder,
14572                offset + cur_offset,
14573                depth,
14574            )?;
14575
14576            _prev_end_offset = cur_offset + envelope_size;
14577            if 8 > max_ordinal {
14578                return Ok(());
14579            }
14580
14581            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14582            // are envelope_size bytes.
14583            let cur_offset: usize = (8 - 1) * envelope_size;
14584
14585            // Zero reserved fields.
14586            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14587
14588            // Safety:
14589            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14590            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14591            //   envelope_size bytes, there is always sufficient room.
14592            fidl::encoding::encode_in_envelope_optional::<
14593                u32,
14594                fidl::encoding::DefaultFuchsiaResourceDialect,
14595            >(
14596                self.uint32_member.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
14597                encoder,
14598                offset + cur_offset,
14599                depth,
14600            )?;
14601
14602            _prev_end_offset = cur_offset + envelope_size;
14603            if 9 > max_ordinal {
14604                return Ok(());
14605            }
14606
14607            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14608            // are envelope_size bytes.
14609            let cur_offset: usize = (9 - 1) * envelope_size;
14610
14611            // Zero reserved fields.
14612            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14613
14614            // Safety:
14615            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14616            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14617            //   envelope_size bytes, there is always sufficient room.
14618            fidl::encoding::encode_in_envelope_optional::<
14619                u64,
14620                fidl::encoding::DefaultFuchsiaResourceDialect,
14621            >(
14622                self.uint64_member.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
14623                encoder,
14624                offset + cur_offset,
14625                depth,
14626            )?;
14627
14628            _prev_end_offset = cur_offset + envelope_size;
14629            if 10 > max_ordinal {
14630                return Ok(());
14631            }
14632
14633            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14634            // are envelope_size bytes.
14635            let cur_offset: usize = (10 - 1) * envelope_size;
14636
14637            // Zero reserved fields.
14638            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14639
14640            // Safety:
14641            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14642            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14643            //   envelope_size bytes, there is always sufficient room.
14644            fidl::encoding::encode_in_envelope_optional::<
14645                f32,
14646                fidl::encoding::DefaultFuchsiaResourceDialect,
14647            >(
14648                self.float32_member.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
14649                encoder,
14650                offset + cur_offset,
14651                depth,
14652            )?;
14653
14654            _prev_end_offset = cur_offset + envelope_size;
14655            if 11 > max_ordinal {
14656                return Ok(());
14657            }
14658
14659            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14660            // are envelope_size bytes.
14661            let cur_offset: usize = (11 - 1) * envelope_size;
14662
14663            // Zero reserved fields.
14664            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14665
14666            // Safety:
14667            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14668            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14669            //   envelope_size bytes, there is always sufficient room.
14670            fidl::encoding::encode_in_envelope_optional::<
14671                f64,
14672                fidl::encoding::DefaultFuchsiaResourceDialect,
14673            >(
14674                self.float64_member.as_ref().map(<f64 as fidl::encoding::ValueTypeMarker>::borrow),
14675                encoder,
14676                offset + cur_offset,
14677                depth,
14678            )?;
14679
14680            _prev_end_offset = cur_offset + envelope_size;
14681            if 12 > max_ordinal {
14682                return Ok(());
14683            }
14684
14685            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14686            // are envelope_size bytes.
14687            let cur_offset: usize = (12 - 1) * envelope_size;
14688
14689            // Zero reserved fields.
14690            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14691
14692            // Safety:
14693            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14694            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14695            //   envelope_size bytes, there is always sufficient room.
14696            fidl::encoding::encode_in_envelope_optional::<
14697                DefaultEnum,
14698                fidl::encoding::DefaultFuchsiaResourceDialect,
14699            >(
14700                self.enum_member
14701                    .as_ref()
14702                    .map(<DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow),
14703                encoder,
14704                offset + cur_offset,
14705                depth,
14706            )?;
14707
14708            _prev_end_offset = cur_offset + envelope_size;
14709            if 13 > max_ordinal {
14710                return Ok(());
14711            }
14712
14713            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14714            // are envelope_size bytes.
14715            let cur_offset: usize = (13 - 1) * envelope_size;
14716
14717            // Zero reserved fields.
14718            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14719
14720            // Safety:
14721            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14722            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14723            //   envelope_size bytes, there is always sufficient room.
14724            fidl::encoding::encode_in_envelope_optional::<
14725                DefaultBits,
14726                fidl::encoding::DefaultFuchsiaResourceDialect,
14727            >(
14728                self.bits_member
14729                    .as_ref()
14730                    .map(<DefaultBits as fidl::encoding::ValueTypeMarker>::borrow),
14731                encoder,
14732                offset + cur_offset,
14733                depth,
14734            )?;
14735
14736            _prev_end_offset = cur_offset + envelope_size;
14737            if 14 > max_ordinal {
14738                return Ok(());
14739            }
14740
14741            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14742            // are envelope_size bytes.
14743            let cur_offset: usize = (14 - 1) * envelope_size;
14744
14745            // Zero reserved fields.
14746            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14747
14748            // Safety:
14749            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14750            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14751            //   envelope_size bytes, there is always sufficient room.
14752            fidl::encoding::encode_in_envelope_optional::<
14753                fidl::encoding::HandleType<
14754                    fidl::NullableHandle,
14755                    { fidl::ObjectType::NONE.into_raw() },
14756                    2147483648,
14757                >,
14758                fidl::encoding::DefaultFuchsiaResourceDialect,
14759            >(
14760                self.handle_member.as_mut().map(
14761                    <fidl::encoding::HandleType<
14762                        fidl::NullableHandle,
14763                        { fidl::ObjectType::NONE.into_raw() },
14764                        2147483648,
14765                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
14766                ),
14767                encoder,
14768                offset + cur_offset,
14769                depth,
14770            )?;
14771
14772            _prev_end_offset = cur_offset + envelope_size;
14773            if 15 > max_ordinal {
14774                return Ok(());
14775            }
14776
14777            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14778            // are envelope_size bytes.
14779            let cur_offset: usize = (15 - 1) * envelope_size;
14780
14781            // Zero reserved fields.
14782            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14783
14784            // Safety:
14785            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14786            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14787            //   envelope_size bytes, there is always sufficient room.
14788            fidl::encoding::encode_in_envelope_optional::<
14789                fidl::encoding::UnboundedString,
14790                fidl::encoding::DefaultFuchsiaResourceDialect,
14791            >(
14792                self.string_member.as_ref().map(
14793                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
14794                ),
14795                encoder,
14796                offset + cur_offset,
14797                depth,
14798            )?;
14799
14800            _prev_end_offset = cur_offset + envelope_size;
14801            if 16 > max_ordinal {
14802                return Ok(());
14803            }
14804
14805            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14806            // are envelope_size bytes.
14807            let cur_offset: usize = (16 - 1) * envelope_size;
14808
14809            // Zero reserved fields.
14810            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14811
14812            // Safety:
14813            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14814            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14815            //   envelope_size bytes, there is always sufficient room.
14816            fidl::encoding::encode_in_envelope_optional::<
14817                ThisIsAStruct,
14818                fidl::encoding::DefaultFuchsiaResourceDialect,
14819            >(
14820                self.struct_member
14821                    .as_ref()
14822                    .map(<ThisIsAStruct as fidl::encoding::ValueTypeMarker>::borrow),
14823                encoder,
14824                offset + cur_offset,
14825                depth,
14826            )?;
14827
14828            _prev_end_offset = cur_offset + envelope_size;
14829            if 17 > max_ordinal {
14830                return Ok(());
14831            }
14832
14833            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14834            // are envelope_size bytes.
14835            let cur_offset: usize = (17 - 1) * envelope_size;
14836
14837            // Zero reserved fields.
14838            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14839
14840            // Safety:
14841            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14842            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14843            //   envelope_size bytes, there is always sufficient room.
14844            fidl::encoding::encode_in_envelope_optional::<
14845                ThisIsAUnion,
14846                fidl::encoding::DefaultFuchsiaResourceDialect,
14847            >(
14848                self.union_member
14849                    .as_ref()
14850                    .map(<ThisIsAUnion as fidl::encoding::ValueTypeMarker>::borrow),
14851                encoder,
14852                offset + cur_offset,
14853                depth,
14854            )?;
14855
14856            _prev_end_offset = cur_offset + envelope_size;
14857            if 18 > max_ordinal {
14858                return Ok(());
14859            }
14860
14861            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14862            // are envelope_size bytes.
14863            let cur_offset: usize = (18 - 1) * envelope_size;
14864
14865            // Zero reserved fields.
14866            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14867
14868            // Safety:
14869            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14870            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14871            //   envelope_size bytes, there is always sufficient room.
14872            fidl::encoding::encode_in_envelope_optional::<
14873                fidl::encoding::Array<u32, 3>,
14874                fidl::encoding::DefaultFuchsiaResourceDialect,
14875            >(
14876                self.array_member.as_ref().map(
14877                    <fidl::encoding::Array<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow,
14878                ),
14879                encoder,
14880                offset + cur_offset,
14881                depth,
14882            )?;
14883
14884            _prev_end_offset = cur_offset + envelope_size;
14885            if 19 > max_ordinal {
14886                return Ok(());
14887            }
14888
14889            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14890            // are envelope_size bytes.
14891            let cur_offset: usize = (19 - 1) * envelope_size;
14892
14893            // Zero reserved fields.
14894            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14895
14896            // Safety:
14897            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14898            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14899            //   envelope_size bytes, there is always sufficient room.
14900            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u32>, fidl::encoding::DefaultFuchsiaResourceDialect>(
14901            self.vector_member.as_ref().map(<fidl::encoding::UnboundedVector<u32> as fidl::encoding::ValueTypeMarker>::borrow),
14902            encoder, offset + cur_offset, depth
14903        )?;
14904
14905            _prev_end_offset = cur_offset + envelope_size;
14906            if 20 > max_ordinal {
14907                return Ok(());
14908            }
14909
14910            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14911            // are envelope_size bytes.
14912            let cur_offset: usize = (20 - 1) * envelope_size;
14913
14914            // Zero reserved fields.
14915            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14916
14917            // Safety:
14918            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14919            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14920            //   envelope_size bytes, there is always sufficient room.
14921            fidl::encoding::encode_in_envelope_optional::<
14922                ThisIsATable,
14923                fidl::encoding::DefaultFuchsiaResourceDialect,
14924            >(
14925                self.table_member
14926                    .as_ref()
14927                    .map(<ThisIsATable as fidl::encoding::ValueTypeMarker>::borrow),
14928                encoder,
14929                offset + cur_offset,
14930                depth,
14931            )?;
14932
14933            _prev_end_offset = cur_offset + envelope_size;
14934            if 21 > max_ordinal {
14935                return Ok(());
14936            }
14937
14938            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14939            // are envelope_size bytes.
14940            let cur_offset: usize = (21 - 1) * envelope_size;
14941
14942            // Zero reserved fields.
14943            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14944
14945            // Safety:
14946            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14947            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14948            //   envelope_size bytes, there is always sufficient room.
14949            fidl::encoding::encode_in_envelope_optional::<
14950                ThisIsAXunion,
14951                fidl::encoding::DefaultFuchsiaResourceDialect,
14952            >(
14953                self.xunion_member
14954                    .as_ref()
14955                    .map(<ThisIsAXunion as fidl::encoding::ValueTypeMarker>::borrow),
14956                encoder,
14957                offset + cur_offset,
14958                depth,
14959            )?;
14960
14961            _prev_end_offset = cur_offset + envelope_size;
14962
14963            Ok(())
14964        }
14965    }
14966
14967    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for AllTypesTable {
14968        #[inline(always)]
14969        fn new_empty() -> Self {
14970            Self::default()
14971        }
14972
14973        unsafe fn decode(
14974            &mut self,
14975            decoder: &mut fidl::encoding::Decoder<
14976                '_,
14977                fidl::encoding::DefaultFuchsiaResourceDialect,
14978            >,
14979            offset: usize,
14980            mut depth: fidl::encoding::Depth,
14981        ) -> fidl::Result<()> {
14982            decoder.debug_check_bounds::<Self>(offset);
14983            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
14984                None => return Err(fidl::Error::NotNullable),
14985                Some(len) => len,
14986            };
14987            // Calling decoder.out_of_line_offset(0) is not allowed.
14988            if len == 0 {
14989                return Ok(());
14990            };
14991            depth.increment()?;
14992            let envelope_size = 8;
14993            let bytes_len = len * envelope_size;
14994            let offset = decoder.out_of_line_offset(bytes_len)?;
14995            // Decode the envelope for each type.
14996            let mut _next_ordinal_to_read = 0;
14997            let mut next_offset = offset;
14998            let end_offset = offset + bytes_len;
14999            _next_ordinal_to_read += 1;
15000            if next_offset >= end_offset {
15001                return Ok(());
15002            }
15003
15004            // Decode unknown envelopes for gaps in ordinals.
15005            while _next_ordinal_to_read < 1 {
15006                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15007                _next_ordinal_to_read += 1;
15008                next_offset += envelope_size;
15009            }
15010
15011            let next_out_of_line = decoder.next_out_of_line();
15012            let handles_before = decoder.remaining_handles();
15013            if let Some((inlined, num_bytes, num_handles)) =
15014                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15015            {
15016                let member_inline_size =
15017                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15018                if inlined != (member_inline_size <= 4) {
15019                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15020                }
15021                let inner_offset;
15022                let mut inner_depth = depth.clone();
15023                if inlined {
15024                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15025                    inner_offset = next_offset;
15026                } else {
15027                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15028                    inner_depth.increment()?;
15029                }
15030                let val_ref = self.bool_member.get_or_insert_with(|| {
15031                    fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect)
15032                });
15033                fidl::decode!(
15034                    bool,
15035                    fidl::encoding::DefaultFuchsiaResourceDialect,
15036                    val_ref,
15037                    decoder,
15038                    inner_offset,
15039                    inner_depth
15040                )?;
15041                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15042                {
15043                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15044                }
15045                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15046                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15047                }
15048            }
15049
15050            next_offset += envelope_size;
15051            _next_ordinal_to_read += 1;
15052            if next_offset >= end_offset {
15053                return Ok(());
15054            }
15055
15056            // Decode unknown envelopes for gaps in ordinals.
15057            while _next_ordinal_to_read < 2 {
15058                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15059                _next_ordinal_to_read += 1;
15060                next_offset += envelope_size;
15061            }
15062
15063            let next_out_of_line = decoder.next_out_of_line();
15064            let handles_before = decoder.remaining_handles();
15065            if let Some((inlined, num_bytes, num_handles)) =
15066                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15067            {
15068                let member_inline_size =
15069                    <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15070                if inlined != (member_inline_size <= 4) {
15071                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15072                }
15073                let inner_offset;
15074                let mut inner_depth = depth.clone();
15075                if inlined {
15076                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15077                    inner_offset = next_offset;
15078                } else {
15079                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15080                    inner_depth.increment()?;
15081                }
15082                let val_ref = self.int8_member.get_or_insert_with(|| {
15083                    fidl::new_empty!(i8, fidl::encoding::DefaultFuchsiaResourceDialect)
15084                });
15085                fidl::decode!(
15086                    i8,
15087                    fidl::encoding::DefaultFuchsiaResourceDialect,
15088                    val_ref,
15089                    decoder,
15090                    inner_offset,
15091                    inner_depth
15092                )?;
15093                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15094                {
15095                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15096                }
15097                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15098                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15099                }
15100            }
15101
15102            next_offset += envelope_size;
15103            _next_ordinal_to_read += 1;
15104            if next_offset >= end_offset {
15105                return Ok(());
15106            }
15107
15108            // Decode unknown envelopes for gaps in ordinals.
15109            while _next_ordinal_to_read < 3 {
15110                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15111                _next_ordinal_to_read += 1;
15112                next_offset += envelope_size;
15113            }
15114
15115            let next_out_of_line = decoder.next_out_of_line();
15116            let handles_before = decoder.remaining_handles();
15117            if let Some((inlined, num_bytes, num_handles)) =
15118                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15119            {
15120                let member_inline_size =
15121                    <i16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15122                if inlined != (member_inline_size <= 4) {
15123                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15124                }
15125                let inner_offset;
15126                let mut inner_depth = depth.clone();
15127                if inlined {
15128                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15129                    inner_offset = next_offset;
15130                } else {
15131                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15132                    inner_depth.increment()?;
15133                }
15134                let val_ref = self.int16_member.get_or_insert_with(|| {
15135                    fidl::new_empty!(i16, fidl::encoding::DefaultFuchsiaResourceDialect)
15136                });
15137                fidl::decode!(
15138                    i16,
15139                    fidl::encoding::DefaultFuchsiaResourceDialect,
15140                    val_ref,
15141                    decoder,
15142                    inner_offset,
15143                    inner_depth
15144                )?;
15145                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15146                {
15147                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15148                }
15149                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15150                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15151                }
15152            }
15153
15154            next_offset += envelope_size;
15155            _next_ordinal_to_read += 1;
15156            if next_offset >= end_offset {
15157                return Ok(());
15158            }
15159
15160            // Decode unknown envelopes for gaps in ordinals.
15161            while _next_ordinal_to_read < 4 {
15162                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15163                _next_ordinal_to_read += 1;
15164                next_offset += envelope_size;
15165            }
15166
15167            let next_out_of_line = decoder.next_out_of_line();
15168            let handles_before = decoder.remaining_handles();
15169            if let Some((inlined, num_bytes, num_handles)) =
15170                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15171            {
15172                let member_inline_size =
15173                    <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15174                if inlined != (member_inline_size <= 4) {
15175                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15176                }
15177                let inner_offset;
15178                let mut inner_depth = depth.clone();
15179                if inlined {
15180                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15181                    inner_offset = next_offset;
15182                } else {
15183                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15184                    inner_depth.increment()?;
15185                }
15186                let val_ref = self.int32_member.get_or_insert_with(|| {
15187                    fidl::new_empty!(i32, fidl::encoding::DefaultFuchsiaResourceDialect)
15188                });
15189                fidl::decode!(
15190                    i32,
15191                    fidl::encoding::DefaultFuchsiaResourceDialect,
15192                    val_ref,
15193                    decoder,
15194                    inner_offset,
15195                    inner_depth
15196                )?;
15197                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15198                {
15199                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15200                }
15201                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15202                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15203                }
15204            }
15205
15206            next_offset += envelope_size;
15207            _next_ordinal_to_read += 1;
15208            if next_offset >= end_offset {
15209                return Ok(());
15210            }
15211
15212            // Decode unknown envelopes for gaps in ordinals.
15213            while _next_ordinal_to_read < 5 {
15214                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15215                _next_ordinal_to_read += 1;
15216                next_offset += envelope_size;
15217            }
15218
15219            let next_out_of_line = decoder.next_out_of_line();
15220            let handles_before = decoder.remaining_handles();
15221            if let Some((inlined, num_bytes, num_handles)) =
15222                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15223            {
15224                let member_inline_size =
15225                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15226                if inlined != (member_inline_size <= 4) {
15227                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15228                }
15229                let inner_offset;
15230                let mut inner_depth = depth.clone();
15231                if inlined {
15232                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15233                    inner_offset = next_offset;
15234                } else {
15235                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15236                    inner_depth.increment()?;
15237                }
15238                let val_ref = self.int64_member.get_or_insert_with(|| {
15239                    fidl::new_empty!(i64, fidl::encoding::DefaultFuchsiaResourceDialect)
15240                });
15241                fidl::decode!(
15242                    i64,
15243                    fidl::encoding::DefaultFuchsiaResourceDialect,
15244                    val_ref,
15245                    decoder,
15246                    inner_offset,
15247                    inner_depth
15248                )?;
15249                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15250                {
15251                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15252                }
15253                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15254                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15255                }
15256            }
15257
15258            next_offset += envelope_size;
15259            _next_ordinal_to_read += 1;
15260            if next_offset >= end_offset {
15261                return Ok(());
15262            }
15263
15264            // Decode unknown envelopes for gaps in ordinals.
15265            while _next_ordinal_to_read < 6 {
15266                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15267                _next_ordinal_to_read += 1;
15268                next_offset += envelope_size;
15269            }
15270
15271            let next_out_of_line = decoder.next_out_of_line();
15272            let handles_before = decoder.remaining_handles();
15273            if let Some((inlined, num_bytes, num_handles)) =
15274                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15275            {
15276                let member_inline_size =
15277                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15278                if inlined != (member_inline_size <= 4) {
15279                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15280                }
15281                let inner_offset;
15282                let mut inner_depth = depth.clone();
15283                if inlined {
15284                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15285                    inner_offset = next_offset;
15286                } else {
15287                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15288                    inner_depth.increment()?;
15289                }
15290                let val_ref = self.uint8_member.get_or_insert_with(|| {
15291                    fidl::new_empty!(u8, fidl::encoding::DefaultFuchsiaResourceDialect)
15292                });
15293                fidl::decode!(
15294                    u8,
15295                    fidl::encoding::DefaultFuchsiaResourceDialect,
15296                    val_ref,
15297                    decoder,
15298                    inner_offset,
15299                    inner_depth
15300                )?;
15301                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15302                {
15303                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15304                }
15305                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15306                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15307                }
15308            }
15309
15310            next_offset += envelope_size;
15311            _next_ordinal_to_read += 1;
15312            if next_offset >= end_offset {
15313                return Ok(());
15314            }
15315
15316            // Decode unknown envelopes for gaps in ordinals.
15317            while _next_ordinal_to_read < 7 {
15318                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15319                _next_ordinal_to_read += 1;
15320                next_offset += envelope_size;
15321            }
15322
15323            let next_out_of_line = decoder.next_out_of_line();
15324            let handles_before = decoder.remaining_handles();
15325            if let Some((inlined, num_bytes, num_handles)) =
15326                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15327            {
15328                let member_inline_size =
15329                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15330                if inlined != (member_inline_size <= 4) {
15331                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15332                }
15333                let inner_offset;
15334                let mut inner_depth = depth.clone();
15335                if inlined {
15336                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15337                    inner_offset = next_offset;
15338                } else {
15339                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15340                    inner_depth.increment()?;
15341                }
15342                let val_ref = self.uint16_member.get_or_insert_with(|| {
15343                    fidl::new_empty!(u16, fidl::encoding::DefaultFuchsiaResourceDialect)
15344                });
15345                fidl::decode!(
15346                    u16,
15347                    fidl::encoding::DefaultFuchsiaResourceDialect,
15348                    val_ref,
15349                    decoder,
15350                    inner_offset,
15351                    inner_depth
15352                )?;
15353                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15354                {
15355                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15356                }
15357                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15358                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15359                }
15360            }
15361
15362            next_offset += envelope_size;
15363            _next_ordinal_to_read += 1;
15364            if next_offset >= end_offset {
15365                return Ok(());
15366            }
15367
15368            // Decode unknown envelopes for gaps in ordinals.
15369            while _next_ordinal_to_read < 8 {
15370                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15371                _next_ordinal_to_read += 1;
15372                next_offset += envelope_size;
15373            }
15374
15375            let next_out_of_line = decoder.next_out_of_line();
15376            let handles_before = decoder.remaining_handles();
15377            if let Some((inlined, num_bytes, num_handles)) =
15378                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15379            {
15380                let member_inline_size =
15381                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15382                if inlined != (member_inline_size <= 4) {
15383                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15384                }
15385                let inner_offset;
15386                let mut inner_depth = depth.clone();
15387                if inlined {
15388                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15389                    inner_offset = next_offset;
15390                } else {
15391                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15392                    inner_depth.increment()?;
15393                }
15394                let val_ref = self.uint32_member.get_or_insert_with(|| {
15395                    fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect)
15396                });
15397                fidl::decode!(
15398                    u32,
15399                    fidl::encoding::DefaultFuchsiaResourceDialect,
15400                    val_ref,
15401                    decoder,
15402                    inner_offset,
15403                    inner_depth
15404                )?;
15405                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15406                {
15407                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15408                }
15409                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15410                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15411                }
15412            }
15413
15414            next_offset += envelope_size;
15415            _next_ordinal_to_read += 1;
15416            if next_offset >= end_offset {
15417                return Ok(());
15418            }
15419
15420            // Decode unknown envelopes for gaps in ordinals.
15421            while _next_ordinal_to_read < 9 {
15422                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15423                _next_ordinal_to_read += 1;
15424                next_offset += envelope_size;
15425            }
15426
15427            let next_out_of_line = decoder.next_out_of_line();
15428            let handles_before = decoder.remaining_handles();
15429            if let Some((inlined, num_bytes, num_handles)) =
15430                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15431            {
15432                let member_inline_size =
15433                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15434                if inlined != (member_inline_size <= 4) {
15435                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15436                }
15437                let inner_offset;
15438                let mut inner_depth = depth.clone();
15439                if inlined {
15440                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15441                    inner_offset = next_offset;
15442                } else {
15443                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15444                    inner_depth.increment()?;
15445                }
15446                let val_ref = self.uint64_member.get_or_insert_with(|| {
15447                    fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect)
15448                });
15449                fidl::decode!(
15450                    u64,
15451                    fidl::encoding::DefaultFuchsiaResourceDialect,
15452                    val_ref,
15453                    decoder,
15454                    inner_offset,
15455                    inner_depth
15456                )?;
15457                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15458                {
15459                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15460                }
15461                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15462                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15463                }
15464            }
15465
15466            next_offset += envelope_size;
15467            _next_ordinal_to_read += 1;
15468            if next_offset >= end_offset {
15469                return Ok(());
15470            }
15471
15472            // Decode unknown envelopes for gaps in ordinals.
15473            while _next_ordinal_to_read < 10 {
15474                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15475                _next_ordinal_to_read += 1;
15476                next_offset += envelope_size;
15477            }
15478
15479            let next_out_of_line = decoder.next_out_of_line();
15480            let handles_before = decoder.remaining_handles();
15481            if let Some((inlined, num_bytes, num_handles)) =
15482                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15483            {
15484                let member_inline_size =
15485                    <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15486                if inlined != (member_inline_size <= 4) {
15487                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15488                }
15489                let inner_offset;
15490                let mut inner_depth = depth.clone();
15491                if inlined {
15492                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15493                    inner_offset = next_offset;
15494                } else {
15495                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15496                    inner_depth.increment()?;
15497                }
15498                let val_ref = self.float32_member.get_or_insert_with(|| {
15499                    fidl::new_empty!(f32, fidl::encoding::DefaultFuchsiaResourceDialect)
15500                });
15501                fidl::decode!(
15502                    f32,
15503                    fidl::encoding::DefaultFuchsiaResourceDialect,
15504                    val_ref,
15505                    decoder,
15506                    inner_offset,
15507                    inner_depth
15508                )?;
15509                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15510                {
15511                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15512                }
15513                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15514                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15515                }
15516            }
15517
15518            next_offset += envelope_size;
15519            _next_ordinal_to_read += 1;
15520            if next_offset >= end_offset {
15521                return Ok(());
15522            }
15523
15524            // Decode unknown envelopes for gaps in ordinals.
15525            while _next_ordinal_to_read < 11 {
15526                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15527                _next_ordinal_to_read += 1;
15528                next_offset += envelope_size;
15529            }
15530
15531            let next_out_of_line = decoder.next_out_of_line();
15532            let handles_before = decoder.remaining_handles();
15533            if let Some((inlined, num_bytes, num_handles)) =
15534                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15535            {
15536                let member_inline_size =
15537                    <f64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15538                if inlined != (member_inline_size <= 4) {
15539                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15540                }
15541                let inner_offset;
15542                let mut inner_depth = depth.clone();
15543                if inlined {
15544                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15545                    inner_offset = next_offset;
15546                } else {
15547                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15548                    inner_depth.increment()?;
15549                }
15550                let val_ref = self.float64_member.get_or_insert_with(|| {
15551                    fidl::new_empty!(f64, fidl::encoding::DefaultFuchsiaResourceDialect)
15552                });
15553                fidl::decode!(
15554                    f64,
15555                    fidl::encoding::DefaultFuchsiaResourceDialect,
15556                    val_ref,
15557                    decoder,
15558                    inner_offset,
15559                    inner_depth
15560                )?;
15561                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15562                {
15563                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15564                }
15565                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15566                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15567                }
15568            }
15569
15570            next_offset += envelope_size;
15571            _next_ordinal_to_read += 1;
15572            if next_offset >= end_offset {
15573                return Ok(());
15574            }
15575
15576            // Decode unknown envelopes for gaps in ordinals.
15577            while _next_ordinal_to_read < 12 {
15578                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15579                _next_ordinal_to_read += 1;
15580                next_offset += envelope_size;
15581            }
15582
15583            let next_out_of_line = decoder.next_out_of_line();
15584            let handles_before = decoder.remaining_handles();
15585            if let Some((inlined, num_bytes, num_handles)) =
15586                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15587            {
15588                let member_inline_size =
15589                    <DefaultEnum as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15590                if inlined != (member_inline_size <= 4) {
15591                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15592                }
15593                let inner_offset;
15594                let mut inner_depth = depth.clone();
15595                if inlined {
15596                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15597                    inner_offset = next_offset;
15598                } else {
15599                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15600                    inner_depth.increment()?;
15601                }
15602                let val_ref = self.enum_member.get_or_insert_with(|| {
15603                    fidl::new_empty!(DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect)
15604                });
15605                fidl::decode!(
15606                    DefaultEnum,
15607                    fidl::encoding::DefaultFuchsiaResourceDialect,
15608                    val_ref,
15609                    decoder,
15610                    inner_offset,
15611                    inner_depth
15612                )?;
15613                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15614                {
15615                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15616                }
15617                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15618                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15619                }
15620            }
15621
15622            next_offset += envelope_size;
15623            _next_ordinal_to_read += 1;
15624            if next_offset >= end_offset {
15625                return Ok(());
15626            }
15627
15628            // Decode unknown envelopes for gaps in ordinals.
15629            while _next_ordinal_to_read < 13 {
15630                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15631                _next_ordinal_to_read += 1;
15632                next_offset += envelope_size;
15633            }
15634
15635            let next_out_of_line = decoder.next_out_of_line();
15636            let handles_before = decoder.remaining_handles();
15637            if let Some((inlined, num_bytes, num_handles)) =
15638                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15639            {
15640                let member_inline_size =
15641                    <DefaultBits as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15642                if inlined != (member_inline_size <= 4) {
15643                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15644                }
15645                let inner_offset;
15646                let mut inner_depth = depth.clone();
15647                if inlined {
15648                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15649                    inner_offset = next_offset;
15650                } else {
15651                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15652                    inner_depth.increment()?;
15653                }
15654                let val_ref = self.bits_member.get_or_insert_with(|| {
15655                    fidl::new_empty!(DefaultBits, fidl::encoding::DefaultFuchsiaResourceDialect)
15656                });
15657                fidl::decode!(
15658                    DefaultBits,
15659                    fidl::encoding::DefaultFuchsiaResourceDialect,
15660                    val_ref,
15661                    decoder,
15662                    inner_offset,
15663                    inner_depth
15664                )?;
15665                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15666                {
15667                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15668                }
15669                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15670                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15671                }
15672            }
15673
15674            next_offset += envelope_size;
15675            _next_ordinal_to_read += 1;
15676            if next_offset >= end_offset {
15677                return Ok(());
15678            }
15679
15680            // Decode unknown envelopes for gaps in ordinals.
15681            while _next_ordinal_to_read < 14 {
15682                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15683                _next_ordinal_to_read += 1;
15684                next_offset += envelope_size;
15685            }
15686
15687            let next_out_of_line = decoder.next_out_of_line();
15688            let handles_before = decoder.remaining_handles();
15689            if let Some((inlined, num_bytes, num_handles)) =
15690                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15691            {
15692                let member_inline_size = <fidl::encoding::HandleType<
15693                    fidl::NullableHandle,
15694                    { fidl::ObjectType::NONE.into_raw() },
15695                    2147483648,
15696                > as fidl::encoding::TypeMarker>::inline_size(
15697                    decoder.context
15698                );
15699                if inlined != (member_inline_size <= 4) {
15700                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15701                }
15702                let inner_offset;
15703                let mut inner_depth = depth.clone();
15704                if inlined {
15705                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15706                    inner_offset = next_offset;
15707                } else {
15708                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15709                    inner_depth.increment()?;
15710                }
15711                let val_ref =
15712                self.handle_member.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
15713                fidl::decode!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
15714                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15715                {
15716                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15717                }
15718                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15719                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15720                }
15721            }
15722
15723            next_offset += envelope_size;
15724            _next_ordinal_to_read += 1;
15725            if next_offset >= end_offset {
15726                return Ok(());
15727            }
15728
15729            // Decode unknown envelopes for gaps in ordinals.
15730            while _next_ordinal_to_read < 15 {
15731                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15732                _next_ordinal_to_read += 1;
15733                next_offset += envelope_size;
15734            }
15735
15736            let next_out_of_line = decoder.next_out_of_line();
15737            let handles_before = decoder.remaining_handles();
15738            if let Some((inlined, num_bytes, num_handles)) =
15739                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15740            {
15741                let member_inline_size =
15742                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
15743                        decoder.context,
15744                    );
15745                if inlined != (member_inline_size <= 4) {
15746                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15747                }
15748                let inner_offset;
15749                let mut inner_depth = depth.clone();
15750                if inlined {
15751                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15752                    inner_offset = next_offset;
15753                } else {
15754                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15755                    inner_depth.increment()?;
15756                }
15757                let val_ref = self.string_member.get_or_insert_with(|| {
15758                    fidl::new_empty!(
15759                        fidl::encoding::UnboundedString,
15760                        fidl::encoding::DefaultFuchsiaResourceDialect
15761                    )
15762                });
15763                fidl::decode!(
15764                    fidl::encoding::UnboundedString,
15765                    fidl::encoding::DefaultFuchsiaResourceDialect,
15766                    val_ref,
15767                    decoder,
15768                    inner_offset,
15769                    inner_depth
15770                )?;
15771                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15772                {
15773                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15774                }
15775                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15776                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15777                }
15778            }
15779
15780            next_offset += envelope_size;
15781            _next_ordinal_to_read += 1;
15782            if next_offset >= end_offset {
15783                return Ok(());
15784            }
15785
15786            // Decode unknown envelopes for gaps in ordinals.
15787            while _next_ordinal_to_read < 16 {
15788                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15789                _next_ordinal_to_read += 1;
15790                next_offset += envelope_size;
15791            }
15792
15793            let next_out_of_line = decoder.next_out_of_line();
15794            let handles_before = decoder.remaining_handles();
15795            if let Some((inlined, num_bytes, num_handles)) =
15796                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15797            {
15798                let member_inline_size =
15799                    <ThisIsAStruct as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15800                if inlined != (member_inline_size <= 4) {
15801                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15802                }
15803                let inner_offset;
15804                let mut inner_depth = depth.clone();
15805                if inlined {
15806                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15807                    inner_offset = next_offset;
15808                } else {
15809                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15810                    inner_depth.increment()?;
15811                }
15812                let val_ref = self.struct_member.get_or_insert_with(|| {
15813                    fidl::new_empty!(ThisIsAStruct, fidl::encoding::DefaultFuchsiaResourceDialect)
15814                });
15815                fidl::decode!(
15816                    ThisIsAStruct,
15817                    fidl::encoding::DefaultFuchsiaResourceDialect,
15818                    val_ref,
15819                    decoder,
15820                    inner_offset,
15821                    inner_depth
15822                )?;
15823                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15824                {
15825                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15826                }
15827                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15828                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15829                }
15830            }
15831
15832            next_offset += envelope_size;
15833            _next_ordinal_to_read += 1;
15834            if next_offset >= end_offset {
15835                return Ok(());
15836            }
15837
15838            // Decode unknown envelopes for gaps in ordinals.
15839            while _next_ordinal_to_read < 17 {
15840                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15841                _next_ordinal_to_read += 1;
15842                next_offset += envelope_size;
15843            }
15844
15845            let next_out_of_line = decoder.next_out_of_line();
15846            let handles_before = decoder.remaining_handles();
15847            if let Some((inlined, num_bytes, num_handles)) =
15848                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15849            {
15850                let member_inline_size =
15851                    <ThisIsAUnion as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15852                if inlined != (member_inline_size <= 4) {
15853                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15854                }
15855                let inner_offset;
15856                let mut inner_depth = depth.clone();
15857                if inlined {
15858                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15859                    inner_offset = next_offset;
15860                } else {
15861                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15862                    inner_depth.increment()?;
15863                }
15864                let val_ref = self.union_member.get_or_insert_with(|| {
15865                    fidl::new_empty!(ThisIsAUnion, fidl::encoding::DefaultFuchsiaResourceDialect)
15866                });
15867                fidl::decode!(
15868                    ThisIsAUnion,
15869                    fidl::encoding::DefaultFuchsiaResourceDialect,
15870                    val_ref,
15871                    decoder,
15872                    inner_offset,
15873                    inner_depth
15874                )?;
15875                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15876                {
15877                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15878                }
15879                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15880                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15881                }
15882            }
15883
15884            next_offset += envelope_size;
15885            _next_ordinal_to_read += 1;
15886            if next_offset >= end_offset {
15887                return Ok(());
15888            }
15889
15890            // Decode unknown envelopes for gaps in ordinals.
15891            while _next_ordinal_to_read < 18 {
15892                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15893                _next_ordinal_to_read += 1;
15894                next_offset += envelope_size;
15895            }
15896
15897            let next_out_of_line = decoder.next_out_of_line();
15898            let handles_before = decoder.remaining_handles();
15899            if let Some((inlined, num_bytes, num_handles)) =
15900                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15901            {
15902                let member_inline_size =
15903                    <fidl::encoding::Array<u32, 3> as fidl::encoding::TypeMarker>::inline_size(
15904                        decoder.context,
15905                    );
15906                if inlined != (member_inline_size <= 4) {
15907                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15908                }
15909                let inner_offset;
15910                let mut inner_depth = depth.clone();
15911                if inlined {
15912                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15913                    inner_offset = next_offset;
15914                } else {
15915                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15916                    inner_depth.increment()?;
15917                }
15918                let val_ref =
15919                self.array_member.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect));
15920                fidl::decode!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
15921                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15922                {
15923                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15924                }
15925                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15926                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15927                }
15928            }
15929
15930            next_offset += envelope_size;
15931            _next_ordinal_to_read += 1;
15932            if next_offset >= end_offset {
15933                return Ok(());
15934            }
15935
15936            // Decode unknown envelopes for gaps in ordinals.
15937            while _next_ordinal_to_read < 19 {
15938                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15939                _next_ordinal_to_read += 1;
15940                next_offset += envelope_size;
15941            }
15942
15943            let next_out_of_line = decoder.next_out_of_line();
15944            let handles_before = decoder.remaining_handles();
15945            if let Some((inlined, num_bytes, num_handles)) =
15946                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15947            {
15948                let member_inline_size = <fidl::encoding::UnboundedVector<u32> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15949                if inlined != (member_inline_size <= 4) {
15950                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15951                }
15952                let inner_offset;
15953                let mut inner_depth = depth.clone();
15954                if inlined {
15955                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15956                    inner_offset = next_offset;
15957                } else {
15958                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15959                    inner_depth.increment()?;
15960                }
15961                let val_ref = self.vector_member.get_or_insert_with(|| {
15962                    fidl::new_empty!(
15963                        fidl::encoding::UnboundedVector<u32>,
15964                        fidl::encoding::DefaultFuchsiaResourceDialect
15965                    )
15966                });
15967                fidl::decode!(
15968                    fidl::encoding::UnboundedVector<u32>,
15969                    fidl::encoding::DefaultFuchsiaResourceDialect,
15970                    val_ref,
15971                    decoder,
15972                    inner_offset,
15973                    inner_depth
15974                )?;
15975                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15976                {
15977                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15978                }
15979                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15980                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15981                }
15982            }
15983
15984            next_offset += envelope_size;
15985            _next_ordinal_to_read += 1;
15986            if next_offset >= end_offset {
15987                return Ok(());
15988            }
15989
15990            // Decode unknown envelopes for gaps in ordinals.
15991            while _next_ordinal_to_read < 20 {
15992                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15993                _next_ordinal_to_read += 1;
15994                next_offset += envelope_size;
15995            }
15996
15997            let next_out_of_line = decoder.next_out_of_line();
15998            let handles_before = decoder.remaining_handles();
15999            if let Some((inlined, num_bytes, num_handles)) =
16000                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16001            {
16002                let member_inline_size =
16003                    <ThisIsATable as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16004                if inlined != (member_inline_size <= 4) {
16005                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16006                }
16007                let inner_offset;
16008                let mut inner_depth = depth.clone();
16009                if inlined {
16010                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16011                    inner_offset = next_offset;
16012                } else {
16013                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16014                    inner_depth.increment()?;
16015                }
16016                let val_ref = self.table_member.get_or_insert_with(|| {
16017                    fidl::new_empty!(ThisIsATable, fidl::encoding::DefaultFuchsiaResourceDialect)
16018                });
16019                fidl::decode!(
16020                    ThisIsATable,
16021                    fidl::encoding::DefaultFuchsiaResourceDialect,
16022                    val_ref,
16023                    decoder,
16024                    inner_offset,
16025                    inner_depth
16026                )?;
16027                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16028                {
16029                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16030                }
16031                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16032                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16033                }
16034            }
16035
16036            next_offset += envelope_size;
16037            _next_ordinal_to_read += 1;
16038            if next_offset >= end_offset {
16039                return Ok(());
16040            }
16041
16042            // Decode unknown envelopes for gaps in ordinals.
16043            while _next_ordinal_to_read < 21 {
16044                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16045                _next_ordinal_to_read += 1;
16046                next_offset += envelope_size;
16047            }
16048
16049            let next_out_of_line = decoder.next_out_of_line();
16050            let handles_before = decoder.remaining_handles();
16051            if let Some((inlined, num_bytes, num_handles)) =
16052                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16053            {
16054                let member_inline_size =
16055                    <ThisIsAXunion as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16056                if inlined != (member_inline_size <= 4) {
16057                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16058                }
16059                let inner_offset;
16060                let mut inner_depth = depth.clone();
16061                if inlined {
16062                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16063                    inner_offset = next_offset;
16064                } else {
16065                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16066                    inner_depth.increment()?;
16067                }
16068                let val_ref = self.xunion_member.get_or_insert_with(|| {
16069                    fidl::new_empty!(ThisIsAXunion, fidl::encoding::DefaultFuchsiaResourceDialect)
16070                });
16071                fidl::decode!(
16072                    ThisIsAXunion,
16073                    fidl::encoding::DefaultFuchsiaResourceDialect,
16074                    val_ref,
16075                    decoder,
16076                    inner_offset,
16077                    inner_depth
16078                )?;
16079                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16080                {
16081                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16082                }
16083                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16084                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16085                }
16086            }
16087
16088            next_offset += envelope_size;
16089
16090            // Decode the remaining unknown envelopes.
16091            while next_offset < end_offset {
16092                _next_ordinal_to_read += 1;
16093                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16094                next_offset += envelope_size;
16095            }
16096
16097            Ok(())
16098        }
16099    }
16100
16101    impl fidl::encoding::ResourceTypeMarker for AllTypesXunion {
16102        type Borrowed<'a> = &'a mut Self;
16103        fn take_or_borrow<'a>(
16104            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
16105        ) -> Self::Borrowed<'a> {
16106            value
16107        }
16108    }
16109
16110    unsafe impl fidl::encoding::TypeMarker for AllTypesXunion {
16111        type Owned = Self;
16112
16113        #[inline(always)]
16114        fn inline_align(_context: fidl::encoding::Context) -> usize {
16115            8
16116        }
16117
16118        #[inline(always)]
16119        fn inline_size(_context: fidl::encoding::Context) -> usize {
16120            16
16121        }
16122    }
16123
16124    unsafe impl
16125        fidl::encoding::Encode<AllTypesXunion, fidl::encoding::DefaultFuchsiaResourceDialect>
16126        for &mut AllTypesXunion
16127    {
16128        #[inline]
16129        unsafe fn encode(
16130            self,
16131            encoder: &mut fidl::encoding::Encoder<
16132                '_,
16133                fidl::encoding::DefaultFuchsiaResourceDialect,
16134            >,
16135            offset: usize,
16136            _depth: fidl::encoding::Depth,
16137        ) -> fidl::Result<()> {
16138            encoder.debug_check_bounds::<AllTypesXunion>(offset);
16139            encoder.write_num::<u64>(self.ordinal(), offset);
16140            match self {
16141            AllTypesXunion::BoolMember(ref val) => {
16142                fidl::encoding::encode_in_envelope::<bool, fidl::encoding::DefaultFuchsiaResourceDialect>(
16143                    <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
16144                    encoder, offset + 8, _depth
16145                )
16146            }
16147            AllTypesXunion::Int8Member(ref val) => {
16148                fidl::encoding::encode_in_envelope::<i8, fidl::encoding::DefaultFuchsiaResourceDialect>(
16149                    <i8 as fidl::encoding::ValueTypeMarker>::borrow(val),
16150                    encoder, offset + 8, _depth
16151                )
16152            }
16153            AllTypesXunion::Int16Member(ref val) => {
16154                fidl::encoding::encode_in_envelope::<i16, fidl::encoding::DefaultFuchsiaResourceDialect>(
16155                    <i16 as fidl::encoding::ValueTypeMarker>::borrow(val),
16156                    encoder, offset + 8, _depth
16157                )
16158            }
16159            AllTypesXunion::Int32Member(ref val) => {
16160                fidl::encoding::encode_in_envelope::<i32, fidl::encoding::DefaultFuchsiaResourceDialect>(
16161                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(val),
16162                    encoder, offset + 8, _depth
16163                )
16164            }
16165            AllTypesXunion::Int64Member(ref val) => {
16166                fidl::encoding::encode_in_envelope::<i64, fidl::encoding::DefaultFuchsiaResourceDialect>(
16167                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(val),
16168                    encoder, offset + 8, _depth
16169                )
16170            }
16171            AllTypesXunion::Uint8Member(ref val) => {
16172                fidl::encoding::encode_in_envelope::<u8, fidl::encoding::DefaultFuchsiaResourceDialect>(
16173                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(val),
16174                    encoder, offset + 8, _depth
16175                )
16176            }
16177            AllTypesXunion::Uint16Member(ref val) => {
16178                fidl::encoding::encode_in_envelope::<u16, fidl::encoding::DefaultFuchsiaResourceDialect>(
16179                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(val),
16180                    encoder, offset + 8, _depth
16181                )
16182            }
16183            AllTypesXunion::Uint32Member(ref val) => {
16184                fidl::encoding::encode_in_envelope::<u32, fidl::encoding::DefaultFuchsiaResourceDialect>(
16185                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
16186                    encoder, offset + 8, _depth
16187                )
16188            }
16189            AllTypesXunion::Uint64Member(ref val) => {
16190                fidl::encoding::encode_in_envelope::<u64, fidl::encoding::DefaultFuchsiaResourceDialect>(
16191                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(val),
16192                    encoder, offset + 8, _depth
16193                )
16194            }
16195            AllTypesXunion::Float32Member(ref val) => {
16196                fidl::encoding::encode_in_envelope::<f32, fidl::encoding::DefaultFuchsiaResourceDialect>(
16197                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(val),
16198                    encoder, offset + 8, _depth
16199                )
16200            }
16201            AllTypesXunion::Float64Member(ref val) => {
16202                fidl::encoding::encode_in_envelope::<f64, fidl::encoding::DefaultFuchsiaResourceDialect>(
16203                    <f64 as fidl::encoding::ValueTypeMarker>::borrow(val),
16204                    encoder, offset + 8, _depth
16205                )
16206            }
16207            AllTypesXunion::EnumMember(ref val) => {
16208                fidl::encoding::encode_in_envelope::<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>(
16209                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(val),
16210                    encoder, offset + 8, _depth
16211                )
16212            }
16213            AllTypesXunion::BitsMember(ref val) => {
16214                fidl::encoding::encode_in_envelope::<DefaultBits, fidl::encoding::DefaultFuchsiaResourceDialect>(
16215                    <DefaultBits as fidl::encoding::ValueTypeMarker>::borrow(val),
16216                    encoder, offset + 8, _depth
16217                )
16218            }
16219            AllTypesXunion::HandleMember(ref mut val) => {
16220                fidl::encoding::encode_in_envelope::<fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect>(
16221                    <fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
16222                    encoder, offset + 8, _depth
16223                )
16224            }
16225            AllTypesXunion::StringMember(ref val) => {
16226                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedString, fidl::encoding::DefaultFuchsiaResourceDialect>(
16227                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(val),
16228                    encoder, offset + 8, _depth
16229                )
16230            }
16231            AllTypesXunion::StructMember(ref val) => {
16232                fidl::encoding::encode_in_envelope::<ThisIsAStruct, fidl::encoding::DefaultFuchsiaResourceDialect>(
16233                    <ThisIsAStruct as fidl::encoding::ValueTypeMarker>::borrow(val),
16234                    encoder, offset + 8, _depth
16235                )
16236            }
16237            AllTypesXunion::UnionMember(ref val) => {
16238                fidl::encoding::encode_in_envelope::<ThisIsAUnion, fidl::encoding::DefaultFuchsiaResourceDialect>(
16239                    <ThisIsAUnion as fidl::encoding::ValueTypeMarker>::borrow(val),
16240                    encoder, offset + 8, _depth
16241                )
16242            }
16243            AllTypesXunion::ArrayMember(ref val) => {
16244                fidl::encoding::encode_in_envelope::<fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect>(
16245                    <fidl::encoding::Array<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow(val),
16246                    encoder, offset + 8, _depth
16247                )
16248            }
16249            AllTypesXunion::VectorMember(ref val) => {
16250                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<u32>, fidl::encoding::DefaultFuchsiaResourceDialect>(
16251                    <fidl::encoding::UnboundedVector<u32> as fidl::encoding::ValueTypeMarker>::borrow(val),
16252                    encoder, offset + 8, _depth
16253                )
16254            }
16255            AllTypesXunion::TableMember(ref val) => {
16256                fidl::encoding::encode_in_envelope::<ThisIsATable, fidl::encoding::DefaultFuchsiaResourceDialect>(
16257                    <ThisIsATable as fidl::encoding::ValueTypeMarker>::borrow(val),
16258                    encoder, offset + 8, _depth
16259                )
16260            }
16261            AllTypesXunion::XunionMember(ref val) => {
16262                fidl::encoding::encode_in_envelope::<ThisIsAXunion, fidl::encoding::DefaultFuchsiaResourceDialect>(
16263                    <ThisIsAXunion as fidl::encoding::ValueTypeMarker>::borrow(val),
16264                    encoder, offset + 8, _depth
16265                )
16266            }
16267            AllTypesXunion::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
16268        }
16269        }
16270    }
16271
16272    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
16273        for AllTypesXunion
16274    {
16275        #[inline(always)]
16276        fn new_empty() -> Self {
16277            Self::__SourceBreaking { unknown_ordinal: 0 }
16278        }
16279
16280        #[inline]
16281        unsafe fn decode(
16282            &mut self,
16283            decoder: &mut fidl::encoding::Decoder<
16284                '_,
16285                fidl::encoding::DefaultFuchsiaResourceDialect,
16286            >,
16287            offset: usize,
16288            mut depth: fidl::encoding::Depth,
16289        ) -> fidl::Result<()> {
16290            decoder.debug_check_bounds::<Self>(offset);
16291            #[allow(unused_variables)]
16292            let next_out_of_line = decoder.next_out_of_line();
16293            let handles_before = decoder.remaining_handles();
16294            let (ordinal, inlined, num_bytes, num_handles) =
16295                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
16296
16297            let member_inline_size = match ordinal {
16298            1 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16299            2 => <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16300            3 => <i16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16301            4 => <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16302            5 => <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16303            6 => <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16304            7 => <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16305            8 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16306            9 => <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16307            10 => <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16308            11 => <f64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16309            12 => <DefaultEnum as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16310            13 => <DefaultBits as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16311            14 => <fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16312            15 => <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16313            16 => <ThisIsAStruct as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16314            17 => <ThisIsAUnion as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16315            18 => <fidl::encoding::Array<u32, 3> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16316            19 => <fidl::encoding::UnboundedVector<u32> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16317            20 => <ThisIsATable as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16318            21 => <ThisIsAXunion as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16319            0 => return Err(fidl::Error::UnknownUnionTag),
16320            _ => num_bytes as usize,
16321        };
16322
16323            if inlined != (member_inline_size <= 4) {
16324                return Err(fidl::Error::InvalidInlineBitInEnvelope);
16325            }
16326            let _inner_offset;
16327            if inlined {
16328                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
16329                _inner_offset = offset + 8;
16330            } else {
16331                depth.increment()?;
16332                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16333            }
16334            match ordinal {
16335                1 => {
16336                    #[allow(irrefutable_let_patterns)]
16337                    if let AllTypesXunion::BoolMember(_) = self {
16338                        // Do nothing, read the value into the object
16339                    } else {
16340                        // Initialize `self` to the right variant
16341                        *self = AllTypesXunion::BoolMember(fidl::new_empty!(
16342                            bool,
16343                            fidl::encoding::DefaultFuchsiaResourceDialect
16344                        ));
16345                    }
16346                    #[allow(irrefutable_let_patterns)]
16347                    if let AllTypesXunion::BoolMember(ref mut val) = self {
16348                        fidl::decode!(
16349                            bool,
16350                            fidl::encoding::DefaultFuchsiaResourceDialect,
16351                            val,
16352                            decoder,
16353                            _inner_offset,
16354                            depth
16355                        )?;
16356                    } else {
16357                        unreachable!()
16358                    }
16359                }
16360                2 => {
16361                    #[allow(irrefutable_let_patterns)]
16362                    if let AllTypesXunion::Int8Member(_) = self {
16363                        // Do nothing, read the value into the object
16364                    } else {
16365                        // Initialize `self` to the right variant
16366                        *self = AllTypesXunion::Int8Member(fidl::new_empty!(
16367                            i8,
16368                            fidl::encoding::DefaultFuchsiaResourceDialect
16369                        ));
16370                    }
16371                    #[allow(irrefutable_let_patterns)]
16372                    if let AllTypesXunion::Int8Member(ref mut val) = self {
16373                        fidl::decode!(
16374                            i8,
16375                            fidl::encoding::DefaultFuchsiaResourceDialect,
16376                            val,
16377                            decoder,
16378                            _inner_offset,
16379                            depth
16380                        )?;
16381                    } else {
16382                        unreachable!()
16383                    }
16384                }
16385                3 => {
16386                    #[allow(irrefutable_let_patterns)]
16387                    if let AllTypesXunion::Int16Member(_) = self {
16388                        // Do nothing, read the value into the object
16389                    } else {
16390                        // Initialize `self` to the right variant
16391                        *self = AllTypesXunion::Int16Member(fidl::new_empty!(
16392                            i16,
16393                            fidl::encoding::DefaultFuchsiaResourceDialect
16394                        ));
16395                    }
16396                    #[allow(irrefutable_let_patterns)]
16397                    if let AllTypesXunion::Int16Member(ref mut val) = self {
16398                        fidl::decode!(
16399                            i16,
16400                            fidl::encoding::DefaultFuchsiaResourceDialect,
16401                            val,
16402                            decoder,
16403                            _inner_offset,
16404                            depth
16405                        )?;
16406                    } else {
16407                        unreachable!()
16408                    }
16409                }
16410                4 => {
16411                    #[allow(irrefutable_let_patterns)]
16412                    if let AllTypesXunion::Int32Member(_) = self {
16413                        // Do nothing, read the value into the object
16414                    } else {
16415                        // Initialize `self` to the right variant
16416                        *self = AllTypesXunion::Int32Member(fidl::new_empty!(
16417                            i32,
16418                            fidl::encoding::DefaultFuchsiaResourceDialect
16419                        ));
16420                    }
16421                    #[allow(irrefutable_let_patterns)]
16422                    if let AllTypesXunion::Int32Member(ref mut val) = self {
16423                        fidl::decode!(
16424                            i32,
16425                            fidl::encoding::DefaultFuchsiaResourceDialect,
16426                            val,
16427                            decoder,
16428                            _inner_offset,
16429                            depth
16430                        )?;
16431                    } else {
16432                        unreachable!()
16433                    }
16434                }
16435                5 => {
16436                    #[allow(irrefutable_let_patterns)]
16437                    if let AllTypesXunion::Int64Member(_) = self {
16438                        // Do nothing, read the value into the object
16439                    } else {
16440                        // Initialize `self` to the right variant
16441                        *self = AllTypesXunion::Int64Member(fidl::new_empty!(
16442                            i64,
16443                            fidl::encoding::DefaultFuchsiaResourceDialect
16444                        ));
16445                    }
16446                    #[allow(irrefutable_let_patterns)]
16447                    if let AllTypesXunion::Int64Member(ref mut val) = self {
16448                        fidl::decode!(
16449                            i64,
16450                            fidl::encoding::DefaultFuchsiaResourceDialect,
16451                            val,
16452                            decoder,
16453                            _inner_offset,
16454                            depth
16455                        )?;
16456                    } else {
16457                        unreachable!()
16458                    }
16459                }
16460                6 => {
16461                    #[allow(irrefutable_let_patterns)]
16462                    if let AllTypesXunion::Uint8Member(_) = self {
16463                        // Do nothing, read the value into the object
16464                    } else {
16465                        // Initialize `self` to the right variant
16466                        *self = AllTypesXunion::Uint8Member(fidl::new_empty!(
16467                            u8,
16468                            fidl::encoding::DefaultFuchsiaResourceDialect
16469                        ));
16470                    }
16471                    #[allow(irrefutable_let_patterns)]
16472                    if let AllTypesXunion::Uint8Member(ref mut val) = self {
16473                        fidl::decode!(
16474                            u8,
16475                            fidl::encoding::DefaultFuchsiaResourceDialect,
16476                            val,
16477                            decoder,
16478                            _inner_offset,
16479                            depth
16480                        )?;
16481                    } else {
16482                        unreachable!()
16483                    }
16484                }
16485                7 => {
16486                    #[allow(irrefutable_let_patterns)]
16487                    if let AllTypesXunion::Uint16Member(_) = self {
16488                        // Do nothing, read the value into the object
16489                    } else {
16490                        // Initialize `self` to the right variant
16491                        *self = AllTypesXunion::Uint16Member(fidl::new_empty!(
16492                            u16,
16493                            fidl::encoding::DefaultFuchsiaResourceDialect
16494                        ));
16495                    }
16496                    #[allow(irrefutable_let_patterns)]
16497                    if let AllTypesXunion::Uint16Member(ref mut val) = self {
16498                        fidl::decode!(
16499                            u16,
16500                            fidl::encoding::DefaultFuchsiaResourceDialect,
16501                            val,
16502                            decoder,
16503                            _inner_offset,
16504                            depth
16505                        )?;
16506                    } else {
16507                        unreachable!()
16508                    }
16509                }
16510                8 => {
16511                    #[allow(irrefutable_let_patterns)]
16512                    if let AllTypesXunion::Uint32Member(_) = self {
16513                        // Do nothing, read the value into the object
16514                    } else {
16515                        // Initialize `self` to the right variant
16516                        *self = AllTypesXunion::Uint32Member(fidl::new_empty!(
16517                            u32,
16518                            fidl::encoding::DefaultFuchsiaResourceDialect
16519                        ));
16520                    }
16521                    #[allow(irrefutable_let_patterns)]
16522                    if let AllTypesXunion::Uint32Member(ref mut val) = self {
16523                        fidl::decode!(
16524                            u32,
16525                            fidl::encoding::DefaultFuchsiaResourceDialect,
16526                            val,
16527                            decoder,
16528                            _inner_offset,
16529                            depth
16530                        )?;
16531                    } else {
16532                        unreachable!()
16533                    }
16534                }
16535                9 => {
16536                    #[allow(irrefutable_let_patterns)]
16537                    if let AllTypesXunion::Uint64Member(_) = self {
16538                        // Do nothing, read the value into the object
16539                    } else {
16540                        // Initialize `self` to the right variant
16541                        *self = AllTypesXunion::Uint64Member(fidl::new_empty!(
16542                            u64,
16543                            fidl::encoding::DefaultFuchsiaResourceDialect
16544                        ));
16545                    }
16546                    #[allow(irrefutable_let_patterns)]
16547                    if let AllTypesXunion::Uint64Member(ref mut val) = self {
16548                        fidl::decode!(
16549                            u64,
16550                            fidl::encoding::DefaultFuchsiaResourceDialect,
16551                            val,
16552                            decoder,
16553                            _inner_offset,
16554                            depth
16555                        )?;
16556                    } else {
16557                        unreachable!()
16558                    }
16559                }
16560                10 => {
16561                    #[allow(irrefutable_let_patterns)]
16562                    if let AllTypesXunion::Float32Member(_) = self {
16563                        // Do nothing, read the value into the object
16564                    } else {
16565                        // Initialize `self` to the right variant
16566                        *self = AllTypesXunion::Float32Member(fidl::new_empty!(
16567                            f32,
16568                            fidl::encoding::DefaultFuchsiaResourceDialect
16569                        ));
16570                    }
16571                    #[allow(irrefutable_let_patterns)]
16572                    if let AllTypesXunion::Float32Member(ref mut val) = self {
16573                        fidl::decode!(
16574                            f32,
16575                            fidl::encoding::DefaultFuchsiaResourceDialect,
16576                            val,
16577                            decoder,
16578                            _inner_offset,
16579                            depth
16580                        )?;
16581                    } else {
16582                        unreachable!()
16583                    }
16584                }
16585                11 => {
16586                    #[allow(irrefutable_let_patterns)]
16587                    if let AllTypesXunion::Float64Member(_) = self {
16588                        // Do nothing, read the value into the object
16589                    } else {
16590                        // Initialize `self` to the right variant
16591                        *self = AllTypesXunion::Float64Member(fidl::new_empty!(
16592                            f64,
16593                            fidl::encoding::DefaultFuchsiaResourceDialect
16594                        ));
16595                    }
16596                    #[allow(irrefutable_let_patterns)]
16597                    if let AllTypesXunion::Float64Member(ref mut val) = self {
16598                        fidl::decode!(
16599                            f64,
16600                            fidl::encoding::DefaultFuchsiaResourceDialect,
16601                            val,
16602                            decoder,
16603                            _inner_offset,
16604                            depth
16605                        )?;
16606                    } else {
16607                        unreachable!()
16608                    }
16609                }
16610                12 => {
16611                    #[allow(irrefutable_let_patterns)]
16612                    if let AllTypesXunion::EnumMember(_) = self {
16613                        // Do nothing, read the value into the object
16614                    } else {
16615                        // Initialize `self` to the right variant
16616                        *self = AllTypesXunion::EnumMember(fidl::new_empty!(
16617                            DefaultEnum,
16618                            fidl::encoding::DefaultFuchsiaResourceDialect
16619                        ));
16620                    }
16621                    #[allow(irrefutable_let_patterns)]
16622                    if let AllTypesXunion::EnumMember(ref mut val) = self {
16623                        fidl::decode!(
16624                            DefaultEnum,
16625                            fidl::encoding::DefaultFuchsiaResourceDialect,
16626                            val,
16627                            decoder,
16628                            _inner_offset,
16629                            depth
16630                        )?;
16631                    } else {
16632                        unreachable!()
16633                    }
16634                }
16635                13 => {
16636                    #[allow(irrefutable_let_patterns)]
16637                    if let AllTypesXunion::BitsMember(_) = self {
16638                        // Do nothing, read the value into the object
16639                    } else {
16640                        // Initialize `self` to the right variant
16641                        *self = AllTypesXunion::BitsMember(fidl::new_empty!(
16642                            DefaultBits,
16643                            fidl::encoding::DefaultFuchsiaResourceDialect
16644                        ));
16645                    }
16646                    #[allow(irrefutable_let_patterns)]
16647                    if let AllTypesXunion::BitsMember(ref mut val) = self {
16648                        fidl::decode!(
16649                            DefaultBits,
16650                            fidl::encoding::DefaultFuchsiaResourceDialect,
16651                            val,
16652                            decoder,
16653                            _inner_offset,
16654                            depth
16655                        )?;
16656                    } else {
16657                        unreachable!()
16658                    }
16659                }
16660                14 => {
16661                    #[allow(irrefutable_let_patterns)]
16662                    if let AllTypesXunion::HandleMember(_) = self {
16663                        // Do nothing, read the value into the object
16664                    } else {
16665                        // Initialize `self` to the right variant
16666                        *self = AllTypesXunion::HandleMember(
16667                            fidl::new_empty!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
16668                        );
16669                    }
16670                    #[allow(irrefutable_let_patterns)]
16671                    if let AllTypesXunion::HandleMember(ref mut val) = self {
16672                        fidl::decode!(fidl::encoding::HandleType<fidl::NullableHandle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val, decoder, _inner_offset, depth)?;
16673                    } else {
16674                        unreachable!()
16675                    }
16676                }
16677                15 => {
16678                    #[allow(irrefutable_let_patterns)]
16679                    if let AllTypesXunion::StringMember(_) = self {
16680                        // Do nothing, read the value into the object
16681                    } else {
16682                        // Initialize `self` to the right variant
16683                        *self = AllTypesXunion::StringMember(fidl::new_empty!(
16684                            fidl::encoding::UnboundedString,
16685                            fidl::encoding::DefaultFuchsiaResourceDialect
16686                        ));
16687                    }
16688                    #[allow(irrefutable_let_patterns)]
16689                    if let AllTypesXunion::StringMember(ref mut val) = self {
16690                        fidl::decode!(
16691                            fidl::encoding::UnboundedString,
16692                            fidl::encoding::DefaultFuchsiaResourceDialect,
16693                            val,
16694                            decoder,
16695                            _inner_offset,
16696                            depth
16697                        )?;
16698                    } else {
16699                        unreachable!()
16700                    }
16701                }
16702                16 => {
16703                    #[allow(irrefutable_let_patterns)]
16704                    if let AllTypesXunion::StructMember(_) = self {
16705                        // Do nothing, read the value into the object
16706                    } else {
16707                        // Initialize `self` to the right variant
16708                        *self = AllTypesXunion::StructMember(fidl::new_empty!(
16709                            ThisIsAStruct,
16710                            fidl::encoding::DefaultFuchsiaResourceDialect
16711                        ));
16712                    }
16713                    #[allow(irrefutable_let_patterns)]
16714                    if let AllTypesXunion::StructMember(ref mut val) = self {
16715                        fidl::decode!(
16716                            ThisIsAStruct,
16717                            fidl::encoding::DefaultFuchsiaResourceDialect,
16718                            val,
16719                            decoder,
16720                            _inner_offset,
16721                            depth
16722                        )?;
16723                    } else {
16724                        unreachable!()
16725                    }
16726                }
16727                17 => {
16728                    #[allow(irrefutable_let_patterns)]
16729                    if let AllTypesXunion::UnionMember(_) = self {
16730                        // Do nothing, read the value into the object
16731                    } else {
16732                        // Initialize `self` to the right variant
16733                        *self = AllTypesXunion::UnionMember(fidl::new_empty!(
16734                            ThisIsAUnion,
16735                            fidl::encoding::DefaultFuchsiaResourceDialect
16736                        ));
16737                    }
16738                    #[allow(irrefutable_let_patterns)]
16739                    if let AllTypesXunion::UnionMember(ref mut val) = self {
16740                        fidl::decode!(
16741                            ThisIsAUnion,
16742                            fidl::encoding::DefaultFuchsiaResourceDialect,
16743                            val,
16744                            decoder,
16745                            _inner_offset,
16746                            depth
16747                        )?;
16748                    } else {
16749                        unreachable!()
16750                    }
16751                }
16752                18 => {
16753                    #[allow(irrefutable_let_patterns)]
16754                    if let AllTypesXunion::ArrayMember(_) = self {
16755                        // Do nothing, read the value into the object
16756                    } else {
16757                        // Initialize `self` to the right variant
16758                        *self = AllTypesXunion::ArrayMember(
16759                            fidl::new_empty!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
16760                        );
16761                    }
16762                    #[allow(irrefutable_let_patterns)]
16763                    if let AllTypesXunion::ArrayMember(ref mut val) = self {
16764                        fidl::decode!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, val, decoder, _inner_offset, depth)?;
16765                    } else {
16766                        unreachable!()
16767                    }
16768                }
16769                19 => {
16770                    #[allow(irrefutable_let_patterns)]
16771                    if let AllTypesXunion::VectorMember(_) = self {
16772                        // Do nothing, read the value into the object
16773                    } else {
16774                        // Initialize `self` to the right variant
16775                        *self = AllTypesXunion::VectorMember(fidl::new_empty!(
16776                            fidl::encoding::UnboundedVector<u32>,
16777                            fidl::encoding::DefaultFuchsiaResourceDialect
16778                        ));
16779                    }
16780                    #[allow(irrefutable_let_patterns)]
16781                    if let AllTypesXunion::VectorMember(ref mut val) = self {
16782                        fidl::decode!(
16783                            fidl::encoding::UnboundedVector<u32>,
16784                            fidl::encoding::DefaultFuchsiaResourceDialect,
16785                            val,
16786                            decoder,
16787                            _inner_offset,
16788                            depth
16789                        )?;
16790                    } else {
16791                        unreachable!()
16792                    }
16793                }
16794                20 => {
16795                    #[allow(irrefutable_let_patterns)]
16796                    if let AllTypesXunion::TableMember(_) = self {
16797                        // Do nothing, read the value into the object
16798                    } else {
16799                        // Initialize `self` to the right variant
16800                        *self = AllTypesXunion::TableMember(fidl::new_empty!(
16801                            ThisIsATable,
16802                            fidl::encoding::DefaultFuchsiaResourceDialect
16803                        ));
16804                    }
16805                    #[allow(irrefutable_let_patterns)]
16806                    if let AllTypesXunion::TableMember(ref mut val) = self {
16807                        fidl::decode!(
16808                            ThisIsATable,
16809                            fidl::encoding::DefaultFuchsiaResourceDialect,
16810                            val,
16811                            decoder,
16812                            _inner_offset,
16813                            depth
16814                        )?;
16815                    } else {
16816                        unreachable!()
16817                    }
16818                }
16819                21 => {
16820                    #[allow(irrefutable_let_patterns)]
16821                    if let AllTypesXunion::XunionMember(_) = self {
16822                        // Do nothing, read the value into the object
16823                    } else {
16824                        // Initialize `self` to the right variant
16825                        *self = AllTypesXunion::XunionMember(fidl::new_empty!(
16826                            ThisIsAXunion,
16827                            fidl::encoding::DefaultFuchsiaResourceDialect
16828                        ));
16829                    }
16830                    #[allow(irrefutable_let_patterns)]
16831                    if let AllTypesXunion::XunionMember(ref mut val) = self {
16832                        fidl::decode!(
16833                            ThisIsAXunion,
16834                            fidl::encoding::DefaultFuchsiaResourceDialect,
16835                            val,
16836                            decoder,
16837                            _inner_offset,
16838                            depth
16839                        )?;
16840                    } else {
16841                        unreachable!()
16842                    }
16843                }
16844                #[allow(deprecated)]
16845                ordinal => {
16846                    for _ in 0..num_handles {
16847                        decoder.drop_next_handle()?;
16848                    }
16849                    *self = AllTypesXunion::__SourceBreaking { unknown_ordinal: ordinal };
16850                }
16851            }
16852            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
16853                return Err(fidl::Error::InvalidNumBytesInEnvelope);
16854            }
16855            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16856                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16857            }
16858            Ok(())
16859        }
16860    }
16861}
fidl_fidl_test_compatibility/fidl_fidl_test_compatibility.rs

fidl_fidl_test_compatibility/
fidl_fidl_test_compatibility.rs
