fidl_fidl_test_compatibility/
fidl_fidl_test_compatibility.rs

1// WARNING: This file is machine generated by fidlgen.
2
3#![warn(clippy::all)]
4#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]
5
6use bitflags::bitflags;
7use fidl::client::QueryResponseFut;
8use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
9use fidl::endpoints::{ControlHandle as _, Responder as _};
10pub use fidl_fidl_test_compatibility__common::*;
11use futures::future::{self, MaybeDone, TryFutureExt};
12use zx_status;
13
14#[derive(Debug, PartialEq)]
15pub struct ArraysStruct {
16    pub bools: [bool; 3],
17    pub int8s: [i8; 3],
18    pub int16s: [i16; 3],
19    pub int32s: [i32; 3],
20    pub int64s: [i64; 3],
21    pub uint8s: [u8; 3],
22    pub uint16s: [u16; 3],
23    pub uint32s: [u32; 3],
24    pub uint64s: [u64; 3],
25    pub float32s: [f32; 3],
26    pub float64s: [f64; 3],
27    pub enums: [DefaultEnum; 3],
28    pub bits: [DefaultBits; 3],
29    pub handles: [fidl::Handle; 3],
30    pub nullable_handles: [Option<fidl::Handle>; 3],
31    pub strings: [String; 3],
32    pub nullable_strings: [Option<String>; 3],
33    pub structs: [ThisIsAStruct; 3],
34    pub nullable_structs: [Option<Box<ThisIsAStruct>>; 3],
35    pub unions: [ThisIsAUnion; 3],
36    pub nullable_unions: [Option<Box<ThisIsAUnion>>; 3],
37    pub arrays: [[u32; 3]; 3],
38    pub vectors: [Vec<u32>; 3],
39    pub nullable_vectors: [Option<Vec<u32>>; 3],
40    pub tables: [ThisIsATable; 3],
41    pub xunions: [ThisIsAXunion; 3],
42}
43
44impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ArraysStruct {}
45
46#[derive(Debug, PartialEq)]
47pub struct EchoEchoArraysRequest {
48    pub value: ArraysStruct,
49    pub forward_to_server: String,
50}
51
52impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoArraysRequest {}
53
54#[derive(Debug, PartialEq)]
55pub struct EchoEchoArraysResponse {
56    pub value: ArraysStruct,
57}
58
59impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoArraysResponse {}
60
61#[derive(Debug, PartialEq)]
62pub struct EchoEchoArraysWithErrorRequest {
63    pub value: ArraysStruct,
64    pub result_err: DefaultEnum,
65    pub forward_to_server: String,
66    pub result_variant: RespondWith,
67}
68
69impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
70    for EchoEchoArraysWithErrorRequest
71{
72}
73
74#[derive(Debug, PartialEq)]
75pub struct EchoEchoEventRequest {
76    pub value: Struct,
77}
78
79impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoEventRequest {}
80
81#[derive(Debug, PartialEq)]
82pub struct EchoEchoStructNoRetValRequest {
83    pub value: Struct,
84    pub forward_to_server: String,
85}
86
87impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
88    for EchoEchoStructNoRetValRequest
89{
90}
91
92#[derive(Debug, PartialEq)]
93pub struct EchoEchoStructRequest {
94    pub value: Struct,
95    pub forward_to_server: String,
96}
97
98impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoStructRequest {}
99
100#[derive(Debug, PartialEq)]
101pub struct EchoEchoStructResponse {
102    pub value: Struct,
103}
104
105impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoStructResponse {}
106
107#[derive(Debug, PartialEq)]
108pub struct EchoEchoStructWithErrorRequest {
109    pub value: Struct,
110    pub result_err: DefaultEnum,
111    pub forward_to_server: String,
112    pub result_variant: RespondWith,
113}
114
115impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
116    for EchoEchoStructWithErrorRequest
117{
118}
119
120#[derive(Debug, PartialEq)]
121pub struct EchoEchoTableRequest {
122    pub value: AllTypesTable,
123    pub forward_to_server: String,
124}
125
126impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoTableRequest {}
127
128#[derive(Debug, PartialEq)]
129pub struct EchoEchoTableResponse {
130    pub value: AllTypesTable,
131}
132
133impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoTableResponse {}
134
135#[derive(Debug, PartialEq)]
136pub struct EchoEchoTableWithErrorRequest {
137    pub value: AllTypesTable,
138    pub result_err: DefaultEnum,
139    pub forward_to_server: String,
140    pub result_variant: RespondWith,
141}
142
143impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
144    for EchoEchoTableWithErrorRequest
145{
146}
147
148#[derive(Debug, PartialEq)]
149pub struct EchoEchoVectorsRequest {
150    pub value: VectorsStruct,
151    pub forward_to_server: String,
152}
153
154impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoVectorsRequest {}
155
156#[derive(Debug, PartialEq)]
157pub struct EchoEchoVectorsResponse {
158    pub value: VectorsStruct,
159}
160
161impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoVectorsResponse {}
162
163#[derive(Debug, PartialEq)]
164pub struct EchoEchoVectorsWithErrorRequest {
165    pub value: VectorsStruct,
166    pub result_err: DefaultEnum,
167    pub forward_to_server: String,
168    pub result_variant: RespondWith,
169}
170
171impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
172    for EchoEchoVectorsWithErrorRequest
173{
174}
175
176#[derive(Debug, PartialEq)]
177pub struct EchoEchoXunionsRequest {
178    pub value: Vec<AllTypesXunion>,
179    pub forward_to_server: String,
180}
181
182impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoXunionsRequest {}
183
184#[derive(Debug, PartialEq)]
185pub struct EchoEchoXunionsResponse {
186    pub value: Vec<AllTypesXunion>,
187}
188
189impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for EchoEchoXunionsResponse {}
190
191#[derive(Debug, PartialEq)]
192pub struct EchoEchoXunionsWithErrorRequest {
193    pub value: Vec<AllTypesXunion>,
194    pub result_err: DefaultEnum,
195    pub forward_to_server: String,
196    pub result_variant: RespondWith,
197}
198
199impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
200    for EchoEchoXunionsWithErrorRequest
201{
202}
203
204#[derive(Debug, PartialEq)]
205pub struct EchoEchoArraysWithErrorResponse {
206    pub value: ArraysStruct,
207}
208
209impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
210    for EchoEchoArraysWithErrorResponse
211{
212}
213
214#[derive(Debug, PartialEq)]
215pub struct EchoEchoStructWithErrorResponse {
216    pub value: Struct,
217}
218
219impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
220    for EchoEchoStructWithErrorResponse
221{
222}
223
224#[derive(Debug, PartialEq)]
225pub struct EchoEchoTableWithErrorResponse {
226    pub value: AllTypesTable,
227}
228
229impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
230    for EchoEchoTableWithErrorResponse
231{
232}
233
234#[derive(Debug, PartialEq)]
235pub struct EchoEchoVectorsWithErrorResponse {
236    pub value: VectorsStruct,
237}
238
239impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
240    for EchoEchoVectorsWithErrorResponse
241{
242}
243
244#[derive(Debug, PartialEq)]
245pub struct EchoEchoXunionsWithErrorResponse {
246    pub value: Vec<AllTypesXunion>,
247}
248
249impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
250    for EchoEchoXunionsWithErrorResponse
251{
252}
253
254#[derive(Debug, PartialEq)]
255pub struct Struct {
256    pub primitive_types: PrimitiveTypes,
257    pub default_values: DefaultValues,
258    pub arrays: Arrays,
259    pub arrays_2d: Arrays2d,
260    pub vectors: Vectors,
261    pub handles: Handles,
262    pub strings: Strings,
263    pub default_enum: DefaultEnum,
264    pub i8_enum: I8Enum,
265    pub i16_enum: I16Enum,
266    pub i32_enum: I32Enum,
267    pub i64_enum: I64Enum,
268    pub u8_enum: U8Enum,
269    pub u16_enum: U16Enum,
270    pub u32_enum: U32Enum,
271    pub u64_enum: U64Enum,
272    pub default_bits: DefaultBits,
273    pub u8_bits: U8Bits,
274    pub u16_bits: U16Bits,
275    pub u32_bits: U32Bits,
276    pub u64_bits: U64Bits,
277    pub structs: Structs,
278    pub unions: Unions,
279    pub table: ThisIsATable,
280    pub xunion: ThisIsAXunion,
281    pub b: bool,
282}
283
284impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for Struct {}
285
286#[derive(Debug, PartialEq)]
287pub struct VectorsStruct {
288    pub bools: Vec<bool>,
289    pub int8s: Vec<i8>,
290    pub int16s: Vec<i16>,
291    pub int32s: Vec<i32>,
292    pub int64s: Vec<i64>,
293    pub uint8s: Vec<u8>,
294    pub uint16s: Vec<u16>,
295    pub uint32s: Vec<u32>,
296    pub uint64s: Vec<u64>,
297    pub float32s: Vec<f32>,
298    pub float64s: Vec<f64>,
299    pub enums: Vec<DefaultEnum>,
300    pub bits: Vec<DefaultBits>,
301    pub handles: Vec<fidl::Handle>,
302    pub nullable_handles: Vec<Option<fidl::Handle>>,
303    pub strings: Vec<String>,
304    pub nullable_strings: Vec<Option<String>>,
305    pub structs: Vec<ThisIsAStruct>,
306    pub nullable_structs: Vec<Option<Box<ThisIsAStruct>>>,
307    pub unions: Vec<ThisIsAUnion>,
308    pub nullable_unions: Vec<Option<Box<ThisIsAUnion>>>,
309    pub arrays: Vec<[u32; 3]>,
310    pub vectors: Vec<Vec<u32>>,
311    pub nullable_vectors: Vec<Option<Vec<u32>>>,
312    pub tables: Vec<ThisIsATable>,
313    pub xunions: Vec<ThisIsAXunion>,
314}
315
316impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for VectorsStruct {}
317
318#[derive(Debug, PartialEq, PartialOrd)]
319pub struct Arrays {
320    pub b_0: [bool; 1],
321    pub i8_0: [i8; 1],
322    pub i16_0: [i16; 1],
323    pub i32_0: [i32; 1],
324    pub i64_0: [i64; 1],
325    pub u8_0: [u8; 1],
326    pub u16_0: [u16; 1],
327    pub u32_0: [u32; 1],
328    pub u64_0: [u64; 1],
329    pub f32_0: [f32; 1],
330    pub f64_0: [f64; 1],
331    pub handle_0: [fidl::Handle; 1],
332    pub b_1: [bool; 3],
333    pub i8_1: [i8; 3],
334    pub i16_1: [i16; 3],
335    pub i32_1: [i32; 3],
336    pub i64_1: [i64; 3],
337    pub u8_1: [u8; 3],
338    pub u16_1: [u16; 3],
339    pub u32_1: [u32; 3],
340    pub u64_1: [u64; 3],
341    pub f32_1: [f32; 3],
342    pub f64_1: [f64; 3],
343    pub handle_1: [fidl::Handle; 3],
344}
345
346impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for Arrays {}
347
348#[derive(Debug, PartialEq, PartialOrd)]
349pub struct Arrays2d {
350    pub b: [[bool; 2]; 3],
351    pub i8: [[i8; 2]; 3],
352    pub i16: [[i16; 2]; 3],
353    pub i32: [[i32; 2]; 3],
354    pub i64: [[i64; 2]; 3],
355    pub u8: [[u8; 2]; 3],
356    pub u16: [[u16; 2]; 3],
357    pub u32: [[u32; 2]; 3],
358    pub u64: [[u64; 2]; 3],
359    pub f32: [[f32; 2]; 3],
360    pub f64: [[f64; 2]; 3],
361    pub handle_handle: [[fidl::Handle; 2]; 3],
362}
363
364impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for Arrays2d {}
365
366#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
367pub struct Handles {
368    pub handle_handle: fidl::Handle,
369    pub process_handle: fidl::Process,
370    pub thread_handle: fidl::Thread,
371    pub vmo_handle: fidl::Vmo,
372    pub event_handle: fidl::Event,
373    pub port_handle: fidl::Port,
374    pub socket_handle: fidl::Socket,
375    pub eventpair_handle: fidl::EventPair,
376    pub job_handle: fidl::Job,
377    pub vmar_handle: fidl::Vmar,
378    pub fifo_handle: fidl::Fifo,
379    pub timer_handle: fidl::Timer,
380    pub nullable_handle_handle: Option<fidl::Handle>,
381    pub nullable_process_handle: Option<fidl::Process>,
382    pub nullable_thread_handle: Option<fidl::Thread>,
383    pub nullable_vmo_handle: Option<fidl::Vmo>,
384    pub nullable_channel_handle: Option<fidl::Channel>,
385    pub nullable_event_handle: Option<fidl::Event>,
386    pub nullable_port_handle: Option<fidl::Port>,
387    pub nullable_interrupt_handle: Option<fidl::Interrupt>,
388    pub nullable_log_handle: Option<fidl::DebugLog>,
389    pub nullable_socket_handle: Option<fidl::Socket>,
390    pub nullable_eventpair_handle: Option<fidl::EventPair>,
391    pub nullable_job_handle: Option<fidl::Job>,
392    pub nullable_vmar_handle: Option<fidl::Vmar>,
393    pub nullable_fifo_handle: Option<fidl::Fifo>,
394    pub nullable_timer_handle: Option<fidl::Timer>,
395}
396
397impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for Handles {}
398
399#[derive(Debug, PartialEq, PartialOrd)]
400pub struct Vectors {
401    pub b_0: Vec<bool>,
402    pub i8_0: Vec<i8>,
403    pub i16_0: Vec<i16>,
404    pub i32_0: Vec<i32>,
405    pub i64_0: Vec<i64>,
406    pub u8_0: Vec<u8>,
407    pub u16_0: Vec<u16>,
408    pub u32_0: Vec<u32>,
409    pub u64_0: Vec<u64>,
410    pub f32_0: Vec<f32>,
411    pub f64_0: Vec<f64>,
412    pub handle_0: Vec<fidl::Handle>,
413    pub b_1: Vec<Vec<bool>>,
414    pub i8_1: Vec<Vec<i8>>,
415    pub i16_1: Vec<Vec<i16>>,
416    pub i32_1: Vec<Vec<i32>>,
417    pub i64_1: Vec<Vec<i64>>,
418    pub u8_1: Vec<Vec<u8>>,
419    pub u16_1: Vec<Vec<u16>>,
420    pub u32_1: Vec<Vec<u32>>,
421    pub u64_1: Vec<Vec<u64>>,
422    pub f32_1: Vec<Vec<f32>>,
423    pub f64_1: Vec<Vec<f64>>,
424    pub handle_1: Vec<Vec<fidl::Handle>>,
425    pub b_sized_0: Vec<bool>,
426    pub i8_sized_0: Vec<i8>,
427    pub i16_sized_0: Vec<i16>,
428    pub i32_sized_0: Vec<i32>,
429    pub i64_sized_0: Vec<i64>,
430    pub u8_sized_0: Vec<u8>,
431    pub u16_sized_0: Vec<u16>,
432    pub u32_sized_0: Vec<u32>,
433    pub u64_sized_0: Vec<u64>,
434    pub f32_sized_0: Vec<f32>,
435    pub f64_sized_0: Vec<f64>,
436    pub handle_sized_0: Vec<fidl::Handle>,
437    pub b_sized_1: Vec<bool>,
438    pub i8_sized_1: Vec<i8>,
439    pub i16_sized_1: Vec<i16>,
440    pub i32_sized_1: Vec<i32>,
441    pub i64_sized_1: Vec<i64>,
442    pub u8_sized_1: Vec<u8>,
443    pub u16_sized_1: Vec<u16>,
444    pub u32_sized_1: Vec<u32>,
445    pub u64_sized_1: Vec<u64>,
446    pub f32_sized_1: Vec<f32>,
447    pub f64_sized_1: Vec<f64>,
448    pub handle_sized_1: Vec<fidl::Handle>,
449    pub b_sized_2: Vec<Vec<bool>>,
450    pub i8_sized_2: Vec<Vec<i8>>,
451    pub i16_sized_2: Vec<Vec<i16>>,
452    pub i32_sized_2: Vec<Vec<i32>>,
453    pub i64_sized_2: Vec<Vec<i64>>,
454    pub u8_sized_2: Vec<Vec<u8>>,
455    pub u16_sized_2: Vec<Vec<u16>>,
456    pub u32_sized_2: Vec<Vec<u32>>,
457    pub u64_sized_2: Vec<Vec<u64>>,
458    pub f32_sized_2: Vec<Vec<f32>>,
459    pub f64_sized_2: Vec<Vec<f64>>,
460    pub handle_sized_2: Vec<Vec<fidl::Handle>>,
461    pub b_nullable_0: Option<Vec<bool>>,
462    pub i8_nullable_0: Option<Vec<i8>>,
463    pub i16_nullable_0: Option<Vec<i16>>,
464    pub i32_nullable_0: Option<Vec<i32>>,
465    pub i64_nullable_0: Option<Vec<i64>>,
466    pub u8_nullable_0: Option<Vec<u8>>,
467    pub u16_nullable_0: Option<Vec<u16>>,
468    pub u32_nullable_0: Option<Vec<u32>>,
469    pub u64_nullable_0: Option<Vec<u64>>,
470    pub f32_nullable_0: Option<Vec<f32>>,
471    pub f64_nullable_0: Option<Vec<f64>>,
472    pub handle_nullable_0: Option<Vec<fidl::Handle>>,
473    pub b_nullable_1: Option<Vec<Vec<bool>>>,
474    pub i8_nullable_1: Option<Vec<Vec<i8>>>,
475    pub i16_nullable_1: Option<Vec<Vec<i16>>>,
476    pub i32_nullable_1: Option<Vec<Vec<i32>>>,
477    pub i64_nullable_1: Option<Vec<Vec<i64>>>,
478    pub u8_nullable_1: Option<Vec<Vec<u8>>>,
479    pub u16_nullable_1: Option<Vec<Vec<u16>>>,
480    pub u32_nullable_1: Option<Vec<Vec<u32>>>,
481    pub u64_nullable_1: Option<Vec<Vec<u64>>>,
482    pub f32_nullable_1: Option<Vec<Vec<f32>>>,
483    pub f64_nullable_1: Option<Vec<Vec<f64>>>,
484    pub handle_nullable_1: Option<Vec<Vec<fidl::Handle>>>,
485    pub b_nullable_sized_0: Option<Vec<bool>>,
486    pub i8_nullable_sized_0: Option<Vec<i8>>,
487    pub i16_nullable_sized_0: Option<Vec<i16>>,
488    pub i32_nullable_sized_0: Option<Vec<i32>>,
489    pub i64_nullable_sized_0: Option<Vec<i64>>,
490    pub u8_nullable_sized_0: Option<Vec<u8>>,
491    pub u16_nullable_sized_0: Option<Vec<u16>>,
492    pub u32_nullable_sized_0: Option<Vec<u32>>,
493    pub u64_nullable_sized_0: Option<Vec<u64>>,
494    pub f32_nullable_sized_0: Option<Vec<f32>>,
495    pub f64_nullable_sized_0: Option<Vec<f64>>,
496    pub handle_nullable_sized_0: Option<Vec<fidl::Handle>>,
497    pub b_nullable_sized_1: Option<Vec<bool>>,
498    pub i8_nullable_sized_1: Option<Vec<i8>>,
499    pub i16_nullable_sized_1: Option<Vec<i16>>,
500    pub i32_nullable_sized_1: Option<Vec<i32>>,
501    pub i64_nullable_sized_1: Option<Vec<i64>>,
502    pub u8_nullable_sized_1: Option<Vec<u8>>,
503    pub u16_nullable_sized_1: Option<Vec<u16>>,
504    pub u32_nullable_sized_1: Option<Vec<u32>>,
505    pub u64_nullable_sized_1: Option<Vec<u64>>,
506    pub f32_nullable_sized_1: Option<Vec<f32>>,
507    pub f64_nullable_sized_1: Option<Vec<f64>>,
508    pub handle_nullable_sized_1: Option<Vec<fidl::Handle>>,
509    pub b_nullable_sized_2: Option<Vec<Vec<bool>>>,
510    pub i8_nullable_sized_2: Option<Vec<Vec<i8>>>,
511    pub i16_nullable_sized_2: Option<Vec<Vec<i16>>>,
512    pub i32_nullable_sized_2: Option<Vec<Vec<i32>>>,
513    pub i64_nullable_sized_2: Option<Vec<Vec<i64>>>,
514    pub u8_nullable_sized_2: Option<Vec<Vec<u8>>>,
515    pub u16_nullable_sized_2: Option<Vec<Vec<u16>>>,
516    pub u32_nullable_sized_2: Option<Vec<Vec<u32>>>,
517    pub u64_nullable_sized_2: Option<Vec<Vec<u64>>>,
518    pub f32_nullable_sized_2: Option<Vec<Vec<f32>>>,
519    pub f64_nullable_sized_2: Option<Vec<Vec<f64>>>,
520    pub handle_nullable_sized_2: Option<Vec<Vec<fidl::Handle>>>,
521}
522
523impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for Vectors {}
524
525#[derive(Debug, Default, PartialEq)]
526pub struct AllTypesTable {
527    pub bool_member: Option<bool>,
528    pub int8_member: Option<i8>,
529    pub int16_member: Option<i16>,
530    pub int32_member: Option<i32>,
531    pub int64_member: Option<i64>,
532    pub uint8_member: Option<u8>,
533    pub uint16_member: Option<u16>,
534    pub uint32_member: Option<u32>,
535    pub uint64_member: Option<u64>,
536    pub float32_member: Option<f32>,
537    pub float64_member: Option<f64>,
538    pub enum_member: Option<DefaultEnum>,
539    pub bits_member: Option<DefaultBits>,
540    pub handle_member: Option<fidl::Handle>,
541    pub string_member: Option<String>,
542    pub struct_member: Option<ThisIsAStruct>,
543    pub union_member: Option<ThisIsAUnion>,
544    pub array_member: Option<[u32; 3]>,
545    pub vector_member: Option<Vec<u32>>,
546    pub table_member: Option<ThisIsATable>,
547    pub xunion_member: Option<ThisIsAXunion>,
548    #[doc(hidden)]
549    pub __source_breaking: fidl::marker::SourceBreaking,
550}
551
552impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for AllTypesTable {}
553
554#[derive(Debug)]
555pub enum AllTypesXunion {
556    BoolMember(bool),
557    Int8Member(i8),
558    Int16Member(i16),
559    Int32Member(i32),
560    Int64Member(i64),
561    Uint8Member(u8),
562    Uint16Member(u16),
563    Uint32Member(u32),
564    Uint64Member(u64),
565    Float32Member(f32),
566    Float64Member(f64),
567    EnumMember(DefaultEnum),
568    BitsMember(DefaultBits),
569    HandleMember(fidl::Handle),
570    StringMember(String),
571    StructMember(ThisIsAStruct),
572    UnionMember(ThisIsAUnion),
573    ArrayMember([u32; 3]),
574    VectorMember(Vec<u32>),
575    TableMember(ThisIsATable),
576    XunionMember(ThisIsAXunion),
577    #[doc(hidden)]
578    __SourceBreaking {
579        unknown_ordinal: u64,
580    },
581}
582
583/// Pattern that matches an unknown `AllTypesXunion` member.
584#[macro_export]
585macro_rules! AllTypesXunionUnknown {
586    () => {
587        _
588    };
589}
590
591// Custom PartialEq so that unknown variants are not equal to themselves.
592impl PartialEq for AllTypesXunion {
593    fn eq(&self, other: &Self) -> bool {
594        match (self, other) {
595            (Self::BoolMember(x), Self::BoolMember(y)) => *x == *y,
596            (Self::Int8Member(x), Self::Int8Member(y)) => *x == *y,
597            (Self::Int16Member(x), Self::Int16Member(y)) => *x == *y,
598            (Self::Int32Member(x), Self::Int32Member(y)) => *x == *y,
599            (Self::Int64Member(x), Self::Int64Member(y)) => *x == *y,
600            (Self::Uint8Member(x), Self::Uint8Member(y)) => *x == *y,
601            (Self::Uint16Member(x), Self::Uint16Member(y)) => *x == *y,
602            (Self::Uint32Member(x), Self::Uint32Member(y)) => *x == *y,
603            (Self::Uint64Member(x), Self::Uint64Member(y)) => *x == *y,
604            (Self::Float32Member(x), Self::Float32Member(y)) => *x == *y,
605            (Self::Float64Member(x), Self::Float64Member(y)) => *x == *y,
606            (Self::EnumMember(x), Self::EnumMember(y)) => *x == *y,
607            (Self::BitsMember(x), Self::BitsMember(y)) => *x == *y,
608            (Self::HandleMember(x), Self::HandleMember(y)) => *x == *y,
609            (Self::StringMember(x), Self::StringMember(y)) => *x == *y,
610            (Self::StructMember(x), Self::StructMember(y)) => *x == *y,
611            (Self::UnionMember(x), Self::UnionMember(y)) => *x == *y,
612            (Self::ArrayMember(x), Self::ArrayMember(y)) => *x == *y,
613            (Self::VectorMember(x), Self::VectorMember(y)) => *x == *y,
614            (Self::TableMember(x), Self::TableMember(y)) => *x == *y,
615            (Self::XunionMember(x), Self::XunionMember(y)) => *x == *y,
616            _ => false,
617        }
618    }
619}
620
621impl AllTypesXunion {
622    #[inline]
623    pub fn ordinal(&self) -> u64 {
624        match *self {
625            Self::BoolMember(_) => 1,
626            Self::Int8Member(_) => 2,
627            Self::Int16Member(_) => 3,
628            Self::Int32Member(_) => 4,
629            Self::Int64Member(_) => 5,
630            Self::Uint8Member(_) => 6,
631            Self::Uint16Member(_) => 7,
632            Self::Uint32Member(_) => 8,
633            Self::Uint64Member(_) => 9,
634            Self::Float32Member(_) => 10,
635            Self::Float64Member(_) => 11,
636            Self::EnumMember(_) => 12,
637            Self::BitsMember(_) => 13,
638            Self::HandleMember(_) => 14,
639            Self::StringMember(_) => 15,
640            Self::StructMember(_) => 16,
641            Self::UnionMember(_) => 17,
642            Self::ArrayMember(_) => 18,
643            Self::VectorMember(_) => 19,
644            Self::TableMember(_) => 20,
645            Self::XunionMember(_) => 21,
646            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
647        }
648    }
649
650    #[inline]
651    pub fn unknown_variant_for_testing() -> Self {
652        Self::__SourceBreaking { unknown_ordinal: 0 }
653    }
654
655    #[inline]
656    pub fn is_unknown(&self) -> bool {
657        match self {
658            Self::__SourceBreaking { .. } => true,
659            _ => false,
660        }
661    }
662}
663
664impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for AllTypesXunion {}
665
666#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
667pub struct ConfigMarker;
668
669impl fidl::endpoints::ProtocolMarker for ConfigMarker {
670    type Proxy = ConfigProxy;
671    type RequestStream = ConfigRequestStream;
672    #[cfg(target_os = "fuchsia")]
673    type SynchronousProxy = ConfigSynchronousProxy;
674
675    const DEBUG_NAME: &'static str = "fidl.test.compatibility.Config";
676}
677impl fidl::endpoints::DiscoverableProtocolMarker for ConfigMarker {}
678
679pub trait ConfigProxyInterface: Send + Sync {
680    type GetImplsResponseFut: std::future::Future<Output = Result<Vec<String>, fidl::Error>> + Send;
681    fn r#get_impls(&self) -> Self::GetImplsResponseFut;
682}
683#[derive(Debug)]
684#[cfg(target_os = "fuchsia")]
685pub struct ConfigSynchronousProxy {
686    client: fidl::client::sync::Client,
687}
688
689#[cfg(target_os = "fuchsia")]
690impl fidl::endpoints::SynchronousProxy for ConfigSynchronousProxy {
691    type Proxy = ConfigProxy;
692    type Protocol = ConfigMarker;
693
694    fn from_channel(inner: fidl::Channel) -> Self {
695        Self::new(inner)
696    }
697
698    fn into_channel(self) -> fidl::Channel {
699        self.client.into_channel()
700    }
701
702    fn as_channel(&self) -> &fidl::Channel {
703        self.client.as_channel()
704    }
705}
706
707#[cfg(target_os = "fuchsia")]
708impl ConfigSynchronousProxy {
709    pub fn new(channel: fidl::Channel) -> Self {
710        let protocol_name = <ConfigMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
711        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
712    }
713
714    pub fn into_channel(self) -> fidl::Channel {
715        self.client.into_channel()
716    }
717
718    /// Waits until an event arrives and returns it. It is safe for other
719    /// threads to make concurrent requests while waiting for an event.
720    pub fn wait_for_event(
721        &self,
722        deadline: zx::MonotonicInstant,
723    ) -> Result<ConfigEvent, fidl::Error> {
724        ConfigEvent::decode(self.client.wait_for_event(deadline)?)
725    }
726
727    pub fn r#get_impls(
728        &self,
729        ___deadline: zx::MonotonicInstant,
730    ) -> Result<Vec<String>, fidl::Error> {
731        let _response =
732            self.client.send_query::<fidl::encoding::EmptyPayload, ConfigGetImplsResponse>(
733                (),
734                0x3b360c86a6dbdfe0,
735                fidl::encoding::DynamicFlags::empty(),
736                ___deadline,
737            )?;
738        Ok(_response.impls)
739    }
740}
741
742#[cfg(target_os = "fuchsia")]
743impl From<ConfigSynchronousProxy> for zx::Handle {
744    fn from(value: ConfigSynchronousProxy) -> Self {
745        value.into_channel().into()
746    }
747}
748
749#[cfg(target_os = "fuchsia")]
750impl From<fidl::Channel> for ConfigSynchronousProxy {
751    fn from(value: fidl::Channel) -> Self {
752        Self::new(value)
753    }
754}
755
756#[cfg(target_os = "fuchsia")]
757impl fidl::endpoints::FromClient for ConfigSynchronousProxy {
758    type Protocol = ConfigMarker;
759
760    fn from_client(value: fidl::endpoints::ClientEnd<ConfigMarker>) -> Self {
761        Self::new(value.into_channel())
762    }
763}
764
765#[derive(Debug, Clone)]
766pub struct ConfigProxy {
767    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
768}
769
770impl fidl::endpoints::Proxy for ConfigProxy {
771    type Protocol = ConfigMarker;
772
773    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
774        Self::new(inner)
775    }
776
777    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
778        self.client.into_channel().map_err(|client| Self { client })
779    }
780
781    fn as_channel(&self) -> &::fidl::AsyncChannel {
782        self.client.as_channel()
783    }
784}
785
786impl ConfigProxy {
787    /// Create a new Proxy for fidl.test.compatibility/Config.
788    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
789        let protocol_name = <ConfigMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
790        Self { client: fidl::client::Client::new(channel, protocol_name) }
791    }
792
793    /// Get a Stream of events from the remote end of the protocol.
794    ///
795    /// # Panics
796    ///
797    /// Panics if the event stream was already taken.
798    pub fn take_event_stream(&self) -> ConfigEventStream {
799        ConfigEventStream { event_receiver: self.client.take_event_receiver() }
800    }
801
802    pub fn r#get_impls(
803        &self,
804    ) -> fidl::client::QueryResponseFut<Vec<String>, fidl::encoding::DefaultFuchsiaResourceDialect>
805    {
806        ConfigProxyInterface::r#get_impls(self)
807    }
808}
809
810impl ConfigProxyInterface for ConfigProxy {
811    type GetImplsResponseFut =
812        fidl::client::QueryResponseFut<Vec<String>, fidl::encoding::DefaultFuchsiaResourceDialect>;
813    fn r#get_impls(&self) -> Self::GetImplsResponseFut {
814        fn _decode(
815            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
816        ) -> Result<Vec<String>, fidl::Error> {
817            let _response = fidl::client::decode_transaction_body::<
818                ConfigGetImplsResponse,
819                fidl::encoding::DefaultFuchsiaResourceDialect,
820                0x3b360c86a6dbdfe0,
821            >(_buf?)?;
822            Ok(_response.impls)
823        }
824        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<String>>(
825            (),
826            0x3b360c86a6dbdfe0,
827            fidl::encoding::DynamicFlags::empty(),
828            _decode,
829        )
830    }
831}
832
833pub struct ConfigEventStream {
834    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
835}
836
837impl std::marker::Unpin for ConfigEventStream {}
838
839impl futures::stream::FusedStream for ConfigEventStream {
840    fn is_terminated(&self) -> bool {
841        self.event_receiver.is_terminated()
842    }
843}
844
845impl futures::Stream for ConfigEventStream {
846    type Item = Result<ConfigEvent, fidl::Error>;
847
848    fn poll_next(
849        mut self: std::pin::Pin<&mut Self>,
850        cx: &mut std::task::Context<'_>,
851    ) -> std::task::Poll<Option<Self::Item>> {
852        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
853            &mut self.event_receiver,
854            cx
855        )?) {
856            Some(buf) => std::task::Poll::Ready(Some(ConfigEvent::decode(buf))),
857            None => std::task::Poll::Ready(None),
858        }
859    }
860}
861
862#[derive(Debug)]
863pub enum ConfigEvent {}
864
865impl ConfigEvent {
866    /// Decodes a message buffer as a [`ConfigEvent`].
867    fn decode(
868        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
869    ) -> Result<ConfigEvent, fidl::Error> {
870        let (bytes, _handles) = buf.split_mut();
871        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
872        debug_assert_eq!(tx_header.tx_id, 0);
873        match tx_header.ordinal {
874            _ => Err(fidl::Error::UnknownOrdinal {
875                ordinal: tx_header.ordinal,
876                protocol_name: <ConfigMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
877            }),
878        }
879    }
880}
881
882/// A Stream of incoming requests for fidl.test.compatibility/Config.
883pub struct ConfigRequestStream {
884    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
885    is_terminated: bool,
886}
887
888impl std::marker::Unpin for ConfigRequestStream {}
889
890impl futures::stream::FusedStream for ConfigRequestStream {
891    fn is_terminated(&self) -> bool {
892        self.is_terminated
893    }
894}
895
896impl fidl::endpoints::RequestStream for ConfigRequestStream {
897    type Protocol = ConfigMarker;
898    type ControlHandle = ConfigControlHandle;
899
900    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
901        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
902    }
903
904    fn control_handle(&self) -> Self::ControlHandle {
905        ConfigControlHandle { inner: self.inner.clone() }
906    }
907
908    fn into_inner(
909        self,
910    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
911    {
912        (self.inner, self.is_terminated)
913    }
914
915    fn from_inner(
916        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
917        is_terminated: bool,
918    ) -> Self {
919        Self { inner, is_terminated }
920    }
921}
922
923impl futures::Stream for ConfigRequestStream {
924    type Item = Result<ConfigRequest, fidl::Error>;
925
926    fn poll_next(
927        mut self: std::pin::Pin<&mut Self>,
928        cx: &mut std::task::Context<'_>,
929    ) -> std::task::Poll<Option<Self::Item>> {
930        let this = &mut *self;
931        if this.inner.check_shutdown(cx) {
932            this.is_terminated = true;
933            return std::task::Poll::Ready(None);
934        }
935        if this.is_terminated {
936            panic!("polled ConfigRequestStream after completion");
937        }
938        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
939            |bytes, handles| {
940                match this.inner.channel().read_etc(cx, bytes, handles) {
941                    std::task::Poll::Ready(Ok(())) => {}
942                    std::task::Poll::Pending => return std::task::Poll::Pending,
943                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
944                        this.is_terminated = true;
945                        return std::task::Poll::Ready(None);
946                    }
947                    std::task::Poll::Ready(Err(e)) => {
948                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
949                            e.into(),
950                        ))))
951                    }
952                }
953
954                // A message has been received from the channel
955                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
956
957                std::task::Poll::Ready(Some(match header.ordinal {
958                    0x3b360c86a6dbdfe0 => {
959                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
960                        let mut req = fidl::new_empty!(
961                            fidl::encoding::EmptyPayload,
962                            fidl::encoding::DefaultFuchsiaResourceDialect
963                        );
964                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
965                        let control_handle = ConfigControlHandle { inner: this.inner.clone() };
966                        Ok(ConfigRequest::GetImpls {
967                            responder: ConfigGetImplsResponder {
968                                control_handle: std::mem::ManuallyDrop::new(control_handle),
969                                tx_id: header.tx_id,
970                            },
971                        })
972                    }
973                    _ => Err(fidl::Error::UnknownOrdinal {
974                        ordinal: header.ordinal,
975                        protocol_name:
976                            <ConfigMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
977                    }),
978                }))
979            },
980        )
981    }
982}
983
984#[derive(Debug)]
985pub enum ConfigRequest {
986    GetImpls { responder: ConfigGetImplsResponder },
987}
988
989impl ConfigRequest {
990    #[allow(irrefutable_let_patterns)]
991    pub fn into_get_impls(self) -> Option<(ConfigGetImplsResponder)> {
992        if let ConfigRequest::GetImpls { responder } = self {
993            Some((responder))
994        } else {
995            None
996        }
997    }
998
999    /// Name of the method defined in FIDL
1000    pub fn method_name(&self) -> &'static str {
1001        match *self {
1002            ConfigRequest::GetImpls { .. } => "get_impls",
1003        }
1004    }
1005}
1006
1007#[derive(Debug, Clone)]
1008pub struct ConfigControlHandle {
1009    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
1010}
1011
1012impl fidl::endpoints::ControlHandle for ConfigControlHandle {
1013    fn shutdown(&self) {
1014        self.inner.shutdown()
1015    }
1016    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
1017        self.inner.shutdown_with_epitaph(status)
1018    }
1019
1020    fn is_closed(&self) -> bool {
1021        self.inner.channel().is_closed()
1022    }
1023    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
1024        self.inner.channel().on_closed()
1025    }
1026
1027    #[cfg(target_os = "fuchsia")]
1028    fn signal_peer(
1029        &self,
1030        clear_mask: zx::Signals,
1031        set_mask: zx::Signals,
1032    ) -> Result<(), zx_status::Status> {
1033        use fidl::Peered;
1034        self.inner.channel().signal_peer(clear_mask, set_mask)
1035    }
1036}
1037
1038impl ConfigControlHandle {}
1039
1040#[must_use = "FIDL methods require a response to be sent"]
1041#[derive(Debug)]
1042pub struct ConfigGetImplsResponder {
1043    control_handle: std::mem::ManuallyDrop<ConfigControlHandle>,
1044    tx_id: u32,
1045}
1046
1047/// Set the the channel to be shutdown (see [`ConfigControlHandle::shutdown`])
1048/// if the responder is dropped without sending a response, so that the client
1049/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
1050impl std::ops::Drop for ConfigGetImplsResponder {
1051    fn drop(&mut self) {
1052        self.control_handle.shutdown();
1053        // Safety: drops once, never accessed again
1054        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1055    }
1056}
1057
1058impl fidl::endpoints::Responder for ConfigGetImplsResponder {
1059    type ControlHandle = ConfigControlHandle;
1060
1061    fn control_handle(&self) -> &ConfigControlHandle {
1062        &self.control_handle
1063    }
1064
1065    fn drop_without_shutdown(mut self) {
1066        // Safety: drops once, never accessed again due to mem::forget
1067        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
1068        // Prevent Drop from running (which would shut down the channel)
1069        std::mem::forget(self);
1070    }
1071}
1072
1073impl ConfigGetImplsResponder {
1074    /// Sends a response to the FIDL transaction.
1075    ///
1076    /// Sets the channel to shutdown if an error occurs.
1077    pub fn send(self, mut impls: &[String]) -> Result<(), fidl::Error> {
1078        let _result = self.send_raw(impls);
1079        if _result.is_err() {
1080            self.control_handle.shutdown();
1081        }
1082        self.drop_without_shutdown();
1083        _result
1084    }
1085
1086    /// Similar to "send" but does not shutdown the channel if an error occurs.
1087    pub fn send_no_shutdown_on_err(self, mut impls: &[String]) -> Result<(), fidl::Error> {
1088        let _result = self.send_raw(impls);
1089        self.drop_without_shutdown();
1090        _result
1091    }
1092
1093    fn send_raw(&self, mut impls: &[String]) -> Result<(), fidl::Error> {
1094        self.control_handle.inner.send::<ConfigGetImplsResponse>(
1095            (impls,),
1096            self.tx_id,
1097            0x3b360c86a6dbdfe0,
1098            fidl::encoding::DynamicFlags::empty(),
1099        )
1100    }
1101}
1102
1103#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
1104pub struct EchoMarker;
1105
1106impl fidl::endpoints::ProtocolMarker for EchoMarker {
1107    type Proxy = EchoProxy;
1108    type RequestStream = EchoRequestStream;
1109    #[cfg(target_os = "fuchsia")]
1110    type SynchronousProxy = EchoSynchronousProxy;
1111
1112    const DEBUG_NAME: &'static str = "fidl.test.compatibility.Echo";
1113}
1114impl fidl::endpoints::DiscoverableProtocolMarker for EchoMarker {}
1115pub type EchoEchoMinimalWithErrorResult = Result<(), u32>;
1116pub type EchoEchoStructWithErrorResult = Result<Struct, DefaultEnum>;
1117pub type EchoEchoArraysWithErrorResult = Result<ArraysStruct, DefaultEnum>;
1118pub type EchoEchoVectorsWithErrorResult = Result<VectorsStruct, DefaultEnum>;
1119pub type EchoEchoTableWithErrorResult = Result<AllTypesTable, DefaultEnum>;
1120pub type EchoEchoXunionsWithErrorResult = Result<Vec<AllTypesXunion>, DefaultEnum>;
1121pub type EchoEchoNamedStructWithErrorResult = Result<fidl_fidl_test_imported::SimpleStruct, u32>;
1122pub type EchoEchoTablePayloadWithErrorResult = Result<ResponseTable, DefaultEnum>;
1123pub type EchoEchoUnionPayloadWithErrorResult = Result<ResponseUnion, DefaultEnum>;
1124
1125pub trait EchoProxyInterface: Send + Sync {
1126    type EchoTableRequestComposedResponseFut: std::future::Future<Output = Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error>>
1127        + Send;
1128    fn r#echo_table_request_composed(
1129        &self,
1130        payload: &fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
1131    ) -> Self::EchoTableRequestComposedResponseFut;
1132    type EchoUnionResponseWithErrorComposedResponseFut: std::future::Future<
1133            Output = Result<
1134                fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
1135                fidl::Error,
1136            >,
1137        > + Send;
1138    fn r#echo_union_response_with_error_composed(
1139        &self,
1140        value: i64,
1141        want_absolute_value: bool,
1142        forward_to_server: &str,
1143        result_err: u32,
1144        result_variant: fidl_fidl_test_imported::WantResponse,
1145    ) -> Self::EchoUnionResponseWithErrorComposedResponseFut;
1146    type EchoMinimalResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
1147    fn r#echo_minimal(&self, forward_to_server: &str) -> Self::EchoMinimalResponseFut;
1148    type EchoMinimalWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoMinimalWithErrorResult, fidl::Error>>
1149        + Send;
1150    fn r#echo_minimal_with_error(
1151        &self,
1152        forward_to_server: &str,
1153        result_variant: RespondWith,
1154    ) -> Self::EchoMinimalWithErrorResponseFut;
1155    fn r#echo_minimal_no_ret_val(&self, forward_to_server: &str) -> Result<(), fidl::Error>;
1156    type EchoStructResponseFut: std::future::Future<Output = Result<Struct, fidl::Error>> + Send;
1157    fn r#echo_struct(&self, value: Struct, forward_to_server: &str) -> Self::EchoStructResponseFut;
1158    type EchoStructWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoStructWithErrorResult, fidl::Error>>
1159        + Send;
1160    fn r#echo_struct_with_error(
1161        &self,
1162        value: Struct,
1163        result_err: DefaultEnum,
1164        forward_to_server: &str,
1165        result_variant: RespondWith,
1166    ) -> Self::EchoStructWithErrorResponseFut;
1167    fn r#echo_struct_no_ret_val(
1168        &self,
1169        value: Struct,
1170        forward_to_server: &str,
1171    ) -> Result<(), fidl::Error>;
1172    type EchoArraysResponseFut: std::future::Future<Output = Result<ArraysStruct, fidl::Error>>
1173        + Send;
1174    fn r#echo_arrays(
1175        &self,
1176        value: ArraysStruct,
1177        forward_to_server: &str,
1178    ) -> Self::EchoArraysResponseFut;
1179    type EchoArraysWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoArraysWithErrorResult, fidl::Error>>
1180        + Send;
1181    fn r#echo_arrays_with_error(
1182        &self,
1183        value: ArraysStruct,
1184        result_err: DefaultEnum,
1185        forward_to_server: &str,
1186        result_variant: RespondWith,
1187    ) -> Self::EchoArraysWithErrorResponseFut;
1188    type EchoVectorsResponseFut: std::future::Future<Output = Result<VectorsStruct, fidl::Error>>
1189        + Send;
1190    fn r#echo_vectors(
1191        &self,
1192        value: VectorsStruct,
1193        forward_to_server: &str,
1194    ) -> Self::EchoVectorsResponseFut;
1195    type EchoVectorsWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoVectorsWithErrorResult, fidl::Error>>
1196        + Send;
1197    fn r#echo_vectors_with_error(
1198        &self,
1199        value: VectorsStruct,
1200        result_err: DefaultEnum,
1201        forward_to_server: &str,
1202        result_variant: RespondWith,
1203    ) -> Self::EchoVectorsWithErrorResponseFut;
1204    type EchoTableResponseFut: std::future::Future<Output = Result<AllTypesTable, fidl::Error>>
1205        + Send;
1206    fn r#echo_table(
1207        &self,
1208        value: AllTypesTable,
1209        forward_to_server: &str,
1210    ) -> Self::EchoTableResponseFut;
1211    type EchoTableWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoTableWithErrorResult, fidl::Error>>
1212        + Send;
1213    fn r#echo_table_with_error(
1214        &self,
1215        value: AllTypesTable,
1216        result_err: DefaultEnum,
1217        forward_to_server: &str,
1218        result_variant: RespondWith,
1219    ) -> Self::EchoTableWithErrorResponseFut;
1220    type EchoXunionsResponseFut: std::future::Future<Output = Result<Vec<AllTypesXunion>, fidl::Error>>
1221        + Send;
1222    fn r#echo_xunions(
1223        &self,
1224        value: Vec<AllTypesXunion>,
1225        forward_to_server: &str,
1226    ) -> Self::EchoXunionsResponseFut;
1227    type EchoXunionsWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoXunionsWithErrorResult, fidl::Error>>
1228        + Send;
1229    fn r#echo_xunions_with_error(
1230        &self,
1231        value: Vec<AllTypesXunion>,
1232        result_err: DefaultEnum,
1233        forward_to_server: &str,
1234        result_variant: RespondWith,
1235    ) -> Self::EchoXunionsWithErrorResponseFut;
1236    type EchoNamedStructResponseFut: std::future::Future<Output = Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error>>
1237        + Send;
1238    fn r#echo_named_struct(
1239        &self,
1240        value: &fidl_fidl_test_imported::SimpleStruct,
1241        forward_to_server: &str,
1242    ) -> Self::EchoNamedStructResponseFut;
1243    type EchoNamedStructWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoNamedStructWithErrorResult, fidl::Error>>
1244        + Send;
1245    fn r#echo_named_struct_with_error(
1246        &self,
1247        value: &fidl_fidl_test_imported::SimpleStruct,
1248        result_err: u32,
1249        forward_to_server: &str,
1250        result_variant: fidl_fidl_test_imported::WantResponse,
1251    ) -> Self::EchoNamedStructWithErrorResponseFut;
1252    fn r#echo_named_struct_no_ret_val(
1253        &self,
1254        value: &fidl_fidl_test_imported::SimpleStruct,
1255        forward_to_server: &str,
1256    ) -> Result<(), fidl::Error>;
1257    type EchoTablePayloadResponseFut: std::future::Future<Output = Result<ResponseTable, fidl::Error>>
1258        + Send;
1259    fn r#echo_table_payload(&self, payload: &RequestTable) -> Self::EchoTablePayloadResponseFut;
1260    type EchoTablePayloadWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoTablePayloadWithErrorResult, fidl::Error>>
1261        + Send;
1262    fn r#echo_table_payload_with_error(
1263        &self,
1264        payload: &EchoEchoTablePayloadWithErrorRequest,
1265    ) -> Self::EchoTablePayloadWithErrorResponseFut;
1266    fn r#echo_table_payload_no_ret_val(&self, payload: &RequestTable) -> Result<(), fidl::Error>;
1267    type EchoUnionPayloadResponseFut: std::future::Future<Output = Result<ResponseUnion, fidl::Error>>
1268        + Send;
1269    fn r#echo_union_payload(&self, payload: &RequestUnion) -> Self::EchoUnionPayloadResponseFut;
1270    type EchoUnionPayloadWithErrorResponseFut: std::future::Future<Output = Result<EchoEchoUnionPayloadWithErrorResult, fidl::Error>>
1271        + Send;
1272    fn r#echo_union_payload_with_error(
1273        &self,
1274        payload: &EchoEchoUnionPayloadWithErrorRequest,
1275    ) -> Self::EchoUnionPayloadWithErrorResponseFut;
1276    fn r#echo_union_payload_no_ret_val(&self, payload: &RequestUnion) -> Result<(), fidl::Error>;
1277}
1278#[derive(Debug)]
1279#[cfg(target_os = "fuchsia")]
1280pub struct EchoSynchronousProxy {
1281    client: fidl::client::sync::Client,
1282}
1283
1284#[cfg(target_os = "fuchsia")]
1285impl fidl::endpoints::SynchronousProxy for EchoSynchronousProxy {
1286    type Proxy = EchoProxy;
1287    type Protocol = EchoMarker;
1288
1289    fn from_channel(inner: fidl::Channel) -> Self {
1290        Self::new(inner)
1291    }
1292
1293    fn into_channel(self) -> fidl::Channel {
1294        self.client.into_channel()
1295    }
1296
1297    fn as_channel(&self) -> &fidl::Channel {
1298        self.client.as_channel()
1299    }
1300}
1301
1302#[cfg(target_os = "fuchsia")]
1303impl EchoSynchronousProxy {
1304    pub fn new(channel: fidl::Channel) -> Self {
1305        let protocol_name = <EchoMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1306        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
1307    }
1308
1309    pub fn into_channel(self) -> fidl::Channel {
1310        self.client.into_channel()
1311    }
1312
1313    /// Waits until an event arrives and returns it. It is safe for other
1314    /// threads to make concurrent requests while waiting for an event.
1315    pub fn wait_for_event(&self, deadline: zx::MonotonicInstant) -> Result<EchoEvent, fidl::Error> {
1316        EchoEvent::decode(self.client.wait_for_event(deadline)?)
1317    }
1318
1319    pub fn r#echo_table_request_composed(
1320        &self,
1321        mut payload: &fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
1322        ___deadline: zx::MonotonicInstant,
1323    ) -> Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error> {
1324        let _response = self.client.send_query::<
1325            fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
1326            fidl_fidl_test_imported::ResponseStruct,
1327        >(
1328            payload,
1329            0x1d545c738c7a8ee,
1330            fidl::encoding::DynamicFlags::empty(),
1331            ___deadline,
1332        )?;
1333        Ok(_response.value)
1334    }
1335
1336    pub fn r#echo_union_response_with_error_composed(
1337        &self,
1338        mut value: i64,
1339        mut want_absolute_value: bool,
1340        mut forward_to_server: &str,
1341        mut result_err: u32,
1342        mut result_variant: fidl_fidl_test_imported::WantResponse,
1343        ___deadline: zx::MonotonicInstant,
1344    ) -> Result<
1345        fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
1346        fidl::Error,
1347    > {
1348        let _response = self.client.send_query::<
1349            fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedRequest,
1350            fidl::encoding::ResultType<fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse, u32>,
1351        >(
1352            (value, want_absolute_value, forward_to_server, result_err, result_variant,),
1353            0x38a67e88d6106443,
1354            fidl::encoding::DynamicFlags::empty(),
1355            ___deadline,
1356        )?;
1357        Ok(_response.map(|x| x))
1358    }
1359
1360    pub fn r#echo_minimal(
1361        &self,
1362        mut forward_to_server: &str,
1363        ___deadline: zx::MonotonicInstant,
1364    ) -> Result<(), fidl::Error> {
1365        let _response =
1366            self.client.send_query::<EchoEchoMinimalRequest, fidl::encoding::EmptyPayload>(
1367                (forward_to_server,),
1368                0x39edd68c837482ec,
1369                fidl::encoding::DynamicFlags::empty(),
1370                ___deadline,
1371            )?;
1372        Ok(_response)
1373    }
1374
1375    pub fn r#echo_minimal_with_error(
1376        &self,
1377        mut forward_to_server: &str,
1378        mut result_variant: RespondWith,
1379        ___deadline: zx::MonotonicInstant,
1380    ) -> Result<EchoEchoMinimalWithErrorResult, fidl::Error> {
1381        let _response = self.client.send_query::<
1382            EchoEchoMinimalWithErrorRequest,
1383            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, u32>,
1384        >(
1385            (forward_to_server, result_variant,),
1386            0x36f4695996e35acc,
1387            fidl::encoding::DynamicFlags::empty(),
1388            ___deadline,
1389        )?;
1390        Ok(_response.map(|x| x))
1391    }
1392
1393    pub fn r#echo_minimal_no_ret_val(
1394        &self,
1395        mut forward_to_server: &str,
1396    ) -> Result<(), fidl::Error> {
1397        self.client.send::<EchoEchoMinimalNoRetValRequest>(
1398            (forward_to_server,),
1399            0x42693c143e2c3694,
1400            fidl::encoding::DynamicFlags::empty(),
1401        )
1402    }
1403
1404    pub fn r#echo_struct(
1405        &self,
1406        mut value: Struct,
1407        mut forward_to_server: &str,
1408        ___deadline: zx::MonotonicInstant,
1409    ) -> Result<Struct, fidl::Error> {
1410        let _response = self.client.send_query::<EchoEchoStructRequest, EchoEchoStructResponse>(
1411            (&mut value, forward_to_server),
1412            0x4c2f85818cc53f37,
1413            fidl::encoding::DynamicFlags::empty(),
1414            ___deadline,
1415        )?;
1416        Ok(_response.value)
1417    }
1418
1419    pub fn r#echo_struct_with_error(
1420        &self,
1421        mut value: Struct,
1422        mut result_err: DefaultEnum,
1423        mut forward_to_server: &str,
1424        mut result_variant: RespondWith,
1425        ___deadline: zx::MonotonicInstant,
1426    ) -> Result<EchoEchoStructWithErrorResult, fidl::Error> {
1427        let _response = self.client.send_query::<
1428            EchoEchoStructWithErrorRequest,
1429            fidl::encoding::ResultType<EchoEchoStructWithErrorResponse, DefaultEnum>,
1430        >(
1431            (&mut value, result_err, forward_to_server, result_variant,),
1432            0x46cb32652c4c0899,
1433            fidl::encoding::DynamicFlags::empty(),
1434            ___deadline,
1435        )?;
1436        Ok(_response.map(|x| x.value))
1437    }
1438
1439    pub fn r#echo_struct_no_ret_val(
1440        &self,
1441        mut value: Struct,
1442        mut forward_to_server: &str,
1443    ) -> Result<(), fidl::Error> {
1444        self.client.send::<EchoEchoStructNoRetValRequest>(
1445            (&mut value, forward_to_server),
1446            0x1f763e602cf5892a,
1447            fidl::encoding::DynamicFlags::empty(),
1448        )
1449    }
1450
1451    pub fn r#echo_arrays(
1452        &self,
1453        mut value: ArraysStruct,
1454        mut forward_to_server: &str,
1455        ___deadline: zx::MonotonicInstant,
1456    ) -> Result<ArraysStruct, fidl::Error> {
1457        let _response = self.client.send_query::<EchoEchoArraysRequest, EchoEchoArraysResponse>(
1458            (&mut value, forward_to_server),
1459            0x1b6019d5611f2470,
1460            fidl::encoding::DynamicFlags::empty(),
1461            ___deadline,
1462        )?;
1463        Ok(_response.value)
1464    }
1465
1466    pub fn r#echo_arrays_with_error(
1467        &self,
1468        mut value: ArraysStruct,
1469        mut result_err: DefaultEnum,
1470        mut forward_to_server: &str,
1471        mut result_variant: RespondWith,
1472        ___deadline: zx::MonotonicInstant,
1473    ) -> Result<EchoEchoArraysWithErrorResult, fidl::Error> {
1474        let _response = self.client.send_query::<
1475            EchoEchoArraysWithErrorRequest,
1476            fidl::encoding::ResultType<EchoEchoArraysWithErrorResponse, DefaultEnum>,
1477        >(
1478            (&mut value, result_err, forward_to_server, result_variant,),
1479            0x6dbf26e67e253afa,
1480            fidl::encoding::DynamicFlags::empty(),
1481            ___deadline,
1482        )?;
1483        Ok(_response.map(|x| x.value))
1484    }
1485
1486    pub fn r#echo_vectors(
1487        &self,
1488        mut value: VectorsStruct,
1489        mut forward_to_server: &str,
1490        ___deadline: zx::MonotonicInstant,
1491    ) -> Result<VectorsStruct, fidl::Error> {
1492        let _response = self.client.send_query::<EchoEchoVectorsRequest, EchoEchoVectorsResponse>(
1493            (&mut value, forward_to_server),
1494            0x1582623f0d9f6e5e,
1495            fidl::encoding::DynamicFlags::empty(),
1496            ___deadline,
1497        )?;
1498        Ok(_response.value)
1499    }
1500
1501    pub fn r#echo_vectors_with_error(
1502        &self,
1503        mut value: VectorsStruct,
1504        mut result_err: DefaultEnum,
1505        mut forward_to_server: &str,
1506        mut result_variant: RespondWith,
1507        ___deadline: zx::MonotonicInstant,
1508    ) -> Result<EchoEchoVectorsWithErrorResult, fidl::Error> {
1509        let _response = self.client.send_query::<
1510            EchoEchoVectorsWithErrorRequest,
1511            fidl::encoding::ResultType<EchoEchoVectorsWithErrorResponse, DefaultEnum>,
1512        >(
1513            (&mut value, result_err, forward_to_server, result_variant,),
1514            0x730f163401e2b3e5,
1515            fidl::encoding::DynamicFlags::empty(),
1516            ___deadline,
1517        )?;
1518        Ok(_response.map(|x| x.value))
1519    }
1520
1521    pub fn r#echo_table(
1522        &self,
1523        mut value: AllTypesTable,
1524        mut forward_to_server: &str,
1525        ___deadline: zx::MonotonicInstant,
1526    ) -> Result<AllTypesTable, fidl::Error> {
1527        let _response = self.client.send_query::<EchoEchoTableRequest, EchoEchoTableResponse>(
1528            (&mut value, forward_to_server),
1529            0x4f1fb0a512f47c4b,
1530            fidl::encoding::DynamicFlags::empty(),
1531            ___deadline,
1532        )?;
1533        Ok(_response.value)
1534    }
1535
1536    pub fn r#echo_table_with_error(
1537        &self,
1538        mut value: AllTypesTable,
1539        mut result_err: DefaultEnum,
1540        mut forward_to_server: &str,
1541        mut result_variant: RespondWith,
1542        ___deadline: zx::MonotonicInstant,
1543    ) -> Result<EchoEchoTableWithErrorResult, fidl::Error> {
1544        let _response = self.client.send_query::<
1545            EchoEchoTableWithErrorRequest,
1546            fidl::encoding::ResultType<EchoEchoTableWithErrorResponse, DefaultEnum>,
1547        >(
1548            (&mut value, result_err, forward_to_server, result_variant,),
1549            0x44e835cb1eb9a931,
1550            fidl::encoding::DynamicFlags::empty(),
1551            ___deadline,
1552        )?;
1553        Ok(_response.map(|x| x.value))
1554    }
1555
1556    pub fn r#echo_xunions(
1557        &self,
1558        mut value: Vec<AllTypesXunion>,
1559        mut forward_to_server: &str,
1560        ___deadline: zx::MonotonicInstant,
1561    ) -> Result<Vec<AllTypesXunion>, fidl::Error> {
1562        let _response = self.client.send_query::<EchoEchoXunionsRequest, EchoEchoXunionsResponse>(
1563            (value.as_mut(), forward_to_server),
1564            0x3dc181909041a583,
1565            fidl::encoding::DynamicFlags::empty(),
1566            ___deadline,
1567        )?;
1568        Ok(_response.value)
1569    }
1570
1571    pub fn r#echo_xunions_with_error(
1572        &self,
1573        mut value: Vec<AllTypesXunion>,
1574        mut result_err: DefaultEnum,
1575        mut forward_to_server: &str,
1576        mut result_variant: RespondWith,
1577        ___deadline: zx::MonotonicInstant,
1578    ) -> Result<EchoEchoXunionsWithErrorResult, fidl::Error> {
1579        let _response = self.client.send_query::<
1580            EchoEchoXunionsWithErrorRequest,
1581            fidl::encoding::ResultType<EchoEchoXunionsWithErrorResponse, DefaultEnum>,
1582        >(
1583            (value.as_mut(), result_err, forward_to_server, result_variant,),
1584            0x75184102667fa766,
1585            fidl::encoding::DynamicFlags::empty(),
1586            ___deadline,
1587        )?;
1588        Ok(_response.map(|x| x.value))
1589    }
1590
1591    pub fn r#echo_named_struct(
1592        &self,
1593        mut value: &fidl_fidl_test_imported::SimpleStruct,
1594        mut forward_to_server: &str,
1595        ___deadline: zx::MonotonicInstant,
1596    ) -> Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error> {
1597        let _response = self.client.send_query::<
1598            fidl_fidl_test_imported::RequestStruct,
1599            fidl_fidl_test_imported::ResponseStruct,
1600        >(
1601            (value, forward_to_server,),
1602            0xf2d4aa9e65f7111,
1603            fidl::encoding::DynamicFlags::empty(),
1604            ___deadline,
1605        )?;
1606        Ok(_response.value)
1607    }
1608
1609    pub fn r#echo_named_struct_with_error(
1610        &self,
1611        mut value: &fidl_fidl_test_imported::SimpleStruct,
1612        mut result_err: u32,
1613        mut forward_to_server: &str,
1614        mut result_variant: fidl_fidl_test_imported::WantResponse,
1615        ___deadline: zx::MonotonicInstant,
1616    ) -> Result<EchoEchoNamedStructWithErrorResult, fidl::Error> {
1617        let _response = self.client.send_query::<
1618            fidl_fidl_test_imported::ErrorableRequestStruct,
1619            fidl::encoding::ResultType<fidl_fidl_test_imported::ResponseStruct, u32>,
1620        >(
1621            (value, result_err, forward_to_server, result_variant,),
1622            0x5766fee9e74442e8,
1623            fidl::encoding::DynamicFlags::empty(),
1624            ___deadline,
1625        )?;
1626        Ok(_response.map(|x| x.value))
1627    }
1628
1629    pub fn r#echo_named_struct_no_ret_val(
1630        &self,
1631        mut value: &fidl_fidl_test_imported::SimpleStruct,
1632        mut forward_to_server: &str,
1633    ) -> Result<(), fidl::Error> {
1634        self.client.send::<fidl_fidl_test_imported::EventTriggeringRequestStruct>(
1635            (value, forward_to_server),
1636            0x3a50bbf7d2113ad7,
1637            fidl::encoding::DynamicFlags::empty(),
1638        )
1639    }
1640
1641    pub fn r#echo_table_payload(
1642        &self,
1643        mut payload: &RequestTable,
1644        ___deadline: zx::MonotonicInstant,
1645    ) -> Result<ResponseTable, fidl::Error> {
1646        let _response = self.client.send_query::<RequestTable, ResponseTable>(
1647            payload,
1648            0x641d98087378c003,
1649            fidl::encoding::DynamicFlags::empty(),
1650            ___deadline,
1651        )?;
1652        Ok(_response)
1653    }
1654
1655    pub fn r#echo_table_payload_with_error(
1656        &self,
1657        mut payload: &EchoEchoTablePayloadWithErrorRequest,
1658        ___deadline: zx::MonotonicInstant,
1659    ) -> Result<EchoEchoTablePayloadWithErrorResult, fidl::Error> {
1660        let _response = self.client.send_query::<
1661            EchoEchoTablePayloadWithErrorRequest,
1662            fidl::encoding::ResultType<ResponseTable, DefaultEnum>,
1663        >(
1664            payload,
1665            0x636ed243761ab66d,
1666            fidl::encoding::DynamicFlags::empty(),
1667            ___deadline,
1668        )?;
1669        Ok(_response.map(|x| x))
1670    }
1671
1672    pub fn r#echo_table_payload_no_ret_val(
1673        &self,
1674        mut payload: &RequestTable,
1675    ) -> Result<(), fidl::Error> {
1676        self.client.send::<RequestTable>(
1677            payload,
1678            0x32961f7d718569f8,
1679            fidl::encoding::DynamicFlags::empty(),
1680        )
1681    }
1682
1683    pub fn r#echo_union_payload(
1684        &self,
1685        mut payload: &RequestUnion,
1686        ___deadline: zx::MonotonicInstant,
1687    ) -> Result<ResponseUnion, fidl::Error> {
1688        let _response = self.client.send_query::<RequestUnion, ResponseUnion>(
1689            payload,
1690            0x66def9e793f10c55,
1691            fidl::encoding::DynamicFlags::empty(),
1692            ___deadline,
1693        )?;
1694        Ok(_response)
1695    }
1696
1697    pub fn r#echo_union_payload_with_error(
1698        &self,
1699        mut payload: &EchoEchoUnionPayloadWithErrorRequest,
1700        ___deadline: zx::MonotonicInstant,
1701    ) -> Result<EchoEchoUnionPayloadWithErrorResult, fidl::Error> {
1702        let _response = self.client.send_query::<
1703            EchoEchoUnionPayloadWithErrorRequest,
1704            fidl::encoding::ResultType<ResponseUnion, DefaultEnum>,
1705        >(
1706            payload,
1707            0x1be890d6e68ef063,
1708            fidl::encoding::DynamicFlags::empty(),
1709            ___deadline,
1710        )?;
1711        Ok(_response.map(|x| x))
1712    }
1713
1714    pub fn r#echo_union_payload_no_ret_val(
1715        &self,
1716        mut payload: &RequestUnion,
1717    ) -> Result<(), fidl::Error> {
1718        self.client.send::<RequestUnion>(
1719            payload,
1720            0x11518bf346430040,
1721            fidl::encoding::DynamicFlags::empty(),
1722        )
1723    }
1724}
1725
1726#[cfg(target_os = "fuchsia")]
1727impl From<EchoSynchronousProxy> for zx::Handle {
1728    fn from(value: EchoSynchronousProxy) -> Self {
1729        value.into_channel().into()
1730    }
1731}
1732
1733#[cfg(target_os = "fuchsia")]
1734impl From<fidl::Channel> for EchoSynchronousProxy {
1735    fn from(value: fidl::Channel) -> Self {
1736        Self::new(value)
1737    }
1738}
1739
1740#[cfg(target_os = "fuchsia")]
1741impl fidl::endpoints::FromClient for EchoSynchronousProxy {
1742    type Protocol = EchoMarker;
1743
1744    fn from_client(value: fidl::endpoints::ClientEnd<EchoMarker>) -> Self {
1745        Self::new(value.into_channel())
1746    }
1747}
1748
1749#[derive(Debug, Clone)]
1750pub struct EchoProxy {
1751    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
1752}
1753
1754impl fidl::endpoints::Proxy for EchoProxy {
1755    type Protocol = EchoMarker;
1756
1757    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
1758        Self::new(inner)
1759    }
1760
1761    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
1762        self.client.into_channel().map_err(|client| Self { client })
1763    }
1764
1765    fn as_channel(&self) -> &::fidl::AsyncChannel {
1766        self.client.as_channel()
1767    }
1768}
1769
1770impl EchoProxy {
1771    /// Create a new Proxy for fidl.test.compatibility/Echo.
1772    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
1773        let protocol_name = <EchoMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
1774        Self { client: fidl::client::Client::new(channel, protocol_name) }
1775    }
1776
1777    /// Get a Stream of events from the remote end of the protocol.
1778    ///
1779    /// # Panics
1780    ///
1781    /// Panics if the event stream was already taken.
1782    pub fn take_event_stream(&self) -> EchoEventStream {
1783        EchoEventStream { event_receiver: self.client.take_event_receiver() }
1784    }
1785
1786    pub fn r#echo_table_request_composed(
1787        &self,
1788        mut payload: &fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
1789    ) -> fidl::client::QueryResponseFut<
1790        fidl_fidl_test_imported::SimpleStruct,
1791        fidl::encoding::DefaultFuchsiaResourceDialect,
1792    > {
1793        EchoProxyInterface::r#echo_table_request_composed(self, payload)
1794    }
1795
1796    pub fn r#echo_union_response_with_error_composed(
1797        &self,
1798        mut value: i64,
1799        mut want_absolute_value: bool,
1800        mut forward_to_server: &str,
1801        mut result_err: u32,
1802        mut result_variant: fidl_fidl_test_imported::WantResponse,
1803    ) -> fidl::client::QueryResponseFut<
1804        fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
1805        fidl::encoding::DefaultFuchsiaResourceDialect,
1806    > {
1807        EchoProxyInterface::r#echo_union_response_with_error_composed(
1808            self,
1809            value,
1810            want_absolute_value,
1811            forward_to_server,
1812            result_err,
1813            result_variant,
1814        )
1815    }
1816
1817    pub fn r#echo_minimal(
1818        &self,
1819        mut forward_to_server: &str,
1820    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
1821        EchoProxyInterface::r#echo_minimal(self, forward_to_server)
1822    }
1823
1824    pub fn r#echo_minimal_with_error(
1825        &self,
1826        mut forward_to_server: &str,
1827        mut result_variant: RespondWith,
1828    ) -> fidl::client::QueryResponseFut<
1829        EchoEchoMinimalWithErrorResult,
1830        fidl::encoding::DefaultFuchsiaResourceDialect,
1831    > {
1832        EchoProxyInterface::r#echo_minimal_with_error(self, forward_to_server, result_variant)
1833    }
1834
1835    pub fn r#echo_minimal_no_ret_val(
1836        &self,
1837        mut forward_to_server: &str,
1838    ) -> Result<(), fidl::Error> {
1839        EchoProxyInterface::r#echo_minimal_no_ret_val(self, forward_to_server)
1840    }
1841
1842    pub fn r#echo_struct(
1843        &self,
1844        mut value: Struct,
1845        mut forward_to_server: &str,
1846    ) -> fidl::client::QueryResponseFut<Struct, fidl::encoding::DefaultFuchsiaResourceDialect> {
1847        EchoProxyInterface::r#echo_struct(self, value, forward_to_server)
1848    }
1849
1850    pub fn r#echo_struct_with_error(
1851        &self,
1852        mut value: Struct,
1853        mut result_err: DefaultEnum,
1854        mut forward_to_server: &str,
1855        mut result_variant: RespondWith,
1856    ) -> fidl::client::QueryResponseFut<
1857        EchoEchoStructWithErrorResult,
1858        fidl::encoding::DefaultFuchsiaResourceDialect,
1859    > {
1860        EchoProxyInterface::r#echo_struct_with_error(
1861            self,
1862            value,
1863            result_err,
1864            forward_to_server,
1865            result_variant,
1866        )
1867    }
1868
1869    pub fn r#echo_struct_no_ret_val(
1870        &self,
1871        mut value: Struct,
1872        mut forward_to_server: &str,
1873    ) -> Result<(), fidl::Error> {
1874        EchoProxyInterface::r#echo_struct_no_ret_val(self, value, forward_to_server)
1875    }
1876
1877    pub fn r#echo_arrays(
1878        &self,
1879        mut value: ArraysStruct,
1880        mut forward_to_server: &str,
1881    ) -> fidl::client::QueryResponseFut<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
1882    {
1883        EchoProxyInterface::r#echo_arrays(self, value, forward_to_server)
1884    }
1885
1886    pub fn r#echo_arrays_with_error(
1887        &self,
1888        mut value: ArraysStruct,
1889        mut result_err: DefaultEnum,
1890        mut forward_to_server: &str,
1891        mut result_variant: RespondWith,
1892    ) -> fidl::client::QueryResponseFut<
1893        EchoEchoArraysWithErrorResult,
1894        fidl::encoding::DefaultFuchsiaResourceDialect,
1895    > {
1896        EchoProxyInterface::r#echo_arrays_with_error(
1897            self,
1898            value,
1899            result_err,
1900            forward_to_server,
1901            result_variant,
1902        )
1903    }
1904
1905    pub fn r#echo_vectors(
1906        &self,
1907        mut value: VectorsStruct,
1908        mut forward_to_server: &str,
1909    ) -> fidl::client::QueryResponseFut<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
1910    {
1911        EchoProxyInterface::r#echo_vectors(self, value, forward_to_server)
1912    }
1913
1914    pub fn r#echo_vectors_with_error(
1915        &self,
1916        mut value: VectorsStruct,
1917        mut result_err: DefaultEnum,
1918        mut forward_to_server: &str,
1919        mut result_variant: RespondWith,
1920    ) -> fidl::client::QueryResponseFut<
1921        EchoEchoVectorsWithErrorResult,
1922        fidl::encoding::DefaultFuchsiaResourceDialect,
1923    > {
1924        EchoProxyInterface::r#echo_vectors_with_error(
1925            self,
1926            value,
1927            result_err,
1928            forward_to_server,
1929            result_variant,
1930        )
1931    }
1932
1933    pub fn r#echo_table(
1934        &self,
1935        mut value: AllTypesTable,
1936        mut forward_to_server: &str,
1937    ) -> fidl::client::QueryResponseFut<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>
1938    {
1939        EchoProxyInterface::r#echo_table(self, value, forward_to_server)
1940    }
1941
1942    pub fn r#echo_table_with_error(
1943        &self,
1944        mut value: AllTypesTable,
1945        mut result_err: DefaultEnum,
1946        mut forward_to_server: &str,
1947        mut result_variant: RespondWith,
1948    ) -> fidl::client::QueryResponseFut<
1949        EchoEchoTableWithErrorResult,
1950        fidl::encoding::DefaultFuchsiaResourceDialect,
1951    > {
1952        EchoProxyInterface::r#echo_table_with_error(
1953            self,
1954            value,
1955            result_err,
1956            forward_to_server,
1957            result_variant,
1958        )
1959    }
1960
1961    pub fn r#echo_xunions(
1962        &self,
1963        mut value: Vec<AllTypesXunion>,
1964        mut forward_to_server: &str,
1965    ) -> fidl::client::QueryResponseFut<
1966        Vec<AllTypesXunion>,
1967        fidl::encoding::DefaultFuchsiaResourceDialect,
1968    > {
1969        EchoProxyInterface::r#echo_xunions(self, value, forward_to_server)
1970    }
1971
1972    pub fn r#echo_xunions_with_error(
1973        &self,
1974        mut value: Vec<AllTypesXunion>,
1975        mut result_err: DefaultEnum,
1976        mut forward_to_server: &str,
1977        mut result_variant: RespondWith,
1978    ) -> fidl::client::QueryResponseFut<
1979        EchoEchoXunionsWithErrorResult,
1980        fidl::encoding::DefaultFuchsiaResourceDialect,
1981    > {
1982        EchoProxyInterface::r#echo_xunions_with_error(
1983            self,
1984            value,
1985            result_err,
1986            forward_to_server,
1987            result_variant,
1988        )
1989    }
1990
1991    pub fn r#echo_named_struct(
1992        &self,
1993        mut value: &fidl_fidl_test_imported::SimpleStruct,
1994        mut forward_to_server: &str,
1995    ) -> fidl::client::QueryResponseFut<
1996        fidl_fidl_test_imported::SimpleStruct,
1997        fidl::encoding::DefaultFuchsiaResourceDialect,
1998    > {
1999        EchoProxyInterface::r#echo_named_struct(self, value, forward_to_server)
2000    }
2001
2002    pub fn r#echo_named_struct_with_error(
2003        &self,
2004        mut value: &fidl_fidl_test_imported::SimpleStruct,
2005        mut result_err: u32,
2006        mut forward_to_server: &str,
2007        mut result_variant: fidl_fidl_test_imported::WantResponse,
2008    ) -> fidl::client::QueryResponseFut<
2009        EchoEchoNamedStructWithErrorResult,
2010        fidl::encoding::DefaultFuchsiaResourceDialect,
2011    > {
2012        EchoProxyInterface::r#echo_named_struct_with_error(
2013            self,
2014            value,
2015            result_err,
2016            forward_to_server,
2017            result_variant,
2018        )
2019    }
2020
2021    pub fn r#echo_named_struct_no_ret_val(
2022        &self,
2023        mut value: &fidl_fidl_test_imported::SimpleStruct,
2024        mut forward_to_server: &str,
2025    ) -> Result<(), fidl::Error> {
2026        EchoProxyInterface::r#echo_named_struct_no_ret_val(self, value, forward_to_server)
2027    }
2028
2029    pub fn r#echo_table_payload(
2030        &self,
2031        mut payload: &RequestTable,
2032    ) -> fidl::client::QueryResponseFut<ResponseTable, fidl::encoding::DefaultFuchsiaResourceDialect>
2033    {
2034        EchoProxyInterface::r#echo_table_payload(self, payload)
2035    }
2036
2037    pub fn r#echo_table_payload_with_error(
2038        &self,
2039        mut payload: &EchoEchoTablePayloadWithErrorRequest,
2040    ) -> fidl::client::QueryResponseFut<
2041        EchoEchoTablePayloadWithErrorResult,
2042        fidl::encoding::DefaultFuchsiaResourceDialect,
2043    > {
2044        EchoProxyInterface::r#echo_table_payload_with_error(self, payload)
2045    }
2046
2047    pub fn r#echo_table_payload_no_ret_val(
2048        &self,
2049        mut payload: &RequestTable,
2050    ) -> Result<(), fidl::Error> {
2051        EchoProxyInterface::r#echo_table_payload_no_ret_val(self, payload)
2052    }
2053
2054    pub fn r#echo_union_payload(
2055        &self,
2056        mut payload: &RequestUnion,
2057    ) -> fidl::client::QueryResponseFut<ResponseUnion, fidl::encoding::DefaultFuchsiaResourceDialect>
2058    {
2059        EchoProxyInterface::r#echo_union_payload(self, payload)
2060    }
2061
2062    pub fn r#echo_union_payload_with_error(
2063        &self,
2064        mut payload: &EchoEchoUnionPayloadWithErrorRequest,
2065    ) -> fidl::client::QueryResponseFut<
2066        EchoEchoUnionPayloadWithErrorResult,
2067        fidl::encoding::DefaultFuchsiaResourceDialect,
2068    > {
2069        EchoProxyInterface::r#echo_union_payload_with_error(self, payload)
2070    }
2071
2072    pub fn r#echo_union_payload_no_ret_val(
2073        &self,
2074        mut payload: &RequestUnion,
2075    ) -> Result<(), fidl::Error> {
2076        EchoProxyInterface::r#echo_union_payload_no_ret_val(self, payload)
2077    }
2078}
2079
2080impl EchoProxyInterface for EchoProxy {
2081    type EchoTableRequestComposedResponseFut = fidl::client::QueryResponseFut<
2082        fidl_fidl_test_imported::SimpleStruct,
2083        fidl::encoding::DefaultFuchsiaResourceDialect,
2084    >;
2085    fn r#echo_table_request_composed(
2086        &self,
2087        mut payload: &fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
2088    ) -> Self::EchoTableRequestComposedResponseFut {
2089        fn _decode(
2090            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2091        ) -> Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error> {
2092            let _response = fidl::client::decode_transaction_body::<
2093                fidl_fidl_test_imported::ResponseStruct,
2094                fidl::encoding::DefaultFuchsiaResourceDialect,
2095                0x1d545c738c7a8ee,
2096            >(_buf?)?;
2097            Ok(_response.value)
2098        }
2099        self.client.send_query_and_decode::<
2100            fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
2101            fidl_fidl_test_imported::SimpleStruct,
2102        >(
2103            payload,
2104            0x1d545c738c7a8ee,
2105            fidl::encoding::DynamicFlags::empty(),
2106            _decode,
2107        )
2108    }
2109
2110    type EchoUnionResponseWithErrorComposedResponseFut = fidl::client::QueryResponseFut<
2111        fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
2112        fidl::encoding::DefaultFuchsiaResourceDialect,
2113    >;
2114    fn r#echo_union_response_with_error_composed(
2115        &self,
2116        mut value: i64,
2117        mut want_absolute_value: bool,
2118        mut forward_to_server: &str,
2119        mut result_err: u32,
2120        mut result_variant: fidl_fidl_test_imported::WantResponse,
2121    ) -> Self::EchoUnionResponseWithErrorComposedResponseFut {
2122        fn _decode(
2123            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2124        ) -> Result<
2125            fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
2126            fidl::Error,
2127        > {
2128            let _response = fidl::client::decode_transaction_body::<
2129                fidl::encoding::ResultType<
2130                    fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse,
2131                    u32,
2132                >,
2133                fidl::encoding::DefaultFuchsiaResourceDialect,
2134                0x38a67e88d6106443,
2135            >(_buf?)?;
2136            Ok(_response.map(|x| x))
2137        }
2138        self.client.send_query_and_decode::<
2139            fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedRequest,
2140            fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResult,
2141        >(
2142            (value, want_absolute_value, forward_to_server, result_err, result_variant,),
2143            0x38a67e88d6106443,
2144            fidl::encoding::DynamicFlags::empty(),
2145            _decode,
2146        )
2147    }
2148
2149    type EchoMinimalResponseFut =
2150        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
2151    fn r#echo_minimal(&self, mut forward_to_server: &str) -> Self::EchoMinimalResponseFut {
2152        fn _decode(
2153            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2154        ) -> Result<(), fidl::Error> {
2155            let _response = fidl::client::decode_transaction_body::<
2156                fidl::encoding::EmptyPayload,
2157                fidl::encoding::DefaultFuchsiaResourceDialect,
2158                0x39edd68c837482ec,
2159            >(_buf?)?;
2160            Ok(_response)
2161        }
2162        self.client.send_query_and_decode::<EchoEchoMinimalRequest, ()>(
2163            (forward_to_server,),
2164            0x39edd68c837482ec,
2165            fidl::encoding::DynamicFlags::empty(),
2166            _decode,
2167        )
2168    }
2169
2170    type EchoMinimalWithErrorResponseFut = fidl::client::QueryResponseFut<
2171        EchoEchoMinimalWithErrorResult,
2172        fidl::encoding::DefaultFuchsiaResourceDialect,
2173    >;
2174    fn r#echo_minimal_with_error(
2175        &self,
2176        mut forward_to_server: &str,
2177        mut result_variant: RespondWith,
2178    ) -> Self::EchoMinimalWithErrorResponseFut {
2179        fn _decode(
2180            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2181        ) -> Result<EchoEchoMinimalWithErrorResult, fidl::Error> {
2182            let _response = fidl::client::decode_transaction_body::<
2183                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, u32>,
2184                fidl::encoding::DefaultFuchsiaResourceDialect,
2185                0x36f4695996e35acc,
2186            >(_buf?)?;
2187            Ok(_response.map(|x| x))
2188        }
2189        self.client.send_query_and_decode::<
2190            EchoEchoMinimalWithErrorRequest,
2191            EchoEchoMinimalWithErrorResult,
2192        >(
2193            (forward_to_server, result_variant,),
2194            0x36f4695996e35acc,
2195            fidl::encoding::DynamicFlags::empty(),
2196            _decode,
2197        )
2198    }
2199
2200    fn r#echo_minimal_no_ret_val(&self, mut forward_to_server: &str) -> Result<(), fidl::Error> {
2201        self.client.send::<EchoEchoMinimalNoRetValRequest>(
2202            (forward_to_server,),
2203            0x42693c143e2c3694,
2204            fidl::encoding::DynamicFlags::empty(),
2205        )
2206    }
2207
2208    type EchoStructResponseFut =
2209        fidl::client::QueryResponseFut<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>;
2210    fn r#echo_struct(
2211        &self,
2212        mut value: Struct,
2213        mut forward_to_server: &str,
2214    ) -> Self::EchoStructResponseFut {
2215        fn _decode(
2216            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2217        ) -> Result<Struct, fidl::Error> {
2218            let _response = fidl::client::decode_transaction_body::<
2219                EchoEchoStructResponse,
2220                fidl::encoding::DefaultFuchsiaResourceDialect,
2221                0x4c2f85818cc53f37,
2222            >(_buf?)?;
2223            Ok(_response.value)
2224        }
2225        self.client.send_query_and_decode::<EchoEchoStructRequest, Struct>(
2226            (&mut value, forward_to_server),
2227            0x4c2f85818cc53f37,
2228            fidl::encoding::DynamicFlags::empty(),
2229            _decode,
2230        )
2231    }
2232
2233    type EchoStructWithErrorResponseFut = fidl::client::QueryResponseFut<
2234        EchoEchoStructWithErrorResult,
2235        fidl::encoding::DefaultFuchsiaResourceDialect,
2236    >;
2237    fn r#echo_struct_with_error(
2238        &self,
2239        mut value: Struct,
2240        mut result_err: DefaultEnum,
2241        mut forward_to_server: &str,
2242        mut result_variant: RespondWith,
2243    ) -> Self::EchoStructWithErrorResponseFut {
2244        fn _decode(
2245            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2246        ) -> Result<EchoEchoStructWithErrorResult, fidl::Error> {
2247            let _response = fidl::client::decode_transaction_body::<
2248                fidl::encoding::ResultType<EchoEchoStructWithErrorResponse, DefaultEnum>,
2249                fidl::encoding::DefaultFuchsiaResourceDialect,
2250                0x46cb32652c4c0899,
2251            >(_buf?)?;
2252            Ok(_response.map(|x| x.value))
2253        }
2254        self.client
2255            .send_query_and_decode::<EchoEchoStructWithErrorRequest, EchoEchoStructWithErrorResult>(
2256                (&mut value, result_err, forward_to_server, result_variant),
2257                0x46cb32652c4c0899,
2258                fidl::encoding::DynamicFlags::empty(),
2259                _decode,
2260            )
2261    }
2262
2263    fn r#echo_struct_no_ret_val(
2264        &self,
2265        mut value: Struct,
2266        mut forward_to_server: &str,
2267    ) -> Result<(), fidl::Error> {
2268        self.client.send::<EchoEchoStructNoRetValRequest>(
2269            (&mut value, forward_to_server),
2270            0x1f763e602cf5892a,
2271            fidl::encoding::DynamicFlags::empty(),
2272        )
2273    }
2274
2275    type EchoArraysResponseFut =
2276        fidl::client::QueryResponseFut<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>;
2277    fn r#echo_arrays(
2278        &self,
2279        mut value: ArraysStruct,
2280        mut forward_to_server: &str,
2281    ) -> Self::EchoArraysResponseFut {
2282        fn _decode(
2283            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2284        ) -> Result<ArraysStruct, fidl::Error> {
2285            let _response = fidl::client::decode_transaction_body::<
2286                EchoEchoArraysResponse,
2287                fidl::encoding::DefaultFuchsiaResourceDialect,
2288                0x1b6019d5611f2470,
2289            >(_buf?)?;
2290            Ok(_response.value)
2291        }
2292        self.client.send_query_and_decode::<EchoEchoArraysRequest, ArraysStruct>(
2293            (&mut value, forward_to_server),
2294            0x1b6019d5611f2470,
2295            fidl::encoding::DynamicFlags::empty(),
2296            _decode,
2297        )
2298    }
2299
2300    type EchoArraysWithErrorResponseFut = fidl::client::QueryResponseFut<
2301        EchoEchoArraysWithErrorResult,
2302        fidl::encoding::DefaultFuchsiaResourceDialect,
2303    >;
2304    fn r#echo_arrays_with_error(
2305        &self,
2306        mut value: ArraysStruct,
2307        mut result_err: DefaultEnum,
2308        mut forward_to_server: &str,
2309        mut result_variant: RespondWith,
2310    ) -> Self::EchoArraysWithErrorResponseFut {
2311        fn _decode(
2312            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2313        ) -> Result<EchoEchoArraysWithErrorResult, fidl::Error> {
2314            let _response = fidl::client::decode_transaction_body::<
2315                fidl::encoding::ResultType<EchoEchoArraysWithErrorResponse, DefaultEnum>,
2316                fidl::encoding::DefaultFuchsiaResourceDialect,
2317                0x6dbf26e67e253afa,
2318            >(_buf?)?;
2319            Ok(_response.map(|x| x.value))
2320        }
2321        self.client
2322            .send_query_and_decode::<EchoEchoArraysWithErrorRequest, EchoEchoArraysWithErrorResult>(
2323                (&mut value, result_err, forward_to_server, result_variant),
2324                0x6dbf26e67e253afa,
2325                fidl::encoding::DynamicFlags::empty(),
2326                _decode,
2327            )
2328    }
2329
2330    type EchoVectorsResponseFut = fidl::client::QueryResponseFut<
2331        VectorsStruct,
2332        fidl::encoding::DefaultFuchsiaResourceDialect,
2333    >;
2334    fn r#echo_vectors(
2335        &self,
2336        mut value: VectorsStruct,
2337        mut forward_to_server: &str,
2338    ) -> Self::EchoVectorsResponseFut {
2339        fn _decode(
2340            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2341        ) -> Result<VectorsStruct, fidl::Error> {
2342            let _response = fidl::client::decode_transaction_body::<
2343                EchoEchoVectorsResponse,
2344                fidl::encoding::DefaultFuchsiaResourceDialect,
2345                0x1582623f0d9f6e5e,
2346            >(_buf?)?;
2347            Ok(_response.value)
2348        }
2349        self.client.send_query_and_decode::<EchoEchoVectorsRequest, VectorsStruct>(
2350            (&mut value, forward_to_server),
2351            0x1582623f0d9f6e5e,
2352            fidl::encoding::DynamicFlags::empty(),
2353            _decode,
2354        )
2355    }
2356
2357    type EchoVectorsWithErrorResponseFut = fidl::client::QueryResponseFut<
2358        EchoEchoVectorsWithErrorResult,
2359        fidl::encoding::DefaultFuchsiaResourceDialect,
2360    >;
2361    fn r#echo_vectors_with_error(
2362        &self,
2363        mut value: VectorsStruct,
2364        mut result_err: DefaultEnum,
2365        mut forward_to_server: &str,
2366        mut result_variant: RespondWith,
2367    ) -> Self::EchoVectorsWithErrorResponseFut {
2368        fn _decode(
2369            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2370        ) -> Result<EchoEchoVectorsWithErrorResult, fidl::Error> {
2371            let _response = fidl::client::decode_transaction_body::<
2372                fidl::encoding::ResultType<EchoEchoVectorsWithErrorResponse, DefaultEnum>,
2373                fidl::encoding::DefaultFuchsiaResourceDialect,
2374                0x730f163401e2b3e5,
2375            >(_buf?)?;
2376            Ok(_response.map(|x| x.value))
2377        }
2378        self.client.send_query_and_decode::<
2379            EchoEchoVectorsWithErrorRequest,
2380            EchoEchoVectorsWithErrorResult,
2381        >(
2382            (&mut value, result_err, forward_to_server, result_variant,),
2383            0x730f163401e2b3e5,
2384            fidl::encoding::DynamicFlags::empty(),
2385            _decode,
2386        )
2387    }
2388
2389    type EchoTableResponseFut = fidl::client::QueryResponseFut<
2390        AllTypesTable,
2391        fidl::encoding::DefaultFuchsiaResourceDialect,
2392    >;
2393    fn r#echo_table(
2394        &self,
2395        mut value: AllTypesTable,
2396        mut forward_to_server: &str,
2397    ) -> Self::EchoTableResponseFut {
2398        fn _decode(
2399            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2400        ) -> Result<AllTypesTable, fidl::Error> {
2401            let _response = fidl::client::decode_transaction_body::<
2402                EchoEchoTableResponse,
2403                fidl::encoding::DefaultFuchsiaResourceDialect,
2404                0x4f1fb0a512f47c4b,
2405            >(_buf?)?;
2406            Ok(_response.value)
2407        }
2408        self.client.send_query_and_decode::<EchoEchoTableRequest, AllTypesTable>(
2409            (&mut value, forward_to_server),
2410            0x4f1fb0a512f47c4b,
2411            fidl::encoding::DynamicFlags::empty(),
2412            _decode,
2413        )
2414    }
2415
2416    type EchoTableWithErrorResponseFut = fidl::client::QueryResponseFut<
2417        EchoEchoTableWithErrorResult,
2418        fidl::encoding::DefaultFuchsiaResourceDialect,
2419    >;
2420    fn r#echo_table_with_error(
2421        &self,
2422        mut value: AllTypesTable,
2423        mut result_err: DefaultEnum,
2424        mut forward_to_server: &str,
2425        mut result_variant: RespondWith,
2426    ) -> Self::EchoTableWithErrorResponseFut {
2427        fn _decode(
2428            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2429        ) -> Result<EchoEchoTableWithErrorResult, fidl::Error> {
2430            let _response = fidl::client::decode_transaction_body::<
2431                fidl::encoding::ResultType<EchoEchoTableWithErrorResponse, DefaultEnum>,
2432                fidl::encoding::DefaultFuchsiaResourceDialect,
2433                0x44e835cb1eb9a931,
2434            >(_buf?)?;
2435            Ok(_response.map(|x| x.value))
2436        }
2437        self.client
2438            .send_query_and_decode::<EchoEchoTableWithErrorRequest, EchoEchoTableWithErrorResult>(
2439                (&mut value, result_err, forward_to_server, result_variant),
2440                0x44e835cb1eb9a931,
2441                fidl::encoding::DynamicFlags::empty(),
2442                _decode,
2443            )
2444    }
2445
2446    type EchoXunionsResponseFut = fidl::client::QueryResponseFut<
2447        Vec<AllTypesXunion>,
2448        fidl::encoding::DefaultFuchsiaResourceDialect,
2449    >;
2450    fn r#echo_xunions(
2451        &self,
2452        mut value: Vec<AllTypesXunion>,
2453        mut forward_to_server: &str,
2454    ) -> Self::EchoXunionsResponseFut {
2455        fn _decode(
2456            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2457        ) -> Result<Vec<AllTypesXunion>, fidl::Error> {
2458            let _response = fidl::client::decode_transaction_body::<
2459                EchoEchoXunionsResponse,
2460                fidl::encoding::DefaultFuchsiaResourceDialect,
2461                0x3dc181909041a583,
2462            >(_buf?)?;
2463            Ok(_response.value)
2464        }
2465        self.client.send_query_and_decode::<EchoEchoXunionsRequest, Vec<AllTypesXunion>>(
2466            (value.as_mut(), forward_to_server),
2467            0x3dc181909041a583,
2468            fidl::encoding::DynamicFlags::empty(),
2469            _decode,
2470        )
2471    }
2472
2473    type EchoXunionsWithErrorResponseFut = fidl::client::QueryResponseFut<
2474        EchoEchoXunionsWithErrorResult,
2475        fidl::encoding::DefaultFuchsiaResourceDialect,
2476    >;
2477    fn r#echo_xunions_with_error(
2478        &self,
2479        mut value: Vec<AllTypesXunion>,
2480        mut result_err: DefaultEnum,
2481        mut forward_to_server: &str,
2482        mut result_variant: RespondWith,
2483    ) -> Self::EchoXunionsWithErrorResponseFut {
2484        fn _decode(
2485            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2486        ) -> Result<EchoEchoXunionsWithErrorResult, fidl::Error> {
2487            let _response = fidl::client::decode_transaction_body::<
2488                fidl::encoding::ResultType<EchoEchoXunionsWithErrorResponse, DefaultEnum>,
2489                fidl::encoding::DefaultFuchsiaResourceDialect,
2490                0x75184102667fa766,
2491            >(_buf?)?;
2492            Ok(_response.map(|x| x.value))
2493        }
2494        self.client.send_query_and_decode::<
2495            EchoEchoXunionsWithErrorRequest,
2496            EchoEchoXunionsWithErrorResult,
2497        >(
2498            (value.as_mut(), result_err, forward_to_server, result_variant,),
2499            0x75184102667fa766,
2500            fidl::encoding::DynamicFlags::empty(),
2501            _decode,
2502        )
2503    }
2504
2505    type EchoNamedStructResponseFut = fidl::client::QueryResponseFut<
2506        fidl_fidl_test_imported::SimpleStruct,
2507        fidl::encoding::DefaultFuchsiaResourceDialect,
2508    >;
2509    fn r#echo_named_struct(
2510        &self,
2511        mut value: &fidl_fidl_test_imported::SimpleStruct,
2512        mut forward_to_server: &str,
2513    ) -> Self::EchoNamedStructResponseFut {
2514        fn _decode(
2515            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2516        ) -> Result<fidl_fidl_test_imported::SimpleStruct, fidl::Error> {
2517            let _response = fidl::client::decode_transaction_body::<
2518                fidl_fidl_test_imported::ResponseStruct,
2519                fidl::encoding::DefaultFuchsiaResourceDialect,
2520                0xf2d4aa9e65f7111,
2521            >(_buf?)?;
2522            Ok(_response.value)
2523        }
2524        self.client.send_query_and_decode::<
2525            fidl_fidl_test_imported::RequestStruct,
2526            fidl_fidl_test_imported::SimpleStruct,
2527        >(
2528            (value, forward_to_server,),
2529            0xf2d4aa9e65f7111,
2530            fidl::encoding::DynamicFlags::empty(),
2531            _decode,
2532        )
2533    }
2534
2535    type EchoNamedStructWithErrorResponseFut = fidl::client::QueryResponseFut<
2536        EchoEchoNamedStructWithErrorResult,
2537        fidl::encoding::DefaultFuchsiaResourceDialect,
2538    >;
2539    fn r#echo_named_struct_with_error(
2540        &self,
2541        mut value: &fidl_fidl_test_imported::SimpleStruct,
2542        mut result_err: u32,
2543        mut forward_to_server: &str,
2544        mut result_variant: fidl_fidl_test_imported::WantResponse,
2545    ) -> Self::EchoNamedStructWithErrorResponseFut {
2546        fn _decode(
2547            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2548        ) -> Result<EchoEchoNamedStructWithErrorResult, fidl::Error> {
2549            let _response = fidl::client::decode_transaction_body::<
2550                fidl::encoding::ResultType<fidl_fidl_test_imported::ResponseStruct, u32>,
2551                fidl::encoding::DefaultFuchsiaResourceDialect,
2552                0x5766fee9e74442e8,
2553            >(_buf?)?;
2554            Ok(_response.map(|x| x.value))
2555        }
2556        self.client.send_query_and_decode::<
2557            fidl_fidl_test_imported::ErrorableRequestStruct,
2558            EchoEchoNamedStructWithErrorResult,
2559        >(
2560            (value, result_err, forward_to_server, result_variant,),
2561            0x5766fee9e74442e8,
2562            fidl::encoding::DynamicFlags::empty(),
2563            _decode,
2564        )
2565    }
2566
2567    fn r#echo_named_struct_no_ret_val(
2568        &self,
2569        mut value: &fidl_fidl_test_imported::SimpleStruct,
2570        mut forward_to_server: &str,
2571    ) -> Result<(), fidl::Error> {
2572        self.client.send::<fidl_fidl_test_imported::EventTriggeringRequestStruct>(
2573            (value, forward_to_server),
2574            0x3a50bbf7d2113ad7,
2575            fidl::encoding::DynamicFlags::empty(),
2576        )
2577    }
2578
2579    type EchoTablePayloadResponseFut = fidl::client::QueryResponseFut<
2580        ResponseTable,
2581        fidl::encoding::DefaultFuchsiaResourceDialect,
2582    >;
2583    fn r#echo_table_payload(
2584        &self,
2585        mut payload: &RequestTable,
2586    ) -> Self::EchoTablePayloadResponseFut {
2587        fn _decode(
2588            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2589        ) -> Result<ResponseTable, fidl::Error> {
2590            let _response = fidl::client::decode_transaction_body::<
2591                ResponseTable,
2592                fidl::encoding::DefaultFuchsiaResourceDialect,
2593                0x641d98087378c003,
2594            >(_buf?)?;
2595            Ok(_response)
2596        }
2597        self.client.send_query_and_decode::<RequestTable, ResponseTable>(
2598            payload,
2599            0x641d98087378c003,
2600            fidl::encoding::DynamicFlags::empty(),
2601            _decode,
2602        )
2603    }
2604
2605    type EchoTablePayloadWithErrorResponseFut = fidl::client::QueryResponseFut<
2606        EchoEchoTablePayloadWithErrorResult,
2607        fidl::encoding::DefaultFuchsiaResourceDialect,
2608    >;
2609    fn r#echo_table_payload_with_error(
2610        &self,
2611        mut payload: &EchoEchoTablePayloadWithErrorRequest,
2612    ) -> Self::EchoTablePayloadWithErrorResponseFut {
2613        fn _decode(
2614            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2615        ) -> Result<EchoEchoTablePayloadWithErrorResult, fidl::Error> {
2616            let _response = fidl::client::decode_transaction_body::<
2617                fidl::encoding::ResultType<ResponseTable, DefaultEnum>,
2618                fidl::encoding::DefaultFuchsiaResourceDialect,
2619                0x636ed243761ab66d,
2620            >(_buf?)?;
2621            Ok(_response.map(|x| x))
2622        }
2623        self.client.send_query_and_decode::<
2624            EchoEchoTablePayloadWithErrorRequest,
2625            EchoEchoTablePayloadWithErrorResult,
2626        >(
2627            payload,
2628            0x636ed243761ab66d,
2629            fidl::encoding::DynamicFlags::empty(),
2630            _decode,
2631        )
2632    }
2633
2634    fn r#echo_table_payload_no_ret_val(
2635        &self,
2636        mut payload: &RequestTable,
2637    ) -> Result<(), fidl::Error> {
2638        self.client.send::<RequestTable>(
2639            payload,
2640            0x32961f7d718569f8,
2641            fidl::encoding::DynamicFlags::empty(),
2642        )
2643    }
2644
2645    type EchoUnionPayloadResponseFut = fidl::client::QueryResponseFut<
2646        ResponseUnion,
2647        fidl::encoding::DefaultFuchsiaResourceDialect,
2648    >;
2649    fn r#echo_union_payload(
2650        &self,
2651        mut payload: &RequestUnion,
2652    ) -> Self::EchoUnionPayloadResponseFut {
2653        fn _decode(
2654            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2655        ) -> Result<ResponseUnion, fidl::Error> {
2656            let _response = fidl::client::decode_transaction_body::<
2657                ResponseUnion,
2658                fidl::encoding::DefaultFuchsiaResourceDialect,
2659                0x66def9e793f10c55,
2660            >(_buf?)?;
2661            Ok(_response)
2662        }
2663        self.client.send_query_and_decode::<RequestUnion, ResponseUnion>(
2664            payload,
2665            0x66def9e793f10c55,
2666            fidl::encoding::DynamicFlags::empty(),
2667            _decode,
2668        )
2669    }
2670
2671    type EchoUnionPayloadWithErrorResponseFut = fidl::client::QueryResponseFut<
2672        EchoEchoUnionPayloadWithErrorResult,
2673        fidl::encoding::DefaultFuchsiaResourceDialect,
2674    >;
2675    fn r#echo_union_payload_with_error(
2676        &self,
2677        mut payload: &EchoEchoUnionPayloadWithErrorRequest,
2678    ) -> Self::EchoUnionPayloadWithErrorResponseFut {
2679        fn _decode(
2680            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
2681        ) -> Result<EchoEchoUnionPayloadWithErrorResult, fidl::Error> {
2682            let _response = fidl::client::decode_transaction_body::<
2683                fidl::encoding::ResultType<ResponseUnion, DefaultEnum>,
2684                fidl::encoding::DefaultFuchsiaResourceDialect,
2685                0x1be890d6e68ef063,
2686            >(_buf?)?;
2687            Ok(_response.map(|x| x))
2688        }
2689        self.client.send_query_and_decode::<
2690            EchoEchoUnionPayloadWithErrorRequest,
2691            EchoEchoUnionPayloadWithErrorResult,
2692        >(
2693            payload,
2694            0x1be890d6e68ef063,
2695            fidl::encoding::DynamicFlags::empty(),
2696            _decode,
2697        )
2698    }
2699
2700    fn r#echo_union_payload_no_ret_val(
2701        &self,
2702        mut payload: &RequestUnion,
2703    ) -> Result<(), fidl::Error> {
2704        self.client.send::<RequestUnion>(
2705            payload,
2706            0x11518bf346430040,
2707            fidl::encoding::DynamicFlags::empty(),
2708        )
2709    }
2710}
2711
2712pub struct EchoEventStream {
2713    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
2714}
2715
2716impl std::marker::Unpin for EchoEventStream {}
2717
2718impl futures::stream::FusedStream for EchoEventStream {
2719    fn is_terminated(&self) -> bool {
2720        self.event_receiver.is_terminated()
2721    }
2722}
2723
2724impl futures::Stream for EchoEventStream {
2725    type Item = Result<EchoEvent, fidl::Error>;
2726
2727    fn poll_next(
2728        mut self: std::pin::Pin<&mut Self>,
2729        cx: &mut std::task::Context<'_>,
2730    ) -> std::task::Poll<Option<Self::Item>> {
2731        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
2732            &mut self.event_receiver,
2733            cx
2734        )?) {
2735            Some(buf) => std::task::Poll::Ready(Some(EchoEvent::decode(buf))),
2736            None => std::task::Poll::Ready(None),
2737        }
2738    }
2739}
2740
2741#[derive(Debug)]
2742pub enum EchoEvent {
2743    EchoMinimalEvent {},
2744    EchoEvent { value: Struct },
2745    OnEchoNamedEvent { value: fidl_fidl_test_imported::SimpleStruct },
2746    OnEchoTablePayloadEvent { payload: ResponseTable },
2747    OnEchoUnionPayloadEvent { payload: ResponseUnion },
2748}
2749
2750impl EchoEvent {
2751    #[allow(irrefutable_let_patterns)]
2752    pub fn into_echo_minimal_event(self) -> Option<()> {
2753        if let EchoEvent::EchoMinimalEvent {} = self {
2754            Some(())
2755        } else {
2756            None
2757        }
2758    }
2759    #[allow(irrefutable_let_patterns)]
2760    pub fn into_echo_event(self) -> Option<Struct> {
2761        if let EchoEvent::EchoEvent { value } = self {
2762            Some((value))
2763        } else {
2764            None
2765        }
2766    }
2767    #[allow(irrefutable_let_patterns)]
2768    pub fn into_on_echo_named_event(self) -> Option<fidl_fidl_test_imported::SimpleStruct> {
2769        if let EchoEvent::OnEchoNamedEvent { value } = self {
2770            Some((value))
2771        } else {
2772            None
2773        }
2774    }
2775    #[allow(irrefutable_let_patterns)]
2776    pub fn into_on_echo_table_payload_event(self) -> Option<ResponseTable> {
2777        if let EchoEvent::OnEchoTablePayloadEvent { payload } = self {
2778            Some((payload))
2779        } else {
2780            None
2781        }
2782    }
2783    #[allow(irrefutable_let_patterns)]
2784    pub fn into_on_echo_union_payload_event(self) -> Option<ResponseUnion> {
2785        if let EchoEvent::OnEchoUnionPayloadEvent { payload } = self {
2786            Some((payload))
2787        } else {
2788            None
2789        }
2790    }
2791
2792    /// Decodes a message buffer as a [`EchoEvent`].
2793    fn decode(
2794        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
2795    ) -> Result<EchoEvent, fidl::Error> {
2796        let (bytes, _handles) = buf.split_mut();
2797        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
2798        debug_assert_eq!(tx_header.tx_id, 0);
2799        match tx_header.ordinal {
2800            0x273b2029f1a0aee2 => {
2801                let mut out = fidl::new_empty!(
2802                    fidl::encoding::EmptyPayload,
2803                    fidl::encoding::DefaultFuchsiaResourceDialect
2804                );
2805                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&tx_header, _body_bytes, _handles, &mut out)?;
2806                Ok((EchoEvent::EchoMinimalEvent {}))
2807            }
2808            0x1219e12e0450024 => {
2809                let mut out = fidl::new_empty!(
2810                    EchoEchoEventRequest,
2811                    fidl::encoding::DefaultFuchsiaResourceDialect
2812                );
2813                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoEventRequest>(&tx_header, _body_bytes, _handles, &mut out)?;
2814                Ok((EchoEvent::EchoEvent { value: out.value }))
2815            }
2816            0x749ebde83348a374 => {
2817                let mut out = fidl::new_empty!(
2818                    fidl_fidl_test_imported::ResponseStruct,
2819                    fidl::encoding::DefaultFuchsiaResourceDialect
2820                );
2821                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::ResponseStruct>(&tx_header, _body_bytes, _handles, &mut out)?;
2822                Ok((EchoEvent::OnEchoNamedEvent { value: out.value }))
2823            }
2824            0x708dddea1cb98430 => {
2825                let mut out =
2826                    fidl::new_empty!(ResponseTable, fidl::encoding::DefaultFuchsiaResourceDialect);
2827                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ResponseTable>(&tx_header, _body_bytes, _handles, &mut out)?;
2828                Ok((EchoEvent::OnEchoTablePayloadEvent { payload: out }))
2829            }
2830            0x642f4c265a05f4c0 => {
2831                let mut out =
2832                    fidl::new_empty!(ResponseUnion, fidl::encoding::DefaultFuchsiaResourceDialect);
2833                fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ResponseUnion>(&tx_header, _body_bytes, _handles, &mut out)?;
2834                Ok((EchoEvent::OnEchoUnionPayloadEvent { payload: out }))
2835            }
2836            _ => Err(fidl::Error::UnknownOrdinal {
2837                ordinal: tx_header.ordinal,
2838                protocol_name: <EchoMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
2839            }),
2840        }
2841    }
2842}
2843
2844/// A Stream of incoming requests for fidl.test.compatibility/Echo.
2845pub struct EchoRequestStream {
2846    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
2847    is_terminated: bool,
2848}
2849
2850impl std::marker::Unpin for EchoRequestStream {}
2851
2852impl futures::stream::FusedStream for EchoRequestStream {
2853    fn is_terminated(&self) -> bool {
2854        self.is_terminated
2855    }
2856}
2857
2858impl fidl::endpoints::RequestStream for EchoRequestStream {
2859    type Protocol = EchoMarker;
2860    type ControlHandle = EchoControlHandle;
2861
2862    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
2863        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
2864    }
2865
2866    fn control_handle(&self) -> Self::ControlHandle {
2867        EchoControlHandle { inner: self.inner.clone() }
2868    }
2869
2870    fn into_inner(
2871        self,
2872    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
2873    {
2874        (self.inner, self.is_terminated)
2875    }
2876
2877    fn from_inner(
2878        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
2879        is_terminated: bool,
2880    ) -> Self {
2881        Self { inner, is_terminated }
2882    }
2883}
2884
2885impl futures::Stream for EchoRequestStream {
2886    type Item = Result<EchoRequest, fidl::Error>;
2887
2888    fn poll_next(
2889        mut self: std::pin::Pin<&mut Self>,
2890        cx: &mut std::task::Context<'_>,
2891    ) -> std::task::Poll<Option<Self::Item>> {
2892        let this = &mut *self;
2893        if this.inner.check_shutdown(cx) {
2894            this.is_terminated = true;
2895            return std::task::Poll::Ready(None);
2896        }
2897        if this.is_terminated {
2898            panic!("polled EchoRequestStream after completion");
2899        }
2900        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
2901            |bytes, handles| {
2902                match this.inner.channel().read_etc(cx, bytes, handles) {
2903                    std::task::Poll::Ready(Ok(())) => {}
2904                    std::task::Poll::Pending => return std::task::Poll::Pending,
2905                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
2906                        this.is_terminated = true;
2907                        return std::task::Poll::Ready(None);
2908                    }
2909                    std::task::Poll::Ready(Err(e)) => {
2910                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
2911                            e.into(),
2912                        ))))
2913                    }
2914                }
2915
2916                // A message has been received from the channel
2917                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
2918
2919                std::task::Poll::Ready(Some(match header.ordinal {
2920                    0x1d545c738c7a8ee => {
2921                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2922                        let mut req = fidl::new_empty!(
2923                            fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
2924                            fidl::encoding::DefaultFuchsiaResourceDialect
2925                        );
2926                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest>(&header, _body_bytes, handles, &mut req)?;
2927                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
2928                        Ok(EchoRequest::EchoTableRequestComposed {
2929                            payload: req,
2930                            responder: EchoEchoTableRequestComposedResponder {
2931                                control_handle: std::mem::ManuallyDrop::new(control_handle),
2932                                tx_id: header.tx_id,
2933                            },
2934                        })
2935                    }
2936                    0x38a67e88d6106443 => {
2937                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2938                        let mut req = fidl::new_empty!(fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
2939                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedRequest>(&header, _body_bytes, handles, &mut req)?;
2940                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
2941                        Ok(EchoRequest::EchoUnionResponseWithErrorComposed {
2942                            value: req.value,
2943                            want_absolute_value: req.want_absolute_value,
2944                            forward_to_server: req.forward_to_server,
2945                            result_err: req.result_err,
2946                            result_variant: req.result_variant,
2947
2948                            responder: EchoEchoUnionResponseWithErrorComposedResponder {
2949                                control_handle: std::mem::ManuallyDrop::new(control_handle),
2950                                tx_id: header.tx_id,
2951                            },
2952                        })
2953                    }
2954                    0x39edd68c837482ec => {
2955                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2956                        let mut req = fidl::new_empty!(
2957                            EchoEchoMinimalRequest,
2958                            fidl::encoding::DefaultFuchsiaResourceDialect
2959                        );
2960                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoMinimalRequest>(&header, _body_bytes, handles, &mut req)?;
2961                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
2962                        Ok(EchoRequest::EchoMinimal {
2963                            forward_to_server: req.forward_to_server,
2964
2965                            responder: EchoEchoMinimalResponder {
2966                                control_handle: std::mem::ManuallyDrop::new(control_handle),
2967                                tx_id: header.tx_id,
2968                            },
2969                        })
2970                    }
2971                    0x36f4695996e35acc => {
2972                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
2973                        let mut req = fidl::new_empty!(
2974                            EchoEchoMinimalWithErrorRequest,
2975                            fidl::encoding::DefaultFuchsiaResourceDialect
2976                        );
2977                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoMinimalWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
2978                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
2979                        Ok(EchoRequest::EchoMinimalWithError {
2980                            forward_to_server: req.forward_to_server,
2981                            result_variant: req.result_variant,
2982
2983                            responder: EchoEchoMinimalWithErrorResponder {
2984                                control_handle: std::mem::ManuallyDrop::new(control_handle),
2985                                tx_id: header.tx_id,
2986                            },
2987                        })
2988                    }
2989                    0x42693c143e2c3694 => {
2990                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
2991                        let mut req = fidl::new_empty!(
2992                            EchoEchoMinimalNoRetValRequest,
2993                            fidl::encoding::DefaultFuchsiaResourceDialect
2994                        );
2995                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoMinimalNoRetValRequest>(&header, _body_bytes, handles, &mut req)?;
2996                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
2997                        Ok(EchoRequest::EchoMinimalNoRetVal {
2998                            forward_to_server: req.forward_to_server,
2999
3000                            control_handle,
3001                        })
3002                    }
3003                    0x4c2f85818cc53f37 => {
3004                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3005                        let mut req = fidl::new_empty!(
3006                            EchoEchoStructRequest,
3007                            fidl::encoding::DefaultFuchsiaResourceDialect
3008                        );
3009                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoStructRequest>(&header, _body_bytes, handles, &mut req)?;
3010                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3011                        Ok(EchoRequest::EchoStruct {
3012                            value: req.value,
3013                            forward_to_server: req.forward_to_server,
3014
3015                            responder: EchoEchoStructResponder {
3016                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3017                                tx_id: header.tx_id,
3018                            },
3019                        })
3020                    }
3021                    0x46cb32652c4c0899 => {
3022                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3023                        let mut req = fidl::new_empty!(
3024                            EchoEchoStructWithErrorRequest,
3025                            fidl::encoding::DefaultFuchsiaResourceDialect
3026                        );
3027                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoStructWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3028                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3029                        Ok(EchoRequest::EchoStructWithError {
3030                            value: req.value,
3031                            result_err: req.result_err,
3032                            forward_to_server: req.forward_to_server,
3033                            result_variant: req.result_variant,
3034
3035                            responder: EchoEchoStructWithErrorResponder {
3036                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3037                                tx_id: header.tx_id,
3038                            },
3039                        })
3040                    }
3041                    0x1f763e602cf5892a => {
3042                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
3043                        let mut req = fidl::new_empty!(
3044                            EchoEchoStructNoRetValRequest,
3045                            fidl::encoding::DefaultFuchsiaResourceDialect
3046                        );
3047                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoStructNoRetValRequest>(&header, _body_bytes, handles, &mut req)?;
3048                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3049                        Ok(EchoRequest::EchoStructNoRetVal {
3050                            value: req.value,
3051                            forward_to_server: req.forward_to_server,
3052
3053                            control_handle,
3054                        })
3055                    }
3056                    0x1b6019d5611f2470 => {
3057                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3058                        let mut req = fidl::new_empty!(
3059                            EchoEchoArraysRequest,
3060                            fidl::encoding::DefaultFuchsiaResourceDialect
3061                        );
3062                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoArraysRequest>(&header, _body_bytes, handles, &mut req)?;
3063                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3064                        Ok(EchoRequest::EchoArrays {
3065                            value: req.value,
3066                            forward_to_server: req.forward_to_server,
3067
3068                            responder: EchoEchoArraysResponder {
3069                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3070                                tx_id: header.tx_id,
3071                            },
3072                        })
3073                    }
3074                    0x6dbf26e67e253afa => {
3075                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3076                        let mut req = fidl::new_empty!(
3077                            EchoEchoArraysWithErrorRequest,
3078                            fidl::encoding::DefaultFuchsiaResourceDialect
3079                        );
3080                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoArraysWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3081                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3082                        Ok(EchoRequest::EchoArraysWithError {
3083                            value: req.value,
3084                            result_err: req.result_err,
3085                            forward_to_server: req.forward_to_server,
3086                            result_variant: req.result_variant,
3087
3088                            responder: EchoEchoArraysWithErrorResponder {
3089                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3090                                tx_id: header.tx_id,
3091                            },
3092                        })
3093                    }
3094                    0x1582623f0d9f6e5e => {
3095                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3096                        let mut req = fidl::new_empty!(
3097                            EchoEchoVectorsRequest,
3098                            fidl::encoding::DefaultFuchsiaResourceDialect
3099                        );
3100                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoVectorsRequest>(&header, _body_bytes, handles, &mut req)?;
3101                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3102                        Ok(EchoRequest::EchoVectors {
3103                            value: req.value,
3104                            forward_to_server: req.forward_to_server,
3105
3106                            responder: EchoEchoVectorsResponder {
3107                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3108                                tx_id: header.tx_id,
3109                            },
3110                        })
3111                    }
3112                    0x730f163401e2b3e5 => {
3113                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3114                        let mut req = fidl::new_empty!(
3115                            EchoEchoVectorsWithErrorRequest,
3116                            fidl::encoding::DefaultFuchsiaResourceDialect
3117                        );
3118                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoVectorsWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3119                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3120                        Ok(EchoRequest::EchoVectorsWithError {
3121                            value: req.value,
3122                            result_err: req.result_err,
3123                            forward_to_server: req.forward_to_server,
3124                            result_variant: req.result_variant,
3125
3126                            responder: EchoEchoVectorsWithErrorResponder {
3127                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3128                                tx_id: header.tx_id,
3129                            },
3130                        })
3131                    }
3132                    0x4f1fb0a512f47c4b => {
3133                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3134                        let mut req = fidl::new_empty!(
3135                            EchoEchoTableRequest,
3136                            fidl::encoding::DefaultFuchsiaResourceDialect
3137                        );
3138                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoTableRequest>(&header, _body_bytes, handles, &mut req)?;
3139                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3140                        Ok(EchoRequest::EchoTable {
3141                            value: req.value,
3142                            forward_to_server: req.forward_to_server,
3143
3144                            responder: EchoEchoTableResponder {
3145                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3146                                tx_id: header.tx_id,
3147                            },
3148                        })
3149                    }
3150                    0x44e835cb1eb9a931 => {
3151                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3152                        let mut req = fidl::new_empty!(
3153                            EchoEchoTableWithErrorRequest,
3154                            fidl::encoding::DefaultFuchsiaResourceDialect
3155                        );
3156                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoTableWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3157                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3158                        Ok(EchoRequest::EchoTableWithError {
3159                            value: req.value,
3160                            result_err: req.result_err,
3161                            forward_to_server: req.forward_to_server,
3162                            result_variant: req.result_variant,
3163
3164                            responder: EchoEchoTableWithErrorResponder {
3165                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3166                                tx_id: header.tx_id,
3167                            },
3168                        })
3169                    }
3170                    0x3dc181909041a583 => {
3171                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3172                        let mut req = fidl::new_empty!(
3173                            EchoEchoXunionsRequest,
3174                            fidl::encoding::DefaultFuchsiaResourceDialect
3175                        );
3176                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoXunionsRequest>(&header, _body_bytes, handles, &mut req)?;
3177                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3178                        Ok(EchoRequest::EchoXunions {
3179                            value: req.value,
3180                            forward_to_server: req.forward_to_server,
3181
3182                            responder: EchoEchoXunionsResponder {
3183                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3184                                tx_id: header.tx_id,
3185                            },
3186                        })
3187                    }
3188                    0x75184102667fa766 => {
3189                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3190                        let mut req = fidl::new_empty!(
3191                            EchoEchoXunionsWithErrorRequest,
3192                            fidl::encoding::DefaultFuchsiaResourceDialect
3193                        );
3194                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoXunionsWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3195                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3196                        Ok(EchoRequest::EchoXunionsWithError {
3197                            value: req.value,
3198                            result_err: req.result_err,
3199                            forward_to_server: req.forward_to_server,
3200                            result_variant: req.result_variant,
3201
3202                            responder: EchoEchoXunionsWithErrorResponder {
3203                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3204                                tx_id: header.tx_id,
3205                            },
3206                        })
3207                    }
3208                    0xf2d4aa9e65f7111 => {
3209                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3210                        let mut req = fidl::new_empty!(
3211                            fidl_fidl_test_imported::RequestStruct,
3212                            fidl::encoding::DefaultFuchsiaResourceDialect
3213                        );
3214                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::RequestStruct>(&header, _body_bytes, handles, &mut req)?;
3215                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3216                        Ok(EchoRequest::EchoNamedStruct {
3217                            value: req.value,
3218                            forward_to_server: req.forward_to_server,
3219
3220                            responder: EchoEchoNamedStructResponder {
3221                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3222                                tx_id: header.tx_id,
3223                            },
3224                        })
3225                    }
3226                    0x5766fee9e74442e8 => {
3227                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3228                        let mut req = fidl::new_empty!(
3229                            fidl_fidl_test_imported::ErrorableRequestStruct,
3230                            fidl::encoding::DefaultFuchsiaResourceDialect
3231                        );
3232                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::ErrorableRequestStruct>(&header, _body_bytes, handles, &mut req)?;
3233                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3234                        Ok(EchoRequest::EchoNamedStructWithError {
3235                            value: req.value,
3236                            result_err: req.result_err,
3237                            forward_to_server: req.forward_to_server,
3238                            result_variant: req.result_variant,
3239
3240                            responder: EchoEchoNamedStructWithErrorResponder {
3241                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3242                                tx_id: header.tx_id,
3243                            },
3244                        })
3245                    }
3246                    0x3a50bbf7d2113ad7 => {
3247                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
3248                        let mut req = fidl::new_empty!(
3249                            fidl_fidl_test_imported::EventTriggeringRequestStruct,
3250                            fidl::encoding::DefaultFuchsiaResourceDialect
3251                        );
3252                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl_fidl_test_imported::EventTriggeringRequestStruct>(&header, _body_bytes, handles, &mut req)?;
3253                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3254                        Ok(EchoRequest::EchoNamedStructNoRetVal {
3255                            value: req.value,
3256                            forward_to_server: req.forward_to_server,
3257
3258                            control_handle,
3259                        })
3260                    }
3261                    0x641d98087378c003 => {
3262                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3263                        let mut req = fidl::new_empty!(
3264                            RequestTable,
3265                            fidl::encoding::DefaultFuchsiaResourceDialect
3266                        );
3267                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RequestTable>(&header, _body_bytes, handles, &mut req)?;
3268                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3269                        Ok(EchoRequest::EchoTablePayload {
3270                            payload: req,
3271                            responder: EchoEchoTablePayloadResponder {
3272                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3273                                tx_id: header.tx_id,
3274                            },
3275                        })
3276                    }
3277                    0x636ed243761ab66d => {
3278                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3279                        let mut req = fidl::new_empty!(
3280                            EchoEchoTablePayloadWithErrorRequest,
3281                            fidl::encoding::DefaultFuchsiaResourceDialect
3282                        );
3283                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoTablePayloadWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3284                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3285                        Ok(EchoRequest::EchoTablePayloadWithError {
3286                            payload: req,
3287                            responder: EchoEchoTablePayloadWithErrorResponder {
3288                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3289                                tx_id: header.tx_id,
3290                            },
3291                        })
3292                    }
3293                    0x32961f7d718569f8 => {
3294                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
3295                        let mut req = fidl::new_empty!(
3296                            RequestTable,
3297                            fidl::encoding::DefaultFuchsiaResourceDialect
3298                        );
3299                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RequestTable>(&header, _body_bytes, handles, &mut req)?;
3300                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3301                        Ok(EchoRequest::EchoTablePayloadNoRetVal { payload: req, control_handle })
3302                    }
3303                    0x66def9e793f10c55 => {
3304                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3305                        let mut req = fidl::new_empty!(
3306                            RequestUnion,
3307                            fidl::encoding::DefaultFuchsiaResourceDialect
3308                        );
3309                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RequestUnion>(&header, _body_bytes, handles, &mut req)?;
3310                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3311                        Ok(EchoRequest::EchoUnionPayload {
3312                            payload: req,
3313                            responder: EchoEchoUnionPayloadResponder {
3314                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3315                                tx_id: header.tx_id,
3316                            },
3317                        })
3318                    }
3319                    0x1be890d6e68ef063 => {
3320                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
3321                        let mut req = fidl::new_empty!(
3322                            EchoEchoUnionPayloadWithErrorRequest,
3323                            fidl::encoding::DefaultFuchsiaResourceDialect
3324                        );
3325                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<EchoEchoUnionPayloadWithErrorRequest>(&header, _body_bytes, handles, &mut req)?;
3326                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3327                        Ok(EchoRequest::EchoUnionPayloadWithError {
3328                            payload: req,
3329                            responder: EchoEchoUnionPayloadWithErrorResponder {
3330                                control_handle: std::mem::ManuallyDrop::new(control_handle),
3331                                tx_id: header.tx_id,
3332                            },
3333                        })
3334                    }
3335                    0x11518bf346430040 => {
3336                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
3337                        let mut req = fidl::new_empty!(
3338                            RequestUnion,
3339                            fidl::encoding::DefaultFuchsiaResourceDialect
3340                        );
3341                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<RequestUnion>(&header, _body_bytes, handles, &mut req)?;
3342                        let control_handle = EchoControlHandle { inner: this.inner.clone() };
3343                        Ok(EchoRequest::EchoUnionPayloadNoRetVal { payload: req, control_handle })
3344                    }
3345                    _ => Err(fidl::Error::UnknownOrdinal {
3346                        ordinal: header.ordinal,
3347                        protocol_name: <EchoMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
3348                    }),
3349                }))
3350            },
3351        )
3352    }
3353}
3354
3355#[derive(Debug)]
3356pub enum EchoRequest {
3357    EchoTableRequestComposed {
3358        payload: fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
3359        responder: EchoEchoTableRequestComposedResponder,
3360    },
3361    EchoUnionResponseWithErrorComposed {
3362        value: i64,
3363        want_absolute_value: bool,
3364        forward_to_server: String,
3365        result_err: u32,
3366        result_variant: fidl_fidl_test_imported::WantResponse,
3367        responder: EchoEchoUnionResponseWithErrorComposedResponder,
3368    },
3369    EchoMinimal {
3370        forward_to_server: String,
3371        responder: EchoEchoMinimalResponder,
3372    },
3373    EchoMinimalWithError {
3374        forward_to_server: String,
3375        result_variant: RespondWith,
3376        responder: EchoEchoMinimalWithErrorResponder,
3377    },
3378    EchoMinimalNoRetVal {
3379        forward_to_server: String,
3380        control_handle: EchoControlHandle,
3381    },
3382    EchoStruct {
3383        value: Struct,
3384        forward_to_server: String,
3385        responder: EchoEchoStructResponder,
3386    },
3387    EchoStructWithError {
3388        value: Struct,
3389        result_err: DefaultEnum,
3390        forward_to_server: String,
3391        result_variant: RespondWith,
3392        responder: EchoEchoStructWithErrorResponder,
3393    },
3394    EchoStructNoRetVal {
3395        value: Struct,
3396        forward_to_server: String,
3397        control_handle: EchoControlHandle,
3398    },
3399    EchoArrays {
3400        value: ArraysStruct,
3401        forward_to_server: String,
3402        responder: EchoEchoArraysResponder,
3403    },
3404    EchoArraysWithError {
3405        value: ArraysStruct,
3406        result_err: DefaultEnum,
3407        forward_to_server: String,
3408        result_variant: RespondWith,
3409        responder: EchoEchoArraysWithErrorResponder,
3410    },
3411    EchoVectors {
3412        value: VectorsStruct,
3413        forward_to_server: String,
3414        responder: EchoEchoVectorsResponder,
3415    },
3416    EchoVectorsWithError {
3417        value: VectorsStruct,
3418        result_err: DefaultEnum,
3419        forward_to_server: String,
3420        result_variant: RespondWith,
3421        responder: EchoEchoVectorsWithErrorResponder,
3422    },
3423    EchoTable {
3424        value: AllTypesTable,
3425        forward_to_server: String,
3426        responder: EchoEchoTableResponder,
3427    },
3428    EchoTableWithError {
3429        value: AllTypesTable,
3430        result_err: DefaultEnum,
3431        forward_to_server: String,
3432        result_variant: RespondWith,
3433        responder: EchoEchoTableWithErrorResponder,
3434    },
3435    EchoXunions {
3436        value: Vec<AllTypesXunion>,
3437        forward_to_server: String,
3438        responder: EchoEchoXunionsResponder,
3439    },
3440    EchoXunionsWithError {
3441        value: Vec<AllTypesXunion>,
3442        result_err: DefaultEnum,
3443        forward_to_server: String,
3444        result_variant: RespondWith,
3445        responder: EchoEchoXunionsWithErrorResponder,
3446    },
3447    EchoNamedStruct {
3448        value: fidl_fidl_test_imported::SimpleStruct,
3449        forward_to_server: String,
3450        responder: EchoEchoNamedStructResponder,
3451    },
3452    EchoNamedStructWithError {
3453        value: fidl_fidl_test_imported::SimpleStruct,
3454        result_err: u32,
3455        forward_to_server: String,
3456        result_variant: fidl_fidl_test_imported::WantResponse,
3457        responder: EchoEchoNamedStructWithErrorResponder,
3458    },
3459    EchoNamedStructNoRetVal {
3460        value: fidl_fidl_test_imported::SimpleStruct,
3461        forward_to_server: String,
3462        control_handle: EchoControlHandle,
3463    },
3464    EchoTablePayload {
3465        payload: RequestTable,
3466        responder: EchoEchoTablePayloadResponder,
3467    },
3468    EchoTablePayloadWithError {
3469        payload: EchoEchoTablePayloadWithErrorRequest,
3470        responder: EchoEchoTablePayloadWithErrorResponder,
3471    },
3472    EchoTablePayloadNoRetVal {
3473        payload: RequestTable,
3474        control_handle: EchoControlHandle,
3475    },
3476    EchoUnionPayload {
3477        payload: RequestUnion,
3478        responder: EchoEchoUnionPayloadResponder,
3479    },
3480    EchoUnionPayloadWithError {
3481        payload: EchoEchoUnionPayloadWithErrorRequest,
3482        responder: EchoEchoUnionPayloadWithErrorResponder,
3483    },
3484    EchoUnionPayloadNoRetVal {
3485        payload: RequestUnion,
3486        control_handle: EchoControlHandle,
3487    },
3488}
3489
3490impl EchoRequest {
3491    #[allow(irrefutable_let_patterns)]
3492    pub fn into_echo_table_request_composed(
3493        self,
3494    ) -> Option<(
3495        fidl_fidl_test_imported::ComposedEchoTableRequestComposedRequest,
3496        EchoEchoTableRequestComposedResponder,
3497    )> {
3498        if let EchoRequest::EchoTableRequestComposed { payload, responder } = self {
3499            Some((payload, responder))
3500        } else {
3501            None
3502        }
3503    }
3504
3505    #[allow(irrefutable_let_patterns)]
3506    pub fn into_echo_union_response_with_error_composed(
3507        self,
3508    ) -> Option<(
3509        i64,
3510        bool,
3511        String,
3512        u32,
3513        fidl_fidl_test_imported::WantResponse,
3514        EchoEchoUnionResponseWithErrorComposedResponder,
3515    )> {
3516        if let EchoRequest::EchoUnionResponseWithErrorComposed {
3517            value,
3518            want_absolute_value,
3519            forward_to_server,
3520            result_err,
3521            result_variant,
3522            responder,
3523        } = self
3524        {
3525            Some((
3526                value,
3527                want_absolute_value,
3528                forward_to_server,
3529                result_err,
3530                result_variant,
3531                responder,
3532            ))
3533        } else {
3534            None
3535        }
3536    }
3537
3538    #[allow(irrefutable_let_patterns)]
3539    pub fn into_echo_minimal(self) -> Option<(String, EchoEchoMinimalResponder)> {
3540        if let EchoRequest::EchoMinimal { forward_to_server, responder } = self {
3541            Some((forward_to_server, responder))
3542        } else {
3543            None
3544        }
3545    }
3546
3547    #[allow(irrefutable_let_patterns)]
3548    pub fn into_echo_minimal_with_error(
3549        self,
3550    ) -> Option<(String, RespondWith, EchoEchoMinimalWithErrorResponder)> {
3551        if let EchoRequest::EchoMinimalWithError { forward_to_server, result_variant, responder } =
3552            self
3553        {
3554            Some((forward_to_server, result_variant, responder))
3555        } else {
3556            None
3557        }
3558    }
3559
3560    #[allow(irrefutable_let_patterns)]
3561    pub fn into_echo_minimal_no_ret_val(self) -> Option<(String, EchoControlHandle)> {
3562        if let EchoRequest::EchoMinimalNoRetVal { forward_to_server, control_handle } = self {
3563            Some((forward_to_server, control_handle))
3564        } else {
3565            None
3566        }
3567    }
3568
3569    #[allow(irrefutable_let_patterns)]
3570    pub fn into_echo_struct(self) -> Option<(Struct, String, EchoEchoStructResponder)> {
3571        if let EchoRequest::EchoStruct { value, forward_to_server, responder } = self {
3572            Some((value, forward_to_server, responder))
3573        } else {
3574            None
3575        }
3576    }
3577
3578    #[allow(irrefutable_let_patterns)]
3579    pub fn into_echo_struct_with_error(
3580        self,
3581    ) -> Option<(Struct, DefaultEnum, String, RespondWith, EchoEchoStructWithErrorResponder)> {
3582        if let EchoRequest::EchoStructWithError {
3583            value,
3584            result_err,
3585            forward_to_server,
3586            result_variant,
3587            responder,
3588        } = self
3589        {
3590            Some((value, result_err, forward_to_server, result_variant, responder))
3591        } else {
3592            None
3593        }
3594    }
3595
3596    #[allow(irrefutable_let_patterns)]
3597    pub fn into_echo_struct_no_ret_val(self) -> Option<(Struct, String, EchoControlHandle)> {
3598        if let EchoRequest::EchoStructNoRetVal { value, forward_to_server, control_handle } = self {
3599            Some((value, forward_to_server, control_handle))
3600        } else {
3601            None
3602        }
3603    }
3604
3605    #[allow(irrefutable_let_patterns)]
3606    pub fn into_echo_arrays(self) -> Option<(ArraysStruct, String, EchoEchoArraysResponder)> {
3607        if let EchoRequest::EchoArrays { value, forward_to_server, responder } = self {
3608            Some((value, forward_to_server, responder))
3609        } else {
3610            None
3611        }
3612    }
3613
3614    #[allow(irrefutable_let_patterns)]
3615    pub fn into_echo_arrays_with_error(
3616        self,
3617    ) -> Option<(ArraysStruct, DefaultEnum, String, RespondWith, EchoEchoArraysWithErrorResponder)>
3618    {
3619        if let EchoRequest::EchoArraysWithError {
3620            value,
3621            result_err,
3622            forward_to_server,
3623            result_variant,
3624            responder,
3625        } = self
3626        {
3627            Some((value, result_err, forward_to_server, result_variant, responder))
3628        } else {
3629            None
3630        }
3631    }
3632
3633    #[allow(irrefutable_let_patterns)]
3634    pub fn into_echo_vectors(self) -> Option<(VectorsStruct, String, EchoEchoVectorsResponder)> {
3635        if let EchoRequest::EchoVectors { value, forward_to_server, responder } = self {
3636            Some((value, forward_to_server, responder))
3637        } else {
3638            None
3639        }
3640    }
3641
3642    #[allow(irrefutable_let_patterns)]
3643    pub fn into_echo_vectors_with_error(
3644        self,
3645    ) -> Option<(VectorsStruct, DefaultEnum, String, RespondWith, EchoEchoVectorsWithErrorResponder)>
3646    {
3647        if let EchoRequest::EchoVectorsWithError {
3648            value,
3649            result_err,
3650            forward_to_server,
3651            result_variant,
3652            responder,
3653        } = self
3654        {
3655            Some((value, result_err, forward_to_server, result_variant, responder))
3656        } else {
3657            None
3658        }
3659    }
3660
3661    #[allow(irrefutable_let_patterns)]
3662    pub fn into_echo_table(self) -> Option<(AllTypesTable, String, EchoEchoTableResponder)> {
3663        if let EchoRequest::EchoTable { value, forward_to_server, responder } = self {
3664            Some((value, forward_to_server, responder))
3665        } else {
3666            None
3667        }
3668    }
3669
3670    #[allow(irrefutable_let_patterns)]
3671    pub fn into_echo_table_with_error(
3672        self,
3673    ) -> Option<(AllTypesTable, DefaultEnum, String, RespondWith, EchoEchoTableWithErrorResponder)>
3674    {
3675        if let EchoRequest::EchoTableWithError {
3676            value,
3677            result_err,
3678            forward_to_server,
3679            result_variant,
3680            responder,
3681        } = self
3682        {
3683            Some((value, result_err, forward_to_server, result_variant, responder))
3684        } else {
3685            None
3686        }
3687    }
3688
3689    #[allow(irrefutable_let_patterns)]
3690    pub fn into_echo_xunions(
3691        self,
3692    ) -> Option<(Vec<AllTypesXunion>, String, EchoEchoXunionsResponder)> {
3693        if let EchoRequest::EchoXunions { value, forward_to_server, responder } = self {
3694            Some((value, forward_to_server, responder))
3695        } else {
3696            None
3697        }
3698    }
3699
3700    #[allow(irrefutable_let_patterns)]
3701    pub fn into_echo_xunions_with_error(
3702        self,
3703    ) -> Option<(
3704        Vec<AllTypesXunion>,
3705        DefaultEnum,
3706        String,
3707        RespondWith,
3708        EchoEchoXunionsWithErrorResponder,
3709    )> {
3710        if let EchoRequest::EchoXunionsWithError {
3711            value,
3712            result_err,
3713            forward_to_server,
3714            result_variant,
3715            responder,
3716        } = self
3717        {
3718            Some((value, result_err, forward_to_server, result_variant, responder))
3719        } else {
3720            None
3721        }
3722    }
3723
3724    #[allow(irrefutable_let_patterns)]
3725    pub fn into_echo_named_struct(
3726        self,
3727    ) -> Option<(fidl_fidl_test_imported::SimpleStruct, String, EchoEchoNamedStructResponder)> {
3728        if let EchoRequest::EchoNamedStruct { value, forward_to_server, responder } = self {
3729            Some((value, forward_to_server, responder))
3730        } else {
3731            None
3732        }
3733    }
3734
3735    #[allow(irrefutable_let_patterns)]
3736    pub fn into_echo_named_struct_with_error(
3737        self,
3738    ) -> Option<(
3739        fidl_fidl_test_imported::SimpleStruct,
3740        u32,
3741        String,
3742        fidl_fidl_test_imported::WantResponse,
3743        EchoEchoNamedStructWithErrorResponder,
3744    )> {
3745        if let EchoRequest::EchoNamedStructWithError {
3746            value,
3747            result_err,
3748            forward_to_server,
3749            result_variant,
3750            responder,
3751        } = self
3752        {
3753            Some((value, result_err, forward_to_server, result_variant, responder))
3754        } else {
3755            None
3756        }
3757    }
3758
3759    #[allow(irrefutable_let_patterns)]
3760    pub fn into_echo_named_struct_no_ret_val(
3761        self,
3762    ) -> Option<(fidl_fidl_test_imported::SimpleStruct, String, EchoControlHandle)> {
3763        if let EchoRequest::EchoNamedStructNoRetVal { value, forward_to_server, control_handle } =
3764            self
3765        {
3766            Some((value, forward_to_server, control_handle))
3767        } else {
3768            None
3769        }
3770    }
3771
3772    #[allow(irrefutable_let_patterns)]
3773    pub fn into_echo_table_payload(self) -> Option<(RequestTable, EchoEchoTablePayloadResponder)> {
3774        if let EchoRequest::EchoTablePayload { payload, responder } = self {
3775            Some((payload, responder))
3776        } else {
3777            None
3778        }
3779    }
3780
3781    #[allow(irrefutable_let_patterns)]
3782    pub fn into_echo_table_payload_with_error(
3783        self,
3784    ) -> Option<(EchoEchoTablePayloadWithErrorRequest, EchoEchoTablePayloadWithErrorResponder)>
3785    {
3786        if let EchoRequest::EchoTablePayloadWithError { payload, responder } = self {
3787            Some((payload, responder))
3788        } else {
3789            None
3790        }
3791    }
3792
3793    #[allow(irrefutable_let_patterns)]
3794    pub fn into_echo_table_payload_no_ret_val(self) -> Option<(RequestTable, EchoControlHandle)> {
3795        if let EchoRequest::EchoTablePayloadNoRetVal { payload, control_handle } = self {
3796            Some((payload, control_handle))
3797        } else {
3798            None
3799        }
3800    }
3801
3802    #[allow(irrefutable_let_patterns)]
3803    pub fn into_echo_union_payload(self) -> Option<(RequestUnion, EchoEchoUnionPayloadResponder)> {
3804        if let EchoRequest::EchoUnionPayload { payload, responder } = self {
3805            Some((payload, responder))
3806        } else {
3807            None
3808        }
3809    }
3810
3811    #[allow(irrefutable_let_patterns)]
3812    pub fn into_echo_union_payload_with_error(
3813        self,
3814    ) -> Option<(EchoEchoUnionPayloadWithErrorRequest, EchoEchoUnionPayloadWithErrorResponder)>
3815    {
3816        if let EchoRequest::EchoUnionPayloadWithError { payload, responder } = self {
3817            Some((payload, responder))
3818        } else {
3819            None
3820        }
3821    }
3822
3823    #[allow(irrefutable_let_patterns)]
3824    pub fn into_echo_union_payload_no_ret_val(self) -> Option<(RequestUnion, EchoControlHandle)> {
3825        if let EchoRequest::EchoUnionPayloadNoRetVal { payload, control_handle } = self {
3826            Some((payload, control_handle))
3827        } else {
3828            None
3829        }
3830    }
3831
3832    /// Name of the method defined in FIDL
3833    pub fn method_name(&self) -> &'static str {
3834        match *self {
3835            EchoRequest::EchoTableRequestComposed { .. } => "echo_table_request_composed",
3836            EchoRequest::EchoUnionResponseWithErrorComposed { .. } => {
3837                "echo_union_response_with_error_composed"
3838            }
3839            EchoRequest::EchoMinimal { .. } => "echo_minimal",
3840            EchoRequest::EchoMinimalWithError { .. } => "echo_minimal_with_error",
3841            EchoRequest::EchoMinimalNoRetVal { .. } => "echo_minimal_no_ret_val",
3842            EchoRequest::EchoStruct { .. } => "echo_struct",
3843            EchoRequest::EchoStructWithError { .. } => "echo_struct_with_error",
3844            EchoRequest::EchoStructNoRetVal { .. } => "echo_struct_no_ret_val",
3845            EchoRequest::EchoArrays { .. } => "echo_arrays",
3846            EchoRequest::EchoArraysWithError { .. } => "echo_arrays_with_error",
3847            EchoRequest::EchoVectors { .. } => "echo_vectors",
3848            EchoRequest::EchoVectorsWithError { .. } => "echo_vectors_with_error",
3849            EchoRequest::EchoTable { .. } => "echo_table",
3850            EchoRequest::EchoTableWithError { .. } => "echo_table_with_error",
3851            EchoRequest::EchoXunions { .. } => "echo_xunions",
3852            EchoRequest::EchoXunionsWithError { .. } => "echo_xunions_with_error",
3853            EchoRequest::EchoNamedStruct { .. } => "echo_named_struct",
3854            EchoRequest::EchoNamedStructWithError { .. } => "echo_named_struct_with_error",
3855            EchoRequest::EchoNamedStructNoRetVal { .. } => "echo_named_struct_no_ret_val",
3856            EchoRequest::EchoTablePayload { .. } => "echo_table_payload",
3857            EchoRequest::EchoTablePayloadWithError { .. } => "echo_table_payload_with_error",
3858            EchoRequest::EchoTablePayloadNoRetVal { .. } => "echo_table_payload_no_ret_val",
3859            EchoRequest::EchoUnionPayload { .. } => "echo_union_payload",
3860            EchoRequest::EchoUnionPayloadWithError { .. } => "echo_union_payload_with_error",
3861            EchoRequest::EchoUnionPayloadNoRetVal { .. } => "echo_union_payload_no_ret_val",
3862        }
3863    }
3864}
3865
3866#[derive(Debug, Clone)]
3867pub struct EchoControlHandle {
3868    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
3869}
3870
3871impl fidl::endpoints::ControlHandle for EchoControlHandle {
3872    fn shutdown(&self) {
3873        self.inner.shutdown()
3874    }
3875    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
3876        self.inner.shutdown_with_epitaph(status)
3877    }
3878
3879    fn is_closed(&self) -> bool {
3880        self.inner.channel().is_closed()
3881    }
3882    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
3883        self.inner.channel().on_closed()
3884    }
3885
3886    #[cfg(target_os = "fuchsia")]
3887    fn signal_peer(
3888        &self,
3889        clear_mask: zx::Signals,
3890        set_mask: zx::Signals,
3891    ) -> Result<(), zx_status::Status> {
3892        use fidl::Peered;
3893        self.inner.channel().signal_peer(clear_mask, set_mask)
3894    }
3895}
3896
3897impl EchoControlHandle {
3898    pub fn send_echo_minimal_event(&self) -> Result<(), fidl::Error> {
3899        self.inner.send::<fidl::encoding::EmptyPayload>(
3900            (),
3901            0,
3902            0x273b2029f1a0aee2,
3903            fidl::encoding::DynamicFlags::empty(),
3904        )
3905    }
3906
3907    pub fn send_echo_event(&self, mut value: Struct) -> Result<(), fidl::Error> {
3908        self.inner.send::<EchoEchoEventRequest>(
3909            (&mut value,),
3910            0,
3911            0x1219e12e0450024,
3912            fidl::encoding::DynamicFlags::empty(),
3913        )
3914    }
3915
3916    pub fn send_on_echo_named_event(
3917        &self,
3918        mut value: &fidl_fidl_test_imported::SimpleStruct,
3919    ) -> Result<(), fidl::Error> {
3920        self.inner.send::<fidl_fidl_test_imported::ResponseStruct>(
3921            (value,),
3922            0,
3923            0x749ebde83348a374,
3924            fidl::encoding::DynamicFlags::empty(),
3925        )
3926    }
3927
3928    pub fn send_on_echo_table_payload_event(
3929        &self,
3930        mut payload: &ResponseTable,
3931    ) -> Result<(), fidl::Error> {
3932        self.inner.send::<ResponseTable>(
3933            payload,
3934            0,
3935            0x708dddea1cb98430,
3936            fidl::encoding::DynamicFlags::empty(),
3937        )
3938    }
3939
3940    pub fn send_on_echo_union_payload_event(
3941        &self,
3942        mut payload: &ResponseUnion,
3943    ) -> Result<(), fidl::Error> {
3944        self.inner.send::<ResponseUnion>(
3945            payload,
3946            0,
3947            0x642f4c265a05f4c0,
3948            fidl::encoding::DynamicFlags::empty(),
3949        )
3950    }
3951}
3952
3953#[must_use = "FIDL methods require a response to be sent"]
3954#[derive(Debug)]
3955pub struct EchoEchoTableRequestComposedResponder {
3956    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
3957    tx_id: u32,
3958}
3959
3960/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
3961/// if the responder is dropped without sending a response, so that the client
3962/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
3963impl std::ops::Drop for EchoEchoTableRequestComposedResponder {
3964    fn drop(&mut self) {
3965        self.control_handle.shutdown();
3966        // Safety: drops once, never accessed again
3967        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3968    }
3969}
3970
3971impl fidl::endpoints::Responder for EchoEchoTableRequestComposedResponder {
3972    type ControlHandle = EchoControlHandle;
3973
3974    fn control_handle(&self) -> &EchoControlHandle {
3975        &self.control_handle
3976    }
3977
3978    fn drop_without_shutdown(mut self) {
3979        // Safety: drops once, never accessed again due to mem::forget
3980        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
3981        // Prevent Drop from running (which would shut down the channel)
3982        std::mem::forget(self);
3983    }
3984}
3985
3986impl EchoEchoTableRequestComposedResponder {
3987    /// Sends a response to the FIDL transaction.
3988    ///
3989    /// Sets the channel to shutdown if an error occurs.
3990    pub fn send(
3991        self,
3992        mut value: &fidl_fidl_test_imported::SimpleStruct,
3993    ) -> Result<(), fidl::Error> {
3994        let _result = self.send_raw(value);
3995        if _result.is_err() {
3996            self.control_handle.shutdown();
3997        }
3998        self.drop_without_shutdown();
3999        _result
4000    }
4001
4002    /// Similar to "send" but does not shutdown the channel if an error occurs.
4003    pub fn send_no_shutdown_on_err(
4004        self,
4005        mut value: &fidl_fidl_test_imported::SimpleStruct,
4006    ) -> Result<(), fidl::Error> {
4007        let _result = self.send_raw(value);
4008        self.drop_without_shutdown();
4009        _result
4010    }
4011
4012    fn send_raw(
4013        &self,
4014        mut value: &fidl_fidl_test_imported::SimpleStruct,
4015    ) -> Result<(), fidl::Error> {
4016        self.control_handle.inner.send::<fidl_fidl_test_imported::ResponseStruct>(
4017            (value,),
4018            self.tx_id,
4019            0x1d545c738c7a8ee,
4020            fidl::encoding::DynamicFlags::empty(),
4021        )
4022    }
4023}
4024
4025#[must_use = "FIDL methods require a response to be sent"]
4026#[derive(Debug)]
4027pub struct EchoEchoUnionResponseWithErrorComposedResponder {
4028    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4029    tx_id: u32,
4030}
4031
4032/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4033/// if the responder is dropped without sending a response, so that the client
4034/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4035impl std::ops::Drop for EchoEchoUnionResponseWithErrorComposedResponder {
4036    fn drop(&mut self) {
4037        self.control_handle.shutdown();
4038        // Safety: drops once, never accessed again
4039        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4040    }
4041}
4042
4043impl fidl::endpoints::Responder for EchoEchoUnionResponseWithErrorComposedResponder {
4044    type ControlHandle = EchoControlHandle;
4045
4046    fn control_handle(&self) -> &EchoControlHandle {
4047        &self.control_handle
4048    }
4049
4050    fn drop_without_shutdown(mut self) {
4051        // Safety: drops once, never accessed again due to mem::forget
4052        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4053        // Prevent Drop from running (which would shut down the channel)
4054        std::mem::forget(self);
4055    }
4056}
4057
4058impl EchoEchoUnionResponseWithErrorComposedResponder {
4059    /// Sends a response to the FIDL transaction.
4060    ///
4061    /// Sets the channel to shutdown if an error occurs.
4062    pub fn send(
4063        self,
4064        mut result: Result<
4065            &fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse,
4066            u32,
4067        >,
4068    ) -> Result<(), fidl::Error> {
4069        let _result = self.send_raw(result);
4070        if _result.is_err() {
4071            self.control_handle.shutdown();
4072        }
4073        self.drop_without_shutdown();
4074        _result
4075    }
4076
4077    /// Similar to "send" but does not shutdown the channel if an error occurs.
4078    pub fn send_no_shutdown_on_err(
4079        self,
4080        mut result: Result<
4081            &fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse,
4082            u32,
4083        >,
4084    ) -> Result<(), fidl::Error> {
4085        let _result = self.send_raw(result);
4086        self.drop_without_shutdown();
4087        _result
4088    }
4089
4090    fn send_raw(
4091        &self,
4092        mut result: Result<
4093            &fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse,
4094            u32,
4095        >,
4096    ) -> Result<(), fidl::Error> {
4097        self.control_handle.inner.send::<fidl::encoding::ResultType<
4098            fidl_fidl_test_imported::ComposedEchoUnionResponseWithErrorComposedResponse,
4099            u32,
4100        >>(
4101            result,
4102            self.tx_id,
4103            0x38a67e88d6106443,
4104            fidl::encoding::DynamicFlags::empty(),
4105        )
4106    }
4107}
4108
4109#[must_use = "FIDL methods require a response to be sent"]
4110#[derive(Debug)]
4111pub struct EchoEchoMinimalResponder {
4112    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4113    tx_id: u32,
4114}
4115
4116/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4117/// if the responder is dropped without sending a response, so that the client
4118/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4119impl std::ops::Drop for EchoEchoMinimalResponder {
4120    fn drop(&mut self) {
4121        self.control_handle.shutdown();
4122        // Safety: drops once, never accessed again
4123        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4124    }
4125}
4126
4127impl fidl::endpoints::Responder for EchoEchoMinimalResponder {
4128    type ControlHandle = EchoControlHandle;
4129
4130    fn control_handle(&self) -> &EchoControlHandle {
4131        &self.control_handle
4132    }
4133
4134    fn drop_without_shutdown(mut self) {
4135        // Safety: drops once, never accessed again due to mem::forget
4136        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4137        // Prevent Drop from running (which would shut down the channel)
4138        std::mem::forget(self);
4139    }
4140}
4141
4142impl EchoEchoMinimalResponder {
4143    /// Sends a response to the FIDL transaction.
4144    ///
4145    /// Sets the channel to shutdown if an error occurs.
4146    pub fn send(self) -> Result<(), fidl::Error> {
4147        let _result = self.send_raw();
4148        if _result.is_err() {
4149            self.control_handle.shutdown();
4150        }
4151        self.drop_without_shutdown();
4152        _result
4153    }
4154
4155    /// Similar to "send" but does not shutdown the channel if an error occurs.
4156    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
4157        let _result = self.send_raw();
4158        self.drop_without_shutdown();
4159        _result
4160    }
4161
4162    fn send_raw(&self) -> Result<(), fidl::Error> {
4163        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
4164            (),
4165            self.tx_id,
4166            0x39edd68c837482ec,
4167            fidl::encoding::DynamicFlags::empty(),
4168        )
4169    }
4170}
4171
4172#[must_use = "FIDL methods require a response to be sent"]
4173#[derive(Debug)]
4174pub struct EchoEchoMinimalWithErrorResponder {
4175    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4176    tx_id: u32,
4177}
4178
4179/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4180/// if the responder is dropped without sending a response, so that the client
4181/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4182impl std::ops::Drop for EchoEchoMinimalWithErrorResponder {
4183    fn drop(&mut self) {
4184        self.control_handle.shutdown();
4185        // Safety: drops once, never accessed again
4186        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4187    }
4188}
4189
4190impl fidl::endpoints::Responder for EchoEchoMinimalWithErrorResponder {
4191    type ControlHandle = EchoControlHandle;
4192
4193    fn control_handle(&self) -> &EchoControlHandle {
4194        &self.control_handle
4195    }
4196
4197    fn drop_without_shutdown(mut self) {
4198        // Safety: drops once, never accessed again due to mem::forget
4199        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4200        // Prevent Drop from running (which would shut down the channel)
4201        std::mem::forget(self);
4202    }
4203}
4204
4205impl EchoEchoMinimalWithErrorResponder {
4206    /// Sends a response to the FIDL transaction.
4207    ///
4208    /// Sets the channel to shutdown if an error occurs.
4209    pub fn send(self, mut result: Result<(), u32>) -> Result<(), fidl::Error> {
4210        let _result = self.send_raw(result);
4211        if _result.is_err() {
4212            self.control_handle.shutdown();
4213        }
4214        self.drop_without_shutdown();
4215        _result
4216    }
4217
4218    /// Similar to "send" but does not shutdown the channel if an error occurs.
4219    pub fn send_no_shutdown_on_err(self, mut result: Result<(), u32>) -> Result<(), fidl::Error> {
4220        let _result = self.send_raw(result);
4221        self.drop_without_shutdown();
4222        _result
4223    }
4224
4225    fn send_raw(&self, mut result: Result<(), u32>) -> Result<(), fidl::Error> {
4226        self.control_handle
4227            .inner
4228            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, u32>>(
4229                result,
4230                self.tx_id,
4231                0x36f4695996e35acc,
4232                fidl::encoding::DynamicFlags::empty(),
4233            )
4234    }
4235}
4236
4237#[must_use = "FIDL methods require a response to be sent"]
4238#[derive(Debug)]
4239pub struct EchoEchoStructResponder {
4240    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4241    tx_id: u32,
4242}
4243
4244/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4245/// if the responder is dropped without sending a response, so that the client
4246/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4247impl std::ops::Drop for EchoEchoStructResponder {
4248    fn drop(&mut self) {
4249        self.control_handle.shutdown();
4250        // Safety: drops once, never accessed again
4251        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4252    }
4253}
4254
4255impl fidl::endpoints::Responder for EchoEchoStructResponder {
4256    type ControlHandle = EchoControlHandle;
4257
4258    fn control_handle(&self) -> &EchoControlHandle {
4259        &self.control_handle
4260    }
4261
4262    fn drop_without_shutdown(mut self) {
4263        // Safety: drops once, never accessed again due to mem::forget
4264        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4265        // Prevent Drop from running (which would shut down the channel)
4266        std::mem::forget(self);
4267    }
4268}
4269
4270impl EchoEchoStructResponder {
4271    /// Sends a response to the FIDL transaction.
4272    ///
4273    /// Sets the channel to shutdown if an error occurs.
4274    pub fn send(self, mut value: Struct) -> Result<(), fidl::Error> {
4275        let _result = self.send_raw(value);
4276        if _result.is_err() {
4277            self.control_handle.shutdown();
4278        }
4279        self.drop_without_shutdown();
4280        _result
4281    }
4282
4283    /// Similar to "send" but does not shutdown the channel if an error occurs.
4284    pub fn send_no_shutdown_on_err(self, mut value: Struct) -> Result<(), fidl::Error> {
4285        let _result = self.send_raw(value);
4286        self.drop_without_shutdown();
4287        _result
4288    }
4289
4290    fn send_raw(&self, mut value: Struct) -> Result<(), fidl::Error> {
4291        self.control_handle.inner.send::<EchoEchoStructResponse>(
4292            (&mut value,),
4293            self.tx_id,
4294            0x4c2f85818cc53f37,
4295            fidl::encoding::DynamicFlags::empty(),
4296        )
4297    }
4298}
4299
4300#[must_use = "FIDL methods require a response to be sent"]
4301#[derive(Debug)]
4302pub struct EchoEchoStructWithErrorResponder {
4303    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4304    tx_id: u32,
4305}
4306
4307/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4308/// if the responder is dropped without sending a response, so that the client
4309/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4310impl std::ops::Drop for EchoEchoStructWithErrorResponder {
4311    fn drop(&mut self) {
4312        self.control_handle.shutdown();
4313        // Safety: drops once, never accessed again
4314        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4315    }
4316}
4317
4318impl fidl::endpoints::Responder for EchoEchoStructWithErrorResponder {
4319    type ControlHandle = EchoControlHandle;
4320
4321    fn control_handle(&self) -> &EchoControlHandle {
4322        &self.control_handle
4323    }
4324
4325    fn drop_without_shutdown(mut self) {
4326        // Safety: drops once, never accessed again due to mem::forget
4327        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4328        // Prevent Drop from running (which would shut down the channel)
4329        std::mem::forget(self);
4330    }
4331}
4332
4333impl EchoEchoStructWithErrorResponder {
4334    /// Sends a response to the FIDL transaction.
4335    ///
4336    /// Sets the channel to shutdown if an error occurs.
4337    pub fn send(self, mut result: Result<Struct, DefaultEnum>) -> Result<(), fidl::Error> {
4338        let _result = self.send_raw(result);
4339        if _result.is_err() {
4340            self.control_handle.shutdown();
4341        }
4342        self.drop_without_shutdown();
4343        _result
4344    }
4345
4346    /// Similar to "send" but does not shutdown the channel if an error occurs.
4347    pub fn send_no_shutdown_on_err(
4348        self,
4349        mut result: Result<Struct, DefaultEnum>,
4350    ) -> Result<(), fidl::Error> {
4351        let _result = self.send_raw(result);
4352        self.drop_without_shutdown();
4353        _result
4354    }
4355
4356    fn send_raw(&self, mut result: Result<Struct, DefaultEnum>) -> Result<(), fidl::Error> {
4357        self.control_handle.inner.send::<fidl::encoding::ResultType<
4358            EchoEchoStructWithErrorResponse,
4359            DefaultEnum,
4360        >>(
4361            result.as_mut().map_err(|e| *e).map(|value| (value,)),
4362            self.tx_id,
4363            0x46cb32652c4c0899,
4364            fidl::encoding::DynamicFlags::empty(),
4365        )
4366    }
4367}
4368
4369#[must_use = "FIDL methods require a response to be sent"]
4370#[derive(Debug)]
4371pub struct EchoEchoArraysResponder {
4372    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4373    tx_id: u32,
4374}
4375
4376/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4377/// if the responder is dropped without sending a response, so that the client
4378/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4379impl std::ops::Drop for EchoEchoArraysResponder {
4380    fn drop(&mut self) {
4381        self.control_handle.shutdown();
4382        // Safety: drops once, never accessed again
4383        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4384    }
4385}
4386
4387impl fidl::endpoints::Responder for EchoEchoArraysResponder {
4388    type ControlHandle = EchoControlHandle;
4389
4390    fn control_handle(&self) -> &EchoControlHandle {
4391        &self.control_handle
4392    }
4393
4394    fn drop_without_shutdown(mut self) {
4395        // Safety: drops once, never accessed again due to mem::forget
4396        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4397        // Prevent Drop from running (which would shut down the channel)
4398        std::mem::forget(self);
4399    }
4400}
4401
4402impl EchoEchoArraysResponder {
4403    /// Sends a response to the FIDL transaction.
4404    ///
4405    /// Sets the channel to shutdown if an error occurs.
4406    pub fn send(self, mut value: ArraysStruct) -> Result<(), fidl::Error> {
4407        let _result = self.send_raw(value);
4408        if _result.is_err() {
4409            self.control_handle.shutdown();
4410        }
4411        self.drop_without_shutdown();
4412        _result
4413    }
4414
4415    /// Similar to "send" but does not shutdown the channel if an error occurs.
4416    pub fn send_no_shutdown_on_err(self, mut value: ArraysStruct) -> Result<(), fidl::Error> {
4417        let _result = self.send_raw(value);
4418        self.drop_without_shutdown();
4419        _result
4420    }
4421
4422    fn send_raw(&self, mut value: ArraysStruct) -> Result<(), fidl::Error> {
4423        self.control_handle.inner.send::<EchoEchoArraysResponse>(
4424            (&mut value,),
4425            self.tx_id,
4426            0x1b6019d5611f2470,
4427            fidl::encoding::DynamicFlags::empty(),
4428        )
4429    }
4430}
4431
4432#[must_use = "FIDL methods require a response to be sent"]
4433#[derive(Debug)]
4434pub struct EchoEchoArraysWithErrorResponder {
4435    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4436    tx_id: u32,
4437}
4438
4439/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4440/// if the responder is dropped without sending a response, so that the client
4441/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4442impl std::ops::Drop for EchoEchoArraysWithErrorResponder {
4443    fn drop(&mut self) {
4444        self.control_handle.shutdown();
4445        // Safety: drops once, never accessed again
4446        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4447    }
4448}
4449
4450impl fidl::endpoints::Responder for EchoEchoArraysWithErrorResponder {
4451    type ControlHandle = EchoControlHandle;
4452
4453    fn control_handle(&self) -> &EchoControlHandle {
4454        &self.control_handle
4455    }
4456
4457    fn drop_without_shutdown(mut self) {
4458        // Safety: drops once, never accessed again due to mem::forget
4459        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4460        // Prevent Drop from running (which would shut down the channel)
4461        std::mem::forget(self);
4462    }
4463}
4464
4465impl EchoEchoArraysWithErrorResponder {
4466    /// Sends a response to the FIDL transaction.
4467    ///
4468    /// Sets the channel to shutdown if an error occurs.
4469    pub fn send(self, mut result: Result<ArraysStruct, DefaultEnum>) -> Result<(), fidl::Error> {
4470        let _result = self.send_raw(result);
4471        if _result.is_err() {
4472            self.control_handle.shutdown();
4473        }
4474        self.drop_without_shutdown();
4475        _result
4476    }
4477
4478    /// Similar to "send" but does not shutdown the channel if an error occurs.
4479    pub fn send_no_shutdown_on_err(
4480        self,
4481        mut result: Result<ArraysStruct, DefaultEnum>,
4482    ) -> Result<(), fidl::Error> {
4483        let _result = self.send_raw(result);
4484        self.drop_without_shutdown();
4485        _result
4486    }
4487
4488    fn send_raw(&self, mut result: Result<ArraysStruct, DefaultEnum>) -> Result<(), fidl::Error> {
4489        self.control_handle.inner.send::<fidl::encoding::ResultType<
4490            EchoEchoArraysWithErrorResponse,
4491            DefaultEnum,
4492        >>(
4493            result.as_mut().map_err(|e| *e).map(|value| (value,)),
4494            self.tx_id,
4495            0x6dbf26e67e253afa,
4496            fidl::encoding::DynamicFlags::empty(),
4497        )
4498    }
4499}
4500
4501#[must_use = "FIDL methods require a response to be sent"]
4502#[derive(Debug)]
4503pub struct EchoEchoVectorsResponder {
4504    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4505    tx_id: u32,
4506}
4507
4508/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4509/// if the responder is dropped without sending a response, so that the client
4510/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4511impl std::ops::Drop for EchoEchoVectorsResponder {
4512    fn drop(&mut self) {
4513        self.control_handle.shutdown();
4514        // Safety: drops once, never accessed again
4515        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4516    }
4517}
4518
4519impl fidl::endpoints::Responder for EchoEchoVectorsResponder {
4520    type ControlHandle = EchoControlHandle;
4521
4522    fn control_handle(&self) -> &EchoControlHandle {
4523        &self.control_handle
4524    }
4525
4526    fn drop_without_shutdown(mut self) {
4527        // Safety: drops once, never accessed again due to mem::forget
4528        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4529        // Prevent Drop from running (which would shut down the channel)
4530        std::mem::forget(self);
4531    }
4532}
4533
4534impl EchoEchoVectorsResponder {
4535    /// Sends a response to the FIDL transaction.
4536    ///
4537    /// Sets the channel to shutdown if an error occurs.
4538    pub fn send(self, mut value: VectorsStruct) -> Result<(), fidl::Error> {
4539        let _result = self.send_raw(value);
4540        if _result.is_err() {
4541            self.control_handle.shutdown();
4542        }
4543        self.drop_without_shutdown();
4544        _result
4545    }
4546
4547    /// Similar to "send" but does not shutdown the channel if an error occurs.
4548    pub fn send_no_shutdown_on_err(self, mut value: VectorsStruct) -> Result<(), fidl::Error> {
4549        let _result = self.send_raw(value);
4550        self.drop_without_shutdown();
4551        _result
4552    }
4553
4554    fn send_raw(&self, mut value: VectorsStruct) -> Result<(), fidl::Error> {
4555        self.control_handle.inner.send::<EchoEchoVectorsResponse>(
4556            (&mut value,),
4557            self.tx_id,
4558            0x1582623f0d9f6e5e,
4559            fidl::encoding::DynamicFlags::empty(),
4560        )
4561    }
4562}
4563
4564#[must_use = "FIDL methods require a response to be sent"]
4565#[derive(Debug)]
4566pub struct EchoEchoVectorsWithErrorResponder {
4567    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4568    tx_id: u32,
4569}
4570
4571/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4572/// if the responder is dropped without sending a response, so that the client
4573/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4574impl std::ops::Drop for EchoEchoVectorsWithErrorResponder {
4575    fn drop(&mut self) {
4576        self.control_handle.shutdown();
4577        // Safety: drops once, never accessed again
4578        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4579    }
4580}
4581
4582impl fidl::endpoints::Responder for EchoEchoVectorsWithErrorResponder {
4583    type ControlHandle = EchoControlHandle;
4584
4585    fn control_handle(&self) -> &EchoControlHandle {
4586        &self.control_handle
4587    }
4588
4589    fn drop_without_shutdown(mut self) {
4590        // Safety: drops once, never accessed again due to mem::forget
4591        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4592        // Prevent Drop from running (which would shut down the channel)
4593        std::mem::forget(self);
4594    }
4595}
4596
4597impl EchoEchoVectorsWithErrorResponder {
4598    /// Sends a response to the FIDL transaction.
4599    ///
4600    /// Sets the channel to shutdown if an error occurs.
4601    pub fn send(self, mut result: Result<VectorsStruct, DefaultEnum>) -> Result<(), fidl::Error> {
4602        let _result = self.send_raw(result);
4603        if _result.is_err() {
4604            self.control_handle.shutdown();
4605        }
4606        self.drop_without_shutdown();
4607        _result
4608    }
4609
4610    /// Similar to "send" but does not shutdown the channel if an error occurs.
4611    pub fn send_no_shutdown_on_err(
4612        self,
4613        mut result: Result<VectorsStruct, DefaultEnum>,
4614    ) -> Result<(), fidl::Error> {
4615        let _result = self.send_raw(result);
4616        self.drop_without_shutdown();
4617        _result
4618    }
4619
4620    fn send_raw(&self, mut result: Result<VectorsStruct, DefaultEnum>) -> Result<(), fidl::Error> {
4621        self.control_handle.inner.send::<fidl::encoding::ResultType<
4622            EchoEchoVectorsWithErrorResponse,
4623            DefaultEnum,
4624        >>(
4625            result.as_mut().map_err(|e| *e).map(|value| (value,)),
4626            self.tx_id,
4627            0x730f163401e2b3e5,
4628            fidl::encoding::DynamicFlags::empty(),
4629        )
4630    }
4631}
4632
4633#[must_use = "FIDL methods require a response to be sent"]
4634#[derive(Debug)]
4635pub struct EchoEchoTableResponder {
4636    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4637    tx_id: u32,
4638}
4639
4640/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4641/// if the responder is dropped without sending a response, so that the client
4642/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4643impl std::ops::Drop for EchoEchoTableResponder {
4644    fn drop(&mut self) {
4645        self.control_handle.shutdown();
4646        // Safety: drops once, never accessed again
4647        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4648    }
4649}
4650
4651impl fidl::endpoints::Responder for EchoEchoTableResponder {
4652    type ControlHandle = EchoControlHandle;
4653
4654    fn control_handle(&self) -> &EchoControlHandle {
4655        &self.control_handle
4656    }
4657
4658    fn drop_without_shutdown(mut self) {
4659        // Safety: drops once, never accessed again due to mem::forget
4660        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4661        // Prevent Drop from running (which would shut down the channel)
4662        std::mem::forget(self);
4663    }
4664}
4665
4666impl EchoEchoTableResponder {
4667    /// Sends a response to the FIDL transaction.
4668    ///
4669    /// Sets the channel to shutdown if an error occurs.
4670    pub fn send(self, mut value: AllTypesTable) -> Result<(), fidl::Error> {
4671        let _result = self.send_raw(value);
4672        if _result.is_err() {
4673            self.control_handle.shutdown();
4674        }
4675        self.drop_without_shutdown();
4676        _result
4677    }
4678
4679    /// Similar to "send" but does not shutdown the channel if an error occurs.
4680    pub fn send_no_shutdown_on_err(self, mut value: AllTypesTable) -> Result<(), fidl::Error> {
4681        let _result = self.send_raw(value);
4682        self.drop_without_shutdown();
4683        _result
4684    }
4685
4686    fn send_raw(&self, mut value: AllTypesTable) -> Result<(), fidl::Error> {
4687        self.control_handle.inner.send::<EchoEchoTableResponse>(
4688            (&mut value,),
4689            self.tx_id,
4690            0x4f1fb0a512f47c4b,
4691            fidl::encoding::DynamicFlags::empty(),
4692        )
4693    }
4694}
4695
4696#[must_use = "FIDL methods require a response to be sent"]
4697#[derive(Debug)]
4698pub struct EchoEchoTableWithErrorResponder {
4699    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4700    tx_id: u32,
4701}
4702
4703/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4704/// if the responder is dropped without sending a response, so that the client
4705/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4706impl std::ops::Drop for EchoEchoTableWithErrorResponder {
4707    fn drop(&mut self) {
4708        self.control_handle.shutdown();
4709        // Safety: drops once, never accessed again
4710        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4711    }
4712}
4713
4714impl fidl::endpoints::Responder for EchoEchoTableWithErrorResponder {
4715    type ControlHandle = EchoControlHandle;
4716
4717    fn control_handle(&self) -> &EchoControlHandle {
4718        &self.control_handle
4719    }
4720
4721    fn drop_without_shutdown(mut self) {
4722        // Safety: drops once, never accessed again due to mem::forget
4723        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4724        // Prevent Drop from running (which would shut down the channel)
4725        std::mem::forget(self);
4726    }
4727}
4728
4729impl EchoEchoTableWithErrorResponder {
4730    /// Sends a response to the FIDL transaction.
4731    ///
4732    /// Sets the channel to shutdown if an error occurs.
4733    pub fn send(self, mut result: Result<AllTypesTable, DefaultEnum>) -> Result<(), fidl::Error> {
4734        let _result = self.send_raw(result);
4735        if _result.is_err() {
4736            self.control_handle.shutdown();
4737        }
4738        self.drop_without_shutdown();
4739        _result
4740    }
4741
4742    /// Similar to "send" but does not shutdown the channel if an error occurs.
4743    pub fn send_no_shutdown_on_err(
4744        self,
4745        mut result: Result<AllTypesTable, DefaultEnum>,
4746    ) -> Result<(), fidl::Error> {
4747        let _result = self.send_raw(result);
4748        self.drop_without_shutdown();
4749        _result
4750    }
4751
4752    fn send_raw(&self, mut result: Result<AllTypesTable, DefaultEnum>) -> Result<(), fidl::Error> {
4753        self.control_handle.inner.send::<fidl::encoding::ResultType<
4754            EchoEchoTableWithErrorResponse,
4755            DefaultEnum,
4756        >>(
4757            result.as_mut().map_err(|e| *e).map(|value| (value,)),
4758            self.tx_id,
4759            0x44e835cb1eb9a931,
4760            fidl::encoding::DynamicFlags::empty(),
4761        )
4762    }
4763}
4764
4765#[must_use = "FIDL methods require a response to be sent"]
4766#[derive(Debug)]
4767pub struct EchoEchoXunionsResponder {
4768    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4769    tx_id: u32,
4770}
4771
4772/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4773/// if the responder is dropped without sending a response, so that the client
4774/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4775impl std::ops::Drop for EchoEchoXunionsResponder {
4776    fn drop(&mut self) {
4777        self.control_handle.shutdown();
4778        // Safety: drops once, never accessed again
4779        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4780    }
4781}
4782
4783impl fidl::endpoints::Responder for EchoEchoXunionsResponder {
4784    type ControlHandle = EchoControlHandle;
4785
4786    fn control_handle(&self) -> &EchoControlHandle {
4787        &self.control_handle
4788    }
4789
4790    fn drop_without_shutdown(mut self) {
4791        // Safety: drops once, never accessed again due to mem::forget
4792        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4793        // Prevent Drop from running (which would shut down the channel)
4794        std::mem::forget(self);
4795    }
4796}
4797
4798impl EchoEchoXunionsResponder {
4799    /// Sends a response to the FIDL transaction.
4800    ///
4801    /// Sets the channel to shutdown if an error occurs.
4802    pub fn send(self, mut value: Vec<AllTypesXunion>) -> Result<(), fidl::Error> {
4803        let _result = self.send_raw(value);
4804        if _result.is_err() {
4805            self.control_handle.shutdown();
4806        }
4807        self.drop_without_shutdown();
4808        _result
4809    }
4810
4811    /// Similar to "send" but does not shutdown the channel if an error occurs.
4812    pub fn send_no_shutdown_on_err(
4813        self,
4814        mut value: Vec<AllTypesXunion>,
4815    ) -> Result<(), fidl::Error> {
4816        let _result = self.send_raw(value);
4817        self.drop_without_shutdown();
4818        _result
4819    }
4820
4821    fn send_raw(&self, mut value: Vec<AllTypesXunion>) -> Result<(), fidl::Error> {
4822        self.control_handle.inner.send::<EchoEchoXunionsResponse>(
4823            (value.as_mut(),),
4824            self.tx_id,
4825            0x3dc181909041a583,
4826            fidl::encoding::DynamicFlags::empty(),
4827        )
4828    }
4829}
4830
4831#[must_use = "FIDL methods require a response to be sent"]
4832#[derive(Debug)]
4833pub struct EchoEchoXunionsWithErrorResponder {
4834    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4835    tx_id: u32,
4836}
4837
4838/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4839/// if the responder is dropped without sending a response, so that the client
4840/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4841impl std::ops::Drop for EchoEchoXunionsWithErrorResponder {
4842    fn drop(&mut self) {
4843        self.control_handle.shutdown();
4844        // Safety: drops once, never accessed again
4845        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4846    }
4847}
4848
4849impl fidl::endpoints::Responder for EchoEchoXunionsWithErrorResponder {
4850    type ControlHandle = EchoControlHandle;
4851
4852    fn control_handle(&self) -> &EchoControlHandle {
4853        &self.control_handle
4854    }
4855
4856    fn drop_without_shutdown(mut self) {
4857        // Safety: drops once, never accessed again due to mem::forget
4858        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4859        // Prevent Drop from running (which would shut down the channel)
4860        std::mem::forget(self);
4861    }
4862}
4863
4864impl EchoEchoXunionsWithErrorResponder {
4865    /// Sends a response to the FIDL transaction.
4866    ///
4867    /// Sets the channel to shutdown if an error occurs.
4868    pub fn send(
4869        self,
4870        mut result: Result<Vec<AllTypesXunion>, DefaultEnum>,
4871    ) -> Result<(), fidl::Error> {
4872        let _result = self.send_raw(result);
4873        if _result.is_err() {
4874            self.control_handle.shutdown();
4875        }
4876        self.drop_without_shutdown();
4877        _result
4878    }
4879
4880    /// Similar to "send" but does not shutdown the channel if an error occurs.
4881    pub fn send_no_shutdown_on_err(
4882        self,
4883        mut result: Result<Vec<AllTypesXunion>, DefaultEnum>,
4884    ) -> Result<(), fidl::Error> {
4885        let _result = self.send_raw(result);
4886        self.drop_without_shutdown();
4887        _result
4888    }
4889
4890    fn send_raw(
4891        &self,
4892        mut result: Result<Vec<AllTypesXunion>, DefaultEnum>,
4893    ) -> Result<(), fidl::Error> {
4894        self.control_handle.inner.send::<fidl::encoding::ResultType<
4895            EchoEchoXunionsWithErrorResponse,
4896            DefaultEnum,
4897        >>(
4898            result.as_mut().map_err(|e| *e).map(|value| (value.as_mut_slice(),)),
4899            self.tx_id,
4900            0x75184102667fa766,
4901            fidl::encoding::DynamicFlags::empty(),
4902        )
4903    }
4904}
4905
4906#[must_use = "FIDL methods require a response to be sent"]
4907#[derive(Debug)]
4908pub struct EchoEchoNamedStructResponder {
4909    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4910    tx_id: u32,
4911}
4912
4913/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4914/// if the responder is dropped without sending a response, so that the client
4915/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4916impl std::ops::Drop for EchoEchoNamedStructResponder {
4917    fn drop(&mut self) {
4918        self.control_handle.shutdown();
4919        // Safety: drops once, never accessed again
4920        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4921    }
4922}
4923
4924impl fidl::endpoints::Responder for EchoEchoNamedStructResponder {
4925    type ControlHandle = EchoControlHandle;
4926
4927    fn control_handle(&self) -> &EchoControlHandle {
4928        &self.control_handle
4929    }
4930
4931    fn drop_without_shutdown(mut self) {
4932        // Safety: drops once, never accessed again due to mem::forget
4933        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4934        // Prevent Drop from running (which would shut down the channel)
4935        std::mem::forget(self);
4936    }
4937}
4938
4939impl EchoEchoNamedStructResponder {
4940    /// Sends a response to the FIDL transaction.
4941    ///
4942    /// Sets the channel to shutdown if an error occurs.
4943    pub fn send(
4944        self,
4945        mut value: &fidl_fidl_test_imported::SimpleStruct,
4946    ) -> Result<(), fidl::Error> {
4947        let _result = self.send_raw(value);
4948        if _result.is_err() {
4949            self.control_handle.shutdown();
4950        }
4951        self.drop_without_shutdown();
4952        _result
4953    }
4954
4955    /// Similar to "send" but does not shutdown the channel if an error occurs.
4956    pub fn send_no_shutdown_on_err(
4957        self,
4958        mut value: &fidl_fidl_test_imported::SimpleStruct,
4959    ) -> Result<(), fidl::Error> {
4960        let _result = self.send_raw(value);
4961        self.drop_without_shutdown();
4962        _result
4963    }
4964
4965    fn send_raw(
4966        &self,
4967        mut value: &fidl_fidl_test_imported::SimpleStruct,
4968    ) -> Result<(), fidl::Error> {
4969        self.control_handle.inner.send::<fidl_fidl_test_imported::ResponseStruct>(
4970            (value,),
4971            self.tx_id,
4972            0xf2d4aa9e65f7111,
4973            fidl::encoding::DynamicFlags::empty(),
4974        )
4975    }
4976}
4977
4978#[must_use = "FIDL methods require a response to be sent"]
4979#[derive(Debug)]
4980pub struct EchoEchoNamedStructWithErrorResponder {
4981    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
4982    tx_id: u32,
4983}
4984
4985/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
4986/// if the responder is dropped without sending a response, so that the client
4987/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
4988impl std::ops::Drop for EchoEchoNamedStructWithErrorResponder {
4989    fn drop(&mut self) {
4990        self.control_handle.shutdown();
4991        // Safety: drops once, never accessed again
4992        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
4993    }
4994}
4995
4996impl fidl::endpoints::Responder for EchoEchoNamedStructWithErrorResponder {
4997    type ControlHandle = EchoControlHandle;
4998
4999    fn control_handle(&self) -> &EchoControlHandle {
5000        &self.control_handle
5001    }
5002
5003    fn drop_without_shutdown(mut self) {
5004        // Safety: drops once, never accessed again due to mem::forget
5005        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5006        // Prevent Drop from running (which would shut down the channel)
5007        std::mem::forget(self);
5008    }
5009}
5010
5011impl EchoEchoNamedStructWithErrorResponder {
5012    /// Sends a response to the FIDL transaction.
5013    ///
5014    /// Sets the channel to shutdown if an error occurs.
5015    pub fn send(
5016        self,
5017        mut result: Result<&fidl_fidl_test_imported::SimpleStruct, u32>,
5018    ) -> Result<(), fidl::Error> {
5019        let _result = self.send_raw(result);
5020        if _result.is_err() {
5021            self.control_handle.shutdown();
5022        }
5023        self.drop_without_shutdown();
5024        _result
5025    }
5026
5027    /// Similar to "send" but does not shutdown the channel if an error occurs.
5028    pub fn send_no_shutdown_on_err(
5029        self,
5030        mut result: Result<&fidl_fidl_test_imported::SimpleStruct, u32>,
5031    ) -> Result<(), fidl::Error> {
5032        let _result = self.send_raw(result);
5033        self.drop_without_shutdown();
5034        _result
5035    }
5036
5037    fn send_raw(
5038        &self,
5039        mut result: Result<&fidl_fidl_test_imported::SimpleStruct, u32>,
5040    ) -> Result<(), fidl::Error> {
5041        self.control_handle.inner.send::<fidl::encoding::ResultType<
5042            fidl_fidl_test_imported::ResponseStruct,
5043            u32,
5044        >>(
5045            result.map(|value| (value,)),
5046            self.tx_id,
5047            0x5766fee9e74442e8,
5048            fidl::encoding::DynamicFlags::empty(),
5049        )
5050    }
5051}
5052
5053#[must_use = "FIDL methods require a response to be sent"]
5054#[derive(Debug)]
5055pub struct EchoEchoTablePayloadResponder {
5056    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
5057    tx_id: u32,
5058}
5059
5060/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
5061/// if the responder is dropped without sending a response, so that the client
5062/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
5063impl std::ops::Drop for EchoEchoTablePayloadResponder {
5064    fn drop(&mut self) {
5065        self.control_handle.shutdown();
5066        // Safety: drops once, never accessed again
5067        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5068    }
5069}
5070
5071impl fidl::endpoints::Responder for EchoEchoTablePayloadResponder {
5072    type ControlHandle = EchoControlHandle;
5073
5074    fn control_handle(&self) -> &EchoControlHandle {
5075        &self.control_handle
5076    }
5077
5078    fn drop_without_shutdown(mut self) {
5079        // Safety: drops once, never accessed again due to mem::forget
5080        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5081        // Prevent Drop from running (which would shut down the channel)
5082        std::mem::forget(self);
5083    }
5084}
5085
5086impl EchoEchoTablePayloadResponder {
5087    /// Sends a response to the FIDL transaction.
5088    ///
5089    /// Sets the channel to shutdown if an error occurs.
5090    pub fn send(self, mut payload: &ResponseTable) -> Result<(), fidl::Error> {
5091        let _result = self.send_raw(payload);
5092        if _result.is_err() {
5093            self.control_handle.shutdown();
5094        }
5095        self.drop_without_shutdown();
5096        _result
5097    }
5098
5099    /// Similar to "send" but does not shutdown the channel if an error occurs.
5100    pub fn send_no_shutdown_on_err(self, mut payload: &ResponseTable) -> Result<(), fidl::Error> {
5101        let _result = self.send_raw(payload);
5102        self.drop_without_shutdown();
5103        _result
5104    }
5105
5106    fn send_raw(&self, mut payload: &ResponseTable) -> Result<(), fidl::Error> {
5107        self.control_handle.inner.send::<ResponseTable>(
5108            payload,
5109            self.tx_id,
5110            0x641d98087378c003,
5111            fidl::encoding::DynamicFlags::empty(),
5112        )
5113    }
5114}
5115
5116#[must_use = "FIDL methods require a response to be sent"]
5117#[derive(Debug)]
5118pub struct EchoEchoTablePayloadWithErrorResponder {
5119    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
5120    tx_id: u32,
5121}
5122
5123/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
5124/// if the responder is dropped without sending a response, so that the client
5125/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
5126impl std::ops::Drop for EchoEchoTablePayloadWithErrorResponder {
5127    fn drop(&mut self) {
5128        self.control_handle.shutdown();
5129        // Safety: drops once, never accessed again
5130        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5131    }
5132}
5133
5134impl fidl::endpoints::Responder for EchoEchoTablePayloadWithErrorResponder {
5135    type ControlHandle = EchoControlHandle;
5136
5137    fn control_handle(&self) -> &EchoControlHandle {
5138        &self.control_handle
5139    }
5140
5141    fn drop_without_shutdown(mut self) {
5142        // Safety: drops once, never accessed again due to mem::forget
5143        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5144        // Prevent Drop from running (which would shut down the channel)
5145        std::mem::forget(self);
5146    }
5147}
5148
5149impl EchoEchoTablePayloadWithErrorResponder {
5150    /// Sends a response to the FIDL transaction.
5151    ///
5152    /// Sets the channel to shutdown if an error occurs.
5153    pub fn send(self, mut result: Result<&ResponseTable, DefaultEnum>) -> Result<(), fidl::Error> {
5154        let _result = self.send_raw(result);
5155        if _result.is_err() {
5156            self.control_handle.shutdown();
5157        }
5158        self.drop_without_shutdown();
5159        _result
5160    }
5161
5162    /// Similar to "send" but does not shutdown the channel if an error occurs.
5163    pub fn send_no_shutdown_on_err(
5164        self,
5165        mut result: Result<&ResponseTable, DefaultEnum>,
5166    ) -> Result<(), fidl::Error> {
5167        let _result = self.send_raw(result);
5168        self.drop_without_shutdown();
5169        _result
5170    }
5171
5172    fn send_raw(&self, mut result: Result<&ResponseTable, DefaultEnum>) -> Result<(), fidl::Error> {
5173        self.control_handle.inner.send::<fidl::encoding::ResultType<ResponseTable, DefaultEnum>>(
5174            result,
5175            self.tx_id,
5176            0x636ed243761ab66d,
5177            fidl::encoding::DynamicFlags::empty(),
5178        )
5179    }
5180}
5181
5182#[must_use = "FIDL methods require a response to be sent"]
5183#[derive(Debug)]
5184pub struct EchoEchoUnionPayloadResponder {
5185    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
5186    tx_id: u32,
5187}
5188
5189/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
5190/// if the responder is dropped without sending a response, so that the client
5191/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
5192impl std::ops::Drop for EchoEchoUnionPayloadResponder {
5193    fn drop(&mut self) {
5194        self.control_handle.shutdown();
5195        // Safety: drops once, never accessed again
5196        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5197    }
5198}
5199
5200impl fidl::endpoints::Responder for EchoEchoUnionPayloadResponder {
5201    type ControlHandle = EchoControlHandle;
5202
5203    fn control_handle(&self) -> &EchoControlHandle {
5204        &self.control_handle
5205    }
5206
5207    fn drop_without_shutdown(mut self) {
5208        // Safety: drops once, never accessed again due to mem::forget
5209        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5210        // Prevent Drop from running (which would shut down the channel)
5211        std::mem::forget(self);
5212    }
5213}
5214
5215impl EchoEchoUnionPayloadResponder {
5216    /// Sends a response to the FIDL transaction.
5217    ///
5218    /// Sets the channel to shutdown if an error occurs.
5219    pub fn send(self, mut payload: &ResponseUnion) -> Result<(), fidl::Error> {
5220        let _result = self.send_raw(payload);
5221        if _result.is_err() {
5222            self.control_handle.shutdown();
5223        }
5224        self.drop_without_shutdown();
5225        _result
5226    }
5227
5228    /// Similar to "send" but does not shutdown the channel if an error occurs.
5229    pub fn send_no_shutdown_on_err(self, mut payload: &ResponseUnion) -> Result<(), fidl::Error> {
5230        let _result = self.send_raw(payload);
5231        self.drop_without_shutdown();
5232        _result
5233    }
5234
5235    fn send_raw(&self, mut payload: &ResponseUnion) -> Result<(), fidl::Error> {
5236        self.control_handle.inner.send::<ResponseUnion>(
5237            payload,
5238            self.tx_id,
5239            0x66def9e793f10c55,
5240            fidl::encoding::DynamicFlags::empty(),
5241        )
5242    }
5243}
5244
5245#[must_use = "FIDL methods require a response to be sent"]
5246#[derive(Debug)]
5247pub struct EchoEchoUnionPayloadWithErrorResponder {
5248    control_handle: std::mem::ManuallyDrop<EchoControlHandle>,
5249    tx_id: u32,
5250}
5251
5252/// Set the the channel to be shutdown (see [`EchoControlHandle::shutdown`])
5253/// if the responder is dropped without sending a response, so that the client
5254/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
5255impl std::ops::Drop for EchoEchoUnionPayloadWithErrorResponder {
5256    fn drop(&mut self) {
5257        self.control_handle.shutdown();
5258        // Safety: drops once, never accessed again
5259        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5260    }
5261}
5262
5263impl fidl::endpoints::Responder for EchoEchoUnionPayloadWithErrorResponder {
5264    type ControlHandle = EchoControlHandle;
5265
5266    fn control_handle(&self) -> &EchoControlHandle {
5267        &self.control_handle
5268    }
5269
5270    fn drop_without_shutdown(mut self) {
5271        // Safety: drops once, never accessed again due to mem::forget
5272        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
5273        // Prevent Drop from running (which would shut down the channel)
5274        std::mem::forget(self);
5275    }
5276}
5277
5278impl EchoEchoUnionPayloadWithErrorResponder {
5279    /// Sends a response to the FIDL transaction.
5280    ///
5281    /// Sets the channel to shutdown if an error occurs.
5282    pub fn send(self, mut result: Result<&ResponseUnion, DefaultEnum>) -> Result<(), fidl::Error> {
5283        let _result = self.send_raw(result);
5284        if _result.is_err() {
5285            self.control_handle.shutdown();
5286        }
5287        self.drop_without_shutdown();
5288        _result
5289    }
5290
5291    /// Similar to "send" but does not shutdown the channel if an error occurs.
5292    pub fn send_no_shutdown_on_err(
5293        self,
5294        mut result: Result<&ResponseUnion, DefaultEnum>,
5295    ) -> Result<(), fidl::Error> {
5296        let _result = self.send_raw(result);
5297        self.drop_without_shutdown();
5298        _result
5299    }
5300
5301    fn send_raw(&self, mut result: Result<&ResponseUnion, DefaultEnum>) -> Result<(), fidl::Error> {
5302        self.control_handle.inner.send::<fidl::encoding::ResultType<ResponseUnion, DefaultEnum>>(
5303            result,
5304            self.tx_id,
5305            0x1be890d6e68ef063,
5306            fidl::encoding::DynamicFlags::empty(),
5307        )
5308    }
5309}
5310
5311mod internal {
5312    use super::*;
5313
5314    impl fidl::encoding::ResourceTypeMarker for ArraysStruct {
5315        type Borrowed<'a> = &'a mut Self;
5316        fn take_or_borrow<'a>(
5317            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
5318        ) -> Self::Borrowed<'a> {
5319            value
5320        }
5321    }
5322
5323    unsafe impl fidl::encoding::TypeMarker for ArraysStruct {
5324        type Owned = Self;
5325
5326        #[inline(always)]
5327        fn inline_align(_context: fidl::encoding::Context) -> usize {
5328            8
5329        }
5330
5331        #[inline(always)]
5332        fn inline_size(_context: fidl::encoding::Context) -> usize {
5333            680
5334        }
5335    }
5336
5337    unsafe impl fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
5338        for &mut ArraysStruct
5339    {
5340        #[inline]
5341        unsafe fn encode(
5342            self,
5343            encoder: &mut fidl::encoding::Encoder<
5344                '_,
5345                fidl::encoding::DefaultFuchsiaResourceDialect,
5346            >,
5347            offset: usize,
5348            _depth: fidl::encoding::Depth,
5349        ) -> fidl::Result<()> {
5350            encoder.debug_check_bounds::<ArraysStruct>(offset);
5351            // Delegate to tuple encoding.
5352            fidl::encoding::Encode::<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
5353                (
5354                    <fidl::encoding::Array<bool, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.bools),
5355                    <fidl::encoding::Array<i8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int8s),
5356                    <fidl::encoding::Array<i16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int16s),
5357                    <fidl::encoding::Array<i32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int32s),
5358                    <fidl::encoding::Array<i64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int64s),
5359                    <fidl::encoding::Array<u8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint8s),
5360                    <fidl::encoding::Array<u16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint16s),
5361                    <fidl::encoding::Array<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint32s),
5362                    <fidl::encoding::Array<u64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint64s),
5363                    <fidl::encoding::Array<f32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.float32s),
5364                    <fidl::encoding::Array<f64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.float64s),
5365                    <fidl::encoding::Array<DefaultEnum, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.enums),
5366                    <fidl::encoding::Array<DefaultBits, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.bits),
5367                    <fidl::encoding::Array<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 3> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handles),
5368                    <fidl::encoding::Array<fidl::encoding::Optional<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>>, 3> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.nullable_handles),
5369                    <fidl::encoding::Array<fidl::encoding::UnboundedString, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.strings),
5370                    <fidl::encoding::Array<fidl::encoding::Optional<fidl::encoding::UnboundedString>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_strings),
5371                    <fidl::encoding::Array<ThisIsAStruct, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.structs),
5372                    <fidl::encoding::Array<fidl::encoding::Boxed<ThisIsAStruct>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_structs),
5373                    <fidl::encoding::Array<ThisIsAUnion, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.unions),
5374                    <fidl::encoding::Array<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_unions),
5375                    <fidl::encoding::Array<fidl::encoding::Array<u32, 3>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.arrays),
5376                    <fidl::encoding::Array<fidl::encoding::UnboundedVector<u32>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.vectors),
5377                    <fidl::encoding::Array<fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_vectors),
5378                    <fidl::encoding::Array<ThisIsATable, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.tables),
5379                    <fidl::encoding::Array<ThisIsAXunion, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.xunions),
5380                ),
5381                encoder, offset, _depth
5382            )
5383        }
5384    }
5385    unsafe impl<
5386            T0: fidl::encoding::Encode<
5387                fidl::encoding::Array<bool, 3>,
5388                fidl::encoding::DefaultFuchsiaResourceDialect,
5389            >,
5390            T1: fidl::encoding::Encode<
5391                fidl::encoding::Array<i8, 3>,
5392                fidl::encoding::DefaultFuchsiaResourceDialect,
5393            >,
5394            T2: fidl::encoding::Encode<
5395                fidl::encoding::Array<i16, 3>,
5396                fidl::encoding::DefaultFuchsiaResourceDialect,
5397            >,
5398            T3: fidl::encoding::Encode<
5399                fidl::encoding::Array<i32, 3>,
5400                fidl::encoding::DefaultFuchsiaResourceDialect,
5401            >,
5402            T4: fidl::encoding::Encode<
5403                fidl::encoding::Array<i64, 3>,
5404                fidl::encoding::DefaultFuchsiaResourceDialect,
5405            >,
5406            T5: fidl::encoding::Encode<
5407                fidl::encoding::Array<u8, 3>,
5408                fidl::encoding::DefaultFuchsiaResourceDialect,
5409            >,
5410            T6: fidl::encoding::Encode<
5411                fidl::encoding::Array<u16, 3>,
5412                fidl::encoding::DefaultFuchsiaResourceDialect,
5413            >,
5414            T7: fidl::encoding::Encode<
5415                fidl::encoding::Array<u32, 3>,
5416                fidl::encoding::DefaultFuchsiaResourceDialect,
5417            >,
5418            T8: fidl::encoding::Encode<
5419                fidl::encoding::Array<u64, 3>,
5420                fidl::encoding::DefaultFuchsiaResourceDialect,
5421            >,
5422            T9: fidl::encoding::Encode<
5423                fidl::encoding::Array<f32, 3>,
5424                fidl::encoding::DefaultFuchsiaResourceDialect,
5425            >,
5426            T10: fidl::encoding::Encode<
5427                fidl::encoding::Array<f64, 3>,
5428                fidl::encoding::DefaultFuchsiaResourceDialect,
5429            >,
5430            T11: fidl::encoding::Encode<
5431                fidl::encoding::Array<DefaultEnum, 3>,
5432                fidl::encoding::DefaultFuchsiaResourceDialect,
5433            >,
5434            T12: fidl::encoding::Encode<
5435                fidl::encoding::Array<DefaultBits, 3>,
5436                fidl::encoding::DefaultFuchsiaResourceDialect,
5437            >,
5438            T13: fidl::encoding::Encode<
5439                fidl::encoding::Array<
5440                    fidl::encoding::HandleType<
5441                        fidl::Handle,
5442                        { fidl::ObjectType::NONE.into_raw() },
5443                        2147483648,
5444                    >,
5445                    3,
5446                >,
5447                fidl::encoding::DefaultFuchsiaResourceDialect,
5448            >,
5449            T14: fidl::encoding::Encode<
5450                fidl::encoding::Array<
5451                    fidl::encoding::Optional<
5452                        fidl::encoding::HandleType<
5453                            fidl::Handle,
5454                            { fidl::ObjectType::NONE.into_raw() },
5455                            2147483648,
5456                        >,
5457                    >,
5458                    3,
5459                >,
5460                fidl::encoding::DefaultFuchsiaResourceDialect,
5461            >,
5462            T15: fidl::encoding::Encode<
5463                fidl::encoding::Array<fidl::encoding::UnboundedString, 3>,
5464                fidl::encoding::DefaultFuchsiaResourceDialect,
5465            >,
5466            T16: fidl::encoding::Encode<
5467                fidl::encoding::Array<fidl::encoding::Optional<fidl::encoding::UnboundedString>, 3>,
5468                fidl::encoding::DefaultFuchsiaResourceDialect,
5469            >,
5470            T17: fidl::encoding::Encode<
5471                fidl::encoding::Array<ThisIsAStruct, 3>,
5472                fidl::encoding::DefaultFuchsiaResourceDialect,
5473            >,
5474            T18: fidl::encoding::Encode<
5475                fidl::encoding::Array<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
5476                fidl::encoding::DefaultFuchsiaResourceDialect,
5477            >,
5478            T19: fidl::encoding::Encode<
5479                fidl::encoding::Array<ThisIsAUnion, 3>,
5480                fidl::encoding::DefaultFuchsiaResourceDialect,
5481            >,
5482            T20: fidl::encoding::Encode<
5483                fidl::encoding::Array<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
5484                fidl::encoding::DefaultFuchsiaResourceDialect,
5485            >,
5486            T21: fidl::encoding::Encode<
5487                fidl::encoding::Array<fidl::encoding::Array<u32, 3>, 3>,
5488                fidl::encoding::DefaultFuchsiaResourceDialect,
5489            >,
5490            T22: fidl::encoding::Encode<
5491                fidl::encoding::Array<fidl::encoding::UnboundedVector<u32>, 3>,
5492                fidl::encoding::DefaultFuchsiaResourceDialect,
5493            >,
5494            T23: fidl::encoding::Encode<
5495                fidl::encoding::Array<
5496                    fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
5497                    3,
5498                >,
5499                fidl::encoding::DefaultFuchsiaResourceDialect,
5500            >,
5501            T24: fidl::encoding::Encode<
5502                fidl::encoding::Array<ThisIsATable, 3>,
5503                fidl::encoding::DefaultFuchsiaResourceDialect,
5504            >,
5505            T25: fidl::encoding::Encode<
5506                fidl::encoding::Array<ThisIsAXunion, 3>,
5507                fidl::encoding::DefaultFuchsiaResourceDialect,
5508            >,
5509        > fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
5510        for (
5511            T0,
5512            T1,
5513            T2,
5514            T3,
5515            T4,
5516            T5,
5517            T6,
5518            T7,
5519            T8,
5520            T9,
5521            T10,
5522            T11,
5523            T12,
5524            T13,
5525            T14,
5526            T15,
5527            T16,
5528            T17,
5529            T18,
5530            T19,
5531            T20,
5532            T21,
5533            T22,
5534            T23,
5535            T24,
5536            T25,
5537        )
5538    {
5539        #[inline]
5540        unsafe fn encode(
5541            self,
5542            encoder: &mut fidl::encoding::Encoder<
5543                '_,
5544                fidl::encoding::DefaultFuchsiaResourceDialect,
5545            >,
5546            offset: usize,
5547            depth: fidl::encoding::Depth,
5548        ) -> fidl::Result<()> {
5549            encoder.debug_check_bounds::<ArraysStruct>(offset);
5550            // Zero out padding regions. There's no need to apply masks
5551            // because the unmasked parts will be overwritten by fields.
5552            unsafe {
5553                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(48);
5554                (ptr as *mut u64).write_unaligned(0);
5555            }
5556            unsafe {
5557                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(56);
5558                (ptr as *mut u64).write_unaligned(0);
5559            }
5560            unsafe {
5561                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(104);
5562                (ptr as *mut u64).write_unaligned(0);
5563            }
5564            unsafe {
5565                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(480);
5566                (ptr as *mut u64).write_unaligned(0);
5567            }
5568            // Write the fields.
5569            self.0.encode(encoder, offset + 0, depth)?;
5570            self.1.encode(encoder, offset + 3, depth)?;
5571            self.2.encode(encoder, offset + 6, depth)?;
5572            self.3.encode(encoder, offset + 12, depth)?;
5573            self.4.encode(encoder, offset + 24, depth)?;
5574            self.5.encode(encoder, offset + 48, depth)?;
5575            self.6.encode(encoder, offset + 52, depth)?;
5576            self.7.encode(encoder, offset + 60, depth)?;
5577            self.8.encode(encoder, offset + 72, depth)?;
5578            self.9.encode(encoder, offset + 96, depth)?;
5579            self.10.encode(encoder, offset + 112, depth)?;
5580            self.11.encode(encoder, offset + 136, depth)?;
5581            self.12.encode(encoder, offset + 148, depth)?;
5582            self.13.encode(encoder, offset + 160, depth)?;
5583            self.14.encode(encoder, offset + 172, depth)?;
5584            self.15.encode(encoder, offset + 184, depth)?;
5585            self.16.encode(encoder, offset + 232, depth)?;
5586            self.17.encode(encoder, offset + 280, depth)?;
5587            self.18.encode(encoder, offset + 328, depth)?;
5588            self.19.encode(encoder, offset + 352, depth)?;
5589            self.20.encode(encoder, offset + 400, depth)?;
5590            self.21.encode(encoder, offset + 448, depth)?;
5591            self.22.encode(encoder, offset + 488, depth)?;
5592            self.23.encode(encoder, offset + 536, depth)?;
5593            self.24.encode(encoder, offset + 584, depth)?;
5594            self.25.encode(encoder, offset + 632, depth)?;
5595            Ok(())
5596        }
5597    }
5598
5599    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for ArraysStruct {
5600        #[inline(always)]
5601        fn new_empty() -> Self {
5602            Self {
5603                bools: fidl::new_empty!(fidl::encoding::Array<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5604                int8s: fidl::new_empty!(fidl::encoding::Array<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5605                int16s: fidl::new_empty!(fidl::encoding::Array<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5606                int32s: fidl::new_empty!(fidl::encoding::Array<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5607                int64s: fidl::new_empty!(fidl::encoding::Array<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5608                uint8s: fidl::new_empty!(fidl::encoding::Array<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5609                uint16s: fidl::new_empty!(fidl::encoding::Array<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5610                uint32s: fidl::new_empty!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5611                uint64s: fidl::new_empty!(fidl::encoding::Array<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5612                float32s: fidl::new_empty!(fidl::encoding::Array<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5613                float64s: fidl::new_empty!(fidl::encoding::Array<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5614                enums: fidl::new_empty!(fidl::encoding::Array<DefaultEnum, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5615                bits: fidl::new_empty!(fidl::encoding::Array<DefaultBits, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5616                handles: fidl::new_empty!(
5617                    fidl::encoding::Array<
5618                        fidl::encoding::HandleType<
5619                            fidl::Handle,
5620                            { fidl::ObjectType::NONE.into_raw() },
5621                            2147483648,
5622                        >,
5623                        3,
5624                    >,
5625                    fidl::encoding::DefaultFuchsiaResourceDialect
5626                ),
5627                nullable_handles: fidl::new_empty!(
5628                    fidl::encoding::Array<
5629                        fidl::encoding::Optional<
5630                            fidl::encoding::HandleType<
5631                                fidl::Handle,
5632                                { fidl::ObjectType::NONE.into_raw() },
5633                                2147483648,
5634                            >,
5635                        >,
5636                        3,
5637                    >,
5638                    fidl::encoding::DefaultFuchsiaResourceDialect
5639                ),
5640                strings: fidl::new_empty!(fidl::encoding::Array<fidl::encoding::UnboundedString, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5641                nullable_strings: fidl::new_empty!(
5642                    fidl::encoding::Array<
5643                        fidl::encoding::Optional<fidl::encoding::UnboundedString>,
5644                        3,
5645                    >,
5646                    fidl::encoding::DefaultFuchsiaResourceDialect
5647                ),
5648                structs: fidl::new_empty!(fidl::encoding::Array<ThisIsAStruct, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5649                nullable_structs: fidl::new_empty!(
5650                    fidl::encoding::Array<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
5651                    fidl::encoding::DefaultFuchsiaResourceDialect
5652                ),
5653                unions: fidl::new_empty!(fidl::encoding::Array<ThisIsAUnion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5654                nullable_unions: fidl::new_empty!(
5655                    fidl::encoding::Array<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
5656                    fidl::encoding::DefaultFuchsiaResourceDialect
5657                ),
5658                arrays: fidl::new_empty!(
5659                    fidl::encoding::Array<fidl::encoding::Array<u32, 3>, 3>,
5660                    fidl::encoding::DefaultFuchsiaResourceDialect
5661                ),
5662                vectors: fidl::new_empty!(
5663                    fidl::encoding::Array<fidl::encoding::UnboundedVector<u32>, 3>,
5664                    fidl::encoding::DefaultFuchsiaResourceDialect
5665                ),
5666                nullable_vectors: fidl::new_empty!(
5667                    fidl::encoding::Array<
5668                        fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
5669                        3,
5670                    >,
5671                    fidl::encoding::DefaultFuchsiaResourceDialect
5672                ),
5673                tables: fidl::new_empty!(fidl::encoding::Array<ThisIsATable, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5674                xunions: fidl::new_empty!(fidl::encoding::Array<ThisIsAXunion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
5675            }
5676        }
5677
5678        #[inline]
5679        unsafe fn decode(
5680            &mut self,
5681            decoder: &mut fidl::encoding::Decoder<
5682                '_,
5683                fidl::encoding::DefaultFuchsiaResourceDialect,
5684            >,
5685            offset: usize,
5686            _depth: fidl::encoding::Depth,
5687        ) -> fidl::Result<()> {
5688            decoder.debug_check_bounds::<Self>(offset);
5689            // Verify that padding bytes are zero.
5690            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(48) };
5691            let padval = unsafe { (ptr as *const u64).read_unaligned() };
5692            let mask = 0xff000000u64;
5693            let maskedval = padval & mask;
5694            if maskedval != 0 {
5695                return Err(fidl::Error::NonZeroPadding {
5696                    padding_start: offset + 48 + ((mask as u64).trailing_zeros() / 8) as usize,
5697                });
5698            }
5699            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(56) };
5700            let padval = unsafe { (ptr as *const u64).read_unaligned() };
5701            let mask = 0xffff0000u64;
5702            let maskedval = padval & mask;
5703            if maskedval != 0 {
5704                return Err(fidl::Error::NonZeroPadding {
5705                    padding_start: offset + 56 + ((mask as u64).trailing_zeros() / 8) as usize,
5706                });
5707            }
5708            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(104) };
5709            let padval = unsafe { (ptr as *const u64).read_unaligned() };
5710            let mask = 0xffffffff00000000u64;
5711            let maskedval = padval & mask;
5712            if maskedval != 0 {
5713                return Err(fidl::Error::NonZeroPadding {
5714                    padding_start: offset + 104 + ((mask as u64).trailing_zeros() / 8) as usize,
5715                });
5716            }
5717            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(480) };
5718            let padval = unsafe { (ptr as *const u64).read_unaligned() };
5719            let mask = 0xffffffff00000000u64;
5720            let maskedval = padval & mask;
5721            if maskedval != 0 {
5722                return Err(fidl::Error::NonZeroPadding {
5723                    padding_start: offset + 480 + ((mask as u64).trailing_zeros() / 8) as usize,
5724                });
5725            }
5726            fidl::decode!(fidl::encoding::Array<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.bools, decoder, offset + 0, _depth)?;
5727            fidl::decode!(fidl::encoding::Array<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int8s, decoder, offset + 3, _depth)?;
5728            fidl::decode!(fidl::encoding::Array<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int16s, decoder, offset + 6, _depth)?;
5729            fidl::decode!(fidl::encoding::Array<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int32s, decoder, offset + 12, _depth)?;
5730            fidl::decode!(fidl::encoding::Array<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int64s, decoder, offset + 24, _depth)?;
5731            fidl::decode!(fidl::encoding::Array<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint8s, decoder, offset + 48, _depth)?;
5732            fidl::decode!(fidl::encoding::Array<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint16s, decoder, offset + 52, _depth)?;
5733            fidl::decode!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint32s, decoder, offset + 60, _depth)?;
5734            fidl::decode!(fidl::encoding::Array<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint64s, decoder, offset + 72, _depth)?;
5735            fidl::decode!(fidl::encoding::Array<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.float32s, decoder, offset + 96, _depth)?;
5736            fidl::decode!(fidl::encoding::Array<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.float64s, decoder, offset + 112, _depth)?;
5737            fidl::decode!(fidl::encoding::Array<DefaultEnum, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.enums, decoder, offset + 136, _depth)?;
5738            fidl::decode!(fidl::encoding::Array<DefaultBits, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.bits, decoder, offset + 148, _depth)?;
5739            fidl::decode!(
5740                fidl::encoding::Array<
5741                    fidl::encoding::HandleType<
5742                        fidl::Handle,
5743                        { fidl::ObjectType::NONE.into_raw() },
5744                        2147483648,
5745                    >,
5746                    3,
5747                >,
5748                fidl::encoding::DefaultFuchsiaResourceDialect,
5749                &mut self.handles,
5750                decoder,
5751                offset + 160,
5752                _depth
5753            )?;
5754            fidl::decode!(
5755                fidl::encoding::Array<
5756                    fidl::encoding::Optional<
5757                        fidl::encoding::HandleType<
5758                            fidl::Handle,
5759                            { fidl::ObjectType::NONE.into_raw() },
5760                            2147483648,
5761                        >,
5762                    >,
5763                    3,
5764                >,
5765                fidl::encoding::DefaultFuchsiaResourceDialect,
5766                &mut self.nullable_handles,
5767                decoder,
5768                offset + 172,
5769                _depth
5770            )?;
5771            fidl::decode!(fidl::encoding::Array<fidl::encoding::UnboundedString, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.strings, decoder, offset + 184, _depth)?;
5772            fidl::decode!(
5773                fidl::encoding::Array<fidl::encoding::Optional<fidl::encoding::UnboundedString>, 3>,
5774                fidl::encoding::DefaultFuchsiaResourceDialect,
5775                &mut self.nullable_strings,
5776                decoder,
5777                offset + 232,
5778                _depth
5779            )?;
5780            fidl::decode!(fidl::encoding::Array<ThisIsAStruct, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.structs, decoder, offset + 280, _depth)?;
5781            fidl::decode!(
5782                fidl::encoding::Array<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
5783                fidl::encoding::DefaultFuchsiaResourceDialect,
5784                &mut self.nullable_structs,
5785                decoder,
5786                offset + 328,
5787                _depth
5788            )?;
5789            fidl::decode!(fidl::encoding::Array<ThisIsAUnion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.unions, decoder, offset + 352, _depth)?;
5790            fidl::decode!(
5791                fidl::encoding::Array<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
5792                fidl::encoding::DefaultFuchsiaResourceDialect,
5793                &mut self.nullable_unions,
5794                decoder,
5795                offset + 400,
5796                _depth
5797            )?;
5798            fidl::decode!(
5799                fidl::encoding::Array<fidl::encoding::Array<u32, 3>, 3>,
5800                fidl::encoding::DefaultFuchsiaResourceDialect,
5801                &mut self.arrays,
5802                decoder,
5803                offset + 448,
5804                _depth
5805            )?;
5806            fidl::decode!(
5807                fidl::encoding::Array<fidl::encoding::UnboundedVector<u32>, 3>,
5808                fidl::encoding::DefaultFuchsiaResourceDialect,
5809                &mut self.vectors,
5810                decoder,
5811                offset + 488,
5812                _depth
5813            )?;
5814            fidl::decode!(
5815                fidl::encoding::Array<
5816                    fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
5817                    3,
5818                >,
5819                fidl::encoding::DefaultFuchsiaResourceDialect,
5820                &mut self.nullable_vectors,
5821                decoder,
5822                offset + 536,
5823                _depth
5824            )?;
5825            fidl::decode!(fidl::encoding::Array<ThisIsATable, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.tables, decoder, offset + 584, _depth)?;
5826            fidl::decode!(fidl::encoding::Array<ThisIsAXunion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.xunions, decoder, offset + 632, _depth)?;
5827            Ok(())
5828        }
5829    }
5830
5831    impl fidl::encoding::ResourceTypeMarker for EchoEchoArraysRequest {
5832        type Borrowed<'a> = &'a mut Self;
5833        fn take_or_borrow<'a>(
5834            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
5835        ) -> Self::Borrowed<'a> {
5836            value
5837        }
5838    }
5839
5840    unsafe impl fidl::encoding::TypeMarker for EchoEchoArraysRequest {
5841        type Owned = Self;
5842
5843        #[inline(always)]
5844        fn inline_align(_context: fidl::encoding::Context) -> usize {
5845            8
5846        }
5847
5848        #[inline(always)]
5849        fn inline_size(_context: fidl::encoding::Context) -> usize {
5850            696
5851        }
5852    }
5853
5854    unsafe impl
5855        fidl::encoding::Encode<EchoEchoArraysRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
5856        for &mut EchoEchoArraysRequest
5857    {
5858        #[inline]
5859        unsafe fn encode(
5860            self,
5861            encoder: &mut fidl::encoding::Encoder<
5862                '_,
5863                fidl::encoding::DefaultFuchsiaResourceDialect,
5864            >,
5865            offset: usize,
5866            _depth: fidl::encoding::Depth,
5867        ) -> fidl::Result<()> {
5868            encoder.debug_check_bounds::<EchoEchoArraysRequest>(offset);
5869            // Delegate to tuple encoding.
5870            fidl::encoding::Encode::<
5871                EchoEchoArraysRequest,
5872                fidl::encoding::DefaultFuchsiaResourceDialect,
5873            >::encode(
5874                (
5875                    <ArraysStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
5876                        &mut self.value,
5877                    ),
5878                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
5879                        &self.forward_to_server,
5880                    ),
5881                ),
5882                encoder,
5883                offset,
5884                _depth,
5885            )
5886        }
5887    }
5888    unsafe impl<
5889            T0: fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
5890            T1: fidl::encoding::Encode<
5891                fidl::encoding::UnboundedString,
5892                fidl::encoding::DefaultFuchsiaResourceDialect,
5893            >,
5894        >
5895        fidl::encoding::Encode<EchoEchoArraysRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
5896        for (T0, T1)
5897    {
5898        #[inline]
5899        unsafe fn encode(
5900            self,
5901            encoder: &mut fidl::encoding::Encoder<
5902                '_,
5903                fidl::encoding::DefaultFuchsiaResourceDialect,
5904            >,
5905            offset: usize,
5906            depth: fidl::encoding::Depth,
5907        ) -> fidl::Result<()> {
5908            encoder.debug_check_bounds::<EchoEchoArraysRequest>(offset);
5909            // Zero out padding regions. There's no need to apply masks
5910            // because the unmasked parts will be overwritten by fields.
5911            // Write the fields.
5912            self.0.encode(encoder, offset + 0, depth)?;
5913            self.1.encode(encoder, offset + 680, depth)?;
5914            Ok(())
5915        }
5916    }
5917
5918    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
5919        for EchoEchoArraysRequest
5920    {
5921        #[inline(always)]
5922        fn new_empty() -> Self {
5923            Self {
5924                value: fidl::new_empty!(
5925                    ArraysStruct,
5926                    fidl::encoding::DefaultFuchsiaResourceDialect
5927                ),
5928                forward_to_server: fidl::new_empty!(
5929                    fidl::encoding::UnboundedString,
5930                    fidl::encoding::DefaultFuchsiaResourceDialect
5931                ),
5932            }
5933        }
5934
5935        #[inline]
5936        unsafe fn decode(
5937            &mut self,
5938            decoder: &mut fidl::encoding::Decoder<
5939                '_,
5940                fidl::encoding::DefaultFuchsiaResourceDialect,
5941            >,
5942            offset: usize,
5943            _depth: fidl::encoding::Depth,
5944        ) -> fidl::Result<()> {
5945            decoder.debug_check_bounds::<Self>(offset);
5946            // Verify that padding bytes are zero.
5947            fidl::decode!(
5948                ArraysStruct,
5949                fidl::encoding::DefaultFuchsiaResourceDialect,
5950                &mut self.value,
5951                decoder,
5952                offset + 0,
5953                _depth
5954            )?;
5955            fidl::decode!(
5956                fidl::encoding::UnboundedString,
5957                fidl::encoding::DefaultFuchsiaResourceDialect,
5958                &mut self.forward_to_server,
5959                decoder,
5960                offset + 680,
5961                _depth
5962            )?;
5963            Ok(())
5964        }
5965    }
5966
5967    impl fidl::encoding::ResourceTypeMarker for EchoEchoArraysResponse {
5968        type Borrowed<'a> = &'a mut Self;
5969        fn take_or_borrow<'a>(
5970            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
5971        ) -> Self::Borrowed<'a> {
5972            value
5973        }
5974    }
5975
5976    unsafe impl fidl::encoding::TypeMarker for EchoEchoArraysResponse {
5977        type Owned = Self;
5978
5979        #[inline(always)]
5980        fn inline_align(_context: fidl::encoding::Context) -> usize {
5981            8
5982        }
5983
5984        #[inline(always)]
5985        fn inline_size(_context: fidl::encoding::Context) -> usize {
5986            680
5987        }
5988    }
5989
5990    unsafe impl
5991        fidl::encoding::Encode<
5992            EchoEchoArraysResponse,
5993            fidl::encoding::DefaultFuchsiaResourceDialect,
5994        > for &mut EchoEchoArraysResponse
5995    {
5996        #[inline]
5997        unsafe fn encode(
5998            self,
5999            encoder: &mut fidl::encoding::Encoder<
6000                '_,
6001                fidl::encoding::DefaultFuchsiaResourceDialect,
6002            >,
6003            offset: usize,
6004            _depth: fidl::encoding::Depth,
6005        ) -> fidl::Result<()> {
6006            encoder.debug_check_bounds::<EchoEchoArraysResponse>(offset);
6007            // Delegate to tuple encoding.
6008            fidl::encoding::Encode::<
6009                EchoEchoArraysResponse,
6010                fidl::encoding::DefaultFuchsiaResourceDialect,
6011            >::encode(
6012                (<ArraysStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
6013                    &mut self.value,
6014                ),),
6015                encoder,
6016                offset,
6017                _depth,
6018            )
6019        }
6020    }
6021    unsafe impl<
6022            T0: fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
6023        >
6024        fidl::encoding::Encode<
6025            EchoEchoArraysResponse,
6026            fidl::encoding::DefaultFuchsiaResourceDialect,
6027        > for (T0,)
6028    {
6029        #[inline]
6030        unsafe fn encode(
6031            self,
6032            encoder: &mut fidl::encoding::Encoder<
6033                '_,
6034                fidl::encoding::DefaultFuchsiaResourceDialect,
6035            >,
6036            offset: usize,
6037            depth: fidl::encoding::Depth,
6038        ) -> fidl::Result<()> {
6039            encoder.debug_check_bounds::<EchoEchoArraysResponse>(offset);
6040            // Zero out padding regions. There's no need to apply masks
6041            // because the unmasked parts will be overwritten by fields.
6042            // Write the fields.
6043            self.0.encode(encoder, offset + 0, depth)?;
6044            Ok(())
6045        }
6046    }
6047
6048    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6049        for EchoEchoArraysResponse
6050    {
6051        #[inline(always)]
6052        fn new_empty() -> Self {
6053            Self {
6054                value: fidl::new_empty!(
6055                    ArraysStruct,
6056                    fidl::encoding::DefaultFuchsiaResourceDialect
6057                ),
6058            }
6059        }
6060
6061        #[inline]
6062        unsafe fn decode(
6063            &mut self,
6064            decoder: &mut fidl::encoding::Decoder<
6065                '_,
6066                fidl::encoding::DefaultFuchsiaResourceDialect,
6067            >,
6068            offset: usize,
6069            _depth: fidl::encoding::Depth,
6070        ) -> fidl::Result<()> {
6071            decoder.debug_check_bounds::<Self>(offset);
6072            // Verify that padding bytes are zero.
6073            fidl::decode!(
6074                ArraysStruct,
6075                fidl::encoding::DefaultFuchsiaResourceDialect,
6076                &mut self.value,
6077                decoder,
6078                offset + 0,
6079                _depth
6080            )?;
6081            Ok(())
6082        }
6083    }
6084
6085    impl fidl::encoding::ResourceTypeMarker for EchoEchoArraysWithErrorRequest {
6086        type Borrowed<'a> = &'a mut Self;
6087        fn take_or_borrow<'a>(
6088            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6089        ) -> Self::Borrowed<'a> {
6090            value
6091        }
6092    }
6093
6094    unsafe impl fidl::encoding::TypeMarker for EchoEchoArraysWithErrorRequest {
6095        type Owned = Self;
6096
6097        #[inline(always)]
6098        fn inline_align(_context: fidl::encoding::Context) -> usize {
6099            8
6100        }
6101
6102        #[inline(always)]
6103        fn inline_size(_context: fidl::encoding::Context) -> usize {
6104            712
6105        }
6106    }
6107
6108    unsafe impl
6109        fidl::encoding::Encode<
6110            EchoEchoArraysWithErrorRequest,
6111            fidl::encoding::DefaultFuchsiaResourceDialect,
6112        > for &mut EchoEchoArraysWithErrorRequest
6113    {
6114        #[inline]
6115        unsafe fn encode(
6116            self,
6117            encoder: &mut fidl::encoding::Encoder<
6118                '_,
6119                fidl::encoding::DefaultFuchsiaResourceDialect,
6120            >,
6121            offset: usize,
6122            _depth: fidl::encoding::Depth,
6123        ) -> fidl::Result<()> {
6124            encoder.debug_check_bounds::<EchoEchoArraysWithErrorRequest>(offset);
6125            // Delegate to tuple encoding.
6126            fidl::encoding::Encode::<
6127                EchoEchoArraysWithErrorRequest,
6128                fidl::encoding::DefaultFuchsiaResourceDialect,
6129            >::encode(
6130                (
6131                    <ArraysStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
6132                        &mut self.value,
6133                    ),
6134                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
6135                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
6136                        &self.forward_to_server,
6137                    ),
6138                    <RespondWith as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
6139                ),
6140                encoder,
6141                offset,
6142                _depth,
6143            )
6144        }
6145    }
6146    unsafe impl<
6147            T0: fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
6148            T1: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
6149            T2: fidl::encoding::Encode<
6150                fidl::encoding::UnboundedString,
6151                fidl::encoding::DefaultFuchsiaResourceDialect,
6152            >,
6153            T3: fidl::encoding::Encode<RespondWith, fidl::encoding::DefaultFuchsiaResourceDialect>,
6154        >
6155        fidl::encoding::Encode<
6156            EchoEchoArraysWithErrorRequest,
6157            fidl::encoding::DefaultFuchsiaResourceDialect,
6158        > for (T0, T1, T2, T3)
6159    {
6160        #[inline]
6161        unsafe fn encode(
6162            self,
6163            encoder: &mut fidl::encoding::Encoder<
6164                '_,
6165                fidl::encoding::DefaultFuchsiaResourceDialect,
6166            >,
6167            offset: usize,
6168            depth: fidl::encoding::Depth,
6169        ) -> fidl::Result<()> {
6170            encoder.debug_check_bounds::<EchoEchoArraysWithErrorRequest>(offset);
6171            // Zero out padding regions. There's no need to apply masks
6172            // because the unmasked parts will be overwritten by fields.
6173            unsafe {
6174                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(680);
6175                (ptr as *mut u64).write_unaligned(0);
6176            }
6177            unsafe {
6178                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(704);
6179                (ptr as *mut u64).write_unaligned(0);
6180            }
6181            // Write the fields.
6182            self.0.encode(encoder, offset + 0, depth)?;
6183            self.1.encode(encoder, offset + 680, depth)?;
6184            self.2.encode(encoder, offset + 688, depth)?;
6185            self.3.encode(encoder, offset + 704, depth)?;
6186            Ok(())
6187        }
6188    }
6189
6190    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6191        for EchoEchoArraysWithErrorRequest
6192    {
6193        #[inline(always)]
6194        fn new_empty() -> Self {
6195            Self {
6196                value: fidl::new_empty!(
6197                    ArraysStruct,
6198                    fidl::encoding::DefaultFuchsiaResourceDialect
6199                ),
6200                result_err: fidl::new_empty!(
6201                    DefaultEnum,
6202                    fidl::encoding::DefaultFuchsiaResourceDialect
6203                ),
6204                forward_to_server: fidl::new_empty!(
6205                    fidl::encoding::UnboundedString,
6206                    fidl::encoding::DefaultFuchsiaResourceDialect
6207                ),
6208                result_variant: fidl::new_empty!(
6209                    RespondWith,
6210                    fidl::encoding::DefaultFuchsiaResourceDialect
6211                ),
6212            }
6213        }
6214
6215        #[inline]
6216        unsafe fn decode(
6217            &mut self,
6218            decoder: &mut fidl::encoding::Decoder<
6219                '_,
6220                fidl::encoding::DefaultFuchsiaResourceDialect,
6221            >,
6222            offset: usize,
6223            _depth: fidl::encoding::Depth,
6224        ) -> fidl::Result<()> {
6225            decoder.debug_check_bounds::<Self>(offset);
6226            // Verify that padding bytes are zero.
6227            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(680) };
6228            let padval = unsafe { (ptr as *const u64).read_unaligned() };
6229            let mask = 0xffffffff00000000u64;
6230            let maskedval = padval & mask;
6231            if maskedval != 0 {
6232                return Err(fidl::Error::NonZeroPadding {
6233                    padding_start: offset + 680 + ((mask as u64).trailing_zeros() / 8) as usize,
6234                });
6235            }
6236            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(704) };
6237            let padval = unsafe { (ptr as *const u64).read_unaligned() };
6238            let mask = 0xffffffff00000000u64;
6239            let maskedval = padval & mask;
6240            if maskedval != 0 {
6241                return Err(fidl::Error::NonZeroPadding {
6242                    padding_start: offset + 704 + ((mask as u64).trailing_zeros() / 8) as usize,
6243                });
6244            }
6245            fidl::decode!(
6246                ArraysStruct,
6247                fidl::encoding::DefaultFuchsiaResourceDialect,
6248                &mut self.value,
6249                decoder,
6250                offset + 0,
6251                _depth
6252            )?;
6253            fidl::decode!(
6254                DefaultEnum,
6255                fidl::encoding::DefaultFuchsiaResourceDialect,
6256                &mut self.result_err,
6257                decoder,
6258                offset + 680,
6259                _depth
6260            )?;
6261            fidl::decode!(
6262                fidl::encoding::UnboundedString,
6263                fidl::encoding::DefaultFuchsiaResourceDialect,
6264                &mut self.forward_to_server,
6265                decoder,
6266                offset + 688,
6267                _depth
6268            )?;
6269            fidl::decode!(
6270                RespondWith,
6271                fidl::encoding::DefaultFuchsiaResourceDialect,
6272                &mut self.result_variant,
6273                decoder,
6274                offset + 704,
6275                _depth
6276            )?;
6277            Ok(())
6278        }
6279    }
6280
6281    impl fidl::encoding::ResourceTypeMarker for EchoEchoEventRequest {
6282        type Borrowed<'a> = &'a mut Self;
6283        fn take_or_borrow<'a>(
6284            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6285        ) -> Self::Borrowed<'a> {
6286            value
6287        }
6288    }
6289
6290    unsafe impl fidl::encoding::TypeMarker for EchoEchoEventRequest {
6291        type Owned = Self;
6292
6293        #[inline(always)]
6294        fn inline_align(_context: fidl::encoding::Context) -> usize {
6295            8
6296        }
6297
6298        #[inline(always)]
6299        fn inline_size(_context: fidl::encoding::Context) -> usize {
6300            2912
6301        }
6302    }
6303
6304    unsafe impl
6305        fidl::encoding::Encode<EchoEchoEventRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
6306        for &mut EchoEchoEventRequest
6307    {
6308        #[inline]
6309        unsafe fn encode(
6310            self,
6311            encoder: &mut fidl::encoding::Encoder<
6312                '_,
6313                fidl::encoding::DefaultFuchsiaResourceDialect,
6314            >,
6315            offset: usize,
6316            _depth: fidl::encoding::Depth,
6317        ) -> fidl::Result<()> {
6318            encoder.debug_check_bounds::<EchoEchoEventRequest>(offset);
6319            // Delegate to tuple encoding.
6320            fidl::encoding::Encode::<
6321                EchoEchoEventRequest,
6322                fidl::encoding::DefaultFuchsiaResourceDialect,
6323            >::encode(
6324                (<Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),),
6325                encoder,
6326                offset,
6327                _depth,
6328            )
6329        }
6330    }
6331    unsafe impl<T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>>
6332        fidl::encoding::Encode<EchoEchoEventRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
6333        for (T0,)
6334    {
6335        #[inline]
6336        unsafe fn encode(
6337            self,
6338            encoder: &mut fidl::encoding::Encoder<
6339                '_,
6340                fidl::encoding::DefaultFuchsiaResourceDialect,
6341            >,
6342            offset: usize,
6343            depth: fidl::encoding::Depth,
6344        ) -> fidl::Result<()> {
6345            encoder.debug_check_bounds::<EchoEchoEventRequest>(offset);
6346            // Zero out padding regions. There's no need to apply masks
6347            // because the unmasked parts will be overwritten by fields.
6348            // Write the fields.
6349            self.0.encode(encoder, offset + 0, depth)?;
6350            Ok(())
6351        }
6352    }
6353
6354    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6355        for EchoEchoEventRequest
6356    {
6357        #[inline(always)]
6358        fn new_empty() -> Self {
6359            Self { value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect) }
6360        }
6361
6362        #[inline]
6363        unsafe fn decode(
6364            &mut self,
6365            decoder: &mut fidl::encoding::Decoder<
6366                '_,
6367                fidl::encoding::DefaultFuchsiaResourceDialect,
6368            >,
6369            offset: usize,
6370            _depth: fidl::encoding::Depth,
6371        ) -> fidl::Result<()> {
6372            decoder.debug_check_bounds::<Self>(offset);
6373            // Verify that padding bytes are zero.
6374            fidl::decode!(
6375                Struct,
6376                fidl::encoding::DefaultFuchsiaResourceDialect,
6377                &mut self.value,
6378                decoder,
6379                offset + 0,
6380                _depth
6381            )?;
6382            Ok(())
6383        }
6384    }
6385
6386    impl fidl::encoding::ResourceTypeMarker for EchoEchoStructNoRetValRequest {
6387        type Borrowed<'a> = &'a mut Self;
6388        fn take_or_borrow<'a>(
6389            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6390        ) -> Self::Borrowed<'a> {
6391            value
6392        }
6393    }
6394
6395    unsafe impl fidl::encoding::TypeMarker for EchoEchoStructNoRetValRequest {
6396        type Owned = Self;
6397
6398        #[inline(always)]
6399        fn inline_align(_context: fidl::encoding::Context) -> usize {
6400            8
6401        }
6402
6403        #[inline(always)]
6404        fn inline_size(_context: fidl::encoding::Context) -> usize {
6405            2928
6406        }
6407    }
6408
6409    unsafe impl
6410        fidl::encoding::Encode<
6411            EchoEchoStructNoRetValRequest,
6412            fidl::encoding::DefaultFuchsiaResourceDialect,
6413        > for &mut EchoEchoStructNoRetValRequest
6414    {
6415        #[inline]
6416        unsafe fn encode(
6417            self,
6418            encoder: &mut fidl::encoding::Encoder<
6419                '_,
6420                fidl::encoding::DefaultFuchsiaResourceDialect,
6421            >,
6422            offset: usize,
6423            _depth: fidl::encoding::Depth,
6424        ) -> fidl::Result<()> {
6425            encoder.debug_check_bounds::<EchoEchoStructNoRetValRequest>(offset);
6426            // Delegate to tuple encoding.
6427            fidl::encoding::Encode::<
6428                EchoEchoStructNoRetValRequest,
6429                fidl::encoding::DefaultFuchsiaResourceDialect,
6430            >::encode(
6431                (
6432                    <Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
6433                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
6434                        &self.forward_to_server,
6435                    ),
6436                ),
6437                encoder,
6438                offset,
6439                _depth,
6440            )
6441        }
6442    }
6443    unsafe impl<
6444            T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>,
6445            T1: fidl::encoding::Encode<
6446                fidl::encoding::UnboundedString,
6447                fidl::encoding::DefaultFuchsiaResourceDialect,
6448            >,
6449        >
6450        fidl::encoding::Encode<
6451            EchoEchoStructNoRetValRequest,
6452            fidl::encoding::DefaultFuchsiaResourceDialect,
6453        > for (T0, T1)
6454    {
6455        #[inline]
6456        unsafe fn encode(
6457            self,
6458            encoder: &mut fidl::encoding::Encoder<
6459                '_,
6460                fidl::encoding::DefaultFuchsiaResourceDialect,
6461            >,
6462            offset: usize,
6463            depth: fidl::encoding::Depth,
6464        ) -> fidl::Result<()> {
6465            encoder.debug_check_bounds::<EchoEchoStructNoRetValRequest>(offset);
6466            // Zero out padding regions. There's no need to apply masks
6467            // because the unmasked parts will be overwritten by fields.
6468            // Write the fields.
6469            self.0.encode(encoder, offset + 0, depth)?;
6470            self.1.encode(encoder, offset + 2912, depth)?;
6471            Ok(())
6472        }
6473    }
6474
6475    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6476        for EchoEchoStructNoRetValRequest
6477    {
6478        #[inline(always)]
6479        fn new_empty() -> Self {
6480            Self {
6481                value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect),
6482                forward_to_server: fidl::new_empty!(
6483                    fidl::encoding::UnboundedString,
6484                    fidl::encoding::DefaultFuchsiaResourceDialect
6485                ),
6486            }
6487        }
6488
6489        #[inline]
6490        unsafe fn decode(
6491            &mut self,
6492            decoder: &mut fidl::encoding::Decoder<
6493                '_,
6494                fidl::encoding::DefaultFuchsiaResourceDialect,
6495            >,
6496            offset: usize,
6497            _depth: fidl::encoding::Depth,
6498        ) -> fidl::Result<()> {
6499            decoder.debug_check_bounds::<Self>(offset);
6500            // Verify that padding bytes are zero.
6501            fidl::decode!(
6502                Struct,
6503                fidl::encoding::DefaultFuchsiaResourceDialect,
6504                &mut self.value,
6505                decoder,
6506                offset + 0,
6507                _depth
6508            )?;
6509            fidl::decode!(
6510                fidl::encoding::UnboundedString,
6511                fidl::encoding::DefaultFuchsiaResourceDialect,
6512                &mut self.forward_to_server,
6513                decoder,
6514                offset + 2912,
6515                _depth
6516            )?;
6517            Ok(())
6518        }
6519    }
6520
6521    impl fidl::encoding::ResourceTypeMarker for EchoEchoStructRequest {
6522        type Borrowed<'a> = &'a mut Self;
6523        fn take_or_borrow<'a>(
6524            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6525        ) -> Self::Borrowed<'a> {
6526            value
6527        }
6528    }
6529
6530    unsafe impl fidl::encoding::TypeMarker for EchoEchoStructRequest {
6531        type Owned = Self;
6532
6533        #[inline(always)]
6534        fn inline_align(_context: fidl::encoding::Context) -> usize {
6535            8
6536        }
6537
6538        #[inline(always)]
6539        fn inline_size(_context: fidl::encoding::Context) -> usize {
6540            2928
6541        }
6542    }
6543
6544    unsafe impl
6545        fidl::encoding::Encode<EchoEchoStructRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
6546        for &mut EchoEchoStructRequest
6547    {
6548        #[inline]
6549        unsafe fn encode(
6550            self,
6551            encoder: &mut fidl::encoding::Encoder<
6552                '_,
6553                fidl::encoding::DefaultFuchsiaResourceDialect,
6554            >,
6555            offset: usize,
6556            _depth: fidl::encoding::Depth,
6557        ) -> fidl::Result<()> {
6558            encoder.debug_check_bounds::<EchoEchoStructRequest>(offset);
6559            // Delegate to tuple encoding.
6560            fidl::encoding::Encode::<
6561                EchoEchoStructRequest,
6562                fidl::encoding::DefaultFuchsiaResourceDialect,
6563            >::encode(
6564                (
6565                    <Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
6566                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
6567                        &self.forward_to_server,
6568                    ),
6569                ),
6570                encoder,
6571                offset,
6572                _depth,
6573            )
6574        }
6575    }
6576    unsafe impl<
6577            T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>,
6578            T1: fidl::encoding::Encode<
6579                fidl::encoding::UnboundedString,
6580                fidl::encoding::DefaultFuchsiaResourceDialect,
6581            >,
6582        >
6583        fidl::encoding::Encode<EchoEchoStructRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
6584        for (T0, T1)
6585    {
6586        #[inline]
6587        unsafe fn encode(
6588            self,
6589            encoder: &mut fidl::encoding::Encoder<
6590                '_,
6591                fidl::encoding::DefaultFuchsiaResourceDialect,
6592            >,
6593            offset: usize,
6594            depth: fidl::encoding::Depth,
6595        ) -> fidl::Result<()> {
6596            encoder.debug_check_bounds::<EchoEchoStructRequest>(offset);
6597            // Zero out padding regions. There's no need to apply masks
6598            // because the unmasked parts will be overwritten by fields.
6599            // Write the fields.
6600            self.0.encode(encoder, offset + 0, depth)?;
6601            self.1.encode(encoder, offset + 2912, depth)?;
6602            Ok(())
6603        }
6604    }
6605
6606    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6607        for EchoEchoStructRequest
6608    {
6609        #[inline(always)]
6610        fn new_empty() -> Self {
6611            Self {
6612                value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect),
6613                forward_to_server: fidl::new_empty!(
6614                    fidl::encoding::UnboundedString,
6615                    fidl::encoding::DefaultFuchsiaResourceDialect
6616                ),
6617            }
6618        }
6619
6620        #[inline]
6621        unsafe fn decode(
6622            &mut self,
6623            decoder: &mut fidl::encoding::Decoder<
6624                '_,
6625                fidl::encoding::DefaultFuchsiaResourceDialect,
6626            >,
6627            offset: usize,
6628            _depth: fidl::encoding::Depth,
6629        ) -> fidl::Result<()> {
6630            decoder.debug_check_bounds::<Self>(offset);
6631            // Verify that padding bytes are zero.
6632            fidl::decode!(
6633                Struct,
6634                fidl::encoding::DefaultFuchsiaResourceDialect,
6635                &mut self.value,
6636                decoder,
6637                offset + 0,
6638                _depth
6639            )?;
6640            fidl::decode!(
6641                fidl::encoding::UnboundedString,
6642                fidl::encoding::DefaultFuchsiaResourceDialect,
6643                &mut self.forward_to_server,
6644                decoder,
6645                offset + 2912,
6646                _depth
6647            )?;
6648            Ok(())
6649        }
6650    }
6651
6652    impl fidl::encoding::ResourceTypeMarker for EchoEchoStructResponse {
6653        type Borrowed<'a> = &'a mut Self;
6654        fn take_or_borrow<'a>(
6655            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6656        ) -> Self::Borrowed<'a> {
6657            value
6658        }
6659    }
6660
6661    unsafe impl fidl::encoding::TypeMarker for EchoEchoStructResponse {
6662        type Owned = Self;
6663
6664        #[inline(always)]
6665        fn inline_align(_context: fidl::encoding::Context) -> usize {
6666            8
6667        }
6668
6669        #[inline(always)]
6670        fn inline_size(_context: fidl::encoding::Context) -> usize {
6671            2912
6672        }
6673    }
6674
6675    unsafe impl
6676        fidl::encoding::Encode<
6677            EchoEchoStructResponse,
6678            fidl::encoding::DefaultFuchsiaResourceDialect,
6679        > for &mut EchoEchoStructResponse
6680    {
6681        #[inline]
6682        unsafe fn encode(
6683            self,
6684            encoder: &mut fidl::encoding::Encoder<
6685                '_,
6686                fidl::encoding::DefaultFuchsiaResourceDialect,
6687            >,
6688            offset: usize,
6689            _depth: fidl::encoding::Depth,
6690        ) -> fidl::Result<()> {
6691            encoder.debug_check_bounds::<EchoEchoStructResponse>(offset);
6692            // Delegate to tuple encoding.
6693            fidl::encoding::Encode::<
6694                EchoEchoStructResponse,
6695                fidl::encoding::DefaultFuchsiaResourceDialect,
6696            >::encode(
6697                (<Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),),
6698                encoder,
6699                offset,
6700                _depth,
6701            )
6702        }
6703    }
6704    unsafe impl<T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>>
6705        fidl::encoding::Encode<
6706            EchoEchoStructResponse,
6707            fidl::encoding::DefaultFuchsiaResourceDialect,
6708        > for (T0,)
6709    {
6710        #[inline]
6711        unsafe fn encode(
6712            self,
6713            encoder: &mut fidl::encoding::Encoder<
6714                '_,
6715                fidl::encoding::DefaultFuchsiaResourceDialect,
6716            >,
6717            offset: usize,
6718            depth: fidl::encoding::Depth,
6719        ) -> fidl::Result<()> {
6720            encoder.debug_check_bounds::<EchoEchoStructResponse>(offset);
6721            // Zero out padding regions. There's no need to apply masks
6722            // because the unmasked parts will be overwritten by fields.
6723            // Write the fields.
6724            self.0.encode(encoder, offset + 0, depth)?;
6725            Ok(())
6726        }
6727    }
6728
6729    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6730        for EchoEchoStructResponse
6731    {
6732        #[inline(always)]
6733        fn new_empty() -> Self {
6734            Self { value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect) }
6735        }
6736
6737        #[inline]
6738        unsafe fn decode(
6739            &mut self,
6740            decoder: &mut fidl::encoding::Decoder<
6741                '_,
6742                fidl::encoding::DefaultFuchsiaResourceDialect,
6743            >,
6744            offset: usize,
6745            _depth: fidl::encoding::Depth,
6746        ) -> fidl::Result<()> {
6747            decoder.debug_check_bounds::<Self>(offset);
6748            // Verify that padding bytes are zero.
6749            fidl::decode!(
6750                Struct,
6751                fidl::encoding::DefaultFuchsiaResourceDialect,
6752                &mut self.value,
6753                decoder,
6754                offset + 0,
6755                _depth
6756            )?;
6757            Ok(())
6758        }
6759    }
6760
6761    impl fidl::encoding::ResourceTypeMarker for EchoEchoStructWithErrorRequest {
6762        type Borrowed<'a> = &'a mut Self;
6763        fn take_or_borrow<'a>(
6764            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6765        ) -> Self::Borrowed<'a> {
6766            value
6767        }
6768    }
6769
6770    unsafe impl fidl::encoding::TypeMarker for EchoEchoStructWithErrorRequest {
6771        type Owned = Self;
6772
6773        #[inline(always)]
6774        fn inline_align(_context: fidl::encoding::Context) -> usize {
6775            8
6776        }
6777
6778        #[inline(always)]
6779        fn inline_size(_context: fidl::encoding::Context) -> usize {
6780            2944
6781        }
6782    }
6783
6784    unsafe impl
6785        fidl::encoding::Encode<
6786            EchoEchoStructWithErrorRequest,
6787            fidl::encoding::DefaultFuchsiaResourceDialect,
6788        > for &mut EchoEchoStructWithErrorRequest
6789    {
6790        #[inline]
6791        unsafe fn encode(
6792            self,
6793            encoder: &mut fidl::encoding::Encoder<
6794                '_,
6795                fidl::encoding::DefaultFuchsiaResourceDialect,
6796            >,
6797            offset: usize,
6798            _depth: fidl::encoding::Depth,
6799        ) -> fidl::Result<()> {
6800            encoder.debug_check_bounds::<EchoEchoStructWithErrorRequest>(offset);
6801            // Delegate to tuple encoding.
6802            fidl::encoding::Encode::<
6803                EchoEchoStructWithErrorRequest,
6804                fidl::encoding::DefaultFuchsiaResourceDialect,
6805            >::encode(
6806                (
6807                    <Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
6808                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
6809                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
6810                        &self.forward_to_server,
6811                    ),
6812                    <RespondWith as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
6813                ),
6814                encoder,
6815                offset,
6816                _depth,
6817            )
6818        }
6819    }
6820    unsafe impl<
6821            T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>,
6822            T1: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
6823            T2: fidl::encoding::Encode<
6824                fidl::encoding::UnboundedString,
6825                fidl::encoding::DefaultFuchsiaResourceDialect,
6826            >,
6827            T3: fidl::encoding::Encode<RespondWith, fidl::encoding::DefaultFuchsiaResourceDialect>,
6828        >
6829        fidl::encoding::Encode<
6830            EchoEchoStructWithErrorRequest,
6831            fidl::encoding::DefaultFuchsiaResourceDialect,
6832        > for (T0, T1, T2, T3)
6833    {
6834        #[inline]
6835        unsafe fn encode(
6836            self,
6837            encoder: &mut fidl::encoding::Encoder<
6838                '_,
6839                fidl::encoding::DefaultFuchsiaResourceDialect,
6840            >,
6841            offset: usize,
6842            depth: fidl::encoding::Depth,
6843        ) -> fidl::Result<()> {
6844            encoder.debug_check_bounds::<EchoEchoStructWithErrorRequest>(offset);
6845            // Zero out padding regions. There's no need to apply masks
6846            // because the unmasked parts will be overwritten by fields.
6847            unsafe {
6848                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2912);
6849                (ptr as *mut u64).write_unaligned(0);
6850            }
6851            unsafe {
6852                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2936);
6853                (ptr as *mut u64).write_unaligned(0);
6854            }
6855            // Write the fields.
6856            self.0.encode(encoder, offset + 0, depth)?;
6857            self.1.encode(encoder, offset + 2912, depth)?;
6858            self.2.encode(encoder, offset + 2920, depth)?;
6859            self.3.encode(encoder, offset + 2936, depth)?;
6860            Ok(())
6861        }
6862    }
6863
6864    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
6865        for EchoEchoStructWithErrorRequest
6866    {
6867        #[inline(always)]
6868        fn new_empty() -> Self {
6869            Self {
6870                value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect),
6871                result_err: fidl::new_empty!(
6872                    DefaultEnum,
6873                    fidl::encoding::DefaultFuchsiaResourceDialect
6874                ),
6875                forward_to_server: fidl::new_empty!(
6876                    fidl::encoding::UnboundedString,
6877                    fidl::encoding::DefaultFuchsiaResourceDialect
6878                ),
6879                result_variant: fidl::new_empty!(
6880                    RespondWith,
6881                    fidl::encoding::DefaultFuchsiaResourceDialect
6882                ),
6883            }
6884        }
6885
6886        #[inline]
6887        unsafe fn decode(
6888            &mut self,
6889            decoder: &mut fidl::encoding::Decoder<
6890                '_,
6891                fidl::encoding::DefaultFuchsiaResourceDialect,
6892            >,
6893            offset: usize,
6894            _depth: fidl::encoding::Depth,
6895        ) -> fidl::Result<()> {
6896            decoder.debug_check_bounds::<Self>(offset);
6897            // Verify that padding bytes are zero.
6898            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2912) };
6899            let padval = unsafe { (ptr as *const u64).read_unaligned() };
6900            let mask = 0xffffffff00000000u64;
6901            let maskedval = padval & mask;
6902            if maskedval != 0 {
6903                return Err(fidl::Error::NonZeroPadding {
6904                    padding_start: offset + 2912 + ((mask as u64).trailing_zeros() / 8) as usize,
6905                });
6906            }
6907            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2936) };
6908            let padval = unsafe { (ptr as *const u64).read_unaligned() };
6909            let mask = 0xffffffff00000000u64;
6910            let maskedval = padval & mask;
6911            if maskedval != 0 {
6912                return Err(fidl::Error::NonZeroPadding {
6913                    padding_start: offset + 2936 + ((mask as u64).trailing_zeros() / 8) as usize,
6914                });
6915            }
6916            fidl::decode!(
6917                Struct,
6918                fidl::encoding::DefaultFuchsiaResourceDialect,
6919                &mut self.value,
6920                decoder,
6921                offset + 0,
6922                _depth
6923            )?;
6924            fidl::decode!(
6925                DefaultEnum,
6926                fidl::encoding::DefaultFuchsiaResourceDialect,
6927                &mut self.result_err,
6928                decoder,
6929                offset + 2912,
6930                _depth
6931            )?;
6932            fidl::decode!(
6933                fidl::encoding::UnboundedString,
6934                fidl::encoding::DefaultFuchsiaResourceDialect,
6935                &mut self.forward_to_server,
6936                decoder,
6937                offset + 2920,
6938                _depth
6939            )?;
6940            fidl::decode!(
6941                RespondWith,
6942                fidl::encoding::DefaultFuchsiaResourceDialect,
6943                &mut self.result_variant,
6944                decoder,
6945                offset + 2936,
6946                _depth
6947            )?;
6948            Ok(())
6949        }
6950    }
6951
6952    impl fidl::encoding::ResourceTypeMarker for EchoEchoTableRequest {
6953        type Borrowed<'a> = &'a mut Self;
6954        fn take_or_borrow<'a>(
6955            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
6956        ) -> Self::Borrowed<'a> {
6957            value
6958        }
6959    }
6960
6961    unsafe impl fidl::encoding::TypeMarker for EchoEchoTableRequest {
6962        type Owned = Self;
6963
6964        #[inline(always)]
6965        fn inline_align(_context: fidl::encoding::Context) -> usize {
6966            8
6967        }
6968
6969        #[inline(always)]
6970        fn inline_size(_context: fidl::encoding::Context) -> usize {
6971            32
6972        }
6973    }
6974
6975    unsafe impl
6976        fidl::encoding::Encode<EchoEchoTableRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
6977        for &mut EchoEchoTableRequest
6978    {
6979        #[inline]
6980        unsafe fn encode(
6981            self,
6982            encoder: &mut fidl::encoding::Encoder<
6983                '_,
6984                fidl::encoding::DefaultFuchsiaResourceDialect,
6985            >,
6986            offset: usize,
6987            _depth: fidl::encoding::Depth,
6988        ) -> fidl::Result<()> {
6989            encoder.debug_check_bounds::<EchoEchoTableRequest>(offset);
6990            // Delegate to tuple encoding.
6991            fidl::encoding::Encode::<
6992                EchoEchoTableRequest,
6993                fidl::encoding::DefaultFuchsiaResourceDialect,
6994            >::encode(
6995                (
6996                    <AllTypesTable as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
6997                        &mut self.value,
6998                    ),
6999                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
7000                        &self.forward_to_server,
7001                    ),
7002                ),
7003                encoder,
7004                offset,
7005                _depth,
7006            )
7007        }
7008    }
7009    unsafe impl<
7010            T0: fidl::encoding::Encode<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>,
7011            T1: fidl::encoding::Encode<
7012                fidl::encoding::UnboundedString,
7013                fidl::encoding::DefaultFuchsiaResourceDialect,
7014            >,
7015        >
7016        fidl::encoding::Encode<EchoEchoTableRequest, fidl::encoding::DefaultFuchsiaResourceDialect>
7017        for (T0, T1)
7018    {
7019        #[inline]
7020        unsafe fn encode(
7021            self,
7022            encoder: &mut fidl::encoding::Encoder<
7023                '_,
7024                fidl::encoding::DefaultFuchsiaResourceDialect,
7025            >,
7026            offset: usize,
7027            depth: fidl::encoding::Depth,
7028        ) -> fidl::Result<()> {
7029            encoder.debug_check_bounds::<EchoEchoTableRequest>(offset);
7030            // Zero out padding regions. There's no need to apply masks
7031            // because the unmasked parts will be overwritten by fields.
7032            // Write the fields.
7033            self.0.encode(encoder, offset + 0, depth)?;
7034            self.1.encode(encoder, offset + 16, depth)?;
7035            Ok(())
7036        }
7037    }
7038
7039    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7040        for EchoEchoTableRequest
7041    {
7042        #[inline(always)]
7043        fn new_empty() -> Self {
7044            Self {
7045                value: fidl::new_empty!(
7046                    AllTypesTable,
7047                    fidl::encoding::DefaultFuchsiaResourceDialect
7048                ),
7049                forward_to_server: fidl::new_empty!(
7050                    fidl::encoding::UnboundedString,
7051                    fidl::encoding::DefaultFuchsiaResourceDialect
7052                ),
7053            }
7054        }
7055
7056        #[inline]
7057        unsafe fn decode(
7058            &mut self,
7059            decoder: &mut fidl::encoding::Decoder<
7060                '_,
7061                fidl::encoding::DefaultFuchsiaResourceDialect,
7062            >,
7063            offset: usize,
7064            _depth: fidl::encoding::Depth,
7065        ) -> fidl::Result<()> {
7066            decoder.debug_check_bounds::<Self>(offset);
7067            // Verify that padding bytes are zero.
7068            fidl::decode!(
7069                AllTypesTable,
7070                fidl::encoding::DefaultFuchsiaResourceDialect,
7071                &mut self.value,
7072                decoder,
7073                offset + 0,
7074                _depth
7075            )?;
7076            fidl::decode!(
7077                fidl::encoding::UnboundedString,
7078                fidl::encoding::DefaultFuchsiaResourceDialect,
7079                &mut self.forward_to_server,
7080                decoder,
7081                offset + 16,
7082                _depth
7083            )?;
7084            Ok(())
7085        }
7086    }
7087
7088    impl fidl::encoding::ResourceTypeMarker for EchoEchoTableResponse {
7089        type Borrowed<'a> = &'a mut Self;
7090        fn take_or_borrow<'a>(
7091            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7092        ) -> Self::Borrowed<'a> {
7093            value
7094        }
7095    }
7096
7097    unsafe impl fidl::encoding::TypeMarker for EchoEchoTableResponse {
7098        type Owned = Self;
7099
7100        #[inline(always)]
7101        fn inline_align(_context: fidl::encoding::Context) -> usize {
7102            8
7103        }
7104
7105        #[inline(always)]
7106        fn inline_size(_context: fidl::encoding::Context) -> usize {
7107            16
7108        }
7109    }
7110
7111    unsafe impl
7112        fidl::encoding::Encode<EchoEchoTableResponse, fidl::encoding::DefaultFuchsiaResourceDialect>
7113        for &mut EchoEchoTableResponse
7114    {
7115        #[inline]
7116        unsafe fn encode(
7117            self,
7118            encoder: &mut fidl::encoding::Encoder<
7119                '_,
7120                fidl::encoding::DefaultFuchsiaResourceDialect,
7121            >,
7122            offset: usize,
7123            _depth: fidl::encoding::Depth,
7124        ) -> fidl::Result<()> {
7125            encoder.debug_check_bounds::<EchoEchoTableResponse>(offset);
7126            // Delegate to tuple encoding.
7127            fidl::encoding::Encode::<
7128                EchoEchoTableResponse,
7129                fidl::encoding::DefaultFuchsiaResourceDialect,
7130            >::encode(
7131                (<AllTypesTable as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7132                    &mut self.value,
7133                ),),
7134                encoder,
7135                offset,
7136                _depth,
7137            )
7138        }
7139    }
7140    unsafe impl<
7141            T0: fidl::encoding::Encode<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>,
7142        >
7143        fidl::encoding::Encode<EchoEchoTableResponse, fidl::encoding::DefaultFuchsiaResourceDialect>
7144        for (T0,)
7145    {
7146        #[inline]
7147        unsafe fn encode(
7148            self,
7149            encoder: &mut fidl::encoding::Encoder<
7150                '_,
7151                fidl::encoding::DefaultFuchsiaResourceDialect,
7152            >,
7153            offset: usize,
7154            depth: fidl::encoding::Depth,
7155        ) -> fidl::Result<()> {
7156            encoder.debug_check_bounds::<EchoEchoTableResponse>(offset);
7157            // Zero out padding regions. There's no need to apply masks
7158            // because the unmasked parts will be overwritten by fields.
7159            // Write the fields.
7160            self.0.encode(encoder, offset + 0, depth)?;
7161            Ok(())
7162        }
7163    }
7164
7165    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7166        for EchoEchoTableResponse
7167    {
7168        #[inline(always)]
7169        fn new_empty() -> Self {
7170            Self {
7171                value: fidl::new_empty!(
7172                    AllTypesTable,
7173                    fidl::encoding::DefaultFuchsiaResourceDialect
7174                ),
7175            }
7176        }
7177
7178        #[inline]
7179        unsafe fn decode(
7180            &mut self,
7181            decoder: &mut fidl::encoding::Decoder<
7182                '_,
7183                fidl::encoding::DefaultFuchsiaResourceDialect,
7184            >,
7185            offset: usize,
7186            _depth: fidl::encoding::Depth,
7187        ) -> fidl::Result<()> {
7188            decoder.debug_check_bounds::<Self>(offset);
7189            // Verify that padding bytes are zero.
7190            fidl::decode!(
7191                AllTypesTable,
7192                fidl::encoding::DefaultFuchsiaResourceDialect,
7193                &mut self.value,
7194                decoder,
7195                offset + 0,
7196                _depth
7197            )?;
7198            Ok(())
7199        }
7200    }
7201
7202    impl fidl::encoding::ResourceTypeMarker for EchoEchoTableWithErrorRequest {
7203        type Borrowed<'a> = &'a mut Self;
7204        fn take_or_borrow<'a>(
7205            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7206        ) -> Self::Borrowed<'a> {
7207            value
7208        }
7209    }
7210
7211    unsafe impl fidl::encoding::TypeMarker for EchoEchoTableWithErrorRequest {
7212        type Owned = Self;
7213
7214        #[inline(always)]
7215        fn inline_align(_context: fidl::encoding::Context) -> usize {
7216            8
7217        }
7218
7219        #[inline(always)]
7220        fn inline_size(_context: fidl::encoding::Context) -> usize {
7221            48
7222        }
7223    }
7224
7225    unsafe impl
7226        fidl::encoding::Encode<
7227            EchoEchoTableWithErrorRequest,
7228            fidl::encoding::DefaultFuchsiaResourceDialect,
7229        > for &mut EchoEchoTableWithErrorRequest
7230    {
7231        #[inline]
7232        unsafe fn encode(
7233            self,
7234            encoder: &mut fidl::encoding::Encoder<
7235                '_,
7236                fidl::encoding::DefaultFuchsiaResourceDialect,
7237            >,
7238            offset: usize,
7239            _depth: fidl::encoding::Depth,
7240        ) -> fidl::Result<()> {
7241            encoder.debug_check_bounds::<EchoEchoTableWithErrorRequest>(offset);
7242            // Delegate to tuple encoding.
7243            fidl::encoding::Encode::<
7244                EchoEchoTableWithErrorRequest,
7245                fidl::encoding::DefaultFuchsiaResourceDialect,
7246            >::encode(
7247                (
7248                    <AllTypesTable as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7249                        &mut self.value,
7250                    ),
7251                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
7252                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
7253                        &self.forward_to_server,
7254                    ),
7255                    <RespondWith as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
7256                ),
7257                encoder,
7258                offset,
7259                _depth,
7260            )
7261        }
7262    }
7263    unsafe impl<
7264            T0: fidl::encoding::Encode<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>,
7265            T1: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
7266            T2: fidl::encoding::Encode<
7267                fidl::encoding::UnboundedString,
7268                fidl::encoding::DefaultFuchsiaResourceDialect,
7269            >,
7270            T3: fidl::encoding::Encode<RespondWith, fidl::encoding::DefaultFuchsiaResourceDialect>,
7271        >
7272        fidl::encoding::Encode<
7273            EchoEchoTableWithErrorRequest,
7274            fidl::encoding::DefaultFuchsiaResourceDialect,
7275        > for (T0, T1, T2, T3)
7276    {
7277        #[inline]
7278        unsafe fn encode(
7279            self,
7280            encoder: &mut fidl::encoding::Encoder<
7281                '_,
7282                fidl::encoding::DefaultFuchsiaResourceDialect,
7283            >,
7284            offset: usize,
7285            depth: fidl::encoding::Depth,
7286        ) -> fidl::Result<()> {
7287            encoder.debug_check_bounds::<EchoEchoTableWithErrorRequest>(offset);
7288            // Zero out padding regions. There's no need to apply masks
7289            // because the unmasked parts will be overwritten by fields.
7290            unsafe {
7291                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
7292                (ptr as *mut u64).write_unaligned(0);
7293            }
7294            unsafe {
7295                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
7296                (ptr as *mut u64).write_unaligned(0);
7297            }
7298            // Write the fields.
7299            self.0.encode(encoder, offset + 0, depth)?;
7300            self.1.encode(encoder, offset + 16, depth)?;
7301            self.2.encode(encoder, offset + 24, depth)?;
7302            self.3.encode(encoder, offset + 40, depth)?;
7303            Ok(())
7304        }
7305    }
7306
7307    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7308        for EchoEchoTableWithErrorRequest
7309    {
7310        #[inline(always)]
7311        fn new_empty() -> Self {
7312            Self {
7313                value: fidl::new_empty!(
7314                    AllTypesTable,
7315                    fidl::encoding::DefaultFuchsiaResourceDialect
7316                ),
7317                result_err: fidl::new_empty!(
7318                    DefaultEnum,
7319                    fidl::encoding::DefaultFuchsiaResourceDialect
7320                ),
7321                forward_to_server: fidl::new_empty!(
7322                    fidl::encoding::UnboundedString,
7323                    fidl::encoding::DefaultFuchsiaResourceDialect
7324                ),
7325                result_variant: fidl::new_empty!(
7326                    RespondWith,
7327                    fidl::encoding::DefaultFuchsiaResourceDialect
7328                ),
7329            }
7330        }
7331
7332        #[inline]
7333        unsafe fn decode(
7334            &mut self,
7335            decoder: &mut fidl::encoding::Decoder<
7336                '_,
7337                fidl::encoding::DefaultFuchsiaResourceDialect,
7338            >,
7339            offset: usize,
7340            _depth: fidl::encoding::Depth,
7341        ) -> fidl::Result<()> {
7342            decoder.debug_check_bounds::<Self>(offset);
7343            // Verify that padding bytes are zero.
7344            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
7345            let padval = unsafe { (ptr as *const u64).read_unaligned() };
7346            let mask = 0xffffffff00000000u64;
7347            let maskedval = padval & mask;
7348            if maskedval != 0 {
7349                return Err(fidl::Error::NonZeroPadding {
7350                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
7351                });
7352            }
7353            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
7354            let padval = unsafe { (ptr as *const u64).read_unaligned() };
7355            let mask = 0xffffffff00000000u64;
7356            let maskedval = padval & mask;
7357            if maskedval != 0 {
7358                return Err(fidl::Error::NonZeroPadding {
7359                    padding_start: offset + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
7360                });
7361            }
7362            fidl::decode!(
7363                AllTypesTable,
7364                fidl::encoding::DefaultFuchsiaResourceDialect,
7365                &mut self.value,
7366                decoder,
7367                offset + 0,
7368                _depth
7369            )?;
7370            fidl::decode!(
7371                DefaultEnum,
7372                fidl::encoding::DefaultFuchsiaResourceDialect,
7373                &mut self.result_err,
7374                decoder,
7375                offset + 16,
7376                _depth
7377            )?;
7378            fidl::decode!(
7379                fidl::encoding::UnboundedString,
7380                fidl::encoding::DefaultFuchsiaResourceDialect,
7381                &mut self.forward_to_server,
7382                decoder,
7383                offset + 24,
7384                _depth
7385            )?;
7386            fidl::decode!(
7387                RespondWith,
7388                fidl::encoding::DefaultFuchsiaResourceDialect,
7389                &mut self.result_variant,
7390                decoder,
7391                offset + 40,
7392                _depth
7393            )?;
7394            Ok(())
7395        }
7396    }
7397
7398    impl fidl::encoding::ResourceTypeMarker for EchoEchoVectorsRequest {
7399        type Borrowed<'a> = &'a mut Self;
7400        fn take_or_borrow<'a>(
7401            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7402        ) -> Self::Borrowed<'a> {
7403            value
7404        }
7405    }
7406
7407    unsafe impl fidl::encoding::TypeMarker for EchoEchoVectorsRequest {
7408        type Owned = Self;
7409
7410        #[inline(always)]
7411        fn inline_align(_context: fidl::encoding::Context) -> usize {
7412            8
7413        }
7414
7415        #[inline(always)]
7416        fn inline_size(_context: fidl::encoding::Context) -> usize {
7417            432
7418        }
7419    }
7420
7421    unsafe impl
7422        fidl::encoding::Encode<
7423            EchoEchoVectorsRequest,
7424            fidl::encoding::DefaultFuchsiaResourceDialect,
7425        > for &mut EchoEchoVectorsRequest
7426    {
7427        #[inline]
7428        unsafe fn encode(
7429            self,
7430            encoder: &mut fidl::encoding::Encoder<
7431                '_,
7432                fidl::encoding::DefaultFuchsiaResourceDialect,
7433            >,
7434            offset: usize,
7435            _depth: fidl::encoding::Depth,
7436        ) -> fidl::Result<()> {
7437            encoder.debug_check_bounds::<EchoEchoVectorsRequest>(offset);
7438            // Delegate to tuple encoding.
7439            fidl::encoding::Encode::<
7440                EchoEchoVectorsRequest,
7441                fidl::encoding::DefaultFuchsiaResourceDialect,
7442            >::encode(
7443                (
7444                    <VectorsStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7445                        &mut self.value,
7446                    ),
7447                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
7448                        &self.forward_to_server,
7449                    ),
7450                ),
7451                encoder,
7452                offset,
7453                _depth,
7454            )
7455        }
7456    }
7457    unsafe impl<
7458            T0: fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
7459            T1: fidl::encoding::Encode<
7460                fidl::encoding::UnboundedString,
7461                fidl::encoding::DefaultFuchsiaResourceDialect,
7462            >,
7463        >
7464        fidl::encoding::Encode<
7465            EchoEchoVectorsRequest,
7466            fidl::encoding::DefaultFuchsiaResourceDialect,
7467        > for (T0, T1)
7468    {
7469        #[inline]
7470        unsafe fn encode(
7471            self,
7472            encoder: &mut fidl::encoding::Encoder<
7473                '_,
7474                fidl::encoding::DefaultFuchsiaResourceDialect,
7475            >,
7476            offset: usize,
7477            depth: fidl::encoding::Depth,
7478        ) -> fidl::Result<()> {
7479            encoder.debug_check_bounds::<EchoEchoVectorsRequest>(offset);
7480            // Zero out padding regions. There's no need to apply masks
7481            // because the unmasked parts will be overwritten by fields.
7482            // Write the fields.
7483            self.0.encode(encoder, offset + 0, depth)?;
7484            self.1.encode(encoder, offset + 416, depth)?;
7485            Ok(())
7486        }
7487    }
7488
7489    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7490        for EchoEchoVectorsRequest
7491    {
7492        #[inline(always)]
7493        fn new_empty() -> Self {
7494            Self {
7495                value: fidl::new_empty!(
7496                    VectorsStruct,
7497                    fidl::encoding::DefaultFuchsiaResourceDialect
7498                ),
7499                forward_to_server: fidl::new_empty!(
7500                    fidl::encoding::UnboundedString,
7501                    fidl::encoding::DefaultFuchsiaResourceDialect
7502                ),
7503            }
7504        }
7505
7506        #[inline]
7507        unsafe fn decode(
7508            &mut self,
7509            decoder: &mut fidl::encoding::Decoder<
7510                '_,
7511                fidl::encoding::DefaultFuchsiaResourceDialect,
7512            >,
7513            offset: usize,
7514            _depth: fidl::encoding::Depth,
7515        ) -> fidl::Result<()> {
7516            decoder.debug_check_bounds::<Self>(offset);
7517            // Verify that padding bytes are zero.
7518            fidl::decode!(
7519                VectorsStruct,
7520                fidl::encoding::DefaultFuchsiaResourceDialect,
7521                &mut self.value,
7522                decoder,
7523                offset + 0,
7524                _depth
7525            )?;
7526            fidl::decode!(
7527                fidl::encoding::UnboundedString,
7528                fidl::encoding::DefaultFuchsiaResourceDialect,
7529                &mut self.forward_to_server,
7530                decoder,
7531                offset + 416,
7532                _depth
7533            )?;
7534            Ok(())
7535        }
7536    }
7537
7538    impl fidl::encoding::ResourceTypeMarker for EchoEchoVectorsResponse {
7539        type Borrowed<'a> = &'a mut Self;
7540        fn take_or_borrow<'a>(
7541            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7542        ) -> Self::Borrowed<'a> {
7543            value
7544        }
7545    }
7546
7547    unsafe impl fidl::encoding::TypeMarker for EchoEchoVectorsResponse {
7548        type Owned = Self;
7549
7550        #[inline(always)]
7551        fn inline_align(_context: fidl::encoding::Context) -> usize {
7552            8
7553        }
7554
7555        #[inline(always)]
7556        fn inline_size(_context: fidl::encoding::Context) -> usize {
7557            416
7558        }
7559    }
7560
7561    unsafe impl
7562        fidl::encoding::Encode<
7563            EchoEchoVectorsResponse,
7564            fidl::encoding::DefaultFuchsiaResourceDialect,
7565        > for &mut EchoEchoVectorsResponse
7566    {
7567        #[inline]
7568        unsafe fn encode(
7569            self,
7570            encoder: &mut fidl::encoding::Encoder<
7571                '_,
7572                fidl::encoding::DefaultFuchsiaResourceDialect,
7573            >,
7574            offset: usize,
7575            _depth: fidl::encoding::Depth,
7576        ) -> fidl::Result<()> {
7577            encoder.debug_check_bounds::<EchoEchoVectorsResponse>(offset);
7578            // Delegate to tuple encoding.
7579            fidl::encoding::Encode::<
7580                EchoEchoVectorsResponse,
7581                fidl::encoding::DefaultFuchsiaResourceDialect,
7582            >::encode(
7583                (<VectorsStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7584                    &mut self.value,
7585                ),),
7586                encoder,
7587                offset,
7588                _depth,
7589            )
7590        }
7591    }
7592    unsafe impl<
7593            T0: fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
7594        >
7595        fidl::encoding::Encode<
7596            EchoEchoVectorsResponse,
7597            fidl::encoding::DefaultFuchsiaResourceDialect,
7598        > for (T0,)
7599    {
7600        #[inline]
7601        unsafe fn encode(
7602            self,
7603            encoder: &mut fidl::encoding::Encoder<
7604                '_,
7605                fidl::encoding::DefaultFuchsiaResourceDialect,
7606            >,
7607            offset: usize,
7608            depth: fidl::encoding::Depth,
7609        ) -> fidl::Result<()> {
7610            encoder.debug_check_bounds::<EchoEchoVectorsResponse>(offset);
7611            // Zero out padding regions. There's no need to apply masks
7612            // because the unmasked parts will be overwritten by fields.
7613            // Write the fields.
7614            self.0.encode(encoder, offset + 0, depth)?;
7615            Ok(())
7616        }
7617    }
7618
7619    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7620        for EchoEchoVectorsResponse
7621    {
7622        #[inline(always)]
7623        fn new_empty() -> Self {
7624            Self {
7625                value: fidl::new_empty!(
7626                    VectorsStruct,
7627                    fidl::encoding::DefaultFuchsiaResourceDialect
7628                ),
7629            }
7630        }
7631
7632        #[inline]
7633        unsafe fn decode(
7634            &mut self,
7635            decoder: &mut fidl::encoding::Decoder<
7636                '_,
7637                fidl::encoding::DefaultFuchsiaResourceDialect,
7638            >,
7639            offset: usize,
7640            _depth: fidl::encoding::Depth,
7641        ) -> fidl::Result<()> {
7642            decoder.debug_check_bounds::<Self>(offset);
7643            // Verify that padding bytes are zero.
7644            fidl::decode!(
7645                VectorsStruct,
7646                fidl::encoding::DefaultFuchsiaResourceDialect,
7647                &mut self.value,
7648                decoder,
7649                offset + 0,
7650                _depth
7651            )?;
7652            Ok(())
7653        }
7654    }
7655
7656    impl fidl::encoding::ResourceTypeMarker for EchoEchoVectorsWithErrorRequest {
7657        type Borrowed<'a> = &'a mut Self;
7658        fn take_or_borrow<'a>(
7659            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7660        ) -> Self::Borrowed<'a> {
7661            value
7662        }
7663    }
7664
7665    unsafe impl fidl::encoding::TypeMarker for EchoEchoVectorsWithErrorRequest {
7666        type Owned = Self;
7667
7668        #[inline(always)]
7669        fn inline_align(_context: fidl::encoding::Context) -> usize {
7670            8
7671        }
7672
7673        #[inline(always)]
7674        fn inline_size(_context: fidl::encoding::Context) -> usize {
7675            448
7676        }
7677    }
7678
7679    unsafe impl
7680        fidl::encoding::Encode<
7681            EchoEchoVectorsWithErrorRequest,
7682            fidl::encoding::DefaultFuchsiaResourceDialect,
7683        > for &mut EchoEchoVectorsWithErrorRequest
7684    {
7685        #[inline]
7686        unsafe fn encode(
7687            self,
7688            encoder: &mut fidl::encoding::Encoder<
7689                '_,
7690                fidl::encoding::DefaultFuchsiaResourceDialect,
7691            >,
7692            offset: usize,
7693            _depth: fidl::encoding::Depth,
7694        ) -> fidl::Result<()> {
7695            encoder.debug_check_bounds::<EchoEchoVectorsWithErrorRequest>(offset);
7696            // Delegate to tuple encoding.
7697            fidl::encoding::Encode::<
7698                EchoEchoVectorsWithErrorRequest,
7699                fidl::encoding::DefaultFuchsiaResourceDialect,
7700            >::encode(
7701                (
7702                    <VectorsStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
7703                        &mut self.value,
7704                    ),
7705                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
7706                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
7707                        &self.forward_to_server,
7708                    ),
7709                    <RespondWith as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
7710                ),
7711                encoder,
7712                offset,
7713                _depth,
7714            )
7715        }
7716    }
7717    unsafe impl<
7718            T0: fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
7719            T1: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
7720            T2: fidl::encoding::Encode<
7721                fidl::encoding::UnboundedString,
7722                fidl::encoding::DefaultFuchsiaResourceDialect,
7723            >,
7724            T3: fidl::encoding::Encode<RespondWith, fidl::encoding::DefaultFuchsiaResourceDialect>,
7725        >
7726        fidl::encoding::Encode<
7727            EchoEchoVectorsWithErrorRequest,
7728            fidl::encoding::DefaultFuchsiaResourceDialect,
7729        > for (T0, T1, T2, T3)
7730    {
7731        #[inline]
7732        unsafe fn encode(
7733            self,
7734            encoder: &mut fidl::encoding::Encoder<
7735                '_,
7736                fidl::encoding::DefaultFuchsiaResourceDialect,
7737            >,
7738            offset: usize,
7739            depth: fidl::encoding::Depth,
7740        ) -> fidl::Result<()> {
7741            encoder.debug_check_bounds::<EchoEchoVectorsWithErrorRequest>(offset);
7742            // Zero out padding regions. There's no need to apply masks
7743            // because the unmasked parts will be overwritten by fields.
7744            unsafe {
7745                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(416);
7746                (ptr as *mut u64).write_unaligned(0);
7747            }
7748            unsafe {
7749                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(440);
7750                (ptr as *mut u64).write_unaligned(0);
7751            }
7752            // Write the fields.
7753            self.0.encode(encoder, offset + 0, depth)?;
7754            self.1.encode(encoder, offset + 416, depth)?;
7755            self.2.encode(encoder, offset + 424, depth)?;
7756            self.3.encode(encoder, offset + 440, depth)?;
7757            Ok(())
7758        }
7759    }
7760
7761    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7762        for EchoEchoVectorsWithErrorRequest
7763    {
7764        #[inline(always)]
7765        fn new_empty() -> Self {
7766            Self {
7767                value: fidl::new_empty!(
7768                    VectorsStruct,
7769                    fidl::encoding::DefaultFuchsiaResourceDialect
7770                ),
7771                result_err: fidl::new_empty!(
7772                    DefaultEnum,
7773                    fidl::encoding::DefaultFuchsiaResourceDialect
7774                ),
7775                forward_to_server: fidl::new_empty!(
7776                    fidl::encoding::UnboundedString,
7777                    fidl::encoding::DefaultFuchsiaResourceDialect
7778                ),
7779                result_variant: fidl::new_empty!(
7780                    RespondWith,
7781                    fidl::encoding::DefaultFuchsiaResourceDialect
7782                ),
7783            }
7784        }
7785
7786        #[inline]
7787        unsafe fn decode(
7788            &mut self,
7789            decoder: &mut fidl::encoding::Decoder<
7790                '_,
7791                fidl::encoding::DefaultFuchsiaResourceDialect,
7792            >,
7793            offset: usize,
7794            _depth: fidl::encoding::Depth,
7795        ) -> fidl::Result<()> {
7796            decoder.debug_check_bounds::<Self>(offset);
7797            // Verify that padding bytes are zero.
7798            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(416) };
7799            let padval = unsafe { (ptr as *const u64).read_unaligned() };
7800            let mask = 0xffffffff00000000u64;
7801            let maskedval = padval & mask;
7802            if maskedval != 0 {
7803                return Err(fidl::Error::NonZeroPadding {
7804                    padding_start: offset + 416 + ((mask as u64).trailing_zeros() / 8) as usize,
7805                });
7806            }
7807            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(440) };
7808            let padval = unsafe { (ptr as *const u64).read_unaligned() };
7809            let mask = 0xffffffff00000000u64;
7810            let maskedval = padval & mask;
7811            if maskedval != 0 {
7812                return Err(fidl::Error::NonZeroPadding {
7813                    padding_start: offset + 440 + ((mask as u64).trailing_zeros() / 8) as usize,
7814                });
7815            }
7816            fidl::decode!(
7817                VectorsStruct,
7818                fidl::encoding::DefaultFuchsiaResourceDialect,
7819                &mut self.value,
7820                decoder,
7821                offset + 0,
7822                _depth
7823            )?;
7824            fidl::decode!(
7825                DefaultEnum,
7826                fidl::encoding::DefaultFuchsiaResourceDialect,
7827                &mut self.result_err,
7828                decoder,
7829                offset + 416,
7830                _depth
7831            )?;
7832            fidl::decode!(
7833                fidl::encoding::UnboundedString,
7834                fidl::encoding::DefaultFuchsiaResourceDialect,
7835                &mut self.forward_to_server,
7836                decoder,
7837                offset + 424,
7838                _depth
7839            )?;
7840            fidl::decode!(
7841                RespondWith,
7842                fidl::encoding::DefaultFuchsiaResourceDialect,
7843                &mut self.result_variant,
7844                decoder,
7845                offset + 440,
7846                _depth
7847            )?;
7848            Ok(())
7849        }
7850    }
7851
7852    impl fidl::encoding::ResourceTypeMarker for EchoEchoXunionsRequest {
7853        type Borrowed<'a> = &'a mut Self;
7854        fn take_or_borrow<'a>(
7855            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7856        ) -> Self::Borrowed<'a> {
7857            value
7858        }
7859    }
7860
7861    unsafe impl fidl::encoding::TypeMarker for EchoEchoXunionsRequest {
7862        type Owned = Self;
7863
7864        #[inline(always)]
7865        fn inline_align(_context: fidl::encoding::Context) -> usize {
7866            8
7867        }
7868
7869        #[inline(always)]
7870        fn inline_size(_context: fidl::encoding::Context) -> usize {
7871            32
7872        }
7873    }
7874
7875    unsafe impl
7876        fidl::encoding::Encode<
7877            EchoEchoXunionsRequest,
7878            fidl::encoding::DefaultFuchsiaResourceDialect,
7879        > for &mut EchoEchoXunionsRequest
7880    {
7881        #[inline]
7882        unsafe fn encode(
7883            self,
7884            encoder: &mut fidl::encoding::Encoder<
7885                '_,
7886                fidl::encoding::DefaultFuchsiaResourceDialect,
7887            >,
7888            offset: usize,
7889            _depth: fidl::encoding::Depth,
7890        ) -> fidl::Result<()> {
7891            encoder.debug_check_bounds::<EchoEchoXunionsRequest>(offset);
7892            // Delegate to tuple encoding.
7893            fidl::encoding::Encode::<EchoEchoXunionsRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
7894                (
7895                    <fidl::encoding::UnboundedVector<AllTypesXunion> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
7896                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(&self.forward_to_server),
7897                ),
7898                encoder, offset, _depth
7899            )
7900        }
7901    }
7902    unsafe impl<
7903            T0: fidl::encoding::Encode<
7904                fidl::encoding::UnboundedVector<AllTypesXunion>,
7905                fidl::encoding::DefaultFuchsiaResourceDialect,
7906            >,
7907            T1: fidl::encoding::Encode<
7908                fidl::encoding::UnboundedString,
7909                fidl::encoding::DefaultFuchsiaResourceDialect,
7910            >,
7911        >
7912        fidl::encoding::Encode<
7913            EchoEchoXunionsRequest,
7914            fidl::encoding::DefaultFuchsiaResourceDialect,
7915        > for (T0, T1)
7916    {
7917        #[inline]
7918        unsafe fn encode(
7919            self,
7920            encoder: &mut fidl::encoding::Encoder<
7921                '_,
7922                fidl::encoding::DefaultFuchsiaResourceDialect,
7923            >,
7924            offset: usize,
7925            depth: fidl::encoding::Depth,
7926        ) -> fidl::Result<()> {
7927            encoder.debug_check_bounds::<EchoEchoXunionsRequest>(offset);
7928            // Zero out padding regions. There's no need to apply masks
7929            // because the unmasked parts will be overwritten by fields.
7930            // Write the fields.
7931            self.0.encode(encoder, offset + 0, depth)?;
7932            self.1.encode(encoder, offset + 16, depth)?;
7933            Ok(())
7934        }
7935    }
7936
7937    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
7938        for EchoEchoXunionsRequest
7939    {
7940        #[inline(always)]
7941        fn new_empty() -> Self {
7942            Self {
7943                value: fidl::new_empty!(
7944                    fidl::encoding::UnboundedVector<AllTypesXunion>,
7945                    fidl::encoding::DefaultFuchsiaResourceDialect
7946                ),
7947                forward_to_server: fidl::new_empty!(
7948                    fidl::encoding::UnboundedString,
7949                    fidl::encoding::DefaultFuchsiaResourceDialect
7950                ),
7951            }
7952        }
7953
7954        #[inline]
7955        unsafe fn decode(
7956            &mut self,
7957            decoder: &mut fidl::encoding::Decoder<
7958                '_,
7959                fidl::encoding::DefaultFuchsiaResourceDialect,
7960            >,
7961            offset: usize,
7962            _depth: fidl::encoding::Depth,
7963        ) -> fidl::Result<()> {
7964            decoder.debug_check_bounds::<Self>(offset);
7965            // Verify that padding bytes are zero.
7966            fidl::decode!(
7967                fidl::encoding::UnboundedVector<AllTypesXunion>,
7968                fidl::encoding::DefaultFuchsiaResourceDialect,
7969                &mut self.value,
7970                decoder,
7971                offset + 0,
7972                _depth
7973            )?;
7974            fidl::decode!(
7975                fidl::encoding::UnboundedString,
7976                fidl::encoding::DefaultFuchsiaResourceDialect,
7977                &mut self.forward_to_server,
7978                decoder,
7979                offset + 16,
7980                _depth
7981            )?;
7982            Ok(())
7983        }
7984    }
7985
7986    impl fidl::encoding::ResourceTypeMarker for EchoEchoXunionsResponse {
7987        type Borrowed<'a> = &'a mut Self;
7988        fn take_or_borrow<'a>(
7989            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
7990        ) -> Self::Borrowed<'a> {
7991            value
7992        }
7993    }
7994
7995    unsafe impl fidl::encoding::TypeMarker for EchoEchoXunionsResponse {
7996        type Owned = Self;
7997
7998        #[inline(always)]
7999        fn inline_align(_context: fidl::encoding::Context) -> usize {
8000            8
8001        }
8002
8003        #[inline(always)]
8004        fn inline_size(_context: fidl::encoding::Context) -> usize {
8005            16
8006        }
8007    }
8008
8009    unsafe impl
8010        fidl::encoding::Encode<
8011            EchoEchoXunionsResponse,
8012            fidl::encoding::DefaultFuchsiaResourceDialect,
8013        > for &mut EchoEchoXunionsResponse
8014    {
8015        #[inline]
8016        unsafe fn encode(
8017            self,
8018            encoder: &mut fidl::encoding::Encoder<
8019                '_,
8020                fidl::encoding::DefaultFuchsiaResourceDialect,
8021            >,
8022            offset: usize,
8023            _depth: fidl::encoding::Depth,
8024        ) -> fidl::Result<()> {
8025            encoder.debug_check_bounds::<EchoEchoXunionsResponse>(offset);
8026            // Delegate to tuple encoding.
8027            fidl::encoding::Encode::<EchoEchoXunionsResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
8028                (
8029                    <fidl::encoding::UnboundedVector<AllTypesXunion> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
8030                ),
8031                encoder, offset, _depth
8032            )
8033        }
8034    }
8035    unsafe impl<
8036            T0: fidl::encoding::Encode<
8037                fidl::encoding::UnboundedVector<AllTypesXunion>,
8038                fidl::encoding::DefaultFuchsiaResourceDialect,
8039            >,
8040        >
8041        fidl::encoding::Encode<
8042            EchoEchoXunionsResponse,
8043            fidl::encoding::DefaultFuchsiaResourceDialect,
8044        > for (T0,)
8045    {
8046        #[inline]
8047        unsafe fn encode(
8048            self,
8049            encoder: &mut fidl::encoding::Encoder<
8050                '_,
8051                fidl::encoding::DefaultFuchsiaResourceDialect,
8052            >,
8053            offset: usize,
8054            depth: fidl::encoding::Depth,
8055        ) -> fidl::Result<()> {
8056            encoder.debug_check_bounds::<EchoEchoXunionsResponse>(offset);
8057            // Zero out padding regions. There's no need to apply masks
8058            // because the unmasked parts will be overwritten by fields.
8059            // Write the fields.
8060            self.0.encode(encoder, offset + 0, depth)?;
8061            Ok(())
8062        }
8063    }
8064
8065    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8066        for EchoEchoXunionsResponse
8067    {
8068        #[inline(always)]
8069        fn new_empty() -> Self {
8070            Self {
8071                value: fidl::new_empty!(
8072                    fidl::encoding::UnboundedVector<AllTypesXunion>,
8073                    fidl::encoding::DefaultFuchsiaResourceDialect
8074                ),
8075            }
8076        }
8077
8078        #[inline]
8079        unsafe fn decode(
8080            &mut self,
8081            decoder: &mut fidl::encoding::Decoder<
8082                '_,
8083                fidl::encoding::DefaultFuchsiaResourceDialect,
8084            >,
8085            offset: usize,
8086            _depth: fidl::encoding::Depth,
8087        ) -> fidl::Result<()> {
8088            decoder.debug_check_bounds::<Self>(offset);
8089            // Verify that padding bytes are zero.
8090            fidl::decode!(
8091                fidl::encoding::UnboundedVector<AllTypesXunion>,
8092                fidl::encoding::DefaultFuchsiaResourceDialect,
8093                &mut self.value,
8094                decoder,
8095                offset + 0,
8096                _depth
8097            )?;
8098            Ok(())
8099        }
8100    }
8101
8102    impl fidl::encoding::ResourceTypeMarker for EchoEchoXunionsWithErrorRequest {
8103        type Borrowed<'a> = &'a mut Self;
8104        fn take_or_borrow<'a>(
8105            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8106        ) -> Self::Borrowed<'a> {
8107            value
8108        }
8109    }
8110
8111    unsafe impl fidl::encoding::TypeMarker for EchoEchoXunionsWithErrorRequest {
8112        type Owned = Self;
8113
8114        #[inline(always)]
8115        fn inline_align(_context: fidl::encoding::Context) -> usize {
8116            8
8117        }
8118
8119        #[inline(always)]
8120        fn inline_size(_context: fidl::encoding::Context) -> usize {
8121            48
8122        }
8123    }
8124
8125    unsafe impl
8126        fidl::encoding::Encode<
8127            EchoEchoXunionsWithErrorRequest,
8128            fidl::encoding::DefaultFuchsiaResourceDialect,
8129        > for &mut EchoEchoXunionsWithErrorRequest
8130    {
8131        #[inline]
8132        unsafe fn encode(
8133            self,
8134            encoder: &mut fidl::encoding::Encoder<
8135                '_,
8136                fidl::encoding::DefaultFuchsiaResourceDialect,
8137            >,
8138            offset: usize,
8139            _depth: fidl::encoding::Depth,
8140        ) -> fidl::Result<()> {
8141            encoder.debug_check_bounds::<EchoEchoXunionsWithErrorRequest>(offset);
8142            // Delegate to tuple encoding.
8143            fidl::encoding::Encode::<EchoEchoXunionsWithErrorRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
8144                (
8145                    <fidl::encoding::UnboundedVector<AllTypesXunion> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
8146                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.result_err),
8147                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(&self.forward_to_server),
8148                    <RespondWith as fidl::encoding::ValueTypeMarker>::borrow(&self.result_variant),
8149                ),
8150                encoder, offset, _depth
8151            )
8152        }
8153    }
8154    unsafe impl<
8155            T0: fidl::encoding::Encode<
8156                fidl::encoding::UnboundedVector<AllTypesXunion>,
8157                fidl::encoding::DefaultFuchsiaResourceDialect,
8158            >,
8159            T1: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8160            T2: fidl::encoding::Encode<
8161                fidl::encoding::UnboundedString,
8162                fidl::encoding::DefaultFuchsiaResourceDialect,
8163            >,
8164            T3: fidl::encoding::Encode<RespondWith, fidl::encoding::DefaultFuchsiaResourceDialect>,
8165        >
8166        fidl::encoding::Encode<
8167            EchoEchoXunionsWithErrorRequest,
8168            fidl::encoding::DefaultFuchsiaResourceDialect,
8169        > for (T0, T1, T2, T3)
8170    {
8171        #[inline]
8172        unsafe fn encode(
8173            self,
8174            encoder: &mut fidl::encoding::Encoder<
8175                '_,
8176                fidl::encoding::DefaultFuchsiaResourceDialect,
8177            >,
8178            offset: usize,
8179            depth: fidl::encoding::Depth,
8180        ) -> fidl::Result<()> {
8181            encoder.debug_check_bounds::<EchoEchoXunionsWithErrorRequest>(offset);
8182            // Zero out padding regions. There's no need to apply masks
8183            // because the unmasked parts will be overwritten by fields.
8184            unsafe {
8185                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
8186                (ptr as *mut u64).write_unaligned(0);
8187            }
8188            unsafe {
8189                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(40);
8190                (ptr as *mut u64).write_unaligned(0);
8191            }
8192            // Write the fields.
8193            self.0.encode(encoder, offset + 0, depth)?;
8194            self.1.encode(encoder, offset + 16, depth)?;
8195            self.2.encode(encoder, offset + 24, depth)?;
8196            self.3.encode(encoder, offset + 40, depth)?;
8197            Ok(())
8198        }
8199    }
8200
8201    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8202        for EchoEchoXunionsWithErrorRequest
8203    {
8204        #[inline(always)]
8205        fn new_empty() -> Self {
8206            Self {
8207                value: fidl::new_empty!(
8208                    fidl::encoding::UnboundedVector<AllTypesXunion>,
8209                    fidl::encoding::DefaultFuchsiaResourceDialect
8210                ),
8211                result_err: fidl::new_empty!(
8212                    DefaultEnum,
8213                    fidl::encoding::DefaultFuchsiaResourceDialect
8214                ),
8215                forward_to_server: fidl::new_empty!(
8216                    fidl::encoding::UnboundedString,
8217                    fidl::encoding::DefaultFuchsiaResourceDialect
8218                ),
8219                result_variant: fidl::new_empty!(
8220                    RespondWith,
8221                    fidl::encoding::DefaultFuchsiaResourceDialect
8222                ),
8223            }
8224        }
8225
8226        #[inline]
8227        unsafe fn decode(
8228            &mut self,
8229            decoder: &mut fidl::encoding::Decoder<
8230                '_,
8231                fidl::encoding::DefaultFuchsiaResourceDialect,
8232            >,
8233            offset: usize,
8234            _depth: fidl::encoding::Depth,
8235        ) -> fidl::Result<()> {
8236            decoder.debug_check_bounds::<Self>(offset);
8237            // Verify that padding bytes are zero.
8238            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
8239            let padval = unsafe { (ptr as *const u64).read_unaligned() };
8240            let mask = 0xffffffff00000000u64;
8241            let maskedval = padval & mask;
8242            if maskedval != 0 {
8243                return Err(fidl::Error::NonZeroPadding {
8244                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
8245                });
8246            }
8247            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(40) };
8248            let padval = unsafe { (ptr as *const u64).read_unaligned() };
8249            let mask = 0xffffffff00000000u64;
8250            let maskedval = padval & mask;
8251            if maskedval != 0 {
8252                return Err(fidl::Error::NonZeroPadding {
8253                    padding_start: offset + 40 + ((mask as u64).trailing_zeros() / 8) as usize,
8254                });
8255            }
8256            fidl::decode!(
8257                fidl::encoding::UnboundedVector<AllTypesXunion>,
8258                fidl::encoding::DefaultFuchsiaResourceDialect,
8259                &mut self.value,
8260                decoder,
8261                offset + 0,
8262                _depth
8263            )?;
8264            fidl::decode!(
8265                DefaultEnum,
8266                fidl::encoding::DefaultFuchsiaResourceDialect,
8267                &mut self.result_err,
8268                decoder,
8269                offset + 16,
8270                _depth
8271            )?;
8272            fidl::decode!(
8273                fidl::encoding::UnboundedString,
8274                fidl::encoding::DefaultFuchsiaResourceDialect,
8275                &mut self.forward_to_server,
8276                decoder,
8277                offset + 24,
8278                _depth
8279            )?;
8280            fidl::decode!(
8281                RespondWith,
8282                fidl::encoding::DefaultFuchsiaResourceDialect,
8283                &mut self.result_variant,
8284                decoder,
8285                offset + 40,
8286                _depth
8287            )?;
8288            Ok(())
8289        }
8290    }
8291
8292    impl fidl::encoding::ResourceTypeMarker for EchoEchoArraysWithErrorResponse {
8293        type Borrowed<'a> = &'a mut Self;
8294        fn take_or_borrow<'a>(
8295            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8296        ) -> Self::Borrowed<'a> {
8297            value
8298        }
8299    }
8300
8301    unsafe impl fidl::encoding::TypeMarker for EchoEchoArraysWithErrorResponse {
8302        type Owned = Self;
8303
8304        #[inline(always)]
8305        fn inline_align(_context: fidl::encoding::Context) -> usize {
8306            8
8307        }
8308
8309        #[inline(always)]
8310        fn inline_size(_context: fidl::encoding::Context) -> usize {
8311            680
8312        }
8313    }
8314
8315    unsafe impl
8316        fidl::encoding::Encode<
8317            EchoEchoArraysWithErrorResponse,
8318            fidl::encoding::DefaultFuchsiaResourceDialect,
8319        > for &mut EchoEchoArraysWithErrorResponse
8320    {
8321        #[inline]
8322        unsafe fn encode(
8323            self,
8324            encoder: &mut fidl::encoding::Encoder<
8325                '_,
8326                fidl::encoding::DefaultFuchsiaResourceDialect,
8327            >,
8328            offset: usize,
8329            _depth: fidl::encoding::Depth,
8330        ) -> fidl::Result<()> {
8331            encoder.debug_check_bounds::<EchoEchoArraysWithErrorResponse>(offset);
8332            // Delegate to tuple encoding.
8333            fidl::encoding::Encode::<
8334                EchoEchoArraysWithErrorResponse,
8335                fidl::encoding::DefaultFuchsiaResourceDialect,
8336            >::encode(
8337                (<ArraysStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8338                    &mut self.value,
8339                ),),
8340                encoder,
8341                offset,
8342                _depth,
8343            )
8344        }
8345    }
8346    unsafe impl<
8347            T0: fidl::encoding::Encode<ArraysStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
8348        >
8349        fidl::encoding::Encode<
8350            EchoEchoArraysWithErrorResponse,
8351            fidl::encoding::DefaultFuchsiaResourceDialect,
8352        > for (T0,)
8353    {
8354        #[inline]
8355        unsafe fn encode(
8356            self,
8357            encoder: &mut fidl::encoding::Encoder<
8358                '_,
8359                fidl::encoding::DefaultFuchsiaResourceDialect,
8360            >,
8361            offset: usize,
8362            depth: fidl::encoding::Depth,
8363        ) -> fidl::Result<()> {
8364            encoder.debug_check_bounds::<EchoEchoArraysWithErrorResponse>(offset);
8365            // Zero out padding regions. There's no need to apply masks
8366            // because the unmasked parts will be overwritten by fields.
8367            // Write the fields.
8368            self.0.encode(encoder, offset + 0, depth)?;
8369            Ok(())
8370        }
8371    }
8372
8373    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8374        for EchoEchoArraysWithErrorResponse
8375    {
8376        #[inline(always)]
8377        fn new_empty() -> Self {
8378            Self {
8379                value: fidl::new_empty!(
8380                    ArraysStruct,
8381                    fidl::encoding::DefaultFuchsiaResourceDialect
8382                ),
8383            }
8384        }
8385
8386        #[inline]
8387        unsafe fn decode(
8388            &mut self,
8389            decoder: &mut fidl::encoding::Decoder<
8390                '_,
8391                fidl::encoding::DefaultFuchsiaResourceDialect,
8392            >,
8393            offset: usize,
8394            _depth: fidl::encoding::Depth,
8395        ) -> fidl::Result<()> {
8396            decoder.debug_check_bounds::<Self>(offset);
8397            // Verify that padding bytes are zero.
8398            fidl::decode!(
8399                ArraysStruct,
8400                fidl::encoding::DefaultFuchsiaResourceDialect,
8401                &mut self.value,
8402                decoder,
8403                offset + 0,
8404                _depth
8405            )?;
8406            Ok(())
8407        }
8408    }
8409
8410    impl fidl::encoding::ResourceTypeMarker for EchoEchoStructWithErrorResponse {
8411        type Borrowed<'a> = &'a mut Self;
8412        fn take_or_borrow<'a>(
8413            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8414        ) -> Self::Borrowed<'a> {
8415            value
8416        }
8417    }
8418
8419    unsafe impl fidl::encoding::TypeMarker for EchoEchoStructWithErrorResponse {
8420        type Owned = Self;
8421
8422        #[inline(always)]
8423        fn inline_align(_context: fidl::encoding::Context) -> usize {
8424            8
8425        }
8426
8427        #[inline(always)]
8428        fn inline_size(_context: fidl::encoding::Context) -> usize {
8429            2912
8430        }
8431    }
8432
8433    unsafe impl
8434        fidl::encoding::Encode<
8435            EchoEchoStructWithErrorResponse,
8436            fidl::encoding::DefaultFuchsiaResourceDialect,
8437        > for &mut EchoEchoStructWithErrorResponse
8438    {
8439        #[inline]
8440        unsafe fn encode(
8441            self,
8442            encoder: &mut fidl::encoding::Encoder<
8443                '_,
8444                fidl::encoding::DefaultFuchsiaResourceDialect,
8445            >,
8446            offset: usize,
8447            _depth: fidl::encoding::Depth,
8448        ) -> fidl::Result<()> {
8449            encoder.debug_check_bounds::<EchoEchoStructWithErrorResponse>(offset);
8450            // Delegate to tuple encoding.
8451            fidl::encoding::Encode::<
8452                EchoEchoStructWithErrorResponse,
8453                fidl::encoding::DefaultFuchsiaResourceDialect,
8454            >::encode(
8455                (<Struct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),),
8456                encoder,
8457                offset,
8458                _depth,
8459            )
8460        }
8461    }
8462    unsafe impl<T0: fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>>
8463        fidl::encoding::Encode<
8464            EchoEchoStructWithErrorResponse,
8465            fidl::encoding::DefaultFuchsiaResourceDialect,
8466        > for (T0,)
8467    {
8468        #[inline]
8469        unsafe fn encode(
8470            self,
8471            encoder: &mut fidl::encoding::Encoder<
8472                '_,
8473                fidl::encoding::DefaultFuchsiaResourceDialect,
8474            >,
8475            offset: usize,
8476            depth: fidl::encoding::Depth,
8477        ) -> fidl::Result<()> {
8478            encoder.debug_check_bounds::<EchoEchoStructWithErrorResponse>(offset);
8479            // Zero out padding regions. There's no need to apply masks
8480            // because the unmasked parts will be overwritten by fields.
8481            // Write the fields.
8482            self.0.encode(encoder, offset + 0, depth)?;
8483            Ok(())
8484        }
8485    }
8486
8487    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8488        for EchoEchoStructWithErrorResponse
8489    {
8490        #[inline(always)]
8491        fn new_empty() -> Self {
8492            Self { value: fidl::new_empty!(Struct, fidl::encoding::DefaultFuchsiaResourceDialect) }
8493        }
8494
8495        #[inline]
8496        unsafe fn decode(
8497            &mut self,
8498            decoder: &mut fidl::encoding::Decoder<
8499                '_,
8500                fidl::encoding::DefaultFuchsiaResourceDialect,
8501            >,
8502            offset: usize,
8503            _depth: fidl::encoding::Depth,
8504        ) -> fidl::Result<()> {
8505            decoder.debug_check_bounds::<Self>(offset);
8506            // Verify that padding bytes are zero.
8507            fidl::decode!(
8508                Struct,
8509                fidl::encoding::DefaultFuchsiaResourceDialect,
8510                &mut self.value,
8511                decoder,
8512                offset + 0,
8513                _depth
8514            )?;
8515            Ok(())
8516        }
8517    }
8518
8519    impl fidl::encoding::ResourceTypeMarker for EchoEchoTableWithErrorResponse {
8520        type Borrowed<'a> = &'a mut Self;
8521        fn take_or_borrow<'a>(
8522            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8523        ) -> Self::Borrowed<'a> {
8524            value
8525        }
8526    }
8527
8528    unsafe impl fidl::encoding::TypeMarker for EchoEchoTableWithErrorResponse {
8529        type Owned = Self;
8530
8531        #[inline(always)]
8532        fn inline_align(_context: fidl::encoding::Context) -> usize {
8533            8
8534        }
8535
8536        #[inline(always)]
8537        fn inline_size(_context: fidl::encoding::Context) -> usize {
8538            16
8539        }
8540    }
8541
8542    unsafe impl
8543        fidl::encoding::Encode<
8544            EchoEchoTableWithErrorResponse,
8545            fidl::encoding::DefaultFuchsiaResourceDialect,
8546        > for &mut EchoEchoTableWithErrorResponse
8547    {
8548        #[inline]
8549        unsafe fn encode(
8550            self,
8551            encoder: &mut fidl::encoding::Encoder<
8552                '_,
8553                fidl::encoding::DefaultFuchsiaResourceDialect,
8554            >,
8555            offset: usize,
8556            _depth: fidl::encoding::Depth,
8557        ) -> fidl::Result<()> {
8558            encoder.debug_check_bounds::<EchoEchoTableWithErrorResponse>(offset);
8559            // Delegate to tuple encoding.
8560            fidl::encoding::Encode::<
8561                EchoEchoTableWithErrorResponse,
8562                fidl::encoding::DefaultFuchsiaResourceDialect,
8563            >::encode(
8564                (<AllTypesTable as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8565                    &mut self.value,
8566                ),),
8567                encoder,
8568                offset,
8569                _depth,
8570            )
8571        }
8572    }
8573    unsafe impl<
8574            T0: fidl::encoding::Encode<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>,
8575        >
8576        fidl::encoding::Encode<
8577            EchoEchoTableWithErrorResponse,
8578            fidl::encoding::DefaultFuchsiaResourceDialect,
8579        > for (T0,)
8580    {
8581        #[inline]
8582        unsafe fn encode(
8583            self,
8584            encoder: &mut fidl::encoding::Encoder<
8585                '_,
8586                fidl::encoding::DefaultFuchsiaResourceDialect,
8587            >,
8588            offset: usize,
8589            depth: fidl::encoding::Depth,
8590        ) -> fidl::Result<()> {
8591            encoder.debug_check_bounds::<EchoEchoTableWithErrorResponse>(offset);
8592            // Zero out padding regions. There's no need to apply masks
8593            // because the unmasked parts will be overwritten by fields.
8594            // Write the fields.
8595            self.0.encode(encoder, offset + 0, depth)?;
8596            Ok(())
8597        }
8598    }
8599
8600    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8601        for EchoEchoTableWithErrorResponse
8602    {
8603        #[inline(always)]
8604        fn new_empty() -> Self {
8605            Self {
8606                value: fidl::new_empty!(
8607                    AllTypesTable,
8608                    fidl::encoding::DefaultFuchsiaResourceDialect
8609                ),
8610            }
8611        }
8612
8613        #[inline]
8614        unsafe fn decode(
8615            &mut self,
8616            decoder: &mut fidl::encoding::Decoder<
8617                '_,
8618                fidl::encoding::DefaultFuchsiaResourceDialect,
8619            >,
8620            offset: usize,
8621            _depth: fidl::encoding::Depth,
8622        ) -> fidl::Result<()> {
8623            decoder.debug_check_bounds::<Self>(offset);
8624            // Verify that padding bytes are zero.
8625            fidl::decode!(
8626                AllTypesTable,
8627                fidl::encoding::DefaultFuchsiaResourceDialect,
8628                &mut self.value,
8629                decoder,
8630                offset + 0,
8631                _depth
8632            )?;
8633            Ok(())
8634        }
8635    }
8636
8637    impl fidl::encoding::ResourceTypeMarker for EchoEchoVectorsWithErrorResponse {
8638        type Borrowed<'a> = &'a mut Self;
8639        fn take_or_borrow<'a>(
8640            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8641        ) -> Self::Borrowed<'a> {
8642            value
8643        }
8644    }
8645
8646    unsafe impl fidl::encoding::TypeMarker for EchoEchoVectorsWithErrorResponse {
8647        type Owned = Self;
8648
8649        #[inline(always)]
8650        fn inline_align(_context: fidl::encoding::Context) -> usize {
8651            8
8652        }
8653
8654        #[inline(always)]
8655        fn inline_size(_context: fidl::encoding::Context) -> usize {
8656            416
8657        }
8658    }
8659
8660    unsafe impl
8661        fidl::encoding::Encode<
8662            EchoEchoVectorsWithErrorResponse,
8663            fidl::encoding::DefaultFuchsiaResourceDialect,
8664        > for &mut EchoEchoVectorsWithErrorResponse
8665    {
8666        #[inline]
8667        unsafe fn encode(
8668            self,
8669            encoder: &mut fidl::encoding::Encoder<
8670                '_,
8671                fidl::encoding::DefaultFuchsiaResourceDialect,
8672            >,
8673            offset: usize,
8674            _depth: fidl::encoding::Depth,
8675        ) -> fidl::Result<()> {
8676            encoder.debug_check_bounds::<EchoEchoVectorsWithErrorResponse>(offset);
8677            // Delegate to tuple encoding.
8678            fidl::encoding::Encode::<
8679                EchoEchoVectorsWithErrorResponse,
8680                fidl::encoding::DefaultFuchsiaResourceDialect,
8681            >::encode(
8682                (<VectorsStruct as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8683                    &mut self.value,
8684                ),),
8685                encoder,
8686                offset,
8687                _depth,
8688            )
8689        }
8690    }
8691    unsafe impl<
8692            T0: fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>,
8693        >
8694        fidl::encoding::Encode<
8695            EchoEchoVectorsWithErrorResponse,
8696            fidl::encoding::DefaultFuchsiaResourceDialect,
8697        > for (T0,)
8698    {
8699        #[inline]
8700        unsafe fn encode(
8701            self,
8702            encoder: &mut fidl::encoding::Encoder<
8703                '_,
8704                fidl::encoding::DefaultFuchsiaResourceDialect,
8705            >,
8706            offset: usize,
8707            depth: fidl::encoding::Depth,
8708        ) -> fidl::Result<()> {
8709            encoder.debug_check_bounds::<EchoEchoVectorsWithErrorResponse>(offset);
8710            // Zero out padding regions. There's no need to apply masks
8711            // because the unmasked parts will be overwritten by fields.
8712            // Write the fields.
8713            self.0.encode(encoder, offset + 0, depth)?;
8714            Ok(())
8715        }
8716    }
8717
8718    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8719        for EchoEchoVectorsWithErrorResponse
8720    {
8721        #[inline(always)]
8722        fn new_empty() -> Self {
8723            Self {
8724                value: fidl::new_empty!(
8725                    VectorsStruct,
8726                    fidl::encoding::DefaultFuchsiaResourceDialect
8727                ),
8728            }
8729        }
8730
8731        #[inline]
8732        unsafe fn decode(
8733            &mut self,
8734            decoder: &mut fidl::encoding::Decoder<
8735                '_,
8736                fidl::encoding::DefaultFuchsiaResourceDialect,
8737            >,
8738            offset: usize,
8739            _depth: fidl::encoding::Depth,
8740        ) -> fidl::Result<()> {
8741            decoder.debug_check_bounds::<Self>(offset);
8742            // Verify that padding bytes are zero.
8743            fidl::decode!(
8744                VectorsStruct,
8745                fidl::encoding::DefaultFuchsiaResourceDialect,
8746                &mut self.value,
8747                decoder,
8748                offset + 0,
8749                _depth
8750            )?;
8751            Ok(())
8752        }
8753    }
8754
8755    impl fidl::encoding::ResourceTypeMarker for EchoEchoXunionsWithErrorResponse {
8756        type Borrowed<'a> = &'a mut Self;
8757        fn take_or_borrow<'a>(
8758            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8759        ) -> Self::Borrowed<'a> {
8760            value
8761        }
8762    }
8763
8764    unsafe impl fidl::encoding::TypeMarker for EchoEchoXunionsWithErrorResponse {
8765        type Owned = Self;
8766
8767        #[inline(always)]
8768        fn inline_align(_context: fidl::encoding::Context) -> usize {
8769            8
8770        }
8771
8772        #[inline(always)]
8773        fn inline_size(_context: fidl::encoding::Context) -> usize {
8774            16
8775        }
8776    }
8777
8778    unsafe impl
8779        fidl::encoding::Encode<
8780            EchoEchoXunionsWithErrorResponse,
8781            fidl::encoding::DefaultFuchsiaResourceDialect,
8782        > for &mut EchoEchoXunionsWithErrorResponse
8783    {
8784        #[inline]
8785        unsafe fn encode(
8786            self,
8787            encoder: &mut fidl::encoding::Encoder<
8788                '_,
8789                fidl::encoding::DefaultFuchsiaResourceDialect,
8790            >,
8791            offset: usize,
8792            _depth: fidl::encoding::Depth,
8793        ) -> fidl::Result<()> {
8794            encoder.debug_check_bounds::<EchoEchoXunionsWithErrorResponse>(offset);
8795            // Delegate to tuple encoding.
8796            fidl::encoding::Encode::<EchoEchoXunionsWithErrorResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
8797                (
8798                    <fidl::encoding::UnboundedVector<AllTypesXunion> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.value),
8799                ),
8800                encoder, offset, _depth
8801            )
8802        }
8803    }
8804    unsafe impl<
8805            T0: fidl::encoding::Encode<
8806                fidl::encoding::UnboundedVector<AllTypesXunion>,
8807                fidl::encoding::DefaultFuchsiaResourceDialect,
8808            >,
8809        >
8810        fidl::encoding::Encode<
8811            EchoEchoXunionsWithErrorResponse,
8812            fidl::encoding::DefaultFuchsiaResourceDialect,
8813        > for (T0,)
8814    {
8815        #[inline]
8816        unsafe fn encode(
8817            self,
8818            encoder: &mut fidl::encoding::Encoder<
8819                '_,
8820                fidl::encoding::DefaultFuchsiaResourceDialect,
8821            >,
8822            offset: usize,
8823            depth: fidl::encoding::Depth,
8824        ) -> fidl::Result<()> {
8825            encoder.debug_check_bounds::<EchoEchoXunionsWithErrorResponse>(offset);
8826            // Zero out padding regions. There's no need to apply masks
8827            // because the unmasked parts will be overwritten by fields.
8828            // Write the fields.
8829            self.0.encode(encoder, offset + 0, depth)?;
8830            Ok(())
8831        }
8832    }
8833
8834    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
8835        for EchoEchoXunionsWithErrorResponse
8836    {
8837        #[inline(always)]
8838        fn new_empty() -> Self {
8839            Self {
8840                value: fidl::new_empty!(
8841                    fidl::encoding::UnboundedVector<AllTypesXunion>,
8842                    fidl::encoding::DefaultFuchsiaResourceDialect
8843                ),
8844            }
8845        }
8846
8847        #[inline]
8848        unsafe fn decode(
8849            &mut self,
8850            decoder: &mut fidl::encoding::Decoder<
8851                '_,
8852                fidl::encoding::DefaultFuchsiaResourceDialect,
8853            >,
8854            offset: usize,
8855            _depth: fidl::encoding::Depth,
8856        ) -> fidl::Result<()> {
8857            decoder.debug_check_bounds::<Self>(offset);
8858            // Verify that padding bytes are zero.
8859            fidl::decode!(
8860                fidl::encoding::UnboundedVector<AllTypesXunion>,
8861                fidl::encoding::DefaultFuchsiaResourceDialect,
8862                &mut self.value,
8863                decoder,
8864                offset + 0,
8865                _depth
8866            )?;
8867            Ok(())
8868        }
8869    }
8870
8871    impl fidl::encoding::ResourceTypeMarker for Struct {
8872        type Borrowed<'a> = &'a mut Self;
8873        fn take_or_borrow<'a>(
8874            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
8875        ) -> Self::Borrowed<'a> {
8876            value
8877        }
8878    }
8879
8880    unsafe impl fidl::encoding::TypeMarker for Struct {
8881        type Owned = Self;
8882
8883        #[inline(always)]
8884        fn inline_align(_context: fidl::encoding::Context) -> usize {
8885            8
8886        }
8887
8888        #[inline(always)]
8889        fn inline_size(_context: fidl::encoding::Context) -> usize {
8890            2912
8891        }
8892    }
8893
8894    unsafe impl fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>
8895        for &mut Struct
8896    {
8897        #[inline]
8898        unsafe fn encode(
8899            self,
8900            encoder: &mut fidl::encoding::Encoder<
8901                '_,
8902                fidl::encoding::DefaultFuchsiaResourceDialect,
8903            >,
8904            offset: usize,
8905            _depth: fidl::encoding::Depth,
8906        ) -> fidl::Result<()> {
8907            encoder.debug_check_bounds::<Struct>(offset);
8908            // Delegate to tuple encoding.
8909            fidl::encoding::Encode::<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
8910                (
8911                    <PrimitiveTypes as fidl::encoding::ValueTypeMarker>::borrow(
8912                        &self.primitive_types,
8913                    ),
8914                    <DefaultValues as fidl::encoding::ValueTypeMarker>::borrow(
8915                        &self.default_values,
8916                    ),
8917                    <Arrays as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8918                        &mut self.arrays,
8919                    ),
8920                    <Arrays2d as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8921                        &mut self.arrays_2d,
8922                    ),
8923                    <Vectors as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8924                        &mut self.vectors,
8925                    ),
8926                    <Handles as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
8927                        &mut self.handles,
8928                    ),
8929                    <Strings as fidl::encoding::ValueTypeMarker>::borrow(&self.strings),
8930                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(&self.default_enum),
8931                    <I8Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_enum),
8932                    <I16Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_enum),
8933                    <I32Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_enum),
8934                    <I64Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_enum),
8935                    <U8Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_enum),
8936                    <U16Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_enum),
8937                    <U32Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_enum),
8938                    <U64Enum as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_enum),
8939                    <DefaultBits as fidl::encoding::ValueTypeMarker>::borrow(&self.default_bits),
8940                    <U8Bits as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_bits),
8941                    <U16Bits as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_bits),
8942                    <U32Bits as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_bits),
8943                    <U64Bits as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_bits),
8944                    <Structs as fidl::encoding::ValueTypeMarker>::borrow(&self.structs),
8945                    <Unions as fidl::encoding::ValueTypeMarker>::borrow(&self.unions),
8946                    <ThisIsATable as fidl::encoding::ValueTypeMarker>::borrow(&self.table),
8947                    <ThisIsAXunion as fidl::encoding::ValueTypeMarker>::borrow(&self.xunion),
8948                    <bool as fidl::encoding::ValueTypeMarker>::borrow(&self.b),
8949                ),
8950                encoder,
8951                offset,
8952                _depth,
8953            )
8954        }
8955    }
8956    unsafe impl<
8957            T0: fidl::encoding::Encode<PrimitiveTypes, fidl::encoding::DefaultFuchsiaResourceDialect>,
8958            T1: fidl::encoding::Encode<DefaultValues, fidl::encoding::DefaultFuchsiaResourceDialect>,
8959            T2: fidl::encoding::Encode<Arrays, fidl::encoding::DefaultFuchsiaResourceDialect>,
8960            T3: fidl::encoding::Encode<Arrays2d, fidl::encoding::DefaultFuchsiaResourceDialect>,
8961            T4: fidl::encoding::Encode<Vectors, fidl::encoding::DefaultFuchsiaResourceDialect>,
8962            T5: fidl::encoding::Encode<Handles, fidl::encoding::DefaultFuchsiaResourceDialect>,
8963            T6: fidl::encoding::Encode<Strings, fidl::encoding::DefaultFuchsiaResourceDialect>,
8964            T7: fidl::encoding::Encode<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8965            T8: fidl::encoding::Encode<I8Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8966            T9: fidl::encoding::Encode<I16Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8967            T10: fidl::encoding::Encode<I32Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8968            T11: fidl::encoding::Encode<I64Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8969            T12: fidl::encoding::Encode<U8Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8970            T13: fidl::encoding::Encode<U16Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8971            T14: fidl::encoding::Encode<U32Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8972            T15: fidl::encoding::Encode<U64Enum, fidl::encoding::DefaultFuchsiaResourceDialect>,
8973            T16: fidl::encoding::Encode<DefaultBits, fidl::encoding::DefaultFuchsiaResourceDialect>,
8974            T17: fidl::encoding::Encode<U8Bits, fidl::encoding::DefaultFuchsiaResourceDialect>,
8975            T18: fidl::encoding::Encode<U16Bits, fidl::encoding::DefaultFuchsiaResourceDialect>,
8976            T19: fidl::encoding::Encode<U32Bits, fidl::encoding::DefaultFuchsiaResourceDialect>,
8977            T20: fidl::encoding::Encode<U64Bits, fidl::encoding::DefaultFuchsiaResourceDialect>,
8978            T21: fidl::encoding::Encode<Structs, fidl::encoding::DefaultFuchsiaResourceDialect>,
8979            T22: fidl::encoding::Encode<Unions, fidl::encoding::DefaultFuchsiaResourceDialect>,
8980            T23: fidl::encoding::Encode<ThisIsATable, fidl::encoding::DefaultFuchsiaResourceDialect>,
8981            T24: fidl::encoding::Encode<ThisIsAXunion, fidl::encoding::DefaultFuchsiaResourceDialect>,
8982            T25: fidl::encoding::Encode<bool, fidl::encoding::DefaultFuchsiaResourceDialect>,
8983        > fidl::encoding::Encode<Struct, fidl::encoding::DefaultFuchsiaResourceDialect>
8984        for (
8985            T0,
8986            T1,
8987            T2,
8988            T3,
8989            T4,
8990            T5,
8991            T6,
8992            T7,
8993            T8,
8994            T9,
8995            T10,
8996            T11,
8997            T12,
8998            T13,
8999            T14,
9000            T15,
9001            T16,
9002            T17,
9003            T18,
9004            T19,
9005            T20,
9006            T21,
9007            T22,
9008            T23,
9009            T24,
9010            T25,
9011        )
9012    {
9013        #[inline]
9014        unsafe fn encode(
9015            self,
9016            encoder: &mut fidl::encoding::Encoder<
9017                '_,
9018                fidl::encoding::DefaultFuchsiaResourceDialect,
9019            >,
9020            offset: usize,
9021            depth: fidl::encoding::Depth,
9022        ) -> fidl::Result<()> {
9023            encoder.debug_check_bounds::<Struct>(offset);
9024            // Zero out padding regions. There's no need to apply masks
9025            // because the unmasked parts will be overwritten by fields.
9026            unsafe {
9027                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2640);
9028                (ptr as *mut u64).write_unaligned(0);
9029            }
9030            unsafe {
9031                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2744);
9032                (ptr as *mut u64).write_unaligned(0);
9033            }
9034            unsafe {
9035                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2752);
9036                (ptr as *mut u64).write_unaligned(0);
9037            }
9038            unsafe {
9039                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2768);
9040                (ptr as *mut u64).write_unaligned(0);
9041            }
9042            unsafe {
9043                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2784);
9044                (ptr as *mut u64).write_unaligned(0);
9045            }
9046            unsafe {
9047                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2792);
9048                (ptr as *mut u64).write_unaligned(0);
9049            }
9050            unsafe {
9051                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(2904);
9052                (ptr as *mut u64).write_unaligned(0);
9053            }
9054            // Write the fields.
9055            self.0.encode(encoder, offset + 0, depth)?;
9056            self.1.encode(encoder, offset + 48, depth)?;
9057            self.2.encode(encoder, offset + 120, depth)?;
9058            self.3.encode(encoder, offset + 328, depth)?;
9059            self.4.encode(encoder, offset + 616, depth)?;
9060            self.5.encode(encoder, offset + 2536, depth)?;
9061            self.6.encode(encoder, offset + 2648, depth)?;
9062            self.7.encode(encoder, offset + 2744, depth)?;
9063            self.8.encode(encoder, offset + 2748, depth)?;
9064            self.9.encode(encoder, offset + 2750, depth)?;
9065            self.10.encode(encoder, offset + 2752, depth)?;
9066            self.11.encode(encoder, offset + 2760, depth)?;
9067            self.12.encode(encoder, offset + 2768, depth)?;
9068            self.13.encode(encoder, offset + 2770, depth)?;
9069            self.14.encode(encoder, offset + 2772, depth)?;
9070            self.15.encode(encoder, offset + 2776, depth)?;
9071            self.16.encode(encoder, offset + 2784, depth)?;
9072            self.17.encode(encoder, offset + 2788, depth)?;
9073            self.18.encode(encoder, offset + 2790, depth)?;
9074            self.19.encode(encoder, offset + 2792, depth)?;
9075            self.20.encode(encoder, offset + 2800, depth)?;
9076            self.21.encode(encoder, offset + 2808, depth)?;
9077            self.22.encode(encoder, offset + 2840, depth)?;
9078            self.23.encode(encoder, offset + 2872, depth)?;
9079            self.24.encode(encoder, offset + 2888, depth)?;
9080            self.25.encode(encoder, offset + 2904, depth)?;
9081            Ok(())
9082        }
9083    }
9084
9085    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Struct {
9086        #[inline(always)]
9087        fn new_empty() -> Self {
9088            Self {
9089                primitive_types: fidl::new_empty!(
9090                    PrimitiveTypes,
9091                    fidl::encoding::DefaultFuchsiaResourceDialect
9092                ),
9093                default_values: fidl::new_empty!(
9094                    DefaultValues,
9095                    fidl::encoding::DefaultFuchsiaResourceDialect
9096                ),
9097                arrays: fidl::new_empty!(Arrays, fidl::encoding::DefaultFuchsiaResourceDialect),
9098                arrays_2d: fidl::new_empty!(
9099                    Arrays2d,
9100                    fidl::encoding::DefaultFuchsiaResourceDialect
9101                ),
9102                vectors: fidl::new_empty!(Vectors, fidl::encoding::DefaultFuchsiaResourceDialect),
9103                handles: fidl::new_empty!(Handles, fidl::encoding::DefaultFuchsiaResourceDialect),
9104                strings: fidl::new_empty!(Strings, fidl::encoding::DefaultFuchsiaResourceDialect),
9105                default_enum: fidl::new_empty!(
9106                    DefaultEnum,
9107                    fidl::encoding::DefaultFuchsiaResourceDialect
9108                ),
9109                i8_enum: fidl::new_empty!(I8Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9110                i16_enum: fidl::new_empty!(I16Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9111                i32_enum: fidl::new_empty!(I32Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9112                i64_enum: fidl::new_empty!(I64Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9113                u8_enum: fidl::new_empty!(U8Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9114                u16_enum: fidl::new_empty!(U16Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9115                u32_enum: fidl::new_empty!(U32Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9116                u64_enum: fidl::new_empty!(U64Enum, fidl::encoding::DefaultFuchsiaResourceDialect),
9117                default_bits: fidl::new_empty!(
9118                    DefaultBits,
9119                    fidl::encoding::DefaultFuchsiaResourceDialect
9120                ),
9121                u8_bits: fidl::new_empty!(U8Bits, fidl::encoding::DefaultFuchsiaResourceDialect),
9122                u16_bits: fidl::new_empty!(U16Bits, fidl::encoding::DefaultFuchsiaResourceDialect),
9123                u32_bits: fidl::new_empty!(U32Bits, fidl::encoding::DefaultFuchsiaResourceDialect),
9124                u64_bits: fidl::new_empty!(U64Bits, fidl::encoding::DefaultFuchsiaResourceDialect),
9125                structs: fidl::new_empty!(Structs, fidl::encoding::DefaultFuchsiaResourceDialect),
9126                unions: fidl::new_empty!(Unions, fidl::encoding::DefaultFuchsiaResourceDialect),
9127                table: fidl::new_empty!(
9128                    ThisIsATable,
9129                    fidl::encoding::DefaultFuchsiaResourceDialect
9130                ),
9131                xunion: fidl::new_empty!(
9132                    ThisIsAXunion,
9133                    fidl::encoding::DefaultFuchsiaResourceDialect
9134                ),
9135                b: fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect),
9136            }
9137        }
9138
9139        #[inline]
9140        unsafe fn decode(
9141            &mut self,
9142            decoder: &mut fidl::encoding::Decoder<
9143                '_,
9144                fidl::encoding::DefaultFuchsiaResourceDialect,
9145            >,
9146            offset: usize,
9147            _depth: fidl::encoding::Depth,
9148        ) -> fidl::Result<()> {
9149            decoder.debug_check_bounds::<Self>(offset);
9150            // Verify that padding bytes are zero.
9151            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2640) };
9152            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9153            let mask = 0xffffffff00000000u64;
9154            let maskedval = padval & mask;
9155            if maskedval != 0 {
9156                return Err(fidl::Error::NonZeroPadding {
9157                    padding_start: offset + 2640 + ((mask as u64).trailing_zeros() / 8) as usize,
9158                });
9159            }
9160            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2744) };
9161            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9162            let mask = 0xff0000000000u64;
9163            let maskedval = padval & mask;
9164            if maskedval != 0 {
9165                return Err(fidl::Error::NonZeroPadding {
9166                    padding_start: offset + 2744 + ((mask as u64).trailing_zeros() / 8) as usize,
9167                });
9168            }
9169            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2752) };
9170            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9171            let mask = 0xffffffff00000000u64;
9172            let maskedval = padval & mask;
9173            if maskedval != 0 {
9174                return Err(fidl::Error::NonZeroPadding {
9175                    padding_start: offset + 2752 + ((mask as u64).trailing_zeros() / 8) as usize,
9176                });
9177            }
9178            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2768) };
9179            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9180            let mask = 0xff00u64;
9181            let maskedval = padval & mask;
9182            if maskedval != 0 {
9183                return Err(fidl::Error::NonZeroPadding {
9184                    padding_start: offset + 2768 + ((mask as u64).trailing_zeros() / 8) as usize,
9185                });
9186            }
9187            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2784) };
9188            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9189            let mask = 0xff0000000000u64;
9190            let maskedval = padval & mask;
9191            if maskedval != 0 {
9192                return Err(fidl::Error::NonZeroPadding {
9193                    padding_start: offset + 2784 + ((mask as u64).trailing_zeros() / 8) as usize,
9194                });
9195            }
9196            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2792) };
9197            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9198            let mask = 0xffffffff00000000u64;
9199            let maskedval = padval & mask;
9200            if maskedval != 0 {
9201                return Err(fidl::Error::NonZeroPadding {
9202                    padding_start: offset + 2792 + ((mask as u64).trailing_zeros() / 8) as usize,
9203                });
9204            }
9205            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(2904) };
9206            let padval = unsafe { (ptr as *const u64).read_unaligned() };
9207            let mask = 0xffffffffffffff00u64;
9208            let maskedval = padval & mask;
9209            if maskedval != 0 {
9210                return Err(fidl::Error::NonZeroPadding {
9211                    padding_start: offset + 2904 + ((mask as u64).trailing_zeros() / 8) as usize,
9212                });
9213            }
9214            fidl::decode!(
9215                PrimitiveTypes,
9216                fidl::encoding::DefaultFuchsiaResourceDialect,
9217                &mut self.primitive_types,
9218                decoder,
9219                offset + 0,
9220                _depth
9221            )?;
9222            fidl::decode!(
9223                DefaultValues,
9224                fidl::encoding::DefaultFuchsiaResourceDialect,
9225                &mut self.default_values,
9226                decoder,
9227                offset + 48,
9228                _depth
9229            )?;
9230            fidl::decode!(
9231                Arrays,
9232                fidl::encoding::DefaultFuchsiaResourceDialect,
9233                &mut self.arrays,
9234                decoder,
9235                offset + 120,
9236                _depth
9237            )?;
9238            fidl::decode!(
9239                Arrays2d,
9240                fidl::encoding::DefaultFuchsiaResourceDialect,
9241                &mut self.arrays_2d,
9242                decoder,
9243                offset + 328,
9244                _depth
9245            )?;
9246            fidl::decode!(
9247                Vectors,
9248                fidl::encoding::DefaultFuchsiaResourceDialect,
9249                &mut self.vectors,
9250                decoder,
9251                offset + 616,
9252                _depth
9253            )?;
9254            fidl::decode!(
9255                Handles,
9256                fidl::encoding::DefaultFuchsiaResourceDialect,
9257                &mut self.handles,
9258                decoder,
9259                offset + 2536,
9260                _depth
9261            )?;
9262            fidl::decode!(
9263                Strings,
9264                fidl::encoding::DefaultFuchsiaResourceDialect,
9265                &mut self.strings,
9266                decoder,
9267                offset + 2648,
9268                _depth
9269            )?;
9270            fidl::decode!(
9271                DefaultEnum,
9272                fidl::encoding::DefaultFuchsiaResourceDialect,
9273                &mut self.default_enum,
9274                decoder,
9275                offset + 2744,
9276                _depth
9277            )?;
9278            fidl::decode!(
9279                I8Enum,
9280                fidl::encoding::DefaultFuchsiaResourceDialect,
9281                &mut self.i8_enum,
9282                decoder,
9283                offset + 2748,
9284                _depth
9285            )?;
9286            fidl::decode!(
9287                I16Enum,
9288                fidl::encoding::DefaultFuchsiaResourceDialect,
9289                &mut self.i16_enum,
9290                decoder,
9291                offset + 2750,
9292                _depth
9293            )?;
9294            fidl::decode!(
9295                I32Enum,
9296                fidl::encoding::DefaultFuchsiaResourceDialect,
9297                &mut self.i32_enum,
9298                decoder,
9299                offset + 2752,
9300                _depth
9301            )?;
9302            fidl::decode!(
9303                I64Enum,
9304                fidl::encoding::DefaultFuchsiaResourceDialect,
9305                &mut self.i64_enum,
9306                decoder,
9307                offset + 2760,
9308                _depth
9309            )?;
9310            fidl::decode!(
9311                U8Enum,
9312                fidl::encoding::DefaultFuchsiaResourceDialect,
9313                &mut self.u8_enum,
9314                decoder,
9315                offset + 2768,
9316                _depth
9317            )?;
9318            fidl::decode!(
9319                U16Enum,
9320                fidl::encoding::DefaultFuchsiaResourceDialect,
9321                &mut self.u16_enum,
9322                decoder,
9323                offset + 2770,
9324                _depth
9325            )?;
9326            fidl::decode!(
9327                U32Enum,
9328                fidl::encoding::DefaultFuchsiaResourceDialect,
9329                &mut self.u32_enum,
9330                decoder,
9331                offset + 2772,
9332                _depth
9333            )?;
9334            fidl::decode!(
9335                U64Enum,
9336                fidl::encoding::DefaultFuchsiaResourceDialect,
9337                &mut self.u64_enum,
9338                decoder,
9339                offset + 2776,
9340                _depth
9341            )?;
9342            fidl::decode!(
9343                DefaultBits,
9344                fidl::encoding::DefaultFuchsiaResourceDialect,
9345                &mut self.default_bits,
9346                decoder,
9347                offset + 2784,
9348                _depth
9349            )?;
9350            fidl::decode!(
9351                U8Bits,
9352                fidl::encoding::DefaultFuchsiaResourceDialect,
9353                &mut self.u8_bits,
9354                decoder,
9355                offset + 2788,
9356                _depth
9357            )?;
9358            fidl::decode!(
9359                U16Bits,
9360                fidl::encoding::DefaultFuchsiaResourceDialect,
9361                &mut self.u16_bits,
9362                decoder,
9363                offset + 2790,
9364                _depth
9365            )?;
9366            fidl::decode!(
9367                U32Bits,
9368                fidl::encoding::DefaultFuchsiaResourceDialect,
9369                &mut self.u32_bits,
9370                decoder,
9371                offset + 2792,
9372                _depth
9373            )?;
9374            fidl::decode!(
9375                U64Bits,
9376                fidl::encoding::DefaultFuchsiaResourceDialect,
9377                &mut self.u64_bits,
9378                decoder,
9379                offset + 2800,
9380                _depth
9381            )?;
9382            fidl::decode!(
9383                Structs,
9384                fidl::encoding::DefaultFuchsiaResourceDialect,
9385                &mut self.structs,
9386                decoder,
9387                offset + 2808,
9388                _depth
9389            )?;
9390            fidl::decode!(
9391                Unions,
9392                fidl::encoding::DefaultFuchsiaResourceDialect,
9393                &mut self.unions,
9394                decoder,
9395                offset + 2840,
9396                _depth
9397            )?;
9398            fidl::decode!(
9399                ThisIsATable,
9400                fidl::encoding::DefaultFuchsiaResourceDialect,
9401                &mut self.table,
9402                decoder,
9403                offset + 2872,
9404                _depth
9405            )?;
9406            fidl::decode!(
9407                ThisIsAXunion,
9408                fidl::encoding::DefaultFuchsiaResourceDialect,
9409                &mut self.xunion,
9410                decoder,
9411                offset + 2888,
9412                _depth
9413            )?;
9414            fidl::decode!(
9415                bool,
9416                fidl::encoding::DefaultFuchsiaResourceDialect,
9417                &mut self.b,
9418                decoder,
9419                offset + 2904,
9420                _depth
9421            )?;
9422            Ok(())
9423        }
9424    }
9425
9426    impl fidl::encoding::ResourceTypeMarker for VectorsStruct {
9427        type Borrowed<'a> = &'a mut Self;
9428        fn take_or_borrow<'a>(
9429            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
9430        ) -> Self::Borrowed<'a> {
9431            value
9432        }
9433    }
9434
9435    unsafe impl fidl::encoding::TypeMarker for VectorsStruct {
9436        type Owned = Self;
9437
9438        #[inline(always)]
9439        fn inline_align(_context: fidl::encoding::Context) -> usize {
9440            8
9441        }
9442
9443        #[inline(always)]
9444        fn inline_size(_context: fidl::encoding::Context) -> usize {
9445            416
9446        }
9447    }
9448
9449    unsafe impl fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
9450        for &mut VectorsStruct
9451    {
9452        #[inline]
9453        unsafe fn encode(
9454            self,
9455            encoder: &mut fidl::encoding::Encoder<
9456                '_,
9457                fidl::encoding::DefaultFuchsiaResourceDialect,
9458            >,
9459            offset: usize,
9460            _depth: fidl::encoding::Depth,
9461        ) -> fidl::Result<()> {
9462            encoder.debug_check_bounds::<VectorsStruct>(offset);
9463            // Delegate to tuple encoding.
9464            fidl::encoding::Encode::<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
9465                (
9466                    <fidl::encoding::Vector<bool, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.bools),
9467                    <fidl::encoding::Vector<i8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int8s),
9468                    <fidl::encoding::Vector<i16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int16s),
9469                    <fidl::encoding::Vector<i32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int32s),
9470                    <fidl::encoding::Vector<i64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.int64s),
9471                    <fidl::encoding::Vector<u8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint8s),
9472                    <fidl::encoding::Vector<u16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint16s),
9473                    <fidl::encoding::Vector<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint32s),
9474                    <fidl::encoding::Vector<u64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.uint64s),
9475                    <fidl::encoding::Vector<f32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.float32s),
9476                    <fidl::encoding::Vector<f64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.float64s),
9477                    <fidl::encoding::Vector<DefaultEnum, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.enums),
9478                    <fidl::encoding::Vector<DefaultBits, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.bits),
9479                    <fidl::encoding::Vector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 3> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handles),
9480                    <fidl::encoding::Vector<fidl::encoding::Optional<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>>, 3> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.nullable_handles),
9481                    <fidl::encoding::Vector<fidl::encoding::UnboundedString, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.strings),
9482                    <fidl::encoding::Vector<fidl::encoding::Optional<fidl::encoding::UnboundedString>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_strings),
9483                    <fidl::encoding::Vector<ThisIsAStruct, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.structs),
9484                    <fidl::encoding::Vector<fidl::encoding::Boxed<ThisIsAStruct>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_structs),
9485                    <fidl::encoding::Vector<ThisIsAUnion, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.unions),
9486                    <fidl::encoding::Vector<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_unions),
9487                    <fidl::encoding::Vector<fidl::encoding::Array<u32, 3>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.arrays),
9488                    <fidl::encoding::Vector<fidl::encoding::UnboundedVector<u32>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.vectors),
9489                    <fidl::encoding::Vector<fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.nullable_vectors),
9490                    <fidl::encoding::Vector<ThisIsATable, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.tables),
9491                    <fidl::encoding::Vector<ThisIsAXunion, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.xunions),
9492                ),
9493                encoder, offset, _depth
9494            )
9495        }
9496    }
9497    unsafe impl<
9498            T0: fidl::encoding::Encode<
9499                fidl::encoding::Vector<bool, 3>,
9500                fidl::encoding::DefaultFuchsiaResourceDialect,
9501            >,
9502            T1: fidl::encoding::Encode<
9503                fidl::encoding::Vector<i8, 3>,
9504                fidl::encoding::DefaultFuchsiaResourceDialect,
9505            >,
9506            T2: fidl::encoding::Encode<
9507                fidl::encoding::Vector<i16, 3>,
9508                fidl::encoding::DefaultFuchsiaResourceDialect,
9509            >,
9510            T3: fidl::encoding::Encode<
9511                fidl::encoding::Vector<i32, 3>,
9512                fidl::encoding::DefaultFuchsiaResourceDialect,
9513            >,
9514            T4: fidl::encoding::Encode<
9515                fidl::encoding::Vector<i64, 3>,
9516                fidl::encoding::DefaultFuchsiaResourceDialect,
9517            >,
9518            T5: fidl::encoding::Encode<
9519                fidl::encoding::Vector<u8, 3>,
9520                fidl::encoding::DefaultFuchsiaResourceDialect,
9521            >,
9522            T6: fidl::encoding::Encode<
9523                fidl::encoding::Vector<u16, 3>,
9524                fidl::encoding::DefaultFuchsiaResourceDialect,
9525            >,
9526            T7: fidl::encoding::Encode<
9527                fidl::encoding::Vector<u32, 3>,
9528                fidl::encoding::DefaultFuchsiaResourceDialect,
9529            >,
9530            T8: fidl::encoding::Encode<
9531                fidl::encoding::Vector<u64, 3>,
9532                fidl::encoding::DefaultFuchsiaResourceDialect,
9533            >,
9534            T9: fidl::encoding::Encode<
9535                fidl::encoding::Vector<f32, 3>,
9536                fidl::encoding::DefaultFuchsiaResourceDialect,
9537            >,
9538            T10: fidl::encoding::Encode<
9539                fidl::encoding::Vector<f64, 3>,
9540                fidl::encoding::DefaultFuchsiaResourceDialect,
9541            >,
9542            T11: fidl::encoding::Encode<
9543                fidl::encoding::Vector<DefaultEnum, 3>,
9544                fidl::encoding::DefaultFuchsiaResourceDialect,
9545            >,
9546            T12: fidl::encoding::Encode<
9547                fidl::encoding::Vector<DefaultBits, 3>,
9548                fidl::encoding::DefaultFuchsiaResourceDialect,
9549            >,
9550            T13: fidl::encoding::Encode<
9551                fidl::encoding::Vector<
9552                    fidl::encoding::HandleType<
9553                        fidl::Handle,
9554                        { fidl::ObjectType::NONE.into_raw() },
9555                        2147483648,
9556                    >,
9557                    3,
9558                >,
9559                fidl::encoding::DefaultFuchsiaResourceDialect,
9560            >,
9561            T14: fidl::encoding::Encode<
9562                fidl::encoding::Vector<
9563                    fidl::encoding::Optional<
9564                        fidl::encoding::HandleType<
9565                            fidl::Handle,
9566                            { fidl::ObjectType::NONE.into_raw() },
9567                            2147483648,
9568                        >,
9569                    >,
9570                    3,
9571                >,
9572                fidl::encoding::DefaultFuchsiaResourceDialect,
9573            >,
9574            T15: fidl::encoding::Encode<
9575                fidl::encoding::Vector<fidl::encoding::UnboundedString, 3>,
9576                fidl::encoding::DefaultFuchsiaResourceDialect,
9577            >,
9578            T16: fidl::encoding::Encode<
9579                fidl::encoding::Vector<
9580                    fidl::encoding::Optional<fidl::encoding::UnboundedString>,
9581                    3,
9582                >,
9583                fidl::encoding::DefaultFuchsiaResourceDialect,
9584            >,
9585            T17: fidl::encoding::Encode<
9586                fidl::encoding::Vector<ThisIsAStruct, 3>,
9587                fidl::encoding::DefaultFuchsiaResourceDialect,
9588            >,
9589            T18: fidl::encoding::Encode<
9590                fidl::encoding::Vector<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
9591                fidl::encoding::DefaultFuchsiaResourceDialect,
9592            >,
9593            T19: fidl::encoding::Encode<
9594                fidl::encoding::Vector<ThisIsAUnion, 3>,
9595                fidl::encoding::DefaultFuchsiaResourceDialect,
9596            >,
9597            T20: fidl::encoding::Encode<
9598                fidl::encoding::Vector<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
9599                fidl::encoding::DefaultFuchsiaResourceDialect,
9600            >,
9601            T21: fidl::encoding::Encode<
9602                fidl::encoding::Vector<fidl::encoding::Array<u32, 3>, 3>,
9603                fidl::encoding::DefaultFuchsiaResourceDialect,
9604            >,
9605            T22: fidl::encoding::Encode<
9606                fidl::encoding::Vector<fidl::encoding::UnboundedVector<u32>, 3>,
9607                fidl::encoding::DefaultFuchsiaResourceDialect,
9608            >,
9609            T23: fidl::encoding::Encode<
9610                fidl::encoding::Vector<
9611                    fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
9612                    3,
9613                >,
9614                fidl::encoding::DefaultFuchsiaResourceDialect,
9615            >,
9616            T24: fidl::encoding::Encode<
9617                fidl::encoding::Vector<ThisIsATable, 3>,
9618                fidl::encoding::DefaultFuchsiaResourceDialect,
9619            >,
9620            T25: fidl::encoding::Encode<
9621                fidl::encoding::Vector<ThisIsAXunion, 3>,
9622                fidl::encoding::DefaultFuchsiaResourceDialect,
9623            >,
9624        > fidl::encoding::Encode<VectorsStruct, fidl::encoding::DefaultFuchsiaResourceDialect>
9625        for (
9626            T0,
9627            T1,
9628            T2,
9629            T3,
9630            T4,
9631            T5,
9632            T6,
9633            T7,
9634            T8,
9635            T9,
9636            T10,
9637            T11,
9638            T12,
9639            T13,
9640            T14,
9641            T15,
9642            T16,
9643            T17,
9644            T18,
9645            T19,
9646            T20,
9647            T21,
9648            T22,
9649            T23,
9650            T24,
9651            T25,
9652        )
9653    {
9654        #[inline]
9655        unsafe fn encode(
9656            self,
9657            encoder: &mut fidl::encoding::Encoder<
9658                '_,
9659                fidl::encoding::DefaultFuchsiaResourceDialect,
9660            >,
9661            offset: usize,
9662            depth: fidl::encoding::Depth,
9663        ) -> fidl::Result<()> {
9664            encoder.debug_check_bounds::<VectorsStruct>(offset);
9665            // Zero out padding regions. There's no need to apply masks
9666            // because the unmasked parts will be overwritten by fields.
9667            // Write the fields.
9668            self.0.encode(encoder, offset + 0, depth)?;
9669            self.1.encode(encoder, offset + 16, depth)?;
9670            self.2.encode(encoder, offset + 32, depth)?;
9671            self.3.encode(encoder, offset + 48, depth)?;
9672            self.4.encode(encoder, offset + 64, depth)?;
9673            self.5.encode(encoder, offset + 80, depth)?;
9674            self.6.encode(encoder, offset + 96, depth)?;
9675            self.7.encode(encoder, offset + 112, depth)?;
9676            self.8.encode(encoder, offset + 128, depth)?;
9677            self.9.encode(encoder, offset + 144, depth)?;
9678            self.10.encode(encoder, offset + 160, depth)?;
9679            self.11.encode(encoder, offset + 176, depth)?;
9680            self.12.encode(encoder, offset + 192, depth)?;
9681            self.13.encode(encoder, offset + 208, depth)?;
9682            self.14.encode(encoder, offset + 224, depth)?;
9683            self.15.encode(encoder, offset + 240, depth)?;
9684            self.16.encode(encoder, offset + 256, depth)?;
9685            self.17.encode(encoder, offset + 272, depth)?;
9686            self.18.encode(encoder, offset + 288, depth)?;
9687            self.19.encode(encoder, offset + 304, depth)?;
9688            self.20.encode(encoder, offset + 320, depth)?;
9689            self.21.encode(encoder, offset + 336, depth)?;
9690            self.22.encode(encoder, offset + 352, depth)?;
9691            self.23.encode(encoder, offset + 368, depth)?;
9692            self.24.encode(encoder, offset + 384, depth)?;
9693            self.25.encode(encoder, offset + 400, depth)?;
9694            Ok(())
9695        }
9696    }
9697
9698    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for VectorsStruct {
9699        #[inline(always)]
9700        fn new_empty() -> Self {
9701            Self {
9702                bools: fidl::new_empty!(fidl::encoding::Vector<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9703                int8s: fidl::new_empty!(fidl::encoding::Vector<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9704                int16s: fidl::new_empty!(fidl::encoding::Vector<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9705                int32s: fidl::new_empty!(fidl::encoding::Vector<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9706                int64s: fidl::new_empty!(fidl::encoding::Vector<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9707                uint8s: fidl::new_empty!(fidl::encoding::Vector<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9708                uint16s: fidl::new_empty!(fidl::encoding::Vector<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9709                uint32s: fidl::new_empty!(fidl::encoding::Vector<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9710                uint64s: fidl::new_empty!(fidl::encoding::Vector<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9711                float32s: fidl::new_empty!(fidl::encoding::Vector<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9712                float64s: fidl::new_empty!(fidl::encoding::Vector<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9713                enums: fidl::new_empty!(fidl::encoding::Vector<DefaultEnum, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9714                bits: fidl::new_empty!(fidl::encoding::Vector<DefaultBits, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9715                handles: fidl::new_empty!(
9716                    fidl::encoding::Vector<
9717                        fidl::encoding::HandleType<
9718                            fidl::Handle,
9719                            { fidl::ObjectType::NONE.into_raw() },
9720                            2147483648,
9721                        >,
9722                        3,
9723                    >,
9724                    fidl::encoding::DefaultFuchsiaResourceDialect
9725                ),
9726                nullable_handles: fidl::new_empty!(
9727                    fidl::encoding::Vector<
9728                        fidl::encoding::Optional<
9729                            fidl::encoding::HandleType<
9730                                fidl::Handle,
9731                                { fidl::ObjectType::NONE.into_raw() },
9732                                2147483648,
9733                            >,
9734                        >,
9735                        3,
9736                    >,
9737                    fidl::encoding::DefaultFuchsiaResourceDialect
9738                ),
9739                strings: fidl::new_empty!(fidl::encoding::Vector<fidl::encoding::UnboundedString, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9740                nullable_strings: fidl::new_empty!(
9741                    fidl::encoding::Vector<
9742                        fidl::encoding::Optional<fidl::encoding::UnboundedString>,
9743                        3,
9744                    >,
9745                    fidl::encoding::DefaultFuchsiaResourceDialect
9746                ),
9747                structs: fidl::new_empty!(fidl::encoding::Vector<ThisIsAStruct, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9748                nullable_structs: fidl::new_empty!(
9749                    fidl::encoding::Vector<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
9750                    fidl::encoding::DefaultFuchsiaResourceDialect
9751                ),
9752                unions: fidl::new_empty!(fidl::encoding::Vector<ThisIsAUnion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9753                nullable_unions: fidl::new_empty!(
9754                    fidl::encoding::Vector<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
9755                    fidl::encoding::DefaultFuchsiaResourceDialect
9756                ),
9757                arrays: fidl::new_empty!(
9758                    fidl::encoding::Vector<fidl::encoding::Array<u32, 3>, 3>,
9759                    fidl::encoding::DefaultFuchsiaResourceDialect
9760                ),
9761                vectors: fidl::new_empty!(
9762                    fidl::encoding::Vector<fidl::encoding::UnboundedVector<u32>, 3>,
9763                    fidl::encoding::DefaultFuchsiaResourceDialect
9764                ),
9765                nullable_vectors: fidl::new_empty!(
9766                    fidl::encoding::Vector<
9767                        fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
9768                        3,
9769                    >,
9770                    fidl::encoding::DefaultFuchsiaResourceDialect
9771                ),
9772                tables: fidl::new_empty!(fidl::encoding::Vector<ThisIsATable, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9773                xunions: fidl::new_empty!(fidl::encoding::Vector<ThisIsAXunion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
9774            }
9775        }
9776
9777        #[inline]
9778        unsafe fn decode(
9779            &mut self,
9780            decoder: &mut fidl::encoding::Decoder<
9781                '_,
9782                fidl::encoding::DefaultFuchsiaResourceDialect,
9783            >,
9784            offset: usize,
9785            _depth: fidl::encoding::Depth,
9786        ) -> fidl::Result<()> {
9787            decoder.debug_check_bounds::<Self>(offset);
9788            // Verify that padding bytes are zero.
9789            fidl::decode!(fidl::encoding::Vector<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.bools, decoder, offset + 0, _depth)?;
9790            fidl::decode!(fidl::encoding::Vector<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int8s, decoder, offset + 16, _depth)?;
9791            fidl::decode!(fidl::encoding::Vector<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int16s, decoder, offset + 32, _depth)?;
9792            fidl::decode!(fidl::encoding::Vector<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int32s, decoder, offset + 48, _depth)?;
9793            fidl::decode!(fidl::encoding::Vector<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.int64s, decoder, offset + 64, _depth)?;
9794            fidl::decode!(fidl::encoding::Vector<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint8s, decoder, offset + 80, _depth)?;
9795            fidl::decode!(fidl::encoding::Vector<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint16s, decoder, offset + 96, _depth)?;
9796            fidl::decode!(fidl::encoding::Vector<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint32s, decoder, offset + 112, _depth)?;
9797            fidl::decode!(fidl::encoding::Vector<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.uint64s, decoder, offset + 128, _depth)?;
9798            fidl::decode!(fidl::encoding::Vector<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.float32s, decoder, offset + 144, _depth)?;
9799            fidl::decode!(fidl::encoding::Vector<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.float64s, decoder, offset + 160, _depth)?;
9800            fidl::decode!(fidl::encoding::Vector<DefaultEnum, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.enums, decoder, offset + 176, _depth)?;
9801            fidl::decode!(fidl::encoding::Vector<DefaultBits, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.bits, decoder, offset + 192, _depth)?;
9802            fidl::decode!(
9803                fidl::encoding::Vector<
9804                    fidl::encoding::HandleType<
9805                        fidl::Handle,
9806                        { fidl::ObjectType::NONE.into_raw() },
9807                        2147483648,
9808                    >,
9809                    3,
9810                >,
9811                fidl::encoding::DefaultFuchsiaResourceDialect,
9812                &mut self.handles,
9813                decoder,
9814                offset + 208,
9815                _depth
9816            )?;
9817            fidl::decode!(
9818                fidl::encoding::Vector<
9819                    fidl::encoding::Optional<
9820                        fidl::encoding::HandleType<
9821                            fidl::Handle,
9822                            { fidl::ObjectType::NONE.into_raw() },
9823                            2147483648,
9824                        >,
9825                    >,
9826                    3,
9827                >,
9828                fidl::encoding::DefaultFuchsiaResourceDialect,
9829                &mut self.nullable_handles,
9830                decoder,
9831                offset + 224,
9832                _depth
9833            )?;
9834            fidl::decode!(fidl::encoding::Vector<fidl::encoding::UnboundedString, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.strings, decoder, offset + 240, _depth)?;
9835            fidl::decode!(
9836                fidl::encoding::Vector<
9837                    fidl::encoding::Optional<fidl::encoding::UnboundedString>,
9838                    3,
9839                >,
9840                fidl::encoding::DefaultFuchsiaResourceDialect,
9841                &mut self.nullable_strings,
9842                decoder,
9843                offset + 256,
9844                _depth
9845            )?;
9846            fidl::decode!(fidl::encoding::Vector<ThisIsAStruct, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.structs, decoder, offset + 272, _depth)?;
9847            fidl::decode!(
9848                fidl::encoding::Vector<fidl::encoding::Boxed<ThisIsAStruct>, 3>,
9849                fidl::encoding::DefaultFuchsiaResourceDialect,
9850                &mut self.nullable_structs,
9851                decoder,
9852                offset + 288,
9853                _depth
9854            )?;
9855            fidl::decode!(fidl::encoding::Vector<ThisIsAUnion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.unions, decoder, offset + 304, _depth)?;
9856            fidl::decode!(
9857                fidl::encoding::Vector<fidl::encoding::OptionalUnion<ThisIsAUnion>, 3>,
9858                fidl::encoding::DefaultFuchsiaResourceDialect,
9859                &mut self.nullable_unions,
9860                decoder,
9861                offset + 320,
9862                _depth
9863            )?;
9864            fidl::decode!(
9865                fidl::encoding::Vector<fidl::encoding::Array<u32, 3>, 3>,
9866                fidl::encoding::DefaultFuchsiaResourceDialect,
9867                &mut self.arrays,
9868                decoder,
9869                offset + 336,
9870                _depth
9871            )?;
9872            fidl::decode!(
9873                fidl::encoding::Vector<fidl::encoding::UnboundedVector<u32>, 3>,
9874                fidl::encoding::DefaultFuchsiaResourceDialect,
9875                &mut self.vectors,
9876                decoder,
9877                offset + 352,
9878                _depth
9879            )?;
9880            fidl::decode!(
9881                fidl::encoding::Vector<
9882                    fidl::encoding::Optional<fidl::encoding::UnboundedVector<u32>>,
9883                    3,
9884                >,
9885                fidl::encoding::DefaultFuchsiaResourceDialect,
9886                &mut self.nullable_vectors,
9887                decoder,
9888                offset + 368,
9889                _depth
9890            )?;
9891            fidl::decode!(fidl::encoding::Vector<ThisIsATable, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.tables, decoder, offset + 384, _depth)?;
9892            fidl::decode!(fidl::encoding::Vector<ThisIsAXunion, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.xunions, decoder, offset + 400, _depth)?;
9893            Ok(())
9894        }
9895    }
9896
9897    impl fidl::encoding::ResourceTypeMarker for Arrays {
9898        type Borrowed<'a> = &'a mut Self;
9899        fn take_or_borrow<'a>(
9900            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
9901        ) -> Self::Borrowed<'a> {
9902            value
9903        }
9904    }
9905
9906    unsafe impl fidl::encoding::TypeMarker for Arrays {
9907        type Owned = Self;
9908
9909        #[inline(always)]
9910        fn inline_align(_context: fidl::encoding::Context) -> usize {
9911            8
9912        }
9913
9914        #[inline(always)]
9915        fn inline_size(_context: fidl::encoding::Context) -> usize {
9916            208
9917        }
9918    }
9919
9920    unsafe impl fidl::encoding::Encode<Arrays, fidl::encoding::DefaultFuchsiaResourceDialect>
9921        for &mut Arrays
9922    {
9923        #[inline]
9924        unsafe fn encode(
9925            self,
9926            encoder: &mut fidl::encoding::Encoder<
9927                '_,
9928                fidl::encoding::DefaultFuchsiaResourceDialect,
9929            >,
9930            offset: usize,
9931            _depth: fidl::encoding::Depth,
9932        ) -> fidl::Result<()> {
9933            encoder.debug_check_bounds::<Arrays>(offset);
9934            // Delegate to tuple encoding.
9935            fidl::encoding::Encode::<Arrays, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
9936                (
9937                    <fidl::encoding::Array<bool, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9938                        &self.b_0,
9939                    ),
9940                    <fidl::encoding::Array<i8, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9941                        &self.i8_0,
9942                    ),
9943                    <fidl::encoding::Array<i16, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9944                        &self.i16_0,
9945                    ),
9946                    <fidl::encoding::Array<i32, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9947                        &self.i32_0,
9948                    ),
9949                    <fidl::encoding::Array<i64, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9950                        &self.i64_0,
9951                    ),
9952                    <fidl::encoding::Array<u8, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9953                        &self.u8_0,
9954                    ),
9955                    <fidl::encoding::Array<u16, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9956                        &self.u16_0,
9957                    ),
9958                    <fidl::encoding::Array<u32, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9959                        &self.u32_0,
9960                    ),
9961                    <fidl::encoding::Array<u64, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9962                        &self.u64_0,
9963                    ),
9964                    <fidl::encoding::Array<f32, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9965                        &self.f32_0,
9966                    ),
9967                    <fidl::encoding::Array<f64, 1> as fidl::encoding::ValueTypeMarker>::borrow(
9968                        &self.f64_0,
9969                    ),
9970                    <fidl::encoding::Array<
9971                        fidl::encoding::HandleType<
9972                            fidl::Handle,
9973                            { fidl::ObjectType::NONE.into_raw() },
9974                            2147483648,
9975                        >,
9976                        1,
9977                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
9978                        &mut self.handle_0
9979                    ),
9980                    <fidl::encoding::Array<bool, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9981                        &self.b_1,
9982                    ),
9983                    <fidl::encoding::Array<i8, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9984                        &self.i8_1,
9985                    ),
9986                    <fidl::encoding::Array<i16, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9987                        &self.i16_1,
9988                    ),
9989                    <fidl::encoding::Array<i32, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9990                        &self.i32_1,
9991                    ),
9992                    <fidl::encoding::Array<i64, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9993                        &self.i64_1,
9994                    ),
9995                    <fidl::encoding::Array<u8, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9996                        &self.u8_1,
9997                    ),
9998                    <fidl::encoding::Array<u16, 3> as fidl::encoding::ValueTypeMarker>::borrow(
9999                        &self.u16_1,
10000                    ),
10001                    <fidl::encoding::Array<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow(
10002                        &self.u32_1,
10003                    ),
10004                    <fidl::encoding::Array<u64, 3> as fidl::encoding::ValueTypeMarker>::borrow(
10005                        &self.u64_1,
10006                    ),
10007                    <fidl::encoding::Array<f32, 3> as fidl::encoding::ValueTypeMarker>::borrow(
10008                        &self.f32_1,
10009                    ),
10010                    <fidl::encoding::Array<f64, 3> as fidl::encoding::ValueTypeMarker>::borrow(
10011                        &self.f64_1,
10012                    ),
10013                    <fidl::encoding::Array<
10014                        fidl::encoding::HandleType<
10015                            fidl::Handle,
10016                            { fidl::ObjectType::NONE.into_raw() },
10017                            2147483648,
10018                        >,
10019                        3,
10020                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10021                        &mut self.handle_1
10022                    ),
10023                ),
10024                encoder,
10025                offset,
10026                _depth,
10027            )
10028        }
10029    }
10030    unsafe impl<
10031            T0: fidl::encoding::Encode<
10032                fidl::encoding::Array<bool, 1>,
10033                fidl::encoding::DefaultFuchsiaResourceDialect,
10034            >,
10035            T1: fidl::encoding::Encode<
10036                fidl::encoding::Array<i8, 1>,
10037                fidl::encoding::DefaultFuchsiaResourceDialect,
10038            >,
10039            T2: fidl::encoding::Encode<
10040                fidl::encoding::Array<i16, 1>,
10041                fidl::encoding::DefaultFuchsiaResourceDialect,
10042            >,
10043            T3: fidl::encoding::Encode<
10044                fidl::encoding::Array<i32, 1>,
10045                fidl::encoding::DefaultFuchsiaResourceDialect,
10046            >,
10047            T4: fidl::encoding::Encode<
10048                fidl::encoding::Array<i64, 1>,
10049                fidl::encoding::DefaultFuchsiaResourceDialect,
10050            >,
10051            T5: fidl::encoding::Encode<
10052                fidl::encoding::Array<u8, 1>,
10053                fidl::encoding::DefaultFuchsiaResourceDialect,
10054            >,
10055            T6: fidl::encoding::Encode<
10056                fidl::encoding::Array<u16, 1>,
10057                fidl::encoding::DefaultFuchsiaResourceDialect,
10058            >,
10059            T7: fidl::encoding::Encode<
10060                fidl::encoding::Array<u32, 1>,
10061                fidl::encoding::DefaultFuchsiaResourceDialect,
10062            >,
10063            T8: fidl::encoding::Encode<
10064                fidl::encoding::Array<u64, 1>,
10065                fidl::encoding::DefaultFuchsiaResourceDialect,
10066            >,
10067            T9: fidl::encoding::Encode<
10068                fidl::encoding::Array<f32, 1>,
10069                fidl::encoding::DefaultFuchsiaResourceDialect,
10070            >,
10071            T10: fidl::encoding::Encode<
10072                fidl::encoding::Array<f64, 1>,
10073                fidl::encoding::DefaultFuchsiaResourceDialect,
10074            >,
10075            T11: fidl::encoding::Encode<
10076                fidl::encoding::Array<
10077                    fidl::encoding::HandleType<
10078                        fidl::Handle,
10079                        { fidl::ObjectType::NONE.into_raw() },
10080                        2147483648,
10081                    >,
10082                    1,
10083                >,
10084                fidl::encoding::DefaultFuchsiaResourceDialect,
10085            >,
10086            T12: fidl::encoding::Encode<
10087                fidl::encoding::Array<bool, 3>,
10088                fidl::encoding::DefaultFuchsiaResourceDialect,
10089            >,
10090            T13: fidl::encoding::Encode<
10091                fidl::encoding::Array<i8, 3>,
10092                fidl::encoding::DefaultFuchsiaResourceDialect,
10093            >,
10094            T14: fidl::encoding::Encode<
10095                fidl::encoding::Array<i16, 3>,
10096                fidl::encoding::DefaultFuchsiaResourceDialect,
10097            >,
10098            T15: fidl::encoding::Encode<
10099                fidl::encoding::Array<i32, 3>,
10100                fidl::encoding::DefaultFuchsiaResourceDialect,
10101            >,
10102            T16: fidl::encoding::Encode<
10103                fidl::encoding::Array<i64, 3>,
10104                fidl::encoding::DefaultFuchsiaResourceDialect,
10105            >,
10106            T17: fidl::encoding::Encode<
10107                fidl::encoding::Array<u8, 3>,
10108                fidl::encoding::DefaultFuchsiaResourceDialect,
10109            >,
10110            T18: fidl::encoding::Encode<
10111                fidl::encoding::Array<u16, 3>,
10112                fidl::encoding::DefaultFuchsiaResourceDialect,
10113            >,
10114            T19: fidl::encoding::Encode<
10115                fidl::encoding::Array<u32, 3>,
10116                fidl::encoding::DefaultFuchsiaResourceDialect,
10117            >,
10118            T20: fidl::encoding::Encode<
10119                fidl::encoding::Array<u64, 3>,
10120                fidl::encoding::DefaultFuchsiaResourceDialect,
10121            >,
10122            T21: fidl::encoding::Encode<
10123                fidl::encoding::Array<f32, 3>,
10124                fidl::encoding::DefaultFuchsiaResourceDialect,
10125            >,
10126            T22: fidl::encoding::Encode<
10127                fidl::encoding::Array<f64, 3>,
10128                fidl::encoding::DefaultFuchsiaResourceDialect,
10129            >,
10130            T23: fidl::encoding::Encode<
10131                fidl::encoding::Array<
10132                    fidl::encoding::HandleType<
10133                        fidl::Handle,
10134                        { fidl::ObjectType::NONE.into_raw() },
10135                        2147483648,
10136                    >,
10137                    3,
10138                >,
10139                fidl::encoding::DefaultFuchsiaResourceDialect,
10140            >,
10141        > fidl::encoding::Encode<Arrays, fidl::encoding::DefaultFuchsiaResourceDialect>
10142        for (
10143            T0,
10144            T1,
10145            T2,
10146            T3,
10147            T4,
10148            T5,
10149            T6,
10150            T7,
10151            T8,
10152            T9,
10153            T10,
10154            T11,
10155            T12,
10156            T13,
10157            T14,
10158            T15,
10159            T16,
10160            T17,
10161            T18,
10162            T19,
10163            T20,
10164            T21,
10165            T22,
10166            T23,
10167        )
10168    {
10169        #[inline]
10170        unsafe fn encode(
10171            self,
10172            encoder: &mut fidl::encoding::Encoder<
10173                '_,
10174                fidl::encoding::DefaultFuchsiaResourceDialect,
10175            >,
10176            offset: usize,
10177            depth: fidl::encoding::Depth,
10178        ) -> fidl::Result<()> {
10179            encoder.debug_check_bounds::<Arrays>(offset);
10180            // Zero out padding regions. There's no need to apply masks
10181            // because the unmasked parts will be overwritten by fields.
10182            unsafe {
10183                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
10184                (ptr as *mut u64).write_unaligned(0);
10185            }
10186            unsafe {
10187                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
10188                (ptr as *mut u64).write_unaligned(0);
10189            }
10190            unsafe {
10191                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(72);
10192                (ptr as *mut u64).write_unaligned(0);
10193            }
10194            unsafe {
10195                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(104);
10196                (ptr as *mut u64).write_unaligned(0);
10197            }
10198            unsafe {
10199                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(112);
10200                (ptr as *mut u64).write_unaligned(0);
10201            }
10202            unsafe {
10203                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(160);
10204                (ptr as *mut u64).write_unaligned(0);
10205            }
10206            unsafe {
10207                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(200);
10208                (ptr as *mut u64).write_unaligned(0);
10209            }
10210            // Write the fields.
10211            self.0.encode(encoder, offset + 0, depth)?;
10212            self.1.encode(encoder, offset + 1, depth)?;
10213            self.2.encode(encoder, offset + 2, depth)?;
10214            self.3.encode(encoder, offset + 4, depth)?;
10215            self.4.encode(encoder, offset + 8, depth)?;
10216            self.5.encode(encoder, offset + 16, depth)?;
10217            self.6.encode(encoder, offset + 18, depth)?;
10218            self.7.encode(encoder, offset + 20, depth)?;
10219            self.8.encode(encoder, offset + 24, depth)?;
10220            self.9.encode(encoder, offset + 32, depth)?;
10221            self.10.encode(encoder, offset + 40, depth)?;
10222            self.11.encode(encoder, offset + 48, depth)?;
10223            self.12.encode(encoder, offset + 52, depth)?;
10224            self.13.encode(encoder, offset + 55, depth)?;
10225            self.14.encode(encoder, offset + 58, depth)?;
10226            self.15.encode(encoder, offset + 64, depth)?;
10227            self.16.encode(encoder, offset + 80, depth)?;
10228            self.17.encode(encoder, offset + 104, depth)?;
10229            self.18.encode(encoder, offset + 108, depth)?;
10230            self.19.encode(encoder, offset + 116, depth)?;
10231            self.20.encode(encoder, offset + 128, depth)?;
10232            self.21.encode(encoder, offset + 152, depth)?;
10233            self.22.encode(encoder, offset + 168, depth)?;
10234            self.23.encode(encoder, offset + 192, depth)?;
10235            Ok(())
10236        }
10237    }
10238
10239    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Arrays {
10240        #[inline(always)]
10241        fn new_empty() -> Self {
10242            Self {
10243                b_0: fidl::new_empty!(fidl::encoding::Array<bool, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10244                i8_0: fidl::new_empty!(fidl::encoding::Array<i8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10245                i16_0: fidl::new_empty!(fidl::encoding::Array<i16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10246                i32_0: fidl::new_empty!(fidl::encoding::Array<i32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10247                i64_0: fidl::new_empty!(fidl::encoding::Array<i64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10248                u8_0: fidl::new_empty!(fidl::encoding::Array<u8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10249                u16_0: fidl::new_empty!(fidl::encoding::Array<u16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10250                u32_0: fidl::new_empty!(fidl::encoding::Array<u32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10251                u64_0: fidl::new_empty!(fidl::encoding::Array<u64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10252                f32_0: fidl::new_empty!(fidl::encoding::Array<f32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10253                f64_0: fidl::new_empty!(fidl::encoding::Array<f64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
10254                handle_0: fidl::new_empty!(
10255                    fidl::encoding::Array<
10256                        fidl::encoding::HandleType<
10257                            fidl::Handle,
10258                            { fidl::ObjectType::NONE.into_raw() },
10259                            2147483648,
10260                        >,
10261                        1,
10262                    >,
10263                    fidl::encoding::DefaultFuchsiaResourceDialect
10264                ),
10265                b_1: fidl::new_empty!(fidl::encoding::Array<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10266                i8_1: fidl::new_empty!(fidl::encoding::Array<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10267                i16_1: fidl::new_empty!(fidl::encoding::Array<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10268                i32_1: fidl::new_empty!(fidl::encoding::Array<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10269                i64_1: fidl::new_empty!(fidl::encoding::Array<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10270                u8_1: fidl::new_empty!(fidl::encoding::Array<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10271                u16_1: fidl::new_empty!(fidl::encoding::Array<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10272                u32_1: fidl::new_empty!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10273                u64_1: fidl::new_empty!(fidl::encoding::Array<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10274                f32_1: fidl::new_empty!(fidl::encoding::Array<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10275                f64_1: fidl::new_empty!(fidl::encoding::Array<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
10276                handle_1: fidl::new_empty!(
10277                    fidl::encoding::Array<
10278                        fidl::encoding::HandleType<
10279                            fidl::Handle,
10280                            { fidl::ObjectType::NONE.into_raw() },
10281                            2147483648,
10282                        >,
10283                        3,
10284                    >,
10285                    fidl::encoding::DefaultFuchsiaResourceDialect
10286                ),
10287            }
10288        }
10289
10290        #[inline]
10291        unsafe fn decode(
10292            &mut self,
10293            decoder: &mut fidl::encoding::Decoder<
10294                '_,
10295                fidl::encoding::DefaultFuchsiaResourceDialect,
10296            >,
10297            offset: usize,
10298            _depth: fidl::encoding::Depth,
10299        ) -> fidl::Result<()> {
10300            decoder.debug_check_bounds::<Self>(offset);
10301            // Verify that padding bytes are zero.
10302            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
10303            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10304            let mask = 0xff00u64;
10305            let maskedval = padval & mask;
10306            if maskedval != 0 {
10307                return Err(fidl::Error::NonZeroPadding {
10308                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
10309                });
10310            }
10311            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
10312            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10313            let mask = 0xffffffff00000000u64;
10314            let maskedval = padval & mask;
10315            if maskedval != 0 {
10316                return Err(fidl::Error::NonZeroPadding {
10317                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
10318                });
10319            }
10320            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(72) };
10321            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10322            let mask = 0xffffffff00000000u64;
10323            let maskedval = padval & mask;
10324            if maskedval != 0 {
10325                return Err(fidl::Error::NonZeroPadding {
10326                    padding_start: offset + 72 + ((mask as u64).trailing_zeros() / 8) as usize,
10327                });
10328            }
10329            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(104) };
10330            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10331            let mask = 0xff000000u64;
10332            let maskedval = padval & mask;
10333            if maskedval != 0 {
10334                return Err(fidl::Error::NonZeroPadding {
10335                    padding_start: offset + 104 + ((mask as u64).trailing_zeros() / 8) as usize,
10336                });
10337            }
10338            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(112) };
10339            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10340            let mask = 0xffff0000u64;
10341            let maskedval = padval & mask;
10342            if maskedval != 0 {
10343                return Err(fidl::Error::NonZeroPadding {
10344                    padding_start: offset + 112 + ((mask as u64).trailing_zeros() / 8) as usize,
10345                });
10346            }
10347            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(160) };
10348            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10349            let mask = 0xffffffff00000000u64;
10350            let maskedval = padval & mask;
10351            if maskedval != 0 {
10352                return Err(fidl::Error::NonZeroPadding {
10353                    padding_start: offset + 160 + ((mask as u64).trailing_zeros() / 8) as usize,
10354                });
10355            }
10356            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(200) };
10357            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10358            let mask = 0xffffffff00000000u64;
10359            let maskedval = padval & mask;
10360            if maskedval != 0 {
10361                return Err(fidl::Error::NonZeroPadding {
10362                    padding_start: offset + 200 + ((mask as u64).trailing_zeros() / 8) as usize,
10363                });
10364            }
10365            fidl::decode!(fidl::encoding::Array<bool, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.b_0, decoder, offset + 0, _depth)?;
10366            fidl::decode!(fidl::encoding::Array<i8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i8_0, decoder, offset + 1, _depth)?;
10367            fidl::decode!(fidl::encoding::Array<i16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i16_0, decoder, offset + 2, _depth)?;
10368            fidl::decode!(fidl::encoding::Array<i32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i32_0, decoder, offset + 4, _depth)?;
10369            fidl::decode!(fidl::encoding::Array<i64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i64_0, decoder, offset + 8, _depth)?;
10370            fidl::decode!(fidl::encoding::Array<u8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u8_0, decoder, offset + 16, _depth)?;
10371            fidl::decode!(fidl::encoding::Array<u16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u16_0, decoder, offset + 18, _depth)?;
10372            fidl::decode!(fidl::encoding::Array<u32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u32_0, decoder, offset + 20, _depth)?;
10373            fidl::decode!(fidl::encoding::Array<u64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u64_0, decoder, offset + 24, _depth)?;
10374            fidl::decode!(fidl::encoding::Array<f32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f32_0, decoder, offset + 32, _depth)?;
10375            fidl::decode!(fidl::encoding::Array<f64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f64_0, decoder, offset + 40, _depth)?;
10376            fidl::decode!(
10377                fidl::encoding::Array<
10378                    fidl::encoding::HandleType<
10379                        fidl::Handle,
10380                        { fidl::ObjectType::NONE.into_raw() },
10381                        2147483648,
10382                    >,
10383                    1,
10384                >,
10385                fidl::encoding::DefaultFuchsiaResourceDialect,
10386                &mut self.handle_0,
10387                decoder,
10388                offset + 48,
10389                _depth
10390            )?;
10391            fidl::decode!(fidl::encoding::Array<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.b_1, decoder, offset + 52, _depth)?;
10392            fidl::decode!(fidl::encoding::Array<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i8_1, decoder, offset + 55, _depth)?;
10393            fidl::decode!(fidl::encoding::Array<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i16_1, decoder, offset + 58, _depth)?;
10394            fidl::decode!(fidl::encoding::Array<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i32_1, decoder, offset + 64, _depth)?;
10395            fidl::decode!(fidl::encoding::Array<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i64_1, decoder, offset + 80, _depth)?;
10396            fidl::decode!(fidl::encoding::Array<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u8_1, decoder, offset + 104, _depth)?;
10397            fidl::decode!(fidl::encoding::Array<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u16_1, decoder, offset + 108, _depth)?;
10398            fidl::decode!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u32_1, decoder, offset + 116, _depth)?;
10399            fidl::decode!(fidl::encoding::Array<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u64_1, decoder, offset + 128, _depth)?;
10400            fidl::decode!(fidl::encoding::Array<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f32_1, decoder, offset + 152, _depth)?;
10401            fidl::decode!(fidl::encoding::Array<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f64_1, decoder, offset + 168, _depth)?;
10402            fidl::decode!(
10403                fidl::encoding::Array<
10404                    fidl::encoding::HandleType<
10405                        fidl::Handle,
10406                        { fidl::ObjectType::NONE.into_raw() },
10407                        2147483648,
10408                    >,
10409                    3,
10410                >,
10411                fidl::encoding::DefaultFuchsiaResourceDialect,
10412                &mut self.handle_1,
10413                decoder,
10414                offset + 192,
10415                _depth
10416            )?;
10417            Ok(())
10418        }
10419    }
10420
10421    impl fidl::encoding::ResourceTypeMarker for Arrays2d {
10422        type Borrowed<'a> = &'a mut Self;
10423        fn take_or_borrow<'a>(
10424            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
10425        ) -> Self::Borrowed<'a> {
10426            value
10427        }
10428    }
10429
10430    unsafe impl fidl::encoding::TypeMarker for Arrays2d {
10431        type Owned = Self;
10432
10433        #[inline(always)]
10434        fn inline_align(_context: fidl::encoding::Context) -> usize {
10435            8
10436        }
10437
10438        #[inline(always)]
10439        fn inline_size(_context: fidl::encoding::Context) -> usize {
10440            288
10441        }
10442    }
10443
10444    unsafe impl fidl::encoding::Encode<Arrays2d, fidl::encoding::DefaultFuchsiaResourceDialect>
10445        for &mut Arrays2d
10446    {
10447        #[inline]
10448        unsafe fn encode(
10449            self,
10450            encoder: &mut fidl::encoding::Encoder<
10451                '_,
10452                fidl::encoding::DefaultFuchsiaResourceDialect,
10453            >,
10454            offset: usize,
10455            _depth: fidl::encoding::Depth,
10456        ) -> fidl::Result<()> {
10457            encoder.debug_check_bounds::<Arrays2d>(offset);
10458            // Delegate to tuple encoding.
10459            fidl::encoding::Encode::<Arrays2d, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
10460                (
10461                    <fidl::encoding::Array<fidl::encoding::Array<bool, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.b),
10462                    <fidl::encoding::Array<fidl::encoding::Array<i8, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8),
10463                    <fidl::encoding::Array<fidl::encoding::Array<i16, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16),
10464                    <fidl::encoding::Array<fidl::encoding::Array<i32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32),
10465                    <fidl::encoding::Array<fidl::encoding::Array<i64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64),
10466                    <fidl::encoding::Array<fidl::encoding::Array<u8, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8),
10467                    <fidl::encoding::Array<fidl::encoding::Array<u16, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16),
10468                    <fidl::encoding::Array<fidl::encoding::Array<u32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32),
10469                    <fidl::encoding::Array<fidl::encoding::Array<u64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64),
10470                    <fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32),
10471                    <fidl::encoding::Array<fidl::encoding::Array<f64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64),
10472                    <fidl::encoding::Array<fidl::encoding::Array<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 2>, 3> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_handle),
10473                ),
10474                encoder, offset, _depth
10475            )
10476        }
10477    }
10478    unsafe impl<
10479            T0: fidl::encoding::Encode<
10480                fidl::encoding::Array<fidl::encoding::Array<bool, 2>, 3>,
10481                fidl::encoding::DefaultFuchsiaResourceDialect,
10482            >,
10483            T1: fidl::encoding::Encode<
10484                fidl::encoding::Array<fidl::encoding::Array<i8, 2>, 3>,
10485                fidl::encoding::DefaultFuchsiaResourceDialect,
10486            >,
10487            T2: fidl::encoding::Encode<
10488                fidl::encoding::Array<fidl::encoding::Array<i16, 2>, 3>,
10489                fidl::encoding::DefaultFuchsiaResourceDialect,
10490            >,
10491            T3: fidl::encoding::Encode<
10492                fidl::encoding::Array<fidl::encoding::Array<i32, 2>, 3>,
10493                fidl::encoding::DefaultFuchsiaResourceDialect,
10494            >,
10495            T4: fidl::encoding::Encode<
10496                fidl::encoding::Array<fidl::encoding::Array<i64, 2>, 3>,
10497                fidl::encoding::DefaultFuchsiaResourceDialect,
10498            >,
10499            T5: fidl::encoding::Encode<
10500                fidl::encoding::Array<fidl::encoding::Array<u8, 2>, 3>,
10501                fidl::encoding::DefaultFuchsiaResourceDialect,
10502            >,
10503            T6: fidl::encoding::Encode<
10504                fidl::encoding::Array<fidl::encoding::Array<u16, 2>, 3>,
10505                fidl::encoding::DefaultFuchsiaResourceDialect,
10506            >,
10507            T7: fidl::encoding::Encode<
10508                fidl::encoding::Array<fidl::encoding::Array<u32, 2>, 3>,
10509                fidl::encoding::DefaultFuchsiaResourceDialect,
10510            >,
10511            T8: fidl::encoding::Encode<
10512                fidl::encoding::Array<fidl::encoding::Array<u64, 2>, 3>,
10513                fidl::encoding::DefaultFuchsiaResourceDialect,
10514            >,
10515            T9: fidl::encoding::Encode<
10516                fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 3>,
10517                fidl::encoding::DefaultFuchsiaResourceDialect,
10518            >,
10519            T10: fidl::encoding::Encode<
10520                fidl::encoding::Array<fidl::encoding::Array<f64, 2>, 3>,
10521                fidl::encoding::DefaultFuchsiaResourceDialect,
10522            >,
10523            T11: fidl::encoding::Encode<
10524                fidl::encoding::Array<
10525                    fidl::encoding::Array<
10526                        fidl::encoding::HandleType<
10527                            fidl::Handle,
10528                            { fidl::ObjectType::NONE.into_raw() },
10529                            2147483648,
10530                        >,
10531                        2,
10532                    >,
10533                    3,
10534                >,
10535                fidl::encoding::DefaultFuchsiaResourceDialect,
10536            >,
10537        > fidl::encoding::Encode<Arrays2d, fidl::encoding::DefaultFuchsiaResourceDialect>
10538        for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
10539    {
10540        #[inline]
10541        unsafe fn encode(
10542            self,
10543            encoder: &mut fidl::encoding::Encoder<
10544                '_,
10545                fidl::encoding::DefaultFuchsiaResourceDialect,
10546            >,
10547            offset: usize,
10548            depth: fidl::encoding::Depth,
10549        ) -> fidl::Result<()> {
10550            encoder.debug_check_bounds::<Arrays2d>(offset);
10551            // Zero out padding regions. There's no need to apply masks
10552            // because the unmasked parts will be overwritten by fields.
10553            unsafe {
10554                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(112);
10555                (ptr as *mut u64).write_unaligned(0);
10556            }
10557            unsafe {
10558                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(136);
10559                (ptr as *mut u64).write_unaligned(0);
10560            }
10561            // Write the fields.
10562            self.0.encode(encoder, offset + 0, depth)?;
10563            self.1.encode(encoder, offset + 6, depth)?;
10564            self.2.encode(encoder, offset + 12, depth)?;
10565            self.3.encode(encoder, offset + 24, depth)?;
10566            self.4.encode(encoder, offset + 48, depth)?;
10567            self.5.encode(encoder, offset + 96, depth)?;
10568            self.6.encode(encoder, offset + 102, depth)?;
10569            self.7.encode(encoder, offset + 116, depth)?;
10570            self.8.encode(encoder, offset + 144, depth)?;
10571            self.9.encode(encoder, offset + 192, depth)?;
10572            self.10.encode(encoder, offset + 216, depth)?;
10573            self.11.encode(encoder, offset + 264, depth)?;
10574            Ok(())
10575        }
10576    }
10577
10578    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Arrays2d {
10579        #[inline(always)]
10580        fn new_empty() -> Self {
10581            Self {
10582                b: fidl::new_empty!(
10583                    fidl::encoding::Array<fidl::encoding::Array<bool, 2>, 3>,
10584                    fidl::encoding::DefaultFuchsiaResourceDialect
10585                ),
10586                i8: fidl::new_empty!(
10587                    fidl::encoding::Array<fidl::encoding::Array<i8, 2>, 3>,
10588                    fidl::encoding::DefaultFuchsiaResourceDialect
10589                ),
10590                i16: fidl::new_empty!(
10591                    fidl::encoding::Array<fidl::encoding::Array<i16, 2>, 3>,
10592                    fidl::encoding::DefaultFuchsiaResourceDialect
10593                ),
10594                i32: fidl::new_empty!(
10595                    fidl::encoding::Array<fidl::encoding::Array<i32, 2>, 3>,
10596                    fidl::encoding::DefaultFuchsiaResourceDialect
10597                ),
10598                i64: fidl::new_empty!(
10599                    fidl::encoding::Array<fidl::encoding::Array<i64, 2>, 3>,
10600                    fidl::encoding::DefaultFuchsiaResourceDialect
10601                ),
10602                u8: fidl::new_empty!(
10603                    fidl::encoding::Array<fidl::encoding::Array<u8, 2>, 3>,
10604                    fidl::encoding::DefaultFuchsiaResourceDialect
10605                ),
10606                u16: fidl::new_empty!(
10607                    fidl::encoding::Array<fidl::encoding::Array<u16, 2>, 3>,
10608                    fidl::encoding::DefaultFuchsiaResourceDialect
10609                ),
10610                u32: fidl::new_empty!(
10611                    fidl::encoding::Array<fidl::encoding::Array<u32, 2>, 3>,
10612                    fidl::encoding::DefaultFuchsiaResourceDialect
10613                ),
10614                u64: fidl::new_empty!(
10615                    fidl::encoding::Array<fidl::encoding::Array<u64, 2>, 3>,
10616                    fidl::encoding::DefaultFuchsiaResourceDialect
10617                ),
10618                f32: fidl::new_empty!(
10619                    fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 3>,
10620                    fidl::encoding::DefaultFuchsiaResourceDialect
10621                ),
10622                f64: fidl::new_empty!(
10623                    fidl::encoding::Array<fidl::encoding::Array<f64, 2>, 3>,
10624                    fidl::encoding::DefaultFuchsiaResourceDialect
10625                ),
10626                handle_handle: fidl::new_empty!(
10627                    fidl::encoding::Array<
10628                        fidl::encoding::Array<
10629                            fidl::encoding::HandleType<
10630                                fidl::Handle,
10631                                { fidl::ObjectType::NONE.into_raw() },
10632                                2147483648,
10633                            >,
10634                            2,
10635                        >,
10636                        3,
10637                    >,
10638                    fidl::encoding::DefaultFuchsiaResourceDialect
10639                ),
10640            }
10641        }
10642
10643        #[inline]
10644        unsafe fn decode(
10645            &mut self,
10646            decoder: &mut fidl::encoding::Decoder<
10647                '_,
10648                fidl::encoding::DefaultFuchsiaResourceDialect,
10649            >,
10650            offset: usize,
10651            _depth: fidl::encoding::Depth,
10652        ) -> fidl::Result<()> {
10653            decoder.debug_check_bounds::<Self>(offset);
10654            // Verify that padding bytes are zero.
10655            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(112) };
10656            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10657            let mask = 0xffff0000u64;
10658            let maskedval = padval & mask;
10659            if maskedval != 0 {
10660                return Err(fidl::Error::NonZeroPadding {
10661                    padding_start: offset + 112 + ((mask as u64).trailing_zeros() / 8) as usize,
10662                });
10663            }
10664            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(136) };
10665            let padval = unsafe { (ptr as *const u64).read_unaligned() };
10666            let mask = 0xffffffff00000000u64;
10667            let maskedval = padval & mask;
10668            if maskedval != 0 {
10669                return Err(fidl::Error::NonZeroPadding {
10670                    padding_start: offset + 136 + ((mask as u64).trailing_zeros() / 8) as usize,
10671                });
10672            }
10673            fidl::decode!(
10674                fidl::encoding::Array<fidl::encoding::Array<bool, 2>, 3>,
10675                fidl::encoding::DefaultFuchsiaResourceDialect,
10676                &mut self.b,
10677                decoder,
10678                offset + 0,
10679                _depth
10680            )?;
10681            fidl::decode!(
10682                fidl::encoding::Array<fidl::encoding::Array<i8, 2>, 3>,
10683                fidl::encoding::DefaultFuchsiaResourceDialect,
10684                &mut self.i8,
10685                decoder,
10686                offset + 6,
10687                _depth
10688            )?;
10689            fidl::decode!(
10690                fidl::encoding::Array<fidl::encoding::Array<i16, 2>, 3>,
10691                fidl::encoding::DefaultFuchsiaResourceDialect,
10692                &mut self.i16,
10693                decoder,
10694                offset + 12,
10695                _depth
10696            )?;
10697            fidl::decode!(
10698                fidl::encoding::Array<fidl::encoding::Array<i32, 2>, 3>,
10699                fidl::encoding::DefaultFuchsiaResourceDialect,
10700                &mut self.i32,
10701                decoder,
10702                offset + 24,
10703                _depth
10704            )?;
10705            fidl::decode!(
10706                fidl::encoding::Array<fidl::encoding::Array<i64, 2>, 3>,
10707                fidl::encoding::DefaultFuchsiaResourceDialect,
10708                &mut self.i64,
10709                decoder,
10710                offset + 48,
10711                _depth
10712            )?;
10713            fidl::decode!(
10714                fidl::encoding::Array<fidl::encoding::Array<u8, 2>, 3>,
10715                fidl::encoding::DefaultFuchsiaResourceDialect,
10716                &mut self.u8,
10717                decoder,
10718                offset + 96,
10719                _depth
10720            )?;
10721            fidl::decode!(
10722                fidl::encoding::Array<fidl::encoding::Array<u16, 2>, 3>,
10723                fidl::encoding::DefaultFuchsiaResourceDialect,
10724                &mut self.u16,
10725                decoder,
10726                offset + 102,
10727                _depth
10728            )?;
10729            fidl::decode!(
10730                fidl::encoding::Array<fidl::encoding::Array<u32, 2>, 3>,
10731                fidl::encoding::DefaultFuchsiaResourceDialect,
10732                &mut self.u32,
10733                decoder,
10734                offset + 116,
10735                _depth
10736            )?;
10737            fidl::decode!(
10738                fidl::encoding::Array<fidl::encoding::Array<u64, 2>, 3>,
10739                fidl::encoding::DefaultFuchsiaResourceDialect,
10740                &mut self.u64,
10741                decoder,
10742                offset + 144,
10743                _depth
10744            )?;
10745            fidl::decode!(
10746                fidl::encoding::Array<fidl::encoding::Array<f32, 2>, 3>,
10747                fidl::encoding::DefaultFuchsiaResourceDialect,
10748                &mut self.f32,
10749                decoder,
10750                offset + 192,
10751                _depth
10752            )?;
10753            fidl::decode!(
10754                fidl::encoding::Array<fidl::encoding::Array<f64, 2>, 3>,
10755                fidl::encoding::DefaultFuchsiaResourceDialect,
10756                &mut self.f64,
10757                decoder,
10758                offset + 216,
10759                _depth
10760            )?;
10761            fidl::decode!(
10762                fidl::encoding::Array<
10763                    fidl::encoding::Array<
10764                        fidl::encoding::HandleType<
10765                            fidl::Handle,
10766                            { fidl::ObjectType::NONE.into_raw() },
10767                            2147483648,
10768                        >,
10769                        2,
10770                    >,
10771                    3,
10772                >,
10773                fidl::encoding::DefaultFuchsiaResourceDialect,
10774                &mut self.handle_handle,
10775                decoder,
10776                offset + 264,
10777                _depth
10778            )?;
10779            Ok(())
10780        }
10781    }
10782
10783    impl fidl::encoding::ResourceTypeMarker for Handles {
10784        type Borrowed<'a> = &'a mut Self;
10785        fn take_or_borrow<'a>(
10786            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
10787        ) -> Self::Borrowed<'a> {
10788            value
10789        }
10790    }
10791
10792    unsafe impl fidl::encoding::TypeMarker for Handles {
10793        type Owned = Self;
10794
10795        #[inline(always)]
10796        fn inline_align(_context: fidl::encoding::Context) -> usize {
10797            4
10798        }
10799
10800        #[inline(always)]
10801        fn inline_size(_context: fidl::encoding::Context) -> usize {
10802            108
10803        }
10804    }
10805
10806    unsafe impl fidl::encoding::Encode<Handles, fidl::encoding::DefaultFuchsiaResourceDialect>
10807        for &mut Handles
10808    {
10809        #[inline]
10810        unsafe fn encode(
10811            self,
10812            encoder: &mut fidl::encoding::Encoder<
10813                '_,
10814                fidl::encoding::DefaultFuchsiaResourceDialect,
10815            >,
10816            offset: usize,
10817            _depth: fidl::encoding::Depth,
10818        ) -> fidl::Result<()> {
10819            encoder.debug_check_bounds::<Handles>(offset);
10820            // Delegate to tuple encoding.
10821            fidl::encoding::Encode::<Handles, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
10822                (
10823                    <fidl::encoding::HandleType<
10824                        fidl::Handle,
10825                        { fidl::ObjectType::NONE.into_raw() },
10826                        2147483648,
10827                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10828                        &mut self.handle_handle,
10829                    ),
10830                    <fidl::encoding::HandleType<
10831                        fidl::Process,
10832                        { fidl::ObjectType::PROCESS.into_raw() },
10833                        2147483648,
10834                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10835                        &mut self.process_handle,
10836                    ),
10837                    <fidl::encoding::HandleType<
10838                        fidl::Thread,
10839                        { fidl::ObjectType::THREAD.into_raw() },
10840                        2147483648,
10841                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10842                        &mut self.thread_handle,
10843                    ),
10844                    <fidl::encoding::HandleType<
10845                        fidl::Vmo,
10846                        { fidl::ObjectType::VMO.into_raw() },
10847                        2147483648,
10848                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10849                        &mut self.vmo_handle
10850                    ),
10851                    <fidl::encoding::HandleType<
10852                        fidl::Event,
10853                        { fidl::ObjectType::EVENT.into_raw() },
10854                        2147483648,
10855                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10856                        &mut self.event_handle,
10857                    ),
10858                    <fidl::encoding::HandleType<
10859                        fidl::Port,
10860                        { fidl::ObjectType::PORT.into_raw() },
10861                        2147483648,
10862                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10863                        &mut self.port_handle
10864                    ),
10865                    <fidl::encoding::HandleType<
10866                        fidl::Socket,
10867                        { fidl::ObjectType::SOCKET.into_raw() },
10868                        2147483648,
10869                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10870                        &mut self.socket_handle,
10871                    ),
10872                    <fidl::encoding::HandleType<
10873                        fidl::EventPair,
10874                        { fidl::ObjectType::EVENTPAIR.into_raw() },
10875                        2147483648,
10876                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10877                        &mut self.eventpair_handle,
10878                    ),
10879                    <fidl::encoding::HandleType<
10880                        fidl::Job,
10881                        { fidl::ObjectType::JOB.into_raw() },
10882                        2147483648,
10883                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10884                        &mut self.job_handle
10885                    ),
10886                    <fidl::encoding::HandleType<
10887                        fidl::Vmar,
10888                        { fidl::ObjectType::VMAR.into_raw() },
10889                        2147483648,
10890                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10891                        &mut self.vmar_handle
10892                    ),
10893                    <fidl::encoding::HandleType<
10894                        fidl::Fifo,
10895                        { fidl::ObjectType::FIFO.into_raw() },
10896                        2147483648,
10897                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10898                        &mut self.fifo_handle
10899                    ),
10900                    <fidl::encoding::HandleType<
10901                        fidl::Timer,
10902                        { fidl::ObjectType::TIMER.into_raw() },
10903                        2147483648,
10904                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10905                        &mut self.timer_handle,
10906                    ),
10907                    <fidl::encoding::Optional<
10908                        fidl::encoding::HandleType<
10909                            fidl::Handle,
10910                            { fidl::ObjectType::NONE.into_raw() },
10911                            2147483648,
10912                        >,
10913                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10914                        &mut self.nullable_handle_handle,
10915                    ),
10916                    <fidl::encoding::Optional<
10917                        fidl::encoding::HandleType<
10918                            fidl::Process,
10919                            { fidl::ObjectType::PROCESS.into_raw() },
10920                            2147483648,
10921                        >,
10922                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10923                        &mut self.nullable_process_handle,
10924                    ),
10925                    <fidl::encoding::Optional<
10926                        fidl::encoding::HandleType<
10927                            fidl::Thread,
10928                            { fidl::ObjectType::THREAD.into_raw() },
10929                            2147483648,
10930                        >,
10931                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10932                        &mut self.nullable_thread_handle,
10933                    ),
10934                    <fidl::encoding::Optional<
10935                        fidl::encoding::HandleType<
10936                            fidl::Vmo,
10937                            { fidl::ObjectType::VMO.into_raw() },
10938                            2147483648,
10939                        >,
10940                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10941                        &mut self.nullable_vmo_handle,
10942                    ),
10943                    <fidl::encoding::Optional<
10944                        fidl::encoding::HandleType<
10945                            fidl::Channel,
10946                            { fidl::ObjectType::CHANNEL.into_raw() },
10947                            2147483648,
10948                        >,
10949                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10950                        &mut self.nullable_channel_handle,
10951                    ),
10952                    <fidl::encoding::Optional<
10953                        fidl::encoding::HandleType<
10954                            fidl::Event,
10955                            { fidl::ObjectType::EVENT.into_raw() },
10956                            2147483648,
10957                        >,
10958                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10959                        &mut self.nullable_event_handle,
10960                    ),
10961                    <fidl::encoding::Optional<
10962                        fidl::encoding::HandleType<
10963                            fidl::Port,
10964                            { fidl::ObjectType::PORT.into_raw() },
10965                            2147483648,
10966                        >,
10967                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10968                        &mut self.nullable_port_handle,
10969                    ),
10970                    <fidl::encoding::Optional<
10971                        fidl::encoding::HandleType<
10972                            fidl::Interrupt,
10973                            { fidl::ObjectType::INTERRUPT.into_raw() },
10974                            2147483648,
10975                        >,
10976                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10977                        &mut self.nullable_interrupt_handle,
10978                    ),
10979                    <fidl::encoding::Optional<
10980                        fidl::encoding::HandleType<
10981                            fidl::DebugLog,
10982                            { fidl::ObjectType::DEBUGLOG.into_raw() },
10983                            2147483648,
10984                        >,
10985                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10986                        &mut self.nullable_log_handle,
10987                    ),
10988                    <fidl::encoding::Optional<
10989                        fidl::encoding::HandleType<
10990                            fidl::Socket,
10991                            { fidl::ObjectType::SOCKET.into_raw() },
10992                            2147483648,
10993                        >,
10994                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
10995                        &mut self.nullable_socket_handle,
10996                    ),
10997                    <fidl::encoding::Optional<
10998                        fidl::encoding::HandleType<
10999                            fidl::EventPair,
11000                            { fidl::ObjectType::EVENTPAIR.into_raw() },
11001                            2147483648,
11002                        >,
11003                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
11004                        &mut self.nullable_eventpair_handle,
11005                    ),
11006                    <fidl::encoding::Optional<
11007                        fidl::encoding::HandleType<
11008                            fidl::Job,
11009                            { fidl::ObjectType::JOB.into_raw() },
11010                            2147483648,
11011                        >,
11012                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
11013                        &mut self.nullable_job_handle,
11014                    ),
11015                    <fidl::encoding::Optional<
11016                        fidl::encoding::HandleType<
11017                            fidl::Vmar,
11018                            { fidl::ObjectType::VMAR.into_raw() },
11019                            2147483648,
11020                        >,
11021                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
11022                        &mut self.nullable_vmar_handle,
11023                    ),
11024                    <fidl::encoding::Optional<
11025                        fidl::encoding::HandleType<
11026                            fidl::Fifo,
11027                            { fidl::ObjectType::FIFO.into_raw() },
11028                            2147483648,
11029                        >,
11030                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
11031                        &mut self.nullable_fifo_handle,
11032                    ),
11033                    <fidl::encoding::Optional<
11034                        fidl::encoding::HandleType<
11035                            fidl::Timer,
11036                            { fidl::ObjectType::TIMER.into_raw() },
11037                            2147483648,
11038                        >,
11039                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
11040                        &mut self.nullable_timer_handle,
11041                    ),
11042                ),
11043                encoder,
11044                offset,
11045                _depth,
11046            )
11047        }
11048    }
11049    unsafe impl<
11050            T0: fidl::encoding::Encode<
11051                fidl::encoding::HandleType<
11052                    fidl::Handle,
11053                    { fidl::ObjectType::NONE.into_raw() },
11054                    2147483648,
11055                >,
11056                fidl::encoding::DefaultFuchsiaResourceDialect,
11057            >,
11058            T1: fidl::encoding::Encode<
11059                fidl::encoding::HandleType<
11060                    fidl::Process,
11061                    { fidl::ObjectType::PROCESS.into_raw() },
11062                    2147483648,
11063                >,
11064                fidl::encoding::DefaultFuchsiaResourceDialect,
11065            >,
11066            T2: fidl::encoding::Encode<
11067                fidl::encoding::HandleType<
11068                    fidl::Thread,
11069                    { fidl::ObjectType::THREAD.into_raw() },
11070                    2147483648,
11071                >,
11072                fidl::encoding::DefaultFuchsiaResourceDialect,
11073            >,
11074            T3: fidl::encoding::Encode<
11075                fidl::encoding::HandleType<
11076                    fidl::Vmo,
11077                    { fidl::ObjectType::VMO.into_raw() },
11078                    2147483648,
11079                >,
11080                fidl::encoding::DefaultFuchsiaResourceDialect,
11081            >,
11082            T4: fidl::encoding::Encode<
11083                fidl::encoding::HandleType<
11084                    fidl::Event,
11085                    { fidl::ObjectType::EVENT.into_raw() },
11086                    2147483648,
11087                >,
11088                fidl::encoding::DefaultFuchsiaResourceDialect,
11089            >,
11090            T5: fidl::encoding::Encode<
11091                fidl::encoding::HandleType<
11092                    fidl::Port,
11093                    { fidl::ObjectType::PORT.into_raw() },
11094                    2147483648,
11095                >,
11096                fidl::encoding::DefaultFuchsiaResourceDialect,
11097            >,
11098            T6: fidl::encoding::Encode<
11099                fidl::encoding::HandleType<
11100                    fidl::Socket,
11101                    { fidl::ObjectType::SOCKET.into_raw() },
11102                    2147483648,
11103                >,
11104                fidl::encoding::DefaultFuchsiaResourceDialect,
11105            >,
11106            T7: fidl::encoding::Encode<
11107                fidl::encoding::HandleType<
11108                    fidl::EventPair,
11109                    { fidl::ObjectType::EVENTPAIR.into_raw() },
11110                    2147483648,
11111                >,
11112                fidl::encoding::DefaultFuchsiaResourceDialect,
11113            >,
11114            T8: fidl::encoding::Encode<
11115                fidl::encoding::HandleType<
11116                    fidl::Job,
11117                    { fidl::ObjectType::JOB.into_raw() },
11118                    2147483648,
11119                >,
11120                fidl::encoding::DefaultFuchsiaResourceDialect,
11121            >,
11122            T9: fidl::encoding::Encode<
11123                fidl::encoding::HandleType<
11124                    fidl::Vmar,
11125                    { fidl::ObjectType::VMAR.into_raw() },
11126                    2147483648,
11127                >,
11128                fidl::encoding::DefaultFuchsiaResourceDialect,
11129            >,
11130            T10: fidl::encoding::Encode<
11131                fidl::encoding::HandleType<
11132                    fidl::Fifo,
11133                    { fidl::ObjectType::FIFO.into_raw() },
11134                    2147483648,
11135                >,
11136                fidl::encoding::DefaultFuchsiaResourceDialect,
11137            >,
11138            T11: fidl::encoding::Encode<
11139                fidl::encoding::HandleType<
11140                    fidl::Timer,
11141                    { fidl::ObjectType::TIMER.into_raw() },
11142                    2147483648,
11143                >,
11144                fidl::encoding::DefaultFuchsiaResourceDialect,
11145            >,
11146            T12: fidl::encoding::Encode<
11147                fidl::encoding::Optional<
11148                    fidl::encoding::HandleType<
11149                        fidl::Handle,
11150                        { fidl::ObjectType::NONE.into_raw() },
11151                        2147483648,
11152                    >,
11153                >,
11154                fidl::encoding::DefaultFuchsiaResourceDialect,
11155            >,
11156            T13: fidl::encoding::Encode<
11157                fidl::encoding::Optional<
11158                    fidl::encoding::HandleType<
11159                        fidl::Process,
11160                        { fidl::ObjectType::PROCESS.into_raw() },
11161                        2147483648,
11162                    >,
11163                >,
11164                fidl::encoding::DefaultFuchsiaResourceDialect,
11165            >,
11166            T14: fidl::encoding::Encode<
11167                fidl::encoding::Optional<
11168                    fidl::encoding::HandleType<
11169                        fidl::Thread,
11170                        { fidl::ObjectType::THREAD.into_raw() },
11171                        2147483648,
11172                    >,
11173                >,
11174                fidl::encoding::DefaultFuchsiaResourceDialect,
11175            >,
11176            T15: fidl::encoding::Encode<
11177                fidl::encoding::Optional<
11178                    fidl::encoding::HandleType<
11179                        fidl::Vmo,
11180                        { fidl::ObjectType::VMO.into_raw() },
11181                        2147483648,
11182                    >,
11183                >,
11184                fidl::encoding::DefaultFuchsiaResourceDialect,
11185            >,
11186            T16: fidl::encoding::Encode<
11187                fidl::encoding::Optional<
11188                    fidl::encoding::HandleType<
11189                        fidl::Channel,
11190                        { fidl::ObjectType::CHANNEL.into_raw() },
11191                        2147483648,
11192                    >,
11193                >,
11194                fidl::encoding::DefaultFuchsiaResourceDialect,
11195            >,
11196            T17: fidl::encoding::Encode<
11197                fidl::encoding::Optional<
11198                    fidl::encoding::HandleType<
11199                        fidl::Event,
11200                        { fidl::ObjectType::EVENT.into_raw() },
11201                        2147483648,
11202                    >,
11203                >,
11204                fidl::encoding::DefaultFuchsiaResourceDialect,
11205            >,
11206            T18: fidl::encoding::Encode<
11207                fidl::encoding::Optional<
11208                    fidl::encoding::HandleType<
11209                        fidl::Port,
11210                        { fidl::ObjectType::PORT.into_raw() },
11211                        2147483648,
11212                    >,
11213                >,
11214                fidl::encoding::DefaultFuchsiaResourceDialect,
11215            >,
11216            T19: fidl::encoding::Encode<
11217                fidl::encoding::Optional<
11218                    fidl::encoding::HandleType<
11219                        fidl::Interrupt,
11220                        { fidl::ObjectType::INTERRUPT.into_raw() },
11221                        2147483648,
11222                    >,
11223                >,
11224                fidl::encoding::DefaultFuchsiaResourceDialect,
11225            >,
11226            T20: fidl::encoding::Encode<
11227                fidl::encoding::Optional<
11228                    fidl::encoding::HandleType<
11229                        fidl::DebugLog,
11230                        { fidl::ObjectType::DEBUGLOG.into_raw() },
11231                        2147483648,
11232                    >,
11233                >,
11234                fidl::encoding::DefaultFuchsiaResourceDialect,
11235            >,
11236            T21: fidl::encoding::Encode<
11237                fidl::encoding::Optional<
11238                    fidl::encoding::HandleType<
11239                        fidl::Socket,
11240                        { fidl::ObjectType::SOCKET.into_raw() },
11241                        2147483648,
11242                    >,
11243                >,
11244                fidl::encoding::DefaultFuchsiaResourceDialect,
11245            >,
11246            T22: fidl::encoding::Encode<
11247                fidl::encoding::Optional<
11248                    fidl::encoding::HandleType<
11249                        fidl::EventPair,
11250                        { fidl::ObjectType::EVENTPAIR.into_raw() },
11251                        2147483648,
11252                    >,
11253                >,
11254                fidl::encoding::DefaultFuchsiaResourceDialect,
11255            >,
11256            T23: fidl::encoding::Encode<
11257                fidl::encoding::Optional<
11258                    fidl::encoding::HandleType<
11259                        fidl::Job,
11260                        { fidl::ObjectType::JOB.into_raw() },
11261                        2147483648,
11262                    >,
11263                >,
11264                fidl::encoding::DefaultFuchsiaResourceDialect,
11265            >,
11266            T24: fidl::encoding::Encode<
11267                fidl::encoding::Optional<
11268                    fidl::encoding::HandleType<
11269                        fidl::Vmar,
11270                        { fidl::ObjectType::VMAR.into_raw() },
11271                        2147483648,
11272                    >,
11273                >,
11274                fidl::encoding::DefaultFuchsiaResourceDialect,
11275            >,
11276            T25: fidl::encoding::Encode<
11277                fidl::encoding::Optional<
11278                    fidl::encoding::HandleType<
11279                        fidl::Fifo,
11280                        { fidl::ObjectType::FIFO.into_raw() },
11281                        2147483648,
11282                    >,
11283                >,
11284                fidl::encoding::DefaultFuchsiaResourceDialect,
11285            >,
11286            T26: fidl::encoding::Encode<
11287                fidl::encoding::Optional<
11288                    fidl::encoding::HandleType<
11289                        fidl::Timer,
11290                        { fidl::ObjectType::TIMER.into_raw() },
11291                        2147483648,
11292                    >,
11293                >,
11294                fidl::encoding::DefaultFuchsiaResourceDialect,
11295            >,
11296        > fidl::encoding::Encode<Handles, fidl::encoding::DefaultFuchsiaResourceDialect>
11297        for (
11298            T0,
11299            T1,
11300            T2,
11301            T3,
11302            T4,
11303            T5,
11304            T6,
11305            T7,
11306            T8,
11307            T9,
11308            T10,
11309            T11,
11310            T12,
11311            T13,
11312            T14,
11313            T15,
11314            T16,
11315            T17,
11316            T18,
11317            T19,
11318            T20,
11319            T21,
11320            T22,
11321            T23,
11322            T24,
11323            T25,
11324            T26,
11325        )
11326    {
11327        #[inline]
11328        unsafe fn encode(
11329            self,
11330            encoder: &mut fidl::encoding::Encoder<
11331                '_,
11332                fidl::encoding::DefaultFuchsiaResourceDialect,
11333            >,
11334            offset: usize,
11335            depth: fidl::encoding::Depth,
11336        ) -> fidl::Result<()> {
11337            encoder.debug_check_bounds::<Handles>(offset);
11338            // Zero out padding regions. There's no need to apply masks
11339            // because the unmasked parts will be overwritten by fields.
11340            // Write the fields.
11341            self.0.encode(encoder, offset + 0, depth)?;
11342            self.1.encode(encoder, offset + 4, depth)?;
11343            self.2.encode(encoder, offset + 8, depth)?;
11344            self.3.encode(encoder, offset + 12, depth)?;
11345            self.4.encode(encoder, offset + 16, depth)?;
11346            self.5.encode(encoder, offset + 20, depth)?;
11347            self.6.encode(encoder, offset + 24, depth)?;
11348            self.7.encode(encoder, offset + 28, depth)?;
11349            self.8.encode(encoder, offset + 32, depth)?;
11350            self.9.encode(encoder, offset + 36, depth)?;
11351            self.10.encode(encoder, offset + 40, depth)?;
11352            self.11.encode(encoder, offset + 44, depth)?;
11353            self.12.encode(encoder, offset + 48, depth)?;
11354            self.13.encode(encoder, offset + 52, depth)?;
11355            self.14.encode(encoder, offset + 56, depth)?;
11356            self.15.encode(encoder, offset + 60, depth)?;
11357            self.16.encode(encoder, offset + 64, depth)?;
11358            self.17.encode(encoder, offset + 68, depth)?;
11359            self.18.encode(encoder, offset + 72, depth)?;
11360            self.19.encode(encoder, offset + 76, depth)?;
11361            self.20.encode(encoder, offset + 80, depth)?;
11362            self.21.encode(encoder, offset + 84, depth)?;
11363            self.22.encode(encoder, offset + 88, depth)?;
11364            self.23.encode(encoder, offset + 92, depth)?;
11365            self.24.encode(encoder, offset + 96, depth)?;
11366            self.25.encode(encoder, offset + 100, depth)?;
11367            self.26.encode(encoder, offset + 104, depth)?;
11368            Ok(())
11369        }
11370    }
11371
11372    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Handles {
11373        #[inline(always)]
11374        fn new_empty() -> Self {
11375            Self {
11376                handle_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11377                process_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Process, { fidl::ObjectType::PROCESS.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11378                thread_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Thread, { fidl::ObjectType::THREAD.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11379                vmo_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11380                event_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11381                port_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Port, { fidl::ObjectType::PORT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11382                socket_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11383                eventpair_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11384                job_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Job, { fidl::ObjectType::JOB.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11385                vmar_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Vmar, { fidl::ObjectType::VMAR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11386                fifo_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Fifo, { fidl::ObjectType::FIFO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11387                timer_handle: fidl::new_empty!(fidl::encoding::HandleType<fidl::Timer, { fidl::ObjectType::TIMER.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
11388                nullable_handle_handle: fidl::new_empty!(
11389                    fidl::encoding::Optional<
11390                        fidl::encoding::HandleType<
11391                            fidl::Handle,
11392                            { fidl::ObjectType::NONE.into_raw() },
11393                            2147483648,
11394                        >,
11395                    >,
11396                    fidl::encoding::DefaultFuchsiaResourceDialect
11397                ),
11398                nullable_process_handle: fidl::new_empty!(
11399                    fidl::encoding::Optional<
11400                        fidl::encoding::HandleType<
11401                            fidl::Process,
11402                            { fidl::ObjectType::PROCESS.into_raw() },
11403                            2147483648,
11404                        >,
11405                    >,
11406                    fidl::encoding::DefaultFuchsiaResourceDialect
11407                ),
11408                nullable_thread_handle: fidl::new_empty!(
11409                    fidl::encoding::Optional<
11410                        fidl::encoding::HandleType<
11411                            fidl::Thread,
11412                            { fidl::ObjectType::THREAD.into_raw() },
11413                            2147483648,
11414                        >,
11415                    >,
11416                    fidl::encoding::DefaultFuchsiaResourceDialect
11417                ),
11418                nullable_vmo_handle: fidl::new_empty!(
11419                    fidl::encoding::Optional<
11420                        fidl::encoding::HandleType<
11421                            fidl::Vmo,
11422                            { fidl::ObjectType::VMO.into_raw() },
11423                            2147483648,
11424                        >,
11425                    >,
11426                    fidl::encoding::DefaultFuchsiaResourceDialect
11427                ),
11428                nullable_channel_handle: fidl::new_empty!(
11429                    fidl::encoding::Optional<
11430                        fidl::encoding::HandleType<
11431                            fidl::Channel,
11432                            { fidl::ObjectType::CHANNEL.into_raw() },
11433                            2147483648,
11434                        >,
11435                    >,
11436                    fidl::encoding::DefaultFuchsiaResourceDialect
11437                ),
11438                nullable_event_handle: fidl::new_empty!(
11439                    fidl::encoding::Optional<
11440                        fidl::encoding::HandleType<
11441                            fidl::Event,
11442                            { fidl::ObjectType::EVENT.into_raw() },
11443                            2147483648,
11444                        >,
11445                    >,
11446                    fidl::encoding::DefaultFuchsiaResourceDialect
11447                ),
11448                nullable_port_handle: fidl::new_empty!(
11449                    fidl::encoding::Optional<
11450                        fidl::encoding::HandleType<
11451                            fidl::Port,
11452                            { fidl::ObjectType::PORT.into_raw() },
11453                            2147483648,
11454                        >,
11455                    >,
11456                    fidl::encoding::DefaultFuchsiaResourceDialect
11457                ),
11458                nullable_interrupt_handle: fidl::new_empty!(
11459                    fidl::encoding::Optional<
11460                        fidl::encoding::HandleType<
11461                            fidl::Interrupt,
11462                            { fidl::ObjectType::INTERRUPT.into_raw() },
11463                            2147483648,
11464                        >,
11465                    >,
11466                    fidl::encoding::DefaultFuchsiaResourceDialect
11467                ),
11468                nullable_log_handle: fidl::new_empty!(
11469                    fidl::encoding::Optional<
11470                        fidl::encoding::HandleType<
11471                            fidl::DebugLog,
11472                            { fidl::ObjectType::DEBUGLOG.into_raw() },
11473                            2147483648,
11474                        >,
11475                    >,
11476                    fidl::encoding::DefaultFuchsiaResourceDialect
11477                ),
11478                nullable_socket_handle: fidl::new_empty!(
11479                    fidl::encoding::Optional<
11480                        fidl::encoding::HandleType<
11481                            fidl::Socket,
11482                            { fidl::ObjectType::SOCKET.into_raw() },
11483                            2147483648,
11484                        >,
11485                    >,
11486                    fidl::encoding::DefaultFuchsiaResourceDialect
11487                ),
11488                nullable_eventpair_handle: fidl::new_empty!(
11489                    fidl::encoding::Optional<
11490                        fidl::encoding::HandleType<
11491                            fidl::EventPair,
11492                            { fidl::ObjectType::EVENTPAIR.into_raw() },
11493                            2147483648,
11494                        >,
11495                    >,
11496                    fidl::encoding::DefaultFuchsiaResourceDialect
11497                ),
11498                nullable_job_handle: fidl::new_empty!(
11499                    fidl::encoding::Optional<
11500                        fidl::encoding::HandleType<
11501                            fidl::Job,
11502                            { fidl::ObjectType::JOB.into_raw() },
11503                            2147483648,
11504                        >,
11505                    >,
11506                    fidl::encoding::DefaultFuchsiaResourceDialect
11507                ),
11508                nullable_vmar_handle: fidl::new_empty!(
11509                    fidl::encoding::Optional<
11510                        fidl::encoding::HandleType<
11511                            fidl::Vmar,
11512                            { fidl::ObjectType::VMAR.into_raw() },
11513                            2147483648,
11514                        >,
11515                    >,
11516                    fidl::encoding::DefaultFuchsiaResourceDialect
11517                ),
11518                nullable_fifo_handle: fidl::new_empty!(
11519                    fidl::encoding::Optional<
11520                        fidl::encoding::HandleType<
11521                            fidl::Fifo,
11522                            { fidl::ObjectType::FIFO.into_raw() },
11523                            2147483648,
11524                        >,
11525                    >,
11526                    fidl::encoding::DefaultFuchsiaResourceDialect
11527                ),
11528                nullable_timer_handle: fidl::new_empty!(
11529                    fidl::encoding::Optional<
11530                        fidl::encoding::HandleType<
11531                            fidl::Timer,
11532                            { fidl::ObjectType::TIMER.into_raw() },
11533                            2147483648,
11534                        >,
11535                    >,
11536                    fidl::encoding::DefaultFuchsiaResourceDialect
11537                ),
11538            }
11539        }
11540
11541        #[inline]
11542        unsafe fn decode(
11543            &mut self,
11544            decoder: &mut fidl::encoding::Decoder<
11545                '_,
11546                fidl::encoding::DefaultFuchsiaResourceDialect,
11547            >,
11548            offset: usize,
11549            _depth: fidl::encoding::Depth,
11550        ) -> fidl::Result<()> {
11551            decoder.debug_check_bounds::<Self>(offset);
11552            // Verify that padding bytes are zero.
11553            fidl::decode!(fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.handle_handle, decoder, offset + 0, _depth)?;
11554            fidl::decode!(fidl::encoding::HandleType<fidl::Process, { fidl::ObjectType::PROCESS.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.process_handle, decoder, offset + 4, _depth)?;
11555            fidl::decode!(fidl::encoding::HandleType<fidl::Thread, { fidl::ObjectType::THREAD.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.thread_handle, decoder, offset + 8, _depth)?;
11556            fidl::decode!(fidl::encoding::HandleType<fidl::Vmo, { fidl::ObjectType::VMO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.vmo_handle, decoder, offset + 12, _depth)?;
11557            fidl::decode!(fidl::encoding::HandleType<fidl::Event, { fidl::ObjectType::EVENT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.event_handle, decoder, offset + 16, _depth)?;
11558            fidl::decode!(fidl::encoding::HandleType<fidl::Port, { fidl::ObjectType::PORT.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.port_handle, decoder, offset + 20, _depth)?;
11559            fidl::decode!(fidl::encoding::HandleType<fidl::Socket, { fidl::ObjectType::SOCKET.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.socket_handle, decoder, offset + 24, _depth)?;
11560            fidl::decode!(fidl::encoding::HandleType<fidl::EventPair, { fidl::ObjectType::EVENTPAIR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.eventpair_handle, decoder, offset + 28, _depth)?;
11561            fidl::decode!(fidl::encoding::HandleType<fidl::Job, { fidl::ObjectType::JOB.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.job_handle, decoder, offset + 32, _depth)?;
11562            fidl::decode!(fidl::encoding::HandleType<fidl::Vmar, { fidl::ObjectType::VMAR.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.vmar_handle, decoder, offset + 36, _depth)?;
11563            fidl::decode!(fidl::encoding::HandleType<fidl::Fifo, { fidl::ObjectType::FIFO.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.fifo_handle, decoder, offset + 40, _depth)?;
11564            fidl::decode!(fidl::encoding::HandleType<fidl::Timer, { fidl::ObjectType::TIMER.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.timer_handle, decoder, offset + 44, _depth)?;
11565            fidl::decode!(
11566                fidl::encoding::Optional<
11567                    fidl::encoding::HandleType<
11568                        fidl::Handle,
11569                        { fidl::ObjectType::NONE.into_raw() },
11570                        2147483648,
11571                    >,
11572                >,
11573                fidl::encoding::DefaultFuchsiaResourceDialect,
11574                &mut self.nullable_handle_handle,
11575                decoder,
11576                offset + 48,
11577                _depth
11578            )?;
11579            fidl::decode!(
11580                fidl::encoding::Optional<
11581                    fidl::encoding::HandleType<
11582                        fidl::Process,
11583                        { fidl::ObjectType::PROCESS.into_raw() },
11584                        2147483648,
11585                    >,
11586                >,
11587                fidl::encoding::DefaultFuchsiaResourceDialect,
11588                &mut self.nullable_process_handle,
11589                decoder,
11590                offset + 52,
11591                _depth
11592            )?;
11593            fidl::decode!(
11594                fidl::encoding::Optional<
11595                    fidl::encoding::HandleType<
11596                        fidl::Thread,
11597                        { fidl::ObjectType::THREAD.into_raw() },
11598                        2147483648,
11599                    >,
11600                >,
11601                fidl::encoding::DefaultFuchsiaResourceDialect,
11602                &mut self.nullable_thread_handle,
11603                decoder,
11604                offset + 56,
11605                _depth
11606            )?;
11607            fidl::decode!(
11608                fidl::encoding::Optional<
11609                    fidl::encoding::HandleType<
11610                        fidl::Vmo,
11611                        { fidl::ObjectType::VMO.into_raw() },
11612                        2147483648,
11613                    >,
11614                >,
11615                fidl::encoding::DefaultFuchsiaResourceDialect,
11616                &mut self.nullable_vmo_handle,
11617                decoder,
11618                offset + 60,
11619                _depth
11620            )?;
11621            fidl::decode!(
11622                fidl::encoding::Optional<
11623                    fidl::encoding::HandleType<
11624                        fidl::Channel,
11625                        { fidl::ObjectType::CHANNEL.into_raw() },
11626                        2147483648,
11627                    >,
11628                >,
11629                fidl::encoding::DefaultFuchsiaResourceDialect,
11630                &mut self.nullable_channel_handle,
11631                decoder,
11632                offset + 64,
11633                _depth
11634            )?;
11635            fidl::decode!(
11636                fidl::encoding::Optional<
11637                    fidl::encoding::HandleType<
11638                        fidl::Event,
11639                        { fidl::ObjectType::EVENT.into_raw() },
11640                        2147483648,
11641                    >,
11642                >,
11643                fidl::encoding::DefaultFuchsiaResourceDialect,
11644                &mut self.nullable_event_handle,
11645                decoder,
11646                offset + 68,
11647                _depth
11648            )?;
11649            fidl::decode!(
11650                fidl::encoding::Optional<
11651                    fidl::encoding::HandleType<
11652                        fidl::Port,
11653                        { fidl::ObjectType::PORT.into_raw() },
11654                        2147483648,
11655                    >,
11656                >,
11657                fidl::encoding::DefaultFuchsiaResourceDialect,
11658                &mut self.nullable_port_handle,
11659                decoder,
11660                offset + 72,
11661                _depth
11662            )?;
11663            fidl::decode!(
11664                fidl::encoding::Optional<
11665                    fidl::encoding::HandleType<
11666                        fidl::Interrupt,
11667                        { fidl::ObjectType::INTERRUPT.into_raw() },
11668                        2147483648,
11669                    >,
11670                >,
11671                fidl::encoding::DefaultFuchsiaResourceDialect,
11672                &mut self.nullable_interrupt_handle,
11673                decoder,
11674                offset + 76,
11675                _depth
11676            )?;
11677            fidl::decode!(
11678                fidl::encoding::Optional<
11679                    fidl::encoding::HandleType<
11680                        fidl::DebugLog,
11681                        { fidl::ObjectType::DEBUGLOG.into_raw() },
11682                        2147483648,
11683                    >,
11684                >,
11685                fidl::encoding::DefaultFuchsiaResourceDialect,
11686                &mut self.nullable_log_handle,
11687                decoder,
11688                offset + 80,
11689                _depth
11690            )?;
11691            fidl::decode!(
11692                fidl::encoding::Optional<
11693                    fidl::encoding::HandleType<
11694                        fidl::Socket,
11695                        { fidl::ObjectType::SOCKET.into_raw() },
11696                        2147483648,
11697                    >,
11698                >,
11699                fidl::encoding::DefaultFuchsiaResourceDialect,
11700                &mut self.nullable_socket_handle,
11701                decoder,
11702                offset + 84,
11703                _depth
11704            )?;
11705            fidl::decode!(
11706                fidl::encoding::Optional<
11707                    fidl::encoding::HandleType<
11708                        fidl::EventPair,
11709                        { fidl::ObjectType::EVENTPAIR.into_raw() },
11710                        2147483648,
11711                    >,
11712                >,
11713                fidl::encoding::DefaultFuchsiaResourceDialect,
11714                &mut self.nullable_eventpair_handle,
11715                decoder,
11716                offset + 88,
11717                _depth
11718            )?;
11719            fidl::decode!(
11720                fidl::encoding::Optional<
11721                    fidl::encoding::HandleType<
11722                        fidl::Job,
11723                        { fidl::ObjectType::JOB.into_raw() },
11724                        2147483648,
11725                    >,
11726                >,
11727                fidl::encoding::DefaultFuchsiaResourceDialect,
11728                &mut self.nullable_job_handle,
11729                decoder,
11730                offset + 92,
11731                _depth
11732            )?;
11733            fidl::decode!(
11734                fidl::encoding::Optional<
11735                    fidl::encoding::HandleType<
11736                        fidl::Vmar,
11737                        { fidl::ObjectType::VMAR.into_raw() },
11738                        2147483648,
11739                    >,
11740                >,
11741                fidl::encoding::DefaultFuchsiaResourceDialect,
11742                &mut self.nullable_vmar_handle,
11743                decoder,
11744                offset + 96,
11745                _depth
11746            )?;
11747            fidl::decode!(
11748                fidl::encoding::Optional<
11749                    fidl::encoding::HandleType<
11750                        fidl::Fifo,
11751                        { fidl::ObjectType::FIFO.into_raw() },
11752                        2147483648,
11753                    >,
11754                >,
11755                fidl::encoding::DefaultFuchsiaResourceDialect,
11756                &mut self.nullable_fifo_handle,
11757                decoder,
11758                offset + 100,
11759                _depth
11760            )?;
11761            fidl::decode!(
11762                fidl::encoding::Optional<
11763                    fidl::encoding::HandleType<
11764                        fidl::Timer,
11765                        { fidl::ObjectType::TIMER.into_raw() },
11766                        2147483648,
11767                    >,
11768                >,
11769                fidl::encoding::DefaultFuchsiaResourceDialect,
11770                &mut self.nullable_timer_handle,
11771                decoder,
11772                offset + 104,
11773                _depth
11774            )?;
11775            Ok(())
11776        }
11777    }
11778
11779    impl fidl::encoding::ResourceTypeMarker for Vectors {
11780        type Borrowed<'a> = &'a mut Self;
11781        fn take_or_borrow<'a>(
11782            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
11783        ) -> Self::Borrowed<'a> {
11784            value
11785        }
11786    }
11787
11788    unsafe impl fidl::encoding::TypeMarker for Vectors {
11789        type Owned = Self;
11790
11791        #[inline(always)]
11792        fn inline_align(_context: fidl::encoding::Context) -> usize {
11793            8
11794        }
11795
11796        #[inline(always)]
11797        fn inline_size(_context: fidl::encoding::Context) -> usize {
11798            1920
11799        }
11800    }
11801
11802    unsafe impl fidl::encoding::Encode<Vectors, fidl::encoding::DefaultFuchsiaResourceDialect>
11803        for &mut Vectors
11804    {
11805        #[inline]
11806        unsafe fn encode(
11807            self,
11808            encoder: &mut fidl::encoding::Encoder<
11809                '_,
11810                fidl::encoding::DefaultFuchsiaResourceDialect,
11811            >,
11812            offset: usize,
11813            _depth: fidl::encoding::Depth,
11814        ) -> fidl::Result<()> {
11815            encoder.debug_check_bounds::<Vectors>(offset);
11816            // Delegate to tuple encoding.
11817            fidl::encoding::Encode::<Vectors, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
11818                (
11819                    <fidl::encoding::UnboundedVector<bool> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_0),
11820                    <fidl::encoding::UnboundedVector<i8> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_0),
11821                    <fidl::encoding::UnboundedVector<i16> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_0),
11822                    <fidl::encoding::UnboundedVector<i32> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_0),
11823                    <fidl::encoding::UnboundedVector<i64> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_0),
11824                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_0),
11825                    <fidl::encoding::UnboundedVector<u16> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_0),
11826                    <fidl::encoding::UnboundedVector<u32> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_0),
11827                    <fidl::encoding::UnboundedVector<u64> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_0),
11828                    <fidl::encoding::UnboundedVector<f32> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_0),
11829                    <fidl::encoding::UnboundedVector<f64> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_0),
11830                    <fidl::encoding::UnboundedVector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_0),
11831                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_1),
11832                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_1),
11833                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_1),
11834                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_1),
11835                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_1),
11836                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_1),
11837                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_1),
11838                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_1),
11839                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_1),
11840                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_1),
11841                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_1),
11842                    <fidl::encoding::UnboundedVector<fidl::encoding::Vector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 2>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_1),
11843                    <fidl::encoding::Vector<bool, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_sized_0),
11844                    <fidl::encoding::Vector<i8, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_sized_0),
11845                    <fidl::encoding::Vector<i16, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_sized_0),
11846                    <fidl::encoding::Vector<i32, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_sized_0),
11847                    <fidl::encoding::Vector<i64, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_sized_0),
11848                    <fidl::encoding::Vector<u8, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_sized_0),
11849                    <fidl::encoding::Vector<u16, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_sized_0),
11850                    <fidl::encoding::Vector<u32, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_sized_0),
11851                    <fidl::encoding::Vector<u64, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_sized_0),
11852                    <fidl::encoding::Vector<f32, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_sized_0),
11853                    <fidl::encoding::Vector<f64, 1> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_sized_0),
11854                    <fidl::encoding::Vector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 1> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_sized_0),
11855                    <fidl::encoding::Vector<bool, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_sized_1),
11856                    <fidl::encoding::Vector<i8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_sized_1),
11857                    <fidl::encoding::Vector<i16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_sized_1),
11858                    <fidl::encoding::Vector<i32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_sized_1),
11859                    <fidl::encoding::Vector<i64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_sized_1),
11860                    <fidl::encoding::Vector<u8, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_sized_1),
11861                    <fidl::encoding::Vector<u16, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_sized_1),
11862                    <fidl::encoding::Vector<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_sized_1),
11863                    <fidl::encoding::Vector<u64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_sized_1),
11864                    <fidl::encoding::Vector<f32, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_sized_1),
11865                    <fidl::encoding::Vector<f64, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_sized_1),
11866                    <fidl::encoding::Vector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 3> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_sized_1),
11867                    <fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_sized_2),
11868                    <fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_sized_2),
11869                    <fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_sized_2),
11870                    <fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_sized_2),
11871                    <fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_sized_2),
11872                    <fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_sized_2),
11873                    <fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_sized_2),
11874                    <fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_sized_2),
11875                    <fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_sized_2),
11876                    <fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_sized_2),
11877                    <fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_sized_2),
11878                    <fidl::encoding::Vector<fidl::encoding::Vector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 2>, 3> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_sized_2),
11879                    <fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_nullable_0),
11880                    <fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_nullable_0),
11881                    <fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_nullable_0),
11882                    <fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_nullable_0),
11883                    <fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_nullable_0),
11884                    <fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_nullable_0),
11885                    <fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_nullable_0),
11886                    <fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_nullable_0),
11887                    <fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_nullable_0),
11888                    <fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_nullable_0),
11889                    <fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_nullable_0),
11890                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 1>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_nullable_0),
11891                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_nullable_1),
11892                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_nullable_1),
11893                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_nullable_1),
11894                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_nullable_1),
11895                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_nullable_1),
11896                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_nullable_1),
11897                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_nullable_1),
11898                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_nullable_1),
11899                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_nullable_1),
11900                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_nullable_1),
11901                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_nullable_1),
11902                    <fidl::encoding::Optional<fidl::encoding::UnboundedVector<fidl::encoding::Vector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 2>>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_nullable_1),
11903                    <fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_nullable_sized_0),
11904                    <fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_nullable_sized_0),
11905                    <fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_nullable_sized_0),
11906                    <fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_nullable_sized_0),
11907                    <fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_nullable_sized_0),
11908                    <fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_nullable_sized_0),
11909                    <fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_nullable_sized_0),
11910                    <fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_nullable_sized_0),
11911                    <fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_nullable_sized_0),
11912                    <fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_nullable_sized_0),
11913                    <fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_nullable_sized_0),
11914                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 1>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_nullable_sized_0),
11915                    <fidl::encoding::Optional<fidl::encoding::Vector<bool, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_nullable_sized_1),
11916                    <fidl::encoding::Optional<fidl::encoding::Vector<i8, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_nullable_sized_1),
11917                    <fidl::encoding::Optional<fidl::encoding::Vector<i16, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_nullable_sized_1),
11918                    <fidl::encoding::Optional<fidl::encoding::Vector<i32, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_nullable_sized_1),
11919                    <fidl::encoding::Optional<fidl::encoding::Vector<i64, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_nullable_sized_1),
11920                    <fidl::encoding::Optional<fidl::encoding::Vector<u8, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_nullable_sized_1),
11921                    <fidl::encoding::Optional<fidl::encoding::Vector<u16, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_nullable_sized_1),
11922                    <fidl::encoding::Optional<fidl::encoding::Vector<u32, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_nullable_sized_1),
11923                    <fidl::encoding::Optional<fidl::encoding::Vector<u64, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_nullable_sized_1),
11924                    <fidl::encoding::Optional<fidl::encoding::Vector<f32, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_nullable_sized_1),
11925                    <fidl::encoding::Optional<fidl::encoding::Vector<f64, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_nullable_sized_1),
11926                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 3>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_nullable_sized_1),
11927                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.b_nullable_sized_2),
11928                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i8_nullable_sized_2),
11929                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i16_nullable_sized_2),
11930                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i32_nullable_sized_2),
11931                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.i64_nullable_sized_2),
11932                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u8_nullable_sized_2),
11933                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u16_nullable_sized_2),
11934                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u32_nullable_sized_2),
11935                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.u64_nullable_sized_2),
11936                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f32_nullable_sized_2),
11937                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>> as fidl::encoding::ValueTypeMarker>::borrow(&self.f64_nullable_sized_2),
11938                    <fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, 2>, 3>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.handle_nullable_sized_2),
11939                ),
11940                encoder, offset, _depth
11941            )
11942        }
11943    }
11944    unsafe impl<
11945            T0: fidl::encoding::Encode<
11946                fidl::encoding::UnboundedVector<bool>,
11947                fidl::encoding::DefaultFuchsiaResourceDialect,
11948            >,
11949            T1: fidl::encoding::Encode<
11950                fidl::encoding::UnboundedVector<i8>,
11951                fidl::encoding::DefaultFuchsiaResourceDialect,
11952            >,
11953            T2: fidl::encoding::Encode<
11954                fidl::encoding::UnboundedVector<i16>,
11955                fidl::encoding::DefaultFuchsiaResourceDialect,
11956            >,
11957            T3: fidl::encoding::Encode<
11958                fidl::encoding::UnboundedVector<i32>,
11959                fidl::encoding::DefaultFuchsiaResourceDialect,
11960            >,
11961            T4: fidl::encoding::Encode<
11962                fidl::encoding::UnboundedVector<i64>,
11963                fidl::encoding::DefaultFuchsiaResourceDialect,
11964            >,
11965            T5: fidl::encoding::Encode<
11966                fidl::encoding::UnboundedVector<u8>,
11967                fidl::encoding::DefaultFuchsiaResourceDialect,
11968            >,
11969            T6: fidl::encoding::Encode<
11970                fidl::encoding::UnboundedVector<u16>,
11971                fidl::encoding::DefaultFuchsiaResourceDialect,
11972            >,
11973            T7: fidl::encoding::Encode<
11974                fidl::encoding::UnboundedVector<u32>,
11975                fidl::encoding::DefaultFuchsiaResourceDialect,
11976            >,
11977            T8: fidl::encoding::Encode<
11978                fidl::encoding::UnboundedVector<u64>,
11979                fidl::encoding::DefaultFuchsiaResourceDialect,
11980            >,
11981            T9: fidl::encoding::Encode<
11982                fidl::encoding::UnboundedVector<f32>,
11983                fidl::encoding::DefaultFuchsiaResourceDialect,
11984            >,
11985            T10: fidl::encoding::Encode<
11986                fidl::encoding::UnboundedVector<f64>,
11987                fidl::encoding::DefaultFuchsiaResourceDialect,
11988            >,
11989            T11: fidl::encoding::Encode<
11990                fidl::encoding::UnboundedVector<
11991                    fidl::encoding::HandleType<
11992                        fidl::Handle,
11993                        { fidl::ObjectType::NONE.into_raw() },
11994                        2147483648,
11995                    >,
11996                >,
11997                fidl::encoding::DefaultFuchsiaResourceDialect,
11998            >,
11999            T12: fidl::encoding::Encode<
12000                fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
12001                fidl::encoding::DefaultFuchsiaResourceDialect,
12002            >,
12003            T13: fidl::encoding::Encode<
12004                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
12005                fidl::encoding::DefaultFuchsiaResourceDialect,
12006            >,
12007            T14: fidl::encoding::Encode<
12008                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
12009                fidl::encoding::DefaultFuchsiaResourceDialect,
12010            >,
12011            T15: fidl::encoding::Encode<
12012                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
12013                fidl::encoding::DefaultFuchsiaResourceDialect,
12014            >,
12015            T16: fidl::encoding::Encode<
12016                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
12017                fidl::encoding::DefaultFuchsiaResourceDialect,
12018            >,
12019            T17: fidl::encoding::Encode<
12020                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
12021                fidl::encoding::DefaultFuchsiaResourceDialect,
12022            >,
12023            T18: fidl::encoding::Encode<
12024                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
12025                fidl::encoding::DefaultFuchsiaResourceDialect,
12026            >,
12027            T19: fidl::encoding::Encode<
12028                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
12029                fidl::encoding::DefaultFuchsiaResourceDialect,
12030            >,
12031            T20: fidl::encoding::Encode<
12032                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
12033                fidl::encoding::DefaultFuchsiaResourceDialect,
12034            >,
12035            T21: fidl::encoding::Encode<
12036                fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
12037                fidl::encoding::DefaultFuchsiaResourceDialect,
12038            >,
12039            T22: fidl::encoding::Encode<
12040                fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
12041                fidl::encoding::DefaultFuchsiaResourceDialect,
12042            >,
12043            T23: fidl::encoding::Encode<
12044                fidl::encoding::UnboundedVector<
12045                    fidl::encoding::Vector<
12046                        fidl::encoding::HandleType<
12047                            fidl::Handle,
12048                            { fidl::ObjectType::NONE.into_raw() },
12049                            2147483648,
12050                        >,
12051                        2,
12052                    >,
12053                >,
12054                fidl::encoding::DefaultFuchsiaResourceDialect,
12055            >,
12056            T24: fidl::encoding::Encode<
12057                fidl::encoding::Vector<bool, 1>,
12058                fidl::encoding::DefaultFuchsiaResourceDialect,
12059            >,
12060            T25: fidl::encoding::Encode<
12061                fidl::encoding::Vector<i8, 1>,
12062                fidl::encoding::DefaultFuchsiaResourceDialect,
12063            >,
12064            T26: fidl::encoding::Encode<
12065                fidl::encoding::Vector<i16, 1>,
12066                fidl::encoding::DefaultFuchsiaResourceDialect,
12067            >,
12068            T27: fidl::encoding::Encode<
12069                fidl::encoding::Vector<i32, 1>,
12070                fidl::encoding::DefaultFuchsiaResourceDialect,
12071            >,
12072            T28: fidl::encoding::Encode<
12073                fidl::encoding::Vector<i64, 1>,
12074                fidl::encoding::DefaultFuchsiaResourceDialect,
12075            >,
12076            T29: fidl::encoding::Encode<
12077                fidl::encoding::Vector<u8, 1>,
12078                fidl::encoding::DefaultFuchsiaResourceDialect,
12079            >,
12080            T30: fidl::encoding::Encode<
12081                fidl::encoding::Vector<u16, 1>,
12082                fidl::encoding::DefaultFuchsiaResourceDialect,
12083            >,
12084            T31: fidl::encoding::Encode<
12085                fidl::encoding::Vector<u32, 1>,
12086                fidl::encoding::DefaultFuchsiaResourceDialect,
12087            >,
12088            T32: fidl::encoding::Encode<
12089                fidl::encoding::Vector<u64, 1>,
12090                fidl::encoding::DefaultFuchsiaResourceDialect,
12091            >,
12092            T33: fidl::encoding::Encode<
12093                fidl::encoding::Vector<f32, 1>,
12094                fidl::encoding::DefaultFuchsiaResourceDialect,
12095            >,
12096            T34: fidl::encoding::Encode<
12097                fidl::encoding::Vector<f64, 1>,
12098                fidl::encoding::DefaultFuchsiaResourceDialect,
12099            >,
12100            T35: fidl::encoding::Encode<
12101                fidl::encoding::Vector<
12102                    fidl::encoding::HandleType<
12103                        fidl::Handle,
12104                        { fidl::ObjectType::NONE.into_raw() },
12105                        2147483648,
12106                    >,
12107                    1,
12108                >,
12109                fidl::encoding::DefaultFuchsiaResourceDialect,
12110            >,
12111            T36: fidl::encoding::Encode<
12112                fidl::encoding::Vector<bool, 3>,
12113                fidl::encoding::DefaultFuchsiaResourceDialect,
12114            >,
12115            T37: fidl::encoding::Encode<
12116                fidl::encoding::Vector<i8, 3>,
12117                fidl::encoding::DefaultFuchsiaResourceDialect,
12118            >,
12119            T38: fidl::encoding::Encode<
12120                fidl::encoding::Vector<i16, 3>,
12121                fidl::encoding::DefaultFuchsiaResourceDialect,
12122            >,
12123            T39: fidl::encoding::Encode<
12124                fidl::encoding::Vector<i32, 3>,
12125                fidl::encoding::DefaultFuchsiaResourceDialect,
12126            >,
12127            T40: fidl::encoding::Encode<
12128                fidl::encoding::Vector<i64, 3>,
12129                fidl::encoding::DefaultFuchsiaResourceDialect,
12130            >,
12131            T41: fidl::encoding::Encode<
12132                fidl::encoding::Vector<u8, 3>,
12133                fidl::encoding::DefaultFuchsiaResourceDialect,
12134            >,
12135            T42: fidl::encoding::Encode<
12136                fidl::encoding::Vector<u16, 3>,
12137                fidl::encoding::DefaultFuchsiaResourceDialect,
12138            >,
12139            T43: fidl::encoding::Encode<
12140                fidl::encoding::Vector<u32, 3>,
12141                fidl::encoding::DefaultFuchsiaResourceDialect,
12142            >,
12143            T44: fidl::encoding::Encode<
12144                fidl::encoding::Vector<u64, 3>,
12145                fidl::encoding::DefaultFuchsiaResourceDialect,
12146            >,
12147            T45: fidl::encoding::Encode<
12148                fidl::encoding::Vector<f32, 3>,
12149                fidl::encoding::DefaultFuchsiaResourceDialect,
12150            >,
12151            T46: fidl::encoding::Encode<
12152                fidl::encoding::Vector<f64, 3>,
12153                fidl::encoding::DefaultFuchsiaResourceDialect,
12154            >,
12155            T47: fidl::encoding::Encode<
12156                fidl::encoding::Vector<
12157                    fidl::encoding::HandleType<
12158                        fidl::Handle,
12159                        { fidl::ObjectType::NONE.into_raw() },
12160                        2147483648,
12161                    >,
12162                    3,
12163                >,
12164                fidl::encoding::DefaultFuchsiaResourceDialect,
12165            >,
12166            T48: fidl::encoding::Encode<
12167                fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
12168                fidl::encoding::DefaultFuchsiaResourceDialect,
12169            >,
12170            T49: fidl::encoding::Encode<
12171                fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>,
12172                fidl::encoding::DefaultFuchsiaResourceDialect,
12173            >,
12174            T50: fidl::encoding::Encode<
12175                fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>,
12176                fidl::encoding::DefaultFuchsiaResourceDialect,
12177            >,
12178            T51: fidl::encoding::Encode<
12179                fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>,
12180                fidl::encoding::DefaultFuchsiaResourceDialect,
12181            >,
12182            T52: fidl::encoding::Encode<
12183                fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>,
12184                fidl::encoding::DefaultFuchsiaResourceDialect,
12185            >,
12186            T53: fidl::encoding::Encode<
12187                fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>,
12188                fidl::encoding::DefaultFuchsiaResourceDialect,
12189            >,
12190            T54: fidl::encoding::Encode<
12191                fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>,
12192                fidl::encoding::DefaultFuchsiaResourceDialect,
12193            >,
12194            T55: fidl::encoding::Encode<
12195                fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>,
12196                fidl::encoding::DefaultFuchsiaResourceDialect,
12197            >,
12198            T56: fidl::encoding::Encode<
12199                fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>,
12200                fidl::encoding::DefaultFuchsiaResourceDialect,
12201            >,
12202            T57: fidl::encoding::Encode<
12203                fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>,
12204                fidl::encoding::DefaultFuchsiaResourceDialect,
12205            >,
12206            T58: fidl::encoding::Encode<
12207                fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>,
12208                fidl::encoding::DefaultFuchsiaResourceDialect,
12209            >,
12210            T59: fidl::encoding::Encode<
12211                fidl::encoding::Vector<
12212                    fidl::encoding::Vector<
12213                        fidl::encoding::HandleType<
12214                            fidl::Handle,
12215                            { fidl::ObjectType::NONE.into_raw() },
12216                            2147483648,
12217                        >,
12218                        2,
12219                    >,
12220                    3,
12221                >,
12222                fidl::encoding::DefaultFuchsiaResourceDialect,
12223            >,
12224            T60: fidl::encoding::Encode<
12225                fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
12226                fidl::encoding::DefaultFuchsiaResourceDialect,
12227            >,
12228            T61: fidl::encoding::Encode<
12229                fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
12230                fidl::encoding::DefaultFuchsiaResourceDialect,
12231            >,
12232            T62: fidl::encoding::Encode<
12233                fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
12234                fidl::encoding::DefaultFuchsiaResourceDialect,
12235            >,
12236            T63: fidl::encoding::Encode<
12237                fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
12238                fidl::encoding::DefaultFuchsiaResourceDialect,
12239            >,
12240            T64: fidl::encoding::Encode<
12241                fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
12242                fidl::encoding::DefaultFuchsiaResourceDialect,
12243            >,
12244            T65: fidl::encoding::Encode<
12245                fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
12246                fidl::encoding::DefaultFuchsiaResourceDialect,
12247            >,
12248            T66: fidl::encoding::Encode<
12249                fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
12250                fidl::encoding::DefaultFuchsiaResourceDialect,
12251            >,
12252            T67: fidl::encoding::Encode<
12253                fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
12254                fidl::encoding::DefaultFuchsiaResourceDialect,
12255            >,
12256            T68: fidl::encoding::Encode<
12257                fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
12258                fidl::encoding::DefaultFuchsiaResourceDialect,
12259            >,
12260            T69: fidl::encoding::Encode<
12261                fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
12262                fidl::encoding::DefaultFuchsiaResourceDialect,
12263            >,
12264            T70: fidl::encoding::Encode<
12265                fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
12266                fidl::encoding::DefaultFuchsiaResourceDialect,
12267            >,
12268            T71: fidl::encoding::Encode<
12269                fidl::encoding::Optional<
12270                    fidl::encoding::Vector<
12271                        fidl::encoding::HandleType<
12272                            fidl::Handle,
12273                            { fidl::ObjectType::NONE.into_raw() },
12274                            2147483648,
12275                        >,
12276                        1,
12277                    >,
12278                >,
12279                fidl::encoding::DefaultFuchsiaResourceDialect,
12280            >,
12281            T72: fidl::encoding::Encode<
12282                fidl::encoding::Optional<
12283                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
12284                >,
12285                fidl::encoding::DefaultFuchsiaResourceDialect,
12286            >,
12287            T73: fidl::encoding::Encode<
12288                fidl::encoding::Optional<
12289                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
12290                >,
12291                fidl::encoding::DefaultFuchsiaResourceDialect,
12292            >,
12293            T74: fidl::encoding::Encode<
12294                fidl::encoding::Optional<
12295                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
12296                >,
12297                fidl::encoding::DefaultFuchsiaResourceDialect,
12298            >,
12299            T75: fidl::encoding::Encode<
12300                fidl::encoding::Optional<
12301                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
12302                >,
12303                fidl::encoding::DefaultFuchsiaResourceDialect,
12304            >,
12305            T76: fidl::encoding::Encode<
12306                fidl::encoding::Optional<
12307                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
12308                >,
12309                fidl::encoding::DefaultFuchsiaResourceDialect,
12310            >,
12311            T77: fidl::encoding::Encode<
12312                fidl::encoding::Optional<
12313                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
12314                >,
12315                fidl::encoding::DefaultFuchsiaResourceDialect,
12316            >,
12317            T78: fidl::encoding::Encode<
12318                fidl::encoding::Optional<
12319                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
12320                >,
12321                fidl::encoding::DefaultFuchsiaResourceDialect,
12322            >,
12323            T79: fidl::encoding::Encode<
12324                fidl::encoding::Optional<
12325                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
12326                >,
12327                fidl::encoding::DefaultFuchsiaResourceDialect,
12328            >,
12329            T80: fidl::encoding::Encode<
12330                fidl::encoding::Optional<
12331                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
12332                >,
12333                fidl::encoding::DefaultFuchsiaResourceDialect,
12334            >,
12335            T81: fidl::encoding::Encode<
12336                fidl::encoding::Optional<
12337                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
12338                >,
12339                fidl::encoding::DefaultFuchsiaResourceDialect,
12340            >,
12341            T82: fidl::encoding::Encode<
12342                fidl::encoding::Optional<
12343                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
12344                >,
12345                fidl::encoding::DefaultFuchsiaResourceDialect,
12346            >,
12347            T83: fidl::encoding::Encode<
12348                fidl::encoding::Optional<
12349                    fidl::encoding::UnboundedVector<
12350                        fidl::encoding::Vector<
12351                            fidl::encoding::HandleType<
12352                                fidl::Handle,
12353                                { fidl::ObjectType::NONE.into_raw() },
12354                                2147483648,
12355                            >,
12356                            2,
12357                        >,
12358                    >,
12359                >,
12360                fidl::encoding::DefaultFuchsiaResourceDialect,
12361            >,
12362            T84: fidl::encoding::Encode<
12363                fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
12364                fidl::encoding::DefaultFuchsiaResourceDialect,
12365            >,
12366            T85: fidl::encoding::Encode<
12367                fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
12368                fidl::encoding::DefaultFuchsiaResourceDialect,
12369            >,
12370            T86: fidl::encoding::Encode<
12371                fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
12372                fidl::encoding::DefaultFuchsiaResourceDialect,
12373            >,
12374            T87: fidl::encoding::Encode<
12375                fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
12376                fidl::encoding::DefaultFuchsiaResourceDialect,
12377            >,
12378            T88: fidl::encoding::Encode<
12379                fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
12380                fidl::encoding::DefaultFuchsiaResourceDialect,
12381            >,
12382            T89: fidl::encoding::Encode<
12383                fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
12384                fidl::encoding::DefaultFuchsiaResourceDialect,
12385            >,
12386            T90: fidl::encoding::Encode<
12387                fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
12388                fidl::encoding::DefaultFuchsiaResourceDialect,
12389            >,
12390            T91: fidl::encoding::Encode<
12391                fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
12392                fidl::encoding::DefaultFuchsiaResourceDialect,
12393            >,
12394            T92: fidl::encoding::Encode<
12395                fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
12396                fidl::encoding::DefaultFuchsiaResourceDialect,
12397            >,
12398            T93: fidl::encoding::Encode<
12399                fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
12400                fidl::encoding::DefaultFuchsiaResourceDialect,
12401            >,
12402            T94: fidl::encoding::Encode<
12403                fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
12404                fidl::encoding::DefaultFuchsiaResourceDialect,
12405            >,
12406            T95: fidl::encoding::Encode<
12407                fidl::encoding::Optional<
12408                    fidl::encoding::Vector<
12409                        fidl::encoding::HandleType<
12410                            fidl::Handle,
12411                            { fidl::ObjectType::NONE.into_raw() },
12412                            2147483648,
12413                        >,
12414                        1,
12415                    >,
12416                >,
12417                fidl::encoding::DefaultFuchsiaResourceDialect,
12418            >,
12419            T96: fidl::encoding::Encode<
12420                fidl::encoding::Optional<fidl::encoding::Vector<bool, 3>>,
12421                fidl::encoding::DefaultFuchsiaResourceDialect,
12422            >,
12423            T97: fidl::encoding::Encode<
12424                fidl::encoding::Optional<fidl::encoding::Vector<i8, 3>>,
12425                fidl::encoding::DefaultFuchsiaResourceDialect,
12426            >,
12427            T98: fidl::encoding::Encode<
12428                fidl::encoding::Optional<fidl::encoding::Vector<i16, 3>>,
12429                fidl::encoding::DefaultFuchsiaResourceDialect,
12430            >,
12431            T99: fidl::encoding::Encode<
12432                fidl::encoding::Optional<fidl::encoding::Vector<i32, 3>>,
12433                fidl::encoding::DefaultFuchsiaResourceDialect,
12434            >,
12435            T100: fidl::encoding::Encode<
12436                fidl::encoding::Optional<fidl::encoding::Vector<i64, 3>>,
12437                fidl::encoding::DefaultFuchsiaResourceDialect,
12438            >,
12439            T101: fidl::encoding::Encode<
12440                fidl::encoding::Optional<fidl::encoding::Vector<u8, 3>>,
12441                fidl::encoding::DefaultFuchsiaResourceDialect,
12442            >,
12443            T102: fidl::encoding::Encode<
12444                fidl::encoding::Optional<fidl::encoding::Vector<u16, 3>>,
12445                fidl::encoding::DefaultFuchsiaResourceDialect,
12446            >,
12447            T103: fidl::encoding::Encode<
12448                fidl::encoding::Optional<fidl::encoding::Vector<u32, 3>>,
12449                fidl::encoding::DefaultFuchsiaResourceDialect,
12450            >,
12451            T104: fidl::encoding::Encode<
12452                fidl::encoding::Optional<fidl::encoding::Vector<u64, 3>>,
12453                fidl::encoding::DefaultFuchsiaResourceDialect,
12454            >,
12455            T105: fidl::encoding::Encode<
12456                fidl::encoding::Optional<fidl::encoding::Vector<f32, 3>>,
12457                fidl::encoding::DefaultFuchsiaResourceDialect,
12458            >,
12459            T106: fidl::encoding::Encode<
12460                fidl::encoding::Optional<fidl::encoding::Vector<f64, 3>>,
12461                fidl::encoding::DefaultFuchsiaResourceDialect,
12462            >,
12463            T107: fidl::encoding::Encode<
12464                fidl::encoding::Optional<
12465                    fidl::encoding::Vector<
12466                        fidl::encoding::HandleType<
12467                            fidl::Handle,
12468                            { fidl::ObjectType::NONE.into_raw() },
12469                            2147483648,
12470                        >,
12471                        3,
12472                    >,
12473                >,
12474                fidl::encoding::DefaultFuchsiaResourceDialect,
12475            >,
12476            T108: fidl::encoding::Encode<
12477                fidl::encoding::Optional<
12478                    fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
12479                >,
12480                fidl::encoding::DefaultFuchsiaResourceDialect,
12481            >,
12482            T109: fidl::encoding::Encode<
12483                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>>,
12484                fidl::encoding::DefaultFuchsiaResourceDialect,
12485            >,
12486            T110: fidl::encoding::Encode<
12487                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>>,
12488                fidl::encoding::DefaultFuchsiaResourceDialect,
12489            >,
12490            T111: fidl::encoding::Encode<
12491                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>>,
12492                fidl::encoding::DefaultFuchsiaResourceDialect,
12493            >,
12494            T112: fidl::encoding::Encode<
12495                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>>,
12496                fidl::encoding::DefaultFuchsiaResourceDialect,
12497            >,
12498            T113: fidl::encoding::Encode<
12499                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>>,
12500                fidl::encoding::DefaultFuchsiaResourceDialect,
12501            >,
12502            T114: fidl::encoding::Encode<
12503                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>>,
12504                fidl::encoding::DefaultFuchsiaResourceDialect,
12505            >,
12506            T115: fidl::encoding::Encode<
12507                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>>,
12508                fidl::encoding::DefaultFuchsiaResourceDialect,
12509            >,
12510            T116: fidl::encoding::Encode<
12511                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>>,
12512                fidl::encoding::DefaultFuchsiaResourceDialect,
12513            >,
12514            T117: fidl::encoding::Encode<
12515                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>>,
12516                fidl::encoding::DefaultFuchsiaResourceDialect,
12517            >,
12518            T118: fidl::encoding::Encode<
12519                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>>,
12520                fidl::encoding::DefaultFuchsiaResourceDialect,
12521            >,
12522            T119: fidl::encoding::Encode<
12523                fidl::encoding::Optional<
12524                    fidl::encoding::Vector<
12525                        fidl::encoding::Vector<
12526                            fidl::encoding::HandleType<
12527                                fidl::Handle,
12528                                { fidl::ObjectType::NONE.into_raw() },
12529                                2147483648,
12530                            >,
12531                            2,
12532                        >,
12533                        3,
12534                    >,
12535                >,
12536                fidl::encoding::DefaultFuchsiaResourceDialect,
12537            >,
12538        > fidl::encoding::Encode<Vectors, fidl::encoding::DefaultFuchsiaResourceDialect>
12539        for (
12540            T0,
12541            T1,
12542            T2,
12543            T3,
12544            T4,
12545            T5,
12546            T6,
12547            T7,
12548            T8,
12549            T9,
12550            T10,
12551            T11,
12552            T12,
12553            T13,
12554            T14,
12555            T15,
12556            T16,
12557            T17,
12558            T18,
12559            T19,
12560            T20,
12561            T21,
12562            T22,
12563            T23,
12564            T24,
12565            T25,
12566            T26,
12567            T27,
12568            T28,
12569            T29,
12570            T30,
12571            T31,
12572            T32,
12573            T33,
12574            T34,
12575            T35,
12576            T36,
12577            T37,
12578            T38,
12579            T39,
12580            T40,
12581            T41,
12582            T42,
12583            T43,
12584            T44,
12585            T45,
12586            T46,
12587            T47,
12588            T48,
12589            T49,
12590            T50,
12591            T51,
12592            T52,
12593            T53,
12594            T54,
12595            T55,
12596            T56,
12597            T57,
12598            T58,
12599            T59,
12600            T60,
12601            T61,
12602            T62,
12603            T63,
12604            T64,
12605            T65,
12606            T66,
12607            T67,
12608            T68,
12609            T69,
12610            T70,
12611            T71,
12612            T72,
12613            T73,
12614            T74,
12615            T75,
12616            T76,
12617            T77,
12618            T78,
12619            T79,
12620            T80,
12621            T81,
12622            T82,
12623            T83,
12624            T84,
12625            T85,
12626            T86,
12627            T87,
12628            T88,
12629            T89,
12630            T90,
12631            T91,
12632            T92,
12633            T93,
12634            T94,
12635            T95,
12636            T96,
12637            T97,
12638            T98,
12639            T99,
12640            T100,
12641            T101,
12642            T102,
12643            T103,
12644            T104,
12645            T105,
12646            T106,
12647            T107,
12648            T108,
12649            T109,
12650            T110,
12651            T111,
12652            T112,
12653            T113,
12654            T114,
12655            T115,
12656            T116,
12657            T117,
12658            T118,
12659            T119,
12660        )
12661    {
12662        #[inline]
12663        unsafe fn encode(
12664            self,
12665            encoder: &mut fidl::encoding::Encoder<
12666                '_,
12667                fidl::encoding::DefaultFuchsiaResourceDialect,
12668            >,
12669            offset: usize,
12670            depth: fidl::encoding::Depth,
12671        ) -> fidl::Result<()> {
12672            encoder.debug_check_bounds::<Vectors>(offset);
12673            // Zero out padding regions. There's no need to apply masks
12674            // because the unmasked parts will be overwritten by fields.
12675            // Write the fields.
12676            self.0.encode(encoder, offset + 0, depth)?;
12677            self.1.encode(encoder, offset + 16, depth)?;
12678            self.2.encode(encoder, offset + 32, depth)?;
12679            self.3.encode(encoder, offset + 48, depth)?;
12680            self.4.encode(encoder, offset + 64, depth)?;
12681            self.5.encode(encoder, offset + 80, depth)?;
12682            self.6.encode(encoder, offset + 96, depth)?;
12683            self.7.encode(encoder, offset + 112, depth)?;
12684            self.8.encode(encoder, offset + 128, depth)?;
12685            self.9.encode(encoder, offset + 144, depth)?;
12686            self.10.encode(encoder, offset + 160, depth)?;
12687            self.11.encode(encoder, offset + 176, depth)?;
12688            self.12.encode(encoder, offset + 192, depth)?;
12689            self.13.encode(encoder, offset + 208, depth)?;
12690            self.14.encode(encoder, offset + 224, depth)?;
12691            self.15.encode(encoder, offset + 240, depth)?;
12692            self.16.encode(encoder, offset + 256, depth)?;
12693            self.17.encode(encoder, offset + 272, depth)?;
12694            self.18.encode(encoder, offset + 288, depth)?;
12695            self.19.encode(encoder, offset + 304, depth)?;
12696            self.20.encode(encoder, offset + 320, depth)?;
12697            self.21.encode(encoder, offset + 336, depth)?;
12698            self.22.encode(encoder, offset + 352, depth)?;
12699            self.23.encode(encoder, offset + 368, depth)?;
12700            self.24.encode(encoder, offset + 384, depth)?;
12701            self.25.encode(encoder, offset + 400, depth)?;
12702            self.26.encode(encoder, offset + 416, depth)?;
12703            self.27.encode(encoder, offset + 432, depth)?;
12704            self.28.encode(encoder, offset + 448, depth)?;
12705            self.29.encode(encoder, offset + 464, depth)?;
12706            self.30.encode(encoder, offset + 480, depth)?;
12707            self.31.encode(encoder, offset + 496, depth)?;
12708            self.32.encode(encoder, offset + 512, depth)?;
12709            self.33.encode(encoder, offset + 528, depth)?;
12710            self.34.encode(encoder, offset + 544, depth)?;
12711            self.35.encode(encoder, offset + 560, depth)?;
12712            self.36.encode(encoder, offset + 576, depth)?;
12713            self.37.encode(encoder, offset + 592, depth)?;
12714            self.38.encode(encoder, offset + 608, depth)?;
12715            self.39.encode(encoder, offset + 624, depth)?;
12716            self.40.encode(encoder, offset + 640, depth)?;
12717            self.41.encode(encoder, offset + 656, depth)?;
12718            self.42.encode(encoder, offset + 672, depth)?;
12719            self.43.encode(encoder, offset + 688, depth)?;
12720            self.44.encode(encoder, offset + 704, depth)?;
12721            self.45.encode(encoder, offset + 720, depth)?;
12722            self.46.encode(encoder, offset + 736, depth)?;
12723            self.47.encode(encoder, offset + 752, depth)?;
12724            self.48.encode(encoder, offset + 768, depth)?;
12725            self.49.encode(encoder, offset + 784, depth)?;
12726            self.50.encode(encoder, offset + 800, depth)?;
12727            self.51.encode(encoder, offset + 816, depth)?;
12728            self.52.encode(encoder, offset + 832, depth)?;
12729            self.53.encode(encoder, offset + 848, depth)?;
12730            self.54.encode(encoder, offset + 864, depth)?;
12731            self.55.encode(encoder, offset + 880, depth)?;
12732            self.56.encode(encoder, offset + 896, depth)?;
12733            self.57.encode(encoder, offset + 912, depth)?;
12734            self.58.encode(encoder, offset + 928, depth)?;
12735            self.59.encode(encoder, offset + 944, depth)?;
12736            self.60.encode(encoder, offset + 960, depth)?;
12737            self.61.encode(encoder, offset + 976, depth)?;
12738            self.62.encode(encoder, offset + 992, depth)?;
12739            self.63.encode(encoder, offset + 1008, depth)?;
12740            self.64.encode(encoder, offset + 1024, depth)?;
12741            self.65.encode(encoder, offset + 1040, depth)?;
12742            self.66.encode(encoder, offset + 1056, depth)?;
12743            self.67.encode(encoder, offset + 1072, depth)?;
12744            self.68.encode(encoder, offset + 1088, depth)?;
12745            self.69.encode(encoder, offset + 1104, depth)?;
12746            self.70.encode(encoder, offset + 1120, depth)?;
12747            self.71.encode(encoder, offset + 1136, depth)?;
12748            self.72.encode(encoder, offset + 1152, depth)?;
12749            self.73.encode(encoder, offset + 1168, depth)?;
12750            self.74.encode(encoder, offset + 1184, depth)?;
12751            self.75.encode(encoder, offset + 1200, depth)?;
12752            self.76.encode(encoder, offset + 1216, depth)?;
12753            self.77.encode(encoder, offset + 1232, depth)?;
12754            self.78.encode(encoder, offset + 1248, depth)?;
12755            self.79.encode(encoder, offset + 1264, depth)?;
12756            self.80.encode(encoder, offset + 1280, depth)?;
12757            self.81.encode(encoder, offset + 1296, depth)?;
12758            self.82.encode(encoder, offset + 1312, depth)?;
12759            self.83.encode(encoder, offset + 1328, depth)?;
12760            self.84.encode(encoder, offset + 1344, depth)?;
12761            self.85.encode(encoder, offset + 1360, depth)?;
12762            self.86.encode(encoder, offset + 1376, depth)?;
12763            self.87.encode(encoder, offset + 1392, depth)?;
12764            self.88.encode(encoder, offset + 1408, depth)?;
12765            self.89.encode(encoder, offset + 1424, depth)?;
12766            self.90.encode(encoder, offset + 1440, depth)?;
12767            self.91.encode(encoder, offset + 1456, depth)?;
12768            self.92.encode(encoder, offset + 1472, depth)?;
12769            self.93.encode(encoder, offset + 1488, depth)?;
12770            self.94.encode(encoder, offset + 1504, depth)?;
12771            self.95.encode(encoder, offset + 1520, depth)?;
12772            self.96.encode(encoder, offset + 1536, depth)?;
12773            self.97.encode(encoder, offset + 1552, depth)?;
12774            self.98.encode(encoder, offset + 1568, depth)?;
12775            self.99.encode(encoder, offset + 1584, depth)?;
12776            self.100.encode(encoder, offset + 1600, depth)?;
12777            self.101.encode(encoder, offset + 1616, depth)?;
12778            self.102.encode(encoder, offset + 1632, depth)?;
12779            self.103.encode(encoder, offset + 1648, depth)?;
12780            self.104.encode(encoder, offset + 1664, depth)?;
12781            self.105.encode(encoder, offset + 1680, depth)?;
12782            self.106.encode(encoder, offset + 1696, depth)?;
12783            self.107.encode(encoder, offset + 1712, depth)?;
12784            self.108.encode(encoder, offset + 1728, depth)?;
12785            self.109.encode(encoder, offset + 1744, depth)?;
12786            self.110.encode(encoder, offset + 1760, depth)?;
12787            self.111.encode(encoder, offset + 1776, depth)?;
12788            self.112.encode(encoder, offset + 1792, depth)?;
12789            self.113.encode(encoder, offset + 1808, depth)?;
12790            self.114.encode(encoder, offset + 1824, depth)?;
12791            self.115.encode(encoder, offset + 1840, depth)?;
12792            self.116.encode(encoder, offset + 1856, depth)?;
12793            self.117.encode(encoder, offset + 1872, depth)?;
12794            self.118.encode(encoder, offset + 1888, depth)?;
12795            self.119.encode(encoder, offset + 1904, depth)?;
12796            Ok(())
12797        }
12798    }
12799
12800    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Vectors {
12801        #[inline(always)]
12802        fn new_empty() -> Self {
12803            Self {
12804                b_0: fidl::new_empty!(
12805                    fidl::encoding::UnboundedVector<bool>,
12806                    fidl::encoding::DefaultFuchsiaResourceDialect
12807                ),
12808                i8_0: fidl::new_empty!(
12809                    fidl::encoding::UnboundedVector<i8>,
12810                    fidl::encoding::DefaultFuchsiaResourceDialect
12811                ),
12812                i16_0: fidl::new_empty!(
12813                    fidl::encoding::UnboundedVector<i16>,
12814                    fidl::encoding::DefaultFuchsiaResourceDialect
12815                ),
12816                i32_0: fidl::new_empty!(
12817                    fidl::encoding::UnboundedVector<i32>,
12818                    fidl::encoding::DefaultFuchsiaResourceDialect
12819                ),
12820                i64_0: fidl::new_empty!(
12821                    fidl::encoding::UnboundedVector<i64>,
12822                    fidl::encoding::DefaultFuchsiaResourceDialect
12823                ),
12824                u8_0: fidl::new_empty!(
12825                    fidl::encoding::UnboundedVector<u8>,
12826                    fidl::encoding::DefaultFuchsiaResourceDialect
12827                ),
12828                u16_0: fidl::new_empty!(
12829                    fidl::encoding::UnboundedVector<u16>,
12830                    fidl::encoding::DefaultFuchsiaResourceDialect
12831                ),
12832                u32_0: fidl::new_empty!(
12833                    fidl::encoding::UnboundedVector<u32>,
12834                    fidl::encoding::DefaultFuchsiaResourceDialect
12835                ),
12836                u64_0: fidl::new_empty!(
12837                    fidl::encoding::UnboundedVector<u64>,
12838                    fidl::encoding::DefaultFuchsiaResourceDialect
12839                ),
12840                f32_0: fidl::new_empty!(
12841                    fidl::encoding::UnboundedVector<f32>,
12842                    fidl::encoding::DefaultFuchsiaResourceDialect
12843                ),
12844                f64_0: fidl::new_empty!(
12845                    fidl::encoding::UnboundedVector<f64>,
12846                    fidl::encoding::DefaultFuchsiaResourceDialect
12847                ),
12848                handle_0: fidl::new_empty!(
12849                    fidl::encoding::UnboundedVector<
12850                        fidl::encoding::HandleType<
12851                            fidl::Handle,
12852                            { fidl::ObjectType::NONE.into_raw() },
12853                            2147483648,
12854                        >,
12855                    >,
12856                    fidl::encoding::DefaultFuchsiaResourceDialect
12857                ),
12858                b_1: fidl::new_empty!(
12859                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
12860                    fidl::encoding::DefaultFuchsiaResourceDialect
12861                ),
12862                i8_1: fidl::new_empty!(
12863                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
12864                    fidl::encoding::DefaultFuchsiaResourceDialect
12865                ),
12866                i16_1: fidl::new_empty!(
12867                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
12868                    fidl::encoding::DefaultFuchsiaResourceDialect
12869                ),
12870                i32_1: fidl::new_empty!(
12871                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
12872                    fidl::encoding::DefaultFuchsiaResourceDialect
12873                ),
12874                i64_1: fidl::new_empty!(
12875                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
12876                    fidl::encoding::DefaultFuchsiaResourceDialect
12877                ),
12878                u8_1: fidl::new_empty!(
12879                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
12880                    fidl::encoding::DefaultFuchsiaResourceDialect
12881                ),
12882                u16_1: fidl::new_empty!(
12883                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
12884                    fidl::encoding::DefaultFuchsiaResourceDialect
12885                ),
12886                u32_1: fidl::new_empty!(
12887                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
12888                    fidl::encoding::DefaultFuchsiaResourceDialect
12889                ),
12890                u64_1: fidl::new_empty!(
12891                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
12892                    fidl::encoding::DefaultFuchsiaResourceDialect
12893                ),
12894                f32_1: fidl::new_empty!(
12895                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
12896                    fidl::encoding::DefaultFuchsiaResourceDialect
12897                ),
12898                f64_1: fidl::new_empty!(
12899                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
12900                    fidl::encoding::DefaultFuchsiaResourceDialect
12901                ),
12902                handle_1: fidl::new_empty!(
12903                    fidl::encoding::UnboundedVector<
12904                        fidl::encoding::Vector<
12905                            fidl::encoding::HandleType<
12906                                fidl::Handle,
12907                                { fidl::ObjectType::NONE.into_raw() },
12908                                2147483648,
12909                            >,
12910                            2,
12911                        >,
12912                    >,
12913                    fidl::encoding::DefaultFuchsiaResourceDialect
12914                ),
12915                b_sized_0: fidl::new_empty!(fidl::encoding::Vector<bool, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12916                i8_sized_0: fidl::new_empty!(fidl::encoding::Vector<i8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12917                i16_sized_0: fidl::new_empty!(fidl::encoding::Vector<i16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12918                i32_sized_0: fidl::new_empty!(fidl::encoding::Vector<i32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12919                i64_sized_0: fidl::new_empty!(fidl::encoding::Vector<i64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12920                u8_sized_0: fidl::new_empty!(fidl::encoding::Vector<u8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12921                u16_sized_0: fidl::new_empty!(fidl::encoding::Vector<u16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12922                u32_sized_0: fidl::new_empty!(fidl::encoding::Vector<u32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12923                u64_sized_0: fidl::new_empty!(fidl::encoding::Vector<u64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12924                f32_sized_0: fidl::new_empty!(fidl::encoding::Vector<f32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12925                f64_sized_0: fidl::new_empty!(fidl::encoding::Vector<f64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect),
12926                handle_sized_0: fidl::new_empty!(
12927                    fidl::encoding::Vector<
12928                        fidl::encoding::HandleType<
12929                            fidl::Handle,
12930                            { fidl::ObjectType::NONE.into_raw() },
12931                            2147483648,
12932                        >,
12933                        1,
12934                    >,
12935                    fidl::encoding::DefaultFuchsiaResourceDialect
12936                ),
12937                b_sized_1: fidl::new_empty!(fidl::encoding::Vector<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12938                i8_sized_1: fidl::new_empty!(fidl::encoding::Vector<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12939                i16_sized_1: fidl::new_empty!(fidl::encoding::Vector<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12940                i32_sized_1: fidl::new_empty!(fidl::encoding::Vector<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12941                i64_sized_1: fidl::new_empty!(fidl::encoding::Vector<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12942                u8_sized_1: fidl::new_empty!(fidl::encoding::Vector<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12943                u16_sized_1: fidl::new_empty!(fidl::encoding::Vector<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12944                u32_sized_1: fidl::new_empty!(fidl::encoding::Vector<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12945                u64_sized_1: fidl::new_empty!(fidl::encoding::Vector<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12946                f32_sized_1: fidl::new_empty!(fidl::encoding::Vector<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12947                f64_sized_1: fidl::new_empty!(fidl::encoding::Vector<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
12948                handle_sized_1: fidl::new_empty!(
12949                    fidl::encoding::Vector<
12950                        fidl::encoding::HandleType<
12951                            fidl::Handle,
12952                            { fidl::ObjectType::NONE.into_raw() },
12953                            2147483648,
12954                        >,
12955                        3,
12956                    >,
12957                    fidl::encoding::DefaultFuchsiaResourceDialect
12958                ),
12959                b_sized_2: fidl::new_empty!(
12960                    fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
12961                    fidl::encoding::DefaultFuchsiaResourceDialect
12962                ),
12963                i8_sized_2: fidl::new_empty!(
12964                    fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>,
12965                    fidl::encoding::DefaultFuchsiaResourceDialect
12966                ),
12967                i16_sized_2: fidl::new_empty!(
12968                    fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>,
12969                    fidl::encoding::DefaultFuchsiaResourceDialect
12970                ),
12971                i32_sized_2: fidl::new_empty!(
12972                    fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>,
12973                    fidl::encoding::DefaultFuchsiaResourceDialect
12974                ),
12975                i64_sized_2: fidl::new_empty!(
12976                    fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>,
12977                    fidl::encoding::DefaultFuchsiaResourceDialect
12978                ),
12979                u8_sized_2: fidl::new_empty!(
12980                    fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>,
12981                    fidl::encoding::DefaultFuchsiaResourceDialect
12982                ),
12983                u16_sized_2: fidl::new_empty!(
12984                    fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>,
12985                    fidl::encoding::DefaultFuchsiaResourceDialect
12986                ),
12987                u32_sized_2: fidl::new_empty!(
12988                    fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>,
12989                    fidl::encoding::DefaultFuchsiaResourceDialect
12990                ),
12991                u64_sized_2: fidl::new_empty!(
12992                    fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>,
12993                    fidl::encoding::DefaultFuchsiaResourceDialect
12994                ),
12995                f32_sized_2: fidl::new_empty!(
12996                    fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>,
12997                    fidl::encoding::DefaultFuchsiaResourceDialect
12998                ),
12999                f64_sized_2: fidl::new_empty!(
13000                    fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>,
13001                    fidl::encoding::DefaultFuchsiaResourceDialect
13002                ),
13003                handle_sized_2: fidl::new_empty!(
13004                    fidl::encoding::Vector<
13005                        fidl::encoding::Vector<
13006                            fidl::encoding::HandleType<
13007                                fidl::Handle,
13008                                { fidl::ObjectType::NONE.into_raw() },
13009                                2147483648,
13010                            >,
13011                            2,
13012                        >,
13013                        3,
13014                    >,
13015                    fidl::encoding::DefaultFuchsiaResourceDialect
13016                ),
13017                b_nullable_0: fidl::new_empty!(
13018                    fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
13019                    fidl::encoding::DefaultFuchsiaResourceDialect
13020                ),
13021                i8_nullable_0: fidl::new_empty!(
13022                    fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
13023                    fidl::encoding::DefaultFuchsiaResourceDialect
13024                ),
13025                i16_nullable_0: fidl::new_empty!(
13026                    fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
13027                    fidl::encoding::DefaultFuchsiaResourceDialect
13028                ),
13029                i32_nullable_0: fidl::new_empty!(
13030                    fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
13031                    fidl::encoding::DefaultFuchsiaResourceDialect
13032                ),
13033                i64_nullable_0: fidl::new_empty!(
13034                    fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
13035                    fidl::encoding::DefaultFuchsiaResourceDialect
13036                ),
13037                u8_nullable_0: fidl::new_empty!(
13038                    fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
13039                    fidl::encoding::DefaultFuchsiaResourceDialect
13040                ),
13041                u16_nullable_0: fidl::new_empty!(
13042                    fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
13043                    fidl::encoding::DefaultFuchsiaResourceDialect
13044                ),
13045                u32_nullable_0: fidl::new_empty!(
13046                    fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
13047                    fidl::encoding::DefaultFuchsiaResourceDialect
13048                ),
13049                u64_nullable_0: fidl::new_empty!(
13050                    fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
13051                    fidl::encoding::DefaultFuchsiaResourceDialect
13052                ),
13053                f32_nullable_0: fidl::new_empty!(
13054                    fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
13055                    fidl::encoding::DefaultFuchsiaResourceDialect
13056                ),
13057                f64_nullable_0: fidl::new_empty!(
13058                    fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
13059                    fidl::encoding::DefaultFuchsiaResourceDialect
13060                ),
13061                handle_nullable_0: fidl::new_empty!(
13062                    fidl::encoding::Optional<
13063                        fidl::encoding::Vector<
13064                            fidl::encoding::HandleType<
13065                                fidl::Handle,
13066                                { fidl::ObjectType::NONE.into_raw() },
13067                                2147483648,
13068                            >,
13069                            1,
13070                        >,
13071                    >,
13072                    fidl::encoding::DefaultFuchsiaResourceDialect
13073                ),
13074                b_nullable_1: fidl::new_empty!(
13075                    fidl::encoding::Optional<
13076                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
13077                    >,
13078                    fidl::encoding::DefaultFuchsiaResourceDialect
13079                ),
13080                i8_nullable_1: fidl::new_empty!(
13081                    fidl::encoding::Optional<
13082                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
13083                    >,
13084                    fidl::encoding::DefaultFuchsiaResourceDialect
13085                ),
13086                i16_nullable_1: fidl::new_empty!(
13087                    fidl::encoding::Optional<
13088                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
13089                    >,
13090                    fidl::encoding::DefaultFuchsiaResourceDialect
13091                ),
13092                i32_nullable_1: fidl::new_empty!(
13093                    fidl::encoding::Optional<
13094                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
13095                    >,
13096                    fidl::encoding::DefaultFuchsiaResourceDialect
13097                ),
13098                i64_nullable_1: fidl::new_empty!(
13099                    fidl::encoding::Optional<
13100                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
13101                    >,
13102                    fidl::encoding::DefaultFuchsiaResourceDialect
13103                ),
13104                u8_nullable_1: fidl::new_empty!(
13105                    fidl::encoding::Optional<
13106                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
13107                    >,
13108                    fidl::encoding::DefaultFuchsiaResourceDialect
13109                ),
13110                u16_nullable_1: fidl::new_empty!(
13111                    fidl::encoding::Optional<
13112                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
13113                    >,
13114                    fidl::encoding::DefaultFuchsiaResourceDialect
13115                ),
13116                u32_nullable_1: fidl::new_empty!(
13117                    fidl::encoding::Optional<
13118                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
13119                    >,
13120                    fidl::encoding::DefaultFuchsiaResourceDialect
13121                ),
13122                u64_nullable_1: fidl::new_empty!(
13123                    fidl::encoding::Optional<
13124                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
13125                    >,
13126                    fidl::encoding::DefaultFuchsiaResourceDialect
13127                ),
13128                f32_nullable_1: fidl::new_empty!(
13129                    fidl::encoding::Optional<
13130                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
13131                    >,
13132                    fidl::encoding::DefaultFuchsiaResourceDialect
13133                ),
13134                f64_nullable_1: fidl::new_empty!(
13135                    fidl::encoding::Optional<
13136                        fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
13137                    >,
13138                    fidl::encoding::DefaultFuchsiaResourceDialect
13139                ),
13140                handle_nullable_1: fidl::new_empty!(
13141                    fidl::encoding::Optional<
13142                        fidl::encoding::UnboundedVector<
13143                            fidl::encoding::Vector<
13144                                fidl::encoding::HandleType<
13145                                    fidl::Handle,
13146                                    { fidl::ObjectType::NONE.into_raw() },
13147                                    2147483648,
13148                                >,
13149                                2,
13150                            >,
13151                        >,
13152                    >,
13153                    fidl::encoding::DefaultFuchsiaResourceDialect
13154                ),
13155                b_nullable_sized_0: fidl::new_empty!(
13156                    fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
13157                    fidl::encoding::DefaultFuchsiaResourceDialect
13158                ),
13159                i8_nullable_sized_0: fidl::new_empty!(
13160                    fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
13161                    fidl::encoding::DefaultFuchsiaResourceDialect
13162                ),
13163                i16_nullable_sized_0: fidl::new_empty!(
13164                    fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
13165                    fidl::encoding::DefaultFuchsiaResourceDialect
13166                ),
13167                i32_nullable_sized_0: fidl::new_empty!(
13168                    fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
13169                    fidl::encoding::DefaultFuchsiaResourceDialect
13170                ),
13171                i64_nullable_sized_0: fidl::new_empty!(
13172                    fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
13173                    fidl::encoding::DefaultFuchsiaResourceDialect
13174                ),
13175                u8_nullable_sized_0: fidl::new_empty!(
13176                    fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
13177                    fidl::encoding::DefaultFuchsiaResourceDialect
13178                ),
13179                u16_nullable_sized_0: fidl::new_empty!(
13180                    fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
13181                    fidl::encoding::DefaultFuchsiaResourceDialect
13182                ),
13183                u32_nullable_sized_0: fidl::new_empty!(
13184                    fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
13185                    fidl::encoding::DefaultFuchsiaResourceDialect
13186                ),
13187                u64_nullable_sized_0: fidl::new_empty!(
13188                    fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
13189                    fidl::encoding::DefaultFuchsiaResourceDialect
13190                ),
13191                f32_nullable_sized_0: fidl::new_empty!(
13192                    fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
13193                    fidl::encoding::DefaultFuchsiaResourceDialect
13194                ),
13195                f64_nullable_sized_0: fidl::new_empty!(
13196                    fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
13197                    fidl::encoding::DefaultFuchsiaResourceDialect
13198                ),
13199                handle_nullable_sized_0: fidl::new_empty!(
13200                    fidl::encoding::Optional<
13201                        fidl::encoding::Vector<
13202                            fidl::encoding::HandleType<
13203                                fidl::Handle,
13204                                { fidl::ObjectType::NONE.into_raw() },
13205                                2147483648,
13206                            >,
13207                            1,
13208                        >,
13209                    >,
13210                    fidl::encoding::DefaultFuchsiaResourceDialect
13211                ),
13212                b_nullable_sized_1: fidl::new_empty!(
13213                    fidl::encoding::Optional<fidl::encoding::Vector<bool, 3>>,
13214                    fidl::encoding::DefaultFuchsiaResourceDialect
13215                ),
13216                i8_nullable_sized_1: fidl::new_empty!(
13217                    fidl::encoding::Optional<fidl::encoding::Vector<i8, 3>>,
13218                    fidl::encoding::DefaultFuchsiaResourceDialect
13219                ),
13220                i16_nullable_sized_1: fidl::new_empty!(
13221                    fidl::encoding::Optional<fidl::encoding::Vector<i16, 3>>,
13222                    fidl::encoding::DefaultFuchsiaResourceDialect
13223                ),
13224                i32_nullable_sized_1: fidl::new_empty!(
13225                    fidl::encoding::Optional<fidl::encoding::Vector<i32, 3>>,
13226                    fidl::encoding::DefaultFuchsiaResourceDialect
13227                ),
13228                i64_nullable_sized_1: fidl::new_empty!(
13229                    fidl::encoding::Optional<fidl::encoding::Vector<i64, 3>>,
13230                    fidl::encoding::DefaultFuchsiaResourceDialect
13231                ),
13232                u8_nullable_sized_1: fidl::new_empty!(
13233                    fidl::encoding::Optional<fidl::encoding::Vector<u8, 3>>,
13234                    fidl::encoding::DefaultFuchsiaResourceDialect
13235                ),
13236                u16_nullable_sized_1: fidl::new_empty!(
13237                    fidl::encoding::Optional<fidl::encoding::Vector<u16, 3>>,
13238                    fidl::encoding::DefaultFuchsiaResourceDialect
13239                ),
13240                u32_nullable_sized_1: fidl::new_empty!(
13241                    fidl::encoding::Optional<fidl::encoding::Vector<u32, 3>>,
13242                    fidl::encoding::DefaultFuchsiaResourceDialect
13243                ),
13244                u64_nullable_sized_1: fidl::new_empty!(
13245                    fidl::encoding::Optional<fidl::encoding::Vector<u64, 3>>,
13246                    fidl::encoding::DefaultFuchsiaResourceDialect
13247                ),
13248                f32_nullable_sized_1: fidl::new_empty!(
13249                    fidl::encoding::Optional<fidl::encoding::Vector<f32, 3>>,
13250                    fidl::encoding::DefaultFuchsiaResourceDialect
13251                ),
13252                f64_nullable_sized_1: fidl::new_empty!(
13253                    fidl::encoding::Optional<fidl::encoding::Vector<f64, 3>>,
13254                    fidl::encoding::DefaultFuchsiaResourceDialect
13255                ),
13256                handle_nullable_sized_1: fidl::new_empty!(
13257                    fidl::encoding::Optional<
13258                        fidl::encoding::Vector<
13259                            fidl::encoding::HandleType<
13260                                fidl::Handle,
13261                                { fidl::ObjectType::NONE.into_raw() },
13262                                2147483648,
13263                            >,
13264                            3,
13265                        >,
13266                    >,
13267                    fidl::encoding::DefaultFuchsiaResourceDialect
13268                ),
13269                b_nullable_sized_2: fidl::new_empty!(
13270                    fidl::encoding::Optional<
13271                        fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
13272                    >,
13273                    fidl::encoding::DefaultFuchsiaResourceDialect
13274                ),
13275                i8_nullable_sized_2: fidl::new_empty!(
13276                    fidl::encoding::Optional<
13277                        fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>,
13278                    >,
13279                    fidl::encoding::DefaultFuchsiaResourceDialect
13280                ),
13281                i16_nullable_sized_2: fidl::new_empty!(
13282                    fidl::encoding::Optional<
13283                        fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>,
13284                    >,
13285                    fidl::encoding::DefaultFuchsiaResourceDialect
13286                ),
13287                i32_nullable_sized_2: fidl::new_empty!(
13288                    fidl::encoding::Optional<
13289                        fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>,
13290                    >,
13291                    fidl::encoding::DefaultFuchsiaResourceDialect
13292                ),
13293                i64_nullable_sized_2: fidl::new_empty!(
13294                    fidl::encoding::Optional<
13295                        fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>,
13296                    >,
13297                    fidl::encoding::DefaultFuchsiaResourceDialect
13298                ),
13299                u8_nullable_sized_2: fidl::new_empty!(
13300                    fidl::encoding::Optional<
13301                        fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>,
13302                    >,
13303                    fidl::encoding::DefaultFuchsiaResourceDialect
13304                ),
13305                u16_nullable_sized_2: fidl::new_empty!(
13306                    fidl::encoding::Optional<
13307                        fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>,
13308                    >,
13309                    fidl::encoding::DefaultFuchsiaResourceDialect
13310                ),
13311                u32_nullable_sized_2: fidl::new_empty!(
13312                    fidl::encoding::Optional<
13313                        fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>,
13314                    >,
13315                    fidl::encoding::DefaultFuchsiaResourceDialect
13316                ),
13317                u64_nullable_sized_2: fidl::new_empty!(
13318                    fidl::encoding::Optional<
13319                        fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>,
13320                    >,
13321                    fidl::encoding::DefaultFuchsiaResourceDialect
13322                ),
13323                f32_nullable_sized_2: fidl::new_empty!(
13324                    fidl::encoding::Optional<
13325                        fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>,
13326                    >,
13327                    fidl::encoding::DefaultFuchsiaResourceDialect
13328                ),
13329                f64_nullable_sized_2: fidl::new_empty!(
13330                    fidl::encoding::Optional<
13331                        fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>,
13332                    >,
13333                    fidl::encoding::DefaultFuchsiaResourceDialect
13334                ),
13335                handle_nullable_sized_2: fidl::new_empty!(
13336                    fidl::encoding::Optional<
13337                        fidl::encoding::Vector<
13338                            fidl::encoding::Vector<
13339                                fidl::encoding::HandleType<
13340                                    fidl::Handle,
13341                                    { fidl::ObjectType::NONE.into_raw() },
13342                                    2147483648,
13343                                >,
13344                                2,
13345                            >,
13346                            3,
13347                        >,
13348                    >,
13349                    fidl::encoding::DefaultFuchsiaResourceDialect
13350                ),
13351            }
13352        }
13353
13354        #[inline]
13355        unsafe fn decode(
13356            &mut self,
13357            decoder: &mut fidl::encoding::Decoder<
13358                '_,
13359                fidl::encoding::DefaultFuchsiaResourceDialect,
13360            >,
13361            offset: usize,
13362            _depth: fidl::encoding::Depth,
13363        ) -> fidl::Result<()> {
13364            decoder.debug_check_bounds::<Self>(offset);
13365            // Verify that padding bytes are zero.
13366            fidl::decode!(
13367                fidl::encoding::UnboundedVector<bool>,
13368                fidl::encoding::DefaultFuchsiaResourceDialect,
13369                &mut self.b_0,
13370                decoder,
13371                offset + 0,
13372                _depth
13373            )?;
13374            fidl::decode!(
13375                fidl::encoding::UnboundedVector<i8>,
13376                fidl::encoding::DefaultFuchsiaResourceDialect,
13377                &mut self.i8_0,
13378                decoder,
13379                offset + 16,
13380                _depth
13381            )?;
13382            fidl::decode!(
13383                fidl::encoding::UnboundedVector<i16>,
13384                fidl::encoding::DefaultFuchsiaResourceDialect,
13385                &mut self.i16_0,
13386                decoder,
13387                offset + 32,
13388                _depth
13389            )?;
13390            fidl::decode!(
13391                fidl::encoding::UnboundedVector<i32>,
13392                fidl::encoding::DefaultFuchsiaResourceDialect,
13393                &mut self.i32_0,
13394                decoder,
13395                offset + 48,
13396                _depth
13397            )?;
13398            fidl::decode!(
13399                fidl::encoding::UnboundedVector<i64>,
13400                fidl::encoding::DefaultFuchsiaResourceDialect,
13401                &mut self.i64_0,
13402                decoder,
13403                offset + 64,
13404                _depth
13405            )?;
13406            fidl::decode!(
13407                fidl::encoding::UnboundedVector<u8>,
13408                fidl::encoding::DefaultFuchsiaResourceDialect,
13409                &mut self.u8_0,
13410                decoder,
13411                offset + 80,
13412                _depth
13413            )?;
13414            fidl::decode!(
13415                fidl::encoding::UnboundedVector<u16>,
13416                fidl::encoding::DefaultFuchsiaResourceDialect,
13417                &mut self.u16_0,
13418                decoder,
13419                offset + 96,
13420                _depth
13421            )?;
13422            fidl::decode!(
13423                fidl::encoding::UnboundedVector<u32>,
13424                fidl::encoding::DefaultFuchsiaResourceDialect,
13425                &mut self.u32_0,
13426                decoder,
13427                offset + 112,
13428                _depth
13429            )?;
13430            fidl::decode!(
13431                fidl::encoding::UnboundedVector<u64>,
13432                fidl::encoding::DefaultFuchsiaResourceDialect,
13433                &mut self.u64_0,
13434                decoder,
13435                offset + 128,
13436                _depth
13437            )?;
13438            fidl::decode!(
13439                fidl::encoding::UnboundedVector<f32>,
13440                fidl::encoding::DefaultFuchsiaResourceDialect,
13441                &mut self.f32_0,
13442                decoder,
13443                offset + 144,
13444                _depth
13445            )?;
13446            fidl::decode!(
13447                fidl::encoding::UnboundedVector<f64>,
13448                fidl::encoding::DefaultFuchsiaResourceDialect,
13449                &mut self.f64_0,
13450                decoder,
13451                offset + 160,
13452                _depth
13453            )?;
13454            fidl::decode!(
13455                fidl::encoding::UnboundedVector<
13456                    fidl::encoding::HandleType<
13457                        fidl::Handle,
13458                        { fidl::ObjectType::NONE.into_raw() },
13459                        2147483648,
13460                    >,
13461                >,
13462                fidl::encoding::DefaultFuchsiaResourceDialect,
13463                &mut self.handle_0,
13464                decoder,
13465                offset + 176,
13466                _depth
13467            )?;
13468            fidl::decode!(
13469                fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
13470                fidl::encoding::DefaultFuchsiaResourceDialect,
13471                &mut self.b_1,
13472                decoder,
13473                offset + 192,
13474                _depth
13475            )?;
13476            fidl::decode!(
13477                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
13478                fidl::encoding::DefaultFuchsiaResourceDialect,
13479                &mut self.i8_1,
13480                decoder,
13481                offset + 208,
13482                _depth
13483            )?;
13484            fidl::decode!(
13485                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
13486                fidl::encoding::DefaultFuchsiaResourceDialect,
13487                &mut self.i16_1,
13488                decoder,
13489                offset + 224,
13490                _depth
13491            )?;
13492            fidl::decode!(
13493                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
13494                fidl::encoding::DefaultFuchsiaResourceDialect,
13495                &mut self.i32_1,
13496                decoder,
13497                offset + 240,
13498                _depth
13499            )?;
13500            fidl::decode!(
13501                fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
13502                fidl::encoding::DefaultFuchsiaResourceDialect,
13503                &mut self.i64_1,
13504                decoder,
13505                offset + 256,
13506                _depth
13507            )?;
13508            fidl::decode!(
13509                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
13510                fidl::encoding::DefaultFuchsiaResourceDialect,
13511                &mut self.u8_1,
13512                decoder,
13513                offset + 272,
13514                _depth
13515            )?;
13516            fidl::decode!(
13517                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
13518                fidl::encoding::DefaultFuchsiaResourceDialect,
13519                &mut self.u16_1,
13520                decoder,
13521                offset + 288,
13522                _depth
13523            )?;
13524            fidl::decode!(
13525                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
13526                fidl::encoding::DefaultFuchsiaResourceDialect,
13527                &mut self.u32_1,
13528                decoder,
13529                offset + 304,
13530                _depth
13531            )?;
13532            fidl::decode!(
13533                fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
13534                fidl::encoding::DefaultFuchsiaResourceDialect,
13535                &mut self.u64_1,
13536                decoder,
13537                offset + 320,
13538                _depth
13539            )?;
13540            fidl::decode!(
13541                fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
13542                fidl::encoding::DefaultFuchsiaResourceDialect,
13543                &mut self.f32_1,
13544                decoder,
13545                offset + 336,
13546                _depth
13547            )?;
13548            fidl::decode!(
13549                fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
13550                fidl::encoding::DefaultFuchsiaResourceDialect,
13551                &mut self.f64_1,
13552                decoder,
13553                offset + 352,
13554                _depth
13555            )?;
13556            fidl::decode!(
13557                fidl::encoding::UnboundedVector<
13558                    fidl::encoding::Vector<
13559                        fidl::encoding::HandleType<
13560                            fidl::Handle,
13561                            { fidl::ObjectType::NONE.into_raw() },
13562                            2147483648,
13563                        >,
13564                        2,
13565                    >,
13566                >,
13567                fidl::encoding::DefaultFuchsiaResourceDialect,
13568                &mut self.handle_1,
13569                decoder,
13570                offset + 368,
13571                _depth
13572            )?;
13573            fidl::decode!(fidl::encoding::Vector<bool, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.b_sized_0, decoder, offset + 384, _depth)?;
13574            fidl::decode!(fidl::encoding::Vector<i8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i8_sized_0, decoder, offset + 400, _depth)?;
13575            fidl::decode!(fidl::encoding::Vector<i16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i16_sized_0, decoder, offset + 416, _depth)?;
13576            fidl::decode!(fidl::encoding::Vector<i32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i32_sized_0, decoder, offset + 432, _depth)?;
13577            fidl::decode!(fidl::encoding::Vector<i64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i64_sized_0, decoder, offset + 448, _depth)?;
13578            fidl::decode!(fidl::encoding::Vector<u8, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u8_sized_0, decoder, offset + 464, _depth)?;
13579            fidl::decode!(fidl::encoding::Vector<u16, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u16_sized_0, decoder, offset + 480, _depth)?;
13580            fidl::decode!(fidl::encoding::Vector<u32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u32_sized_0, decoder, offset + 496, _depth)?;
13581            fidl::decode!(fidl::encoding::Vector<u64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u64_sized_0, decoder, offset + 512, _depth)?;
13582            fidl::decode!(fidl::encoding::Vector<f32, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f32_sized_0, decoder, offset + 528, _depth)?;
13583            fidl::decode!(fidl::encoding::Vector<f64, 1>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f64_sized_0, decoder, offset + 544, _depth)?;
13584            fidl::decode!(
13585                fidl::encoding::Vector<
13586                    fidl::encoding::HandleType<
13587                        fidl::Handle,
13588                        { fidl::ObjectType::NONE.into_raw() },
13589                        2147483648,
13590                    >,
13591                    1,
13592                >,
13593                fidl::encoding::DefaultFuchsiaResourceDialect,
13594                &mut self.handle_sized_0,
13595                decoder,
13596                offset + 560,
13597                _depth
13598            )?;
13599            fidl::decode!(fidl::encoding::Vector<bool, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.b_sized_1, decoder, offset + 576, _depth)?;
13600            fidl::decode!(fidl::encoding::Vector<i8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i8_sized_1, decoder, offset + 592, _depth)?;
13601            fidl::decode!(fidl::encoding::Vector<i16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i16_sized_1, decoder, offset + 608, _depth)?;
13602            fidl::decode!(fidl::encoding::Vector<i32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i32_sized_1, decoder, offset + 624, _depth)?;
13603            fidl::decode!(fidl::encoding::Vector<i64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.i64_sized_1, decoder, offset + 640, _depth)?;
13604            fidl::decode!(fidl::encoding::Vector<u8, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u8_sized_1, decoder, offset + 656, _depth)?;
13605            fidl::decode!(fidl::encoding::Vector<u16, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u16_sized_1, decoder, offset + 672, _depth)?;
13606            fidl::decode!(fidl::encoding::Vector<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u32_sized_1, decoder, offset + 688, _depth)?;
13607            fidl::decode!(fidl::encoding::Vector<u64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.u64_sized_1, decoder, offset + 704, _depth)?;
13608            fidl::decode!(fidl::encoding::Vector<f32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f32_sized_1, decoder, offset + 720, _depth)?;
13609            fidl::decode!(fidl::encoding::Vector<f64, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, &mut self.f64_sized_1, decoder, offset + 736, _depth)?;
13610            fidl::decode!(
13611                fidl::encoding::Vector<
13612                    fidl::encoding::HandleType<
13613                        fidl::Handle,
13614                        { fidl::ObjectType::NONE.into_raw() },
13615                        2147483648,
13616                    >,
13617                    3,
13618                >,
13619                fidl::encoding::DefaultFuchsiaResourceDialect,
13620                &mut self.handle_sized_1,
13621                decoder,
13622                offset + 752,
13623                _depth
13624            )?;
13625            fidl::decode!(
13626                fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
13627                fidl::encoding::DefaultFuchsiaResourceDialect,
13628                &mut self.b_sized_2,
13629                decoder,
13630                offset + 768,
13631                _depth
13632            )?;
13633            fidl::decode!(
13634                fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>,
13635                fidl::encoding::DefaultFuchsiaResourceDialect,
13636                &mut self.i8_sized_2,
13637                decoder,
13638                offset + 784,
13639                _depth
13640            )?;
13641            fidl::decode!(
13642                fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>,
13643                fidl::encoding::DefaultFuchsiaResourceDialect,
13644                &mut self.i16_sized_2,
13645                decoder,
13646                offset + 800,
13647                _depth
13648            )?;
13649            fidl::decode!(
13650                fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>,
13651                fidl::encoding::DefaultFuchsiaResourceDialect,
13652                &mut self.i32_sized_2,
13653                decoder,
13654                offset + 816,
13655                _depth
13656            )?;
13657            fidl::decode!(
13658                fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>,
13659                fidl::encoding::DefaultFuchsiaResourceDialect,
13660                &mut self.i64_sized_2,
13661                decoder,
13662                offset + 832,
13663                _depth
13664            )?;
13665            fidl::decode!(
13666                fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>,
13667                fidl::encoding::DefaultFuchsiaResourceDialect,
13668                &mut self.u8_sized_2,
13669                decoder,
13670                offset + 848,
13671                _depth
13672            )?;
13673            fidl::decode!(
13674                fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>,
13675                fidl::encoding::DefaultFuchsiaResourceDialect,
13676                &mut self.u16_sized_2,
13677                decoder,
13678                offset + 864,
13679                _depth
13680            )?;
13681            fidl::decode!(
13682                fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>,
13683                fidl::encoding::DefaultFuchsiaResourceDialect,
13684                &mut self.u32_sized_2,
13685                decoder,
13686                offset + 880,
13687                _depth
13688            )?;
13689            fidl::decode!(
13690                fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>,
13691                fidl::encoding::DefaultFuchsiaResourceDialect,
13692                &mut self.u64_sized_2,
13693                decoder,
13694                offset + 896,
13695                _depth
13696            )?;
13697            fidl::decode!(
13698                fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>,
13699                fidl::encoding::DefaultFuchsiaResourceDialect,
13700                &mut self.f32_sized_2,
13701                decoder,
13702                offset + 912,
13703                _depth
13704            )?;
13705            fidl::decode!(
13706                fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>,
13707                fidl::encoding::DefaultFuchsiaResourceDialect,
13708                &mut self.f64_sized_2,
13709                decoder,
13710                offset + 928,
13711                _depth
13712            )?;
13713            fidl::decode!(
13714                fidl::encoding::Vector<
13715                    fidl::encoding::Vector<
13716                        fidl::encoding::HandleType<
13717                            fidl::Handle,
13718                            { fidl::ObjectType::NONE.into_raw() },
13719                            2147483648,
13720                        >,
13721                        2,
13722                    >,
13723                    3,
13724                >,
13725                fidl::encoding::DefaultFuchsiaResourceDialect,
13726                &mut self.handle_sized_2,
13727                decoder,
13728                offset + 944,
13729                _depth
13730            )?;
13731            fidl::decode!(
13732                fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
13733                fidl::encoding::DefaultFuchsiaResourceDialect,
13734                &mut self.b_nullable_0,
13735                decoder,
13736                offset + 960,
13737                _depth
13738            )?;
13739            fidl::decode!(
13740                fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
13741                fidl::encoding::DefaultFuchsiaResourceDialect,
13742                &mut self.i8_nullable_0,
13743                decoder,
13744                offset + 976,
13745                _depth
13746            )?;
13747            fidl::decode!(
13748                fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
13749                fidl::encoding::DefaultFuchsiaResourceDialect,
13750                &mut self.i16_nullable_0,
13751                decoder,
13752                offset + 992,
13753                _depth
13754            )?;
13755            fidl::decode!(
13756                fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
13757                fidl::encoding::DefaultFuchsiaResourceDialect,
13758                &mut self.i32_nullable_0,
13759                decoder,
13760                offset + 1008,
13761                _depth
13762            )?;
13763            fidl::decode!(
13764                fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
13765                fidl::encoding::DefaultFuchsiaResourceDialect,
13766                &mut self.i64_nullable_0,
13767                decoder,
13768                offset + 1024,
13769                _depth
13770            )?;
13771            fidl::decode!(
13772                fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
13773                fidl::encoding::DefaultFuchsiaResourceDialect,
13774                &mut self.u8_nullable_0,
13775                decoder,
13776                offset + 1040,
13777                _depth
13778            )?;
13779            fidl::decode!(
13780                fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
13781                fidl::encoding::DefaultFuchsiaResourceDialect,
13782                &mut self.u16_nullable_0,
13783                decoder,
13784                offset + 1056,
13785                _depth
13786            )?;
13787            fidl::decode!(
13788                fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
13789                fidl::encoding::DefaultFuchsiaResourceDialect,
13790                &mut self.u32_nullable_0,
13791                decoder,
13792                offset + 1072,
13793                _depth
13794            )?;
13795            fidl::decode!(
13796                fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
13797                fidl::encoding::DefaultFuchsiaResourceDialect,
13798                &mut self.u64_nullable_0,
13799                decoder,
13800                offset + 1088,
13801                _depth
13802            )?;
13803            fidl::decode!(
13804                fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
13805                fidl::encoding::DefaultFuchsiaResourceDialect,
13806                &mut self.f32_nullable_0,
13807                decoder,
13808                offset + 1104,
13809                _depth
13810            )?;
13811            fidl::decode!(
13812                fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
13813                fidl::encoding::DefaultFuchsiaResourceDialect,
13814                &mut self.f64_nullable_0,
13815                decoder,
13816                offset + 1120,
13817                _depth
13818            )?;
13819            fidl::decode!(
13820                fidl::encoding::Optional<
13821                    fidl::encoding::Vector<
13822                        fidl::encoding::HandleType<
13823                            fidl::Handle,
13824                            { fidl::ObjectType::NONE.into_raw() },
13825                            2147483648,
13826                        >,
13827                        1,
13828                    >,
13829                >,
13830                fidl::encoding::DefaultFuchsiaResourceDialect,
13831                &mut self.handle_nullable_0,
13832                decoder,
13833                offset + 1136,
13834                _depth
13835            )?;
13836            fidl::decode!(
13837                fidl::encoding::Optional<
13838                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<bool, 2>>,
13839                >,
13840                fidl::encoding::DefaultFuchsiaResourceDialect,
13841                &mut self.b_nullable_1,
13842                decoder,
13843                offset + 1152,
13844                _depth
13845            )?;
13846            fidl::decode!(
13847                fidl::encoding::Optional<
13848                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i8, 2>>,
13849                >,
13850                fidl::encoding::DefaultFuchsiaResourceDialect,
13851                &mut self.i8_nullable_1,
13852                decoder,
13853                offset + 1168,
13854                _depth
13855            )?;
13856            fidl::decode!(
13857                fidl::encoding::Optional<
13858                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i16, 2>>,
13859                >,
13860                fidl::encoding::DefaultFuchsiaResourceDialect,
13861                &mut self.i16_nullable_1,
13862                decoder,
13863                offset + 1184,
13864                _depth
13865            )?;
13866            fidl::decode!(
13867                fidl::encoding::Optional<
13868                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i32, 2>>,
13869                >,
13870                fidl::encoding::DefaultFuchsiaResourceDialect,
13871                &mut self.i32_nullable_1,
13872                decoder,
13873                offset + 1200,
13874                _depth
13875            )?;
13876            fidl::decode!(
13877                fidl::encoding::Optional<
13878                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<i64, 2>>,
13879                >,
13880                fidl::encoding::DefaultFuchsiaResourceDialect,
13881                &mut self.i64_nullable_1,
13882                decoder,
13883                offset + 1216,
13884                _depth
13885            )?;
13886            fidl::decode!(
13887                fidl::encoding::Optional<
13888                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u8, 2>>,
13889                >,
13890                fidl::encoding::DefaultFuchsiaResourceDialect,
13891                &mut self.u8_nullable_1,
13892                decoder,
13893                offset + 1232,
13894                _depth
13895            )?;
13896            fidl::decode!(
13897                fidl::encoding::Optional<
13898                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u16, 2>>,
13899                >,
13900                fidl::encoding::DefaultFuchsiaResourceDialect,
13901                &mut self.u16_nullable_1,
13902                decoder,
13903                offset + 1248,
13904                _depth
13905            )?;
13906            fidl::decode!(
13907                fidl::encoding::Optional<
13908                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u32, 2>>,
13909                >,
13910                fidl::encoding::DefaultFuchsiaResourceDialect,
13911                &mut self.u32_nullable_1,
13912                decoder,
13913                offset + 1264,
13914                _depth
13915            )?;
13916            fidl::decode!(
13917                fidl::encoding::Optional<
13918                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<u64, 2>>,
13919                >,
13920                fidl::encoding::DefaultFuchsiaResourceDialect,
13921                &mut self.u64_nullable_1,
13922                decoder,
13923                offset + 1280,
13924                _depth
13925            )?;
13926            fidl::decode!(
13927                fidl::encoding::Optional<
13928                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<f32, 2>>,
13929                >,
13930                fidl::encoding::DefaultFuchsiaResourceDialect,
13931                &mut self.f32_nullable_1,
13932                decoder,
13933                offset + 1296,
13934                _depth
13935            )?;
13936            fidl::decode!(
13937                fidl::encoding::Optional<
13938                    fidl::encoding::UnboundedVector<fidl::encoding::Vector<f64, 2>>,
13939                >,
13940                fidl::encoding::DefaultFuchsiaResourceDialect,
13941                &mut self.f64_nullable_1,
13942                decoder,
13943                offset + 1312,
13944                _depth
13945            )?;
13946            fidl::decode!(
13947                fidl::encoding::Optional<
13948                    fidl::encoding::UnboundedVector<
13949                        fidl::encoding::Vector<
13950                            fidl::encoding::HandleType<
13951                                fidl::Handle,
13952                                { fidl::ObjectType::NONE.into_raw() },
13953                                2147483648,
13954                            >,
13955                            2,
13956                        >,
13957                    >,
13958                >,
13959                fidl::encoding::DefaultFuchsiaResourceDialect,
13960                &mut self.handle_nullable_1,
13961                decoder,
13962                offset + 1328,
13963                _depth
13964            )?;
13965            fidl::decode!(
13966                fidl::encoding::Optional<fidl::encoding::Vector<bool, 1>>,
13967                fidl::encoding::DefaultFuchsiaResourceDialect,
13968                &mut self.b_nullable_sized_0,
13969                decoder,
13970                offset + 1344,
13971                _depth
13972            )?;
13973            fidl::decode!(
13974                fidl::encoding::Optional<fidl::encoding::Vector<i8, 1>>,
13975                fidl::encoding::DefaultFuchsiaResourceDialect,
13976                &mut self.i8_nullable_sized_0,
13977                decoder,
13978                offset + 1360,
13979                _depth
13980            )?;
13981            fidl::decode!(
13982                fidl::encoding::Optional<fidl::encoding::Vector<i16, 1>>,
13983                fidl::encoding::DefaultFuchsiaResourceDialect,
13984                &mut self.i16_nullable_sized_0,
13985                decoder,
13986                offset + 1376,
13987                _depth
13988            )?;
13989            fidl::decode!(
13990                fidl::encoding::Optional<fidl::encoding::Vector<i32, 1>>,
13991                fidl::encoding::DefaultFuchsiaResourceDialect,
13992                &mut self.i32_nullable_sized_0,
13993                decoder,
13994                offset + 1392,
13995                _depth
13996            )?;
13997            fidl::decode!(
13998                fidl::encoding::Optional<fidl::encoding::Vector<i64, 1>>,
13999                fidl::encoding::DefaultFuchsiaResourceDialect,
14000                &mut self.i64_nullable_sized_0,
14001                decoder,
14002                offset + 1408,
14003                _depth
14004            )?;
14005            fidl::decode!(
14006                fidl::encoding::Optional<fidl::encoding::Vector<u8, 1>>,
14007                fidl::encoding::DefaultFuchsiaResourceDialect,
14008                &mut self.u8_nullable_sized_0,
14009                decoder,
14010                offset + 1424,
14011                _depth
14012            )?;
14013            fidl::decode!(
14014                fidl::encoding::Optional<fidl::encoding::Vector<u16, 1>>,
14015                fidl::encoding::DefaultFuchsiaResourceDialect,
14016                &mut self.u16_nullable_sized_0,
14017                decoder,
14018                offset + 1440,
14019                _depth
14020            )?;
14021            fidl::decode!(
14022                fidl::encoding::Optional<fidl::encoding::Vector<u32, 1>>,
14023                fidl::encoding::DefaultFuchsiaResourceDialect,
14024                &mut self.u32_nullable_sized_0,
14025                decoder,
14026                offset + 1456,
14027                _depth
14028            )?;
14029            fidl::decode!(
14030                fidl::encoding::Optional<fidl::encoding::Vector<u64, 1>>,
14031                fidl::encoding::DefaultFuchsiaResourceDialect,
14032                &mut self.u64_nullable_sized_0,
14033                decoder,
14034                offset + 1472,
14035                _depth
14036            )?;
14037            fidl::decode!(
14038                fidl::encoding::Optional<fidl::encoding::Vector<f32, 1>>,
14039                fidl::encoding::DefaultFuchsiaResourceDialect,
14040                &mut self.f32_nullable_sized_0,
14041                decoder,
14042                offset + 1488,
14043                _depth
14044            )?;
14045            fidl::decode!(
14046                fidl::encoding::Optional<fidl::encoding::Vector<f64, 1>>,
14047                fidl::encoding::DefaultFuchsiaResourceDialect,
14048                &mut self.f64_nullable_sized_0,
14049                decoder,
14050                offset + 1504,
14051                _depth
14052            )?;
14053            fidl::decode!(
14054                fidl::encoding::Optional<
14055                    fidl::encoding::Vector<
14056                        fidl::encoding::HandleType<
14057                            fidl::Handle,
14058                            { fidl::ObjectType::NONE.into_raw() },
14059                            2147483648,
14060                        >,
14061                        1,
14062                    >,
14063                >,
14064                fidl::encoding::DefaultFuchsiaResourceDialect,
14065                &mut self.handle_nullable_sized_0,
14066                decoder,
14067                offset + 1520,
14068                _depth
14069            )?;
14070            fidl::decode!(
14071                fidl::encoding::Optional<fidl::encoding::Vector<bool, 3>>,
14072                fidl::encoding::DefaultFuchsiaResourceDialect,
14073                &mut self.b_nullable_sized_1,
14074                decoder,
14075                offset + 1536,
14076                _depth
14077            )?;
14078            fidl::decode!(
14079                fidl::encoding::Optional<fidl::encoding::Vector<i8, 3>>,
14080                fidl::encoding::DefaultFuchsiaResourceDialect,
14081                &mut self.i8_nullable_sized_1,
14082                decoder,
14083                offset + 1552,
14084                _depth
14085            )?;
14086            fidl::decode!(
14087                fidl::encoding::Optional<fidl::encoding::Vector<i16, 3>>,
14088                fidl::encoding::DefaultFuchsiaResourceDialect,
14089                &mut self.i16_nullable_sized_1,
14090                decoder,
14091                offset + 1568,
14092                _depth
14093            )?;
14094            fidl::decode!(
14095                fidl::encoding::Optional<fidl::encoding::Vector<i32, 3>>,
14096                fidl::encoding::DefaultFuchsiaResourceDialect,
14097                &mut self.i32_nullable_sized_1,
14098                decoder,
14099                offset + 1584,
14100                _depth
14101            )?;
14102            fidl::decode!(
14103                fidl::encoding::Optional<fidl::encoding::Vector<i64, 3>>,
14104                fidl::encoding::DefaultFuchsiaResourceDialect,
14105                &mut self.i64_nullable_sized_1,
14106                decoder,
14107                offset + 1600,
14108                _depth
14109            )?;
14110            fidl::decode!(
14111                fidl::encoding::Optional<fidl::encoding::Vector<u8, 3>>,
14112                fidl::encoding::DefaultFuchsiaResourceDialect,
14113                &mut self.u8_nullable_sized_1,
14114                decoder,
14115                offset + 1616,
14116                _depth
14117            )?;
14118            fidl::decode!(
14119                fidl::encoding::Optional<fidl::encoding::Vector<u16, 3>>,
14120                fidl::encoding::DefaultFuchsiaResourceDialect,
14121                &mut self.u16_nullable_sized_1,
14122                decoder,
14123                offset + 1632,
14124                _depth
14125            )?;
14126            fidl::decode!(
14127                fidl::encoding::Optional<fidl::encoding::Vector<u32, 3>>,
14128                fidl::encoding::DefaultFuchsiaResourceDialect,
14129                &mut self.u32_nullable_sized_1,
14130                decoder,
14131                offset + 1648,
14132                _depth
14133            )?;
14134            fidl::decode!(
14135                fidl::encoding::Optional<fidl::encoding::Vector<u64, 3>>,
14136                fidl::encoding::DefaultFuchsiaResourceDialect,
14137                &mut self.u64_nullable_sized_1,
14138                decoder,
14139                offset + 1664,
14140                _depth
14141            )?;
14142            fidl::decode!(
14143                fidl::encoding::Optional<fidl::encoding::Vector<f32, 3>>,
14144                fidl::encoding::DefaultFuchsiaResourceDialect,
14145                &mut self.f32_nullable_sized_1,
14146                decoder,
14147                offset + 1680,
14148                _depth
14149            )?;
14150            fidl::decode!(
14151                fidl::encoding::Optional<fidl::encoding::Vector<f64, 3>>,
14152                fidl::encoding::DefaultFuchsiaResourceDialect,
14153                &mut self.f64_nullable_sized_1,
14154                decoder,
14155                offset + 1696,
14156                _depth
14157            )?;
14158            fidl::decode!(
14159                fidl::encoding::Optional<
14160                    fidl::encoding::Vector<
14161                        fidl::encoding::HandleType<
14162                            fidl::Handle,
14163                            { fidl::ObjectType::NONE.into_raw() },
14164                            2147483648,
14165                        >,
14166                        3,
14167                    >,
14168                >,
14169                fidl::encoding::DefaultFuchsiaResourceDialect,
14170                &mut self.handle_nullable_sized_1,
14171                decoder,
14172                offset + 1712,
14173                _depth
14174            )?;
14175            fidl::decode!(
14176                fidl::encoding::Optional<
14177                    fidl::encoding::Vector<fidl::encoding::Vector<bool, 2>, 3>,
14178                >,
14179                fidl::encoding::DefaultFuchsiaResourceDialect,
14180                &mut self.b_nullable_sized_2,
14181                decoder,
14182                offset + 1728,
14183                _depth
14184            )?;
14185            fidl::decode!(
14186                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i8, 2>, 3>>,
14187                fidl::encoding::DefaultFuchsiaResourceDialect,
14188                &mut self.i8_nullable_sized_2,
14189                decoder,
14190                offset + 1744,
14191                _depth
14192            )?;
14193            fidl::decode!(
14194                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i16, 2>, 3>>,
14195                fidl::encoding::DefaultFuchsiaResourceDialect,
14196                &mut self.i16_nullable_sized_2,
14197                decoder,
14198                offset + 1760,
14199                _depth
14200            )?;
14201            fidl::decode!(
14202                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i32, 2>, 3>>,
14203                fidl::encoding::DefaultFuchsiaResourceDialect,
14204                &mut self.i32_nullable_sized_2,
14205                decoder,
14206                offset + 1776,
14207                _depth
14208            )?;
14209            fidl::decode!(
14210                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<i64, 2>, 3>>,
14211                fidl::encoding::DefaultFuchsiaResourceDialect,
14212                &mut self.i64_nullable_sized_2,
14213                decoder,
14214                offset + 1792,
14215                _depth
14216            )?;
14217            fidl::decode!(
14218                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u8, 2>, 3>>,
14219                fidl::encoding::DefaultFuchsiaResourceDialect,
14220                &mut self.u8_nullable_sized_2,
14221                decoder,
14222                offset + 1808,
14223                _depth
14224            )?;
14225            fidl::decode!(
14226                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u16, 2>, 3>>,
14227                fidl::encoding::DefaultFuchsiaResourceDialect,
14228                &mut self.u16_nullable_sized_2,
14229                decoder,
14230                offset + 1824,
14231                _depth
14232            )?;
14233            fidl::decode!(
14234                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u32, 2>, 3>>,
14235                fidl::encoding::DefaultFuchsiaResourceDialect,
14236                &mut self.u32_nullable_sized_2,
14237                decoder,
14238                offset + 1840,
14239                _depth
14240            )?;
14241            fidl::decode!(
14242                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<u64, 2>, 3>>,
14243                fidl::encoding::DefaultFuchsiaResourceDialect,
14244                &mut self.u64_nullable_sized_2,
14245                decoder,
14246                offset + 1856,
14247                _depth
14248            )?;
14249            fidl::decode!(
14250                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f32, 2>, 3>>,
14251                fidl::encoding::DefaultFuchsiaResourceDialect,
14252                &mut self.f32_nullable_sized_2,
14253                decoder,
14254                offset + 1872,
14255                _depth
14256            )?;
14257            fidl::decode!(
14258                fidl::encoding::Optional<fidl::encoding::Vector<fidl::encoding::Vector<f64, 2>, 3>>,
14259                fidl::encoding::DefaultFuchsiaResourceDialect,
14260                &mut self.f64_nullable_sized_2,
14261                decoder,
14262                offset + 1888,
14263                _depth
14264            )?;
14265            fidl::decode!(
14266                fidl::encoding::Optional<
14267                    fidl::encoding::Vector<
14268                        fidl::encoding::Vector<
14269                            fidl::encoding::HandleType<
14270                                fidl::Handle,
14271                                { fidl::ObjectType::NONE.into_raw() },
14272                                2147483648,
14273                            >,
14274                            2,
14275                        >,
14276                        3,
14277                    >,
14278                >,
14279                fidl::encoding::DefaultFuchsiaResourceDialect,
14280                &mut self.handle_nullable_sized_2,
14281                decoder,
14282                offset + 1904,
14283                _depth
14284            )?;
14285            Ok(())
14286        }
14287    }
14288
14289    impl AllTypesTable {
14290        #[inline(always)]
14291        fn max_ordinal_present(&self) -> u64 {
14292            if let Some(_) = self.xunion_member {
14293                return 21;
14294            }
14295            if let Some(_) = self.table_member {
14296                return 20;
14297            }
14298            if let Some(_) = self.vector_member {
14299                return 19;
14300            }
14301            if let Some(_) = self.array_member {
14302                return 18;
14303            }
14304            if let Some(_) = self.union_member {
14305                return 17;
14306            }
14307            if let Some(_) = self.struct_member {
14308                return 16;
14309            }
14310            if let Some(_) = self.string_member {
14311                return 15;
14312            }
14313            if let Some(_) = self.handle_member {
14314                return 14;
14315            }
14316            if let Some(_) = self.bits_member {
14317                return 13;
14318            }
14319            if let Some(_) = self.enum_member {
14320                return 12;
14321            }
14322            if let Some(_) = self.float64_member {
14323                return 11;
14324            }
14325            if let Some(_) = self.float32_member {
14326                return 10;
14327            }
14328            if let Some(_) = self.uint64_member {
14329                return 9;
14330            }
14331            if let Some(_) = self.uint32_member {
14332                return 8;
14333            }
14334            if let Some(_) = self.uint16_member {
14335                return 7;
14336            }
14337            if let Some(_) = self.uint8_member {
14338                return 6;
14339            }
14340            if let Some(_) = self.int64_member {
14341                return 5;
14342            }
14343            if let Some(_) = self.int32_member {
14344                return 4;
14345            }
14346            if let Some(_) = self.int16_member {
14347                return 3;
14348            }
14349            if let Some(_) = self.int8_member {
14350                return 2;
14351            }
14352            if let Some(_) = self.bool_member {
14353                return 1;
14354            }
14355            0
14356        }
14357    }
14358
14359    impl fidl::encoding::ResourceTypeMarker for AllTypesTable {
14360        type Borrowed<'a> = &'a mut Self;
14361        fn take_or_borrow<'a>(
14362            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
14363        ) -> Self::Borrowed<'a> {
14364            value
14365        }
14366    }
14367
14368    unsafe impl fidl::encoding::TypeMarker for AllTypesTable {
14369        type Owned = Self;
14370
14371        #[inline(always)]
14372        fn inline_align(_context: fidl::encoding::Context) -> usize {
14373            8
14374        }
14375
14376        #[inline(always)]
14377        fn inline_size(_context: fidl::encoding::Context) -> usize {
14378            16
14379        }
14380    }
14381
14382    unsafe impl fidl::encoding::Encode<AllTypesTable, fidl::encoding::DefaultFuchsiaResourceDialect>
14383        for &mut AllTypesTable
14384    {
14385        unsafe fn encode(
14386            self,
14387            encoder: &mut fidl::encoding::Encoder<
14388                '_,
14389                fidl::encoding::DefaultFuchsiaResourceDialect,
14390            >,
14391            offset: usize,
14392            mut depth: fidl::encoding::Depth,
14393        ) -> fidl::Result<()> {
14394            encoder.debug_check_bounds::<AllTypesTable>(offset);
14395            // Vector header
14396            let max_ordinal: u64 = self.max_ordinal_present();
14397            encoder.write_num(max_ordinal, offset);
14398            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
14399            // Calling encoder.out_of_line_offset(0) is not allowed.
14400            if max_ordinal == 0 {
14401                return Ok(());
14402            }
14403            depth.increment()?;
14404            let envelope_size = 8;
14405            let bytes_len = max_ordinal as usize * envelope_size;
14406            #[allow(unused_variables)]
14407            let offset = encoder.out_of_line_offset(bytes_len);
14408            let mut _prev_end_offset: usize = 0;
14409            if 1 > max_ordinal {
14410                return Ok(());
14411            }
14412
14413            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14414            // are envelope_size bytes.
14415            let cur_offset: usize = (1 - 1) * envelope_size;
14416
14417            // Zero reserved fields.
14418            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14419
14420            // Safety:
14421            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14422            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14423            //   envelope_size bytes, there is always sufficient room.
14424            fidl::encoding::encode_in_envelope_optional::<
14425                bool,
14426                fidl::encoding::DefaultFuchsiaResourceDialect,
14427            >(
14428                self.bool_member.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
14429                encoder,
14430                offset + cur_offset,
14431                depth,
14432            )?;
14433
14434            _prev_end_offset = cur_offset + envelope_size;
14435            if 2 > max_ordinal {
14436                return Ok(());
14437            }
14438
14439            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14440            // are envelope_size bytes.
14441            let cur_offset: usize = (2 - 1) * envelope_size;
14442
14443            // Zero reserved fields.
14444            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14445
14446            // Safety:
14447            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14448            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14449            //   envelope_size bytes, there is always sufficient room.
14450            fidl::encoding::encode_in_envelope_optional::<
14451                i8,
14452                fidl::encoding::DefaultFuchsiaResourceDialect,
14453            >(
14454                self.int8_member.as_ref().map(<i8 as fidl::encoding::ValueTypeMarker>::borrow),
14455                encoder,
14456                offset + cur_offset,
14457                depth,
14458            )?;
14459
14460            _prev_end_offset = cur_offset + envelope_size;
14461            if 3 > max_ordinal {
14462                return Ok(());
14463            }
14464
14465            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14466            // are envelope_size bytes.
14467            let cur_offset: usize = (3 - 1) * envelope_size;
14468
14469            // Zero reserved fields.
14470            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14471
14472            // Safety:
14473            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14474            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14475            //   envelope_size bytes, there is always sufficient room.
14476            fidl::encoding::encode_in_envelope_optional::<
14477                i16,
14478                fidl::encoding::DefaultFuchsiaResourceDialect,
14479            >(
14480                self.int16_member.as_ref().map(<i16 as fidl::encoding::ValueTypeMarker>::borrow),
14481                encoder,
14482                offset + cur_offset,
14483                depth,
14484            )?;
14485
14486            _prev_end_offset = cur_offset + envelope_size;
14487            if 4 > max_ordinal {
14488                return Ok(());
14489            }
14490
14491            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14492            // are envelope_size bytes.
14493            let cur_offset: usize = (4 - 1) * envelope_size;
14494
14495            // Zero reserved fields.
14496            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14497
14498            // Safety:
14499            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14500            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14501            //   envelope_size bytes, there is always sufficient room.
14502            fidl::encoding::encode_in_envelope_optional::<
14503                i32,
14504                fidl::encoding::DefaultFuchsiaResourceDialect,
14505            >(
14506                self.int32_member.as_ref().map(<i32 as fidl::encoding::ValueTypeMarker>::borrow),
14507                encoder,
14508                offset + cur_offset,
14509                depth,
14510            )?;
14511
14512            _prev_end_offset = cur_offset + envelope_size;
14513            if 5 > max_ordinal {
14514                return Ok(());
14515            }
14516
14517            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14518            // are envelope_size bytes.
14519            let cur_offset: usize = (5 - 1) * envelope_size;
14520
14521            // Zero reserved fields.
14522            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14523
14524            // Safety:
14525            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14526            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14527            //   envelope_size bytes, there is always sufficient room.
14528            fidl::encoding::encode_in_envelope_optional::<
14529                i64,
14530                fidl::encoding::DefaultFuchsiaResourceDialect,
14531            >(
14532                self.int64_member.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
14533                encoder,
14534                offset + cur_offset,
14535                depth,
14536            )?;
14537
14538            _prev_end_offset = cur_offset + envelope_size;
14539            if 6 > max_ordinal {
14540                return Ok(());
14541            }
14542
14543            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14544            // are envelope_size bytes.
14545            let cur_offset: usize = (6 - 1) * envelope_size;
14546
14547            // Zero reserved fields.
14548            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14549
14550            // Safety:
14551            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14552            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14553            //   envelope_size bytes, there is always sufficient room.
14554            fidl::encoding::encode_in_envelope_optional::<
14555                u8,
14556                fidl::encoding::DefaultFuchsiaResourceDialect,
14557            >(
14558                self.uint8_member.as_ref().map(<u8 as fidl::encoding::ValueTypeMarker>::borrow),
14559                encoder,
14560                offset + cur_offset,
14561                depth,
14562            )?;
14563
14564            _prev_end_offset = cur_offset + envelope_size;
14565            if 7 > max_ordinal {
14566                return Ok(());
14567            }
14568
14569            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14570            // are envelope_size bytes.
14571            let cur_offset: usize = (7 - 1) * envelope_size;
14572
14573            // Zero reserved fields.
14574            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14575
14576            // Safety:
14577            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14578            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14579            //   envelope_size bytes, there is always sufficient room.
14580            fidl::encoding::encode_in_envelope_optional::<
14581                u16,
14582                fidl::encoding::DefaultFuchsiaResourceDialect,
14583            >(
14584                self.uint16_member.as_ref().map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
14585                encoder,
14586                offset + cur_offset,
14587                depth,
14588            )?;
14589
14590            _prev_end_offset = cur_offset + envelope_size;
14591            if 8 > max_ordinal {
14592                return Ok(());
14593            }
14594
14595            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14596            // are envelope_size bytes.
14597            let cur_offset: usize = (8 - 1) * envelope_size;
14598
14599            // Zero reserved fields.
14600            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14601
14602            // Safety:
14603            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14604            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14605            //   envelope_size bytes, there is always sufficient room.
14606            fidl::encoding::encode_in_envelope_optional::<
14607                u32,
14608                fidl::encoding::DefaultFuchsiaResourceDialect,
14609            >(
14610                self.uint32_member.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
14611                encoder,
14612                offset + cur_offset,
14613                depth,
14614            )?;
14615
14616            _prev_end_offset = cur_offset + envelope_size;
14617            if 9 > max_ordinal {
14618                return Ok(());
14619            }
14620
14621            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14622            // are envelope_size bytes.
14623            let cur_offset: usize = (9 - 1) * envelope_size;
14624
14625            // Zero reserved fields.
14626            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14627
14628            // Safety:
14629            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14630            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14631            //   envelope_size bytes, there is always sufficient room.
14632            fidl::encoding::encode_in_envelope_optional::<
14633                u64,
14634                fidl::encoding::DefaultFuchsiaResourceDialect,
14635            >(
14636                self.uint64_member.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
14637                encoder,
14638                offset + cur_offset,
14639                depth,
14640            )?;
14641
14642            _prev_end_offset = cur_offset + envelope_size;
14643            if 10 > max_ordinal {
14644                return Ok(());
14645            }
14646
14647            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14648            // are envelope_size bytes.
14649            let cur_offset: usize = (10 - 1) * envelope_size;
14650
14651            // Zero reserved fields.
14652            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14653
14654            // Safety:
14655            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14656            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14657            //   envelope_size bytes, there is always sufficient room.
14658            fidl::encoding::encode_in_envelope_optional::<
14659                f32,
14660                fidl::encoding::DefaultFuchsiaResourceDialect,
14661            >(
14662                self.float32_member.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
14663                encoder,
14664                offset + cur_offset,
14665                depth,
14666            )?;
14667
14668            _prev_end_offset = cur_offset + envelope_size;
14669            if 11 > max_ordinal {
14670                return Ok(());
14671            }
14672
14673            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14674            // are envelope_size bytes.
14675            let cur_offset: usize = (11 - 1) * envelope_size;
14676
14677            // Zero reserved fields.
14678            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14679
14680            // Safety:
14681            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14682            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14683            //   envelope_size bytes, there is always sufficient room.
14684            fidl::encoding::encode_in_envelope_optional::<
14685                f64,
14686                fidl::encoding::DefaultFuchsiaResourceDialect,
14687            >(
14688                self.float64_member.as_ref().map(<f64 as fidl::encoding::ValueTypeMarker>::borrow),
14689                encoder,
14690                offset + cur_offset,
14691                depth,
14692            )?;
14693
14694            _prev_end_offset = cur_offset + envelope_size;
14695            if 12 > max_ordinal {
14696                return Ok(());
14697            }
14698
14699            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14700            // are envelope_size bytes.
14701            let cur_offset: usize = (12 - 1) * envelope_size;
14702
14703            // Zero reserved fields.
14704            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14705
14706            // Safety:
14707            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14708            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14709            //   envelope_size bytes, there is always sufficient room.
14710            fidl::encoding::encode_in_envelope_optional::<
14711                DefaultEnum,
14712                fidl::encoding::DefaultFuchsiaResourceDialect,
14713            >(
14714                self.enum_member
14715                    .as_ref()
14716                    .map(<DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow),
14717                encoder,
14718                offset + cur_offset,
14719                depth,
14720            )?;
14721
14722            _prev_end_offset = cur_offset + envelope_size;
14723            if 13 > max_ordinal {
14724                return Ok(());
14725            }
14726
14727            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14728            // are envelope_size bytes.
14729            let cur_offset: usize = (13 - 1) * envelope_size;
14730
14731            // Zero reserved fields.
14732            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14733
14734            // Safety:
14735            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14736            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14737            //   envelope_size bytes, there is always sufficient room.
14738            fidl::encoding::encode_in_envelope_optional::<
14739                DefaultBits,
14740                fidl::encoding::DefaultFuchsiaResourceDialect,
14741            >(
14742                self.bits_member
14743                    .as_ref()
14744                    .map(<DefaultBits as fidl::encoding::ValueTypeMarker>::borrow),
14745                encoder,
14746                offset + cur_offset,
14747                depth,
14748            )?;
14749
14750            _prev_end_offset = cur_offset + envelope_size;
14751            if 14 > max_ordinal {
14752                return Ok(());
14753            }
14754
14755            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14756            // are envelope_size bytes.
14757            let cur_offset: usize = (14 - 1) * envelope_size;
14758
14759            // Zero reserved fields.
14760            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14761
14762            // Safety:
14763            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14764            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14765            //   envelope_size bytes, there is always sufficient room.
14766            fidl::encoding::encode_in_envelope_optional::<
14767                fidl::encoding::HandleType<
14768                    fidl::Handle,
14769                    { fidl::ObjectType::NONE.into_raw() },
14770                    2147483648,
14771                >,
14772                fidl::encoding::DefaultFuchsiaResourceDialect,
14773            >(
14774                self.handle_member.as_mut().map(
14775                    <fidl::encoding::HandleType<
14776                        fidl::Handle,
14777                        { fidl::ObjectType::NONE.into_raw() },
14778                        2147483648,
14779                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
14780                ),
14781                encoder,
14782                offset + cur_offset,
14783                depth,
14784            )?;
14785
14786            _prev_end_offset = cur_offset + envelope_size;
14787            if 15 > max_ordinal {
14788                return Ok(());
14789            }
14790
14791            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14792            // are envelope_size bytes.
14793            let cur_offset: usize = (15 - 1) * envelope_size;
14794
14795            // Zero reserved fields.
14796            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14797
14798            // Safety:
14799            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14800            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14801            //   envelope_size bytes, there is always sufficient room.
14802            fidl::encoding::encode_in_envelope_optional::<
14803                fidl::encoding::UnboundedString,
14804                fidl::encoding::DefaultFuchsiaResourceDialect,
14805            >(
14806                self.string_member.as_ref().map(
14807                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
14808                ),
14809                encoder,
14810                offset + cur_offset,
14811                depth,
14812            )?;
14813
14814            _prev_end_offset = cur_offset + envelope_size;
14815            if 16 > max_ordinal {
14816                return Ok(());
14817            }
14818
14819            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14820            // are envelope_size bytes.
14821            let cur_offset: usize = (16 - 1) * envelope_size;
14822
14823            // Zero reserved fields.
14824            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14825
14826            // Safety:
14827            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14828            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14829            //   envelope_size bytes, there is always sufficient room.
14830            fidl::encoding::encode_in_envelope_optional::<
14831                ThisIsAStruct,
14832                fidl::encoding::DefaultFuchsiaResourceDialect,
14833            >(
14834                self.struct_member
14835                    .as_ref()
14836                    .map(<ThisIsAStruct as fidl::encoding::ValueTypeMarker>::borrow),
14837                encoder,
14838                offset + cur_offset,
14839                depth,
14840            )?;
14841
14842            _prev_end_offset = cur_offset + envelope_size;
14843            if 17 > max_ordinal {
14844                return Ok(());
14845            }
14846
14847            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14848            // are envelope_size bytes.
14849            let cur_offset: usize = (17 - 1) * envelope_size;
14850
14851            // Zero reserved fields.
14852            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14853
14854            // Safety:
14855            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14856            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14857            //   envelope_size bytes, there is always sufficient room.
14858            fidl::encoding::encode_in_envelope_optional::<
14859                ThisIsAUnion,
14860                fidl::encoding::DefaultFuchsiaResourceDialect,
14861            >(
14862                self.union_member
14863                    .as_ref()
14864                    .map(<ThisIsAUnion as fidl::encoding::ValueTypeMarker>::borrow),
14865                encoder,
14866                offset + cur_offset,
14867                depth,
14868            )?;
14869
14870            _prev_end_offset = cur_offset + envelope_size;
14871            if 18 > max_ordinal {
14872                return Ok(());
14873            }
14874
14875            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14876            // are envelope_size bytes.
14877            let cur_offset: usize = (18 - 1) * envelope_size;
14878
14879            // Zero reserved fields.
14880            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14881
14882            // Safety:
14883            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14884            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14885            //   envelope_size bytes, there is always sufficient room.
14886            fidl::encoding::encode_in_envelope_optional::<
14887                fidl::encoding::Array<u32, 3>,
14888                fidl::encoding::DefaultFuchsiaResourceDialect,
14889            >(
14890                self.array_member.as_ref().map(
14891                    <fidl::encoding::Array<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow,
14892                ),
14893                encoder,
14894                offset + cur_offset,
14895                depth,
14896            )?;
14897
14898            _prev_end_offset = cur_offset + envelope_size;
14899            if 19 > max_ordinal {
14900                return Ok(());
14901            }
14902
14903            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14904            // are envelope_size bytes.
14905            let cur_offset: usize = (19 - 1) * envelope_size;
14906
14907            // Zero reserved fields.
14908            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14909
14910            // Safety:
14911            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14912            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14913            //   envelope_size bytes, there is always sufficient room.
14914            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u32>, fidl::encoding::DefaultFuchsiaResourceDialect>(
14915            self.vector_member.as_ref().map(<fidl::encoding::UnboundedVector<u32> as fidl::encoding::ValueTypeMarker>::borrow),
14916            encoder, offset + cur_offset, depth
14917        )?;
14918
14919            _prev_end_offset = cur_offset + envelope_size;
14920            if 20 > max_ordinal {
14921                return Ok(());
14922            }
14923
14924            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14925            // are envelope_size bytes.
14926            let cur_offset: usize = (20 - 1) * envelope_size;
14927
14928            // Zero reserved fields.
14929            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14930
14931            // Safety:
14932            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14933            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14934            //   envelope_size bytes, there is always sufficient room.
14935            fidl::encoding::encode_in_envelope_optional::<
14936                ThisIsATable,
14937                fidl::encoding::DefaultFuchsiaResourceDialect,
14938            >(
14939                self.table_member
14940                    .as_ref()
14941                    .map(<ThisIsATable as fidl::encoding::ValueTypeMarker>::borrow),
14942                encoder,
14943                offset + cur_offset,
14944                depth,
14945            )?;
14946
14947            _prev_end_offset = cur_offset + envelope_size;
14948            if 21 > max_ordinal {
14949                return Ok(());
14950            }
14951
14952            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
14953            // are envelope_size bytes.
14954            let cur_offset: usize = (21 - 1) * envelope_size;
14955
14956            // Zero reserved fields.
14957            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
14958
14959            // Safety:
14960            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
14961            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
14962            //   envelope_size bytes, there is always sufficient room.
14963            fidl::encoding::encode_in_envelope_optional::<
14964                ThisIsAXunion,
14965                fidl::encoding::DefaultFuchsiaResourceDialect,
14966            >(
14967                self.xunion_member
14968                    .as_ref()
14969                    .map(<ThisIsAXunion as fidl::encoding::ValueTypeMarker>::borrow),
14970                encoder,
14971                offset + cur_offset,
14972                depth,
14973            )?;
14974
14975            _prev_end_offset = cur_offset + envelope_size;
14976
14977            Ok(())
14978        }
14979    }
14980
14981    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for AllTypesTable {
14982        #[inline(always)]
14983        fn new_empty() -> Self {
14984            Self::default()
14985        }
14986
14987        unsafe fn decode(
14988            &mut self,
14989            decoder: &mut fidl::encoding::Decoder<
14990                '_,
14991                fidl::encoding::DefaultFuchsiaResourceDialect,
14992            >,
14993            offset: usize,
14994            mut depth: fidl::encoding::Depth,
14995        ) -> fidl::Result<()> {
14996            decoder.debug_check_bounds::<Self>(offset);
14997            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
14998                None => return Err(fidl::Error::NotNullable),
14999                Some(len) => len,
15000            };
15001            // Calling decoder.out_of_line_offset(0) is not allowed.
15002            if len == 0 {
15003                return Ok(());
15004            };
15005            depth.increment()?;
15006            let envelope_size = 8;
15007            let bytes_len = len * envelope_size;
15008            let offset = decoder.out_of_line_offset(bytes_len)?;
15009            // Decode the envelope for each type.
15010            let mut _next_ordinal_to_read = 0;
15011            let mut next_offset = offset;
15012            let end_offset = offset + bytes_len;
15013            _next_ordinal_to_read += 1;
15014            if next_offset >= end_offset {
15015                return Ok(());
15016            }
15017
15018            // Decode unknown envelopes for gaps in ordinals.
15019            while _next_ordinal_to_read < 1 {
15020                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15021                _next_ordinal_to_read += 1;
15022                next_offset += envelope_size;
15023            }
15024
15025            let next_out_of_line = decoder.next_out_of_line();
15026            let handles_before = decoder.remaining_handles();
15027            if let Some((inlined, num_bytes, num_handles)) =
15028                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15029            {
15030                let member_inline_size =
15031                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15032                if inlined != (member_inline_size <= 4) {
15033                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15034                }
15035                let inner_offset;
15036                let mut inner_depth = depth.clone();
15037                if inlined {
15038                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15039                    inner_offset = next_offset;
15040                } else {
15041                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15042                    inner_depth.increment()?;
15043                }
15044                let val_ref = self.bool_member.get_or_insert_with(|| {
15045                    fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect)
15046                });
15047                fidl::decode!(
15048                    bool,
15049                    fidl::encoding::DefaultFuchsiaResourceDialect,
15050                    val_ref,
15051                    decoder,
15052                    inner_offset,
15053                    inner_depth
15054                )?;
15055                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15056                {
15057                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15058                }
15059                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15060                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15061                }
15062            }
15063
15064            next_offset += envelope_size;
15065            _next_ordinal_to_read += 1;
15066            if next_offset >= end_offset {
15067                return Ok(());
15068            }
15069
15070            // Decode unknown envelopes for gaps in ordinals.
15071            while _next_ordinal_to_read < 2 {
15072                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15073                _next_ordinal_to_read += 1;
15074                next_offset += envelope_size;
15075            }
15076
15077            let next_out_of_line = decoder.next_out_of_line();
15078            let handles_before = decoder.remaining_handles();
15079            if let Some((inlined, num_bytes, num_handles)) =
15080                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15081            {
15082                let member_inline_size =
15083                    <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15084                if inlined != (member_inline_size <= 4) {
15085                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15086                }
15087                let inner_offset;
15088                let mut inner_depth = depth.clone();
15089                if inlined {
15090                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15091                    inner_offset = next_offset;
15092                } else {
15093                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15094                    inner_depth.increment()?;
15095                }
15096                let val_ref = self.int8_member.get_or_insert_with(|| {
15097                    fidl::new_empty!(i8, fidl::encoding::DefaultFuchsiaResourceDialect)
15098                });
15099                fidl::decode!(
15100                    i8,
15101                    fidl::encoding::DefaultFuchsiaResourceDialect,
15102                    val_ref,
15103                    decoder,
15104                    inner_offset,
15105                    inner_depth
15106                )?;
15107                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15108                {
15109                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15110                }
15111                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15112                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15113                }
15114            }
15115
15116            next_offset += envelope_size;
15117            _next_ordinal_to_read += 1;
15118            if next_offset >= end_offset {
15119                return Ok(());
15120            }
15121
15122            // Decode unknown envelopes for gaps in ordinals.
15123            while _next_ordinal_to_read < 3 {
15124                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15125                _next_ordinal_to_read += 1;
15126                next_offset += envelope_size;
15127            }
15128
15129            let next_out_of_line = decoder.next_out_of_line();
15130            let handles_before = decoder.remaining_handles();
15131            if let Some((inlined, num_bytes, num_handles)) =
15132                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15133            {
15134                let member_inline_size =
15135                    <i16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15136                if inlined != (member_inline_size <= 4) {
15137                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15138                }
15139                let inner_offset;
15140                let mut inner_depth = depth.clone();
15141                if inlined {
15142                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15143                    inner_offset = next_offset;
15144                } else {
15145                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15146                    inner_depth.increment()?;
15147                }
15148                let val_ref = self.int16_member.get_or_insert_with(|| {
15149                    fidl::new_empty!(i16, fidl::encoding::DefaultFuchsiaResourceDialect)
15150                });
15151                fidl::decode!(
15152                    i16,
15153                    fidl::encoding::DefaultFuchsiaResourceDialect,
15154                    val_ref,
15155                    decoder,
15156                    inner_offset,
15157                    inner_depth
15158                )?;
15159                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15160                {
15161                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15162                }
15163                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15164                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15165                }
15166            }
15167
15168            next_offset += envelope_size;
15169            _next_ordinal_to_read += 1;
15170            if next_offset >= end_offset {
15171                return Ok(());
15172            }
15173
15174            // Decode unknown envelopes for gaps in ordinals.
15175            while _next_ordinal_to_read < 4 {
15176                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15177                _next_ordinal_to_read += 1;
15178                next_offset += envelope_size;
15179            }
15180
15181            let next_out_of_line = decoder.next_out_of_line();
15182            let handles_before = decoder.remaining_handles();
15183            if let Some((inlined, num_bytes, num_handles)) =
15184                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15185            {
15186                let member_inline_size =
15187                    <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15188                if inlined != (member_inline_size <= 4) {
15189                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15190                }
15191                let inner_offset;
15192                let mut inner_depth = depth.clone();
15193                if inlined {
15194                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15195                    inner_offset = next_offset;
15196                } else {
15197                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15198                    inner_depth.increment()?;
15199                }
15200                let val_ref = self.int32_member.get_or_insert_with(|| {
15201                    fidl::new_empty!(i32, fidl::encoding::DefaultFuchsiaResourceDialect)
15202                });
15203                fidl::decode!(
15204                    i32,
15205                    fidl::encoding::DefaultFuchsiaResourceDialect,
15206                    val_ref,
15207                    decoder,
15208                    inner_offset,
15209                    inner_depth
15210                )?;
15211                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15212                {
15213                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15214                }
15215                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15216                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15217                }
15218            }
15219
15220            next_offset += envelope_size;
15221            _next_ordinal_to_read += 1;
15222            if next_offset >= end_offset {
15223                return Ok(());
15224            }
15225
15226            // Decode unknown envelopes for gaps in ordinals.
15227            while _next_ordinal_to_read < 5 {
15228                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15229                _next_ordinal_to_read += 1;
15230                next_offset += envelope_size;
15231            }
15232
15233            let next_out_of_line = decoder.next_out_of_line();
15234            let handles_before = decoder.remaining_handles();
15235            if let Some((inlined, num_bytes, num_handles)) =
15236                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15237            {
15238                let member_inline_size =
15239                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15240                if inlined != (member_inline_size <= 4) {
15241                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15242                }
15243                let inner_offset;
15244                let mut inner_depth = depth.clone();
15245                if inlined {
15246                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15247                    inner_offset = next_offset;
15248                } else {
15249                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15250                    inner_depth.increment()?;
15251                }
15252                let val_ref = self.int64_member.get_or_insert_with(|| {
15253                    fidl::new_empty!(i64, fidl::encoding::DefaultFuchsiaResourceDialect)
15254                });
15255                fidl::decode!(
15256                    i64,
15257                    fidl::encoding::DefaultFuchsiaResourceDialect,
15258                    val_ref,
15259                    decoder,
15260                    inner_offset,
15261                    inner_depth
15262                )?;
15263                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15264                {
15265                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15266                }
15267                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15268                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15269                }
15270            }
15271
15272            next_offset += envelope_size;
15273            _next_ordinal_to_read += 1;
15274            if next_offset >= end_offset {
15275                return Ok(());
15276            }
15277
15278            // Decode unknown envelopes for gaps in ordinals.
15279            while _next_ordinal_to_read < 6 {
15280                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15281                _next_ordinal_to_read += 1;
15282                next_offset += envelope_size;
15283            }
15284
15285            let next_out_of_line = decoder.next_out_of_line();
15286            let handles_before = decoder.remaining_handles();
15287            if let Some((inlined, num_bytes, num_handles)) =
15288                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15289            {
15290                let member_inline_size =
15291                    <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15292                if inlined != (member_inline_size <= 4) {
15293                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15294                }
15295                let inner_offset;
15296                let mut inner_depth = depth.clone();
15297                if inlined {
15298                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15299                    inner_offset = next_offset;
15300                } else {
15301                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15302                    inner_depth.increment()?;
15303                }
15304                let val_ref = self.uint8_member.get_or_insert_with(|| {
15305                    fidl::new_empty!(u8, fidl::encoding::DefaultFuchsiaResourceDialect)
15306                });
15307                fidl::decode!(
15308                    u8,
15309                    fidl::encoding::DefaultFuchsiaResourceDialect,
15310                    val_ref,
15311                    decoder,
15312                    inner_offset,
15313                    inner_depth
15314                )?;
15315                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15316                {
15317                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15318                }
15319                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15320                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15321                }
15322            }
15323
15324            next_offset += envelope_size;
15325            _next_ordinal_to_read += 1;
15326            if next_offset >= end_offset {
15327                return Ok(());
15328            }
15329
15330            // Decode unknown envelopes for gaps in ordinals.
15331            while _next_ordinal_to_read < 7 {
15332                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15333                _next_ordinal_to_read += 1;
15334                next_offset += envelope_size;
15335            }
15336
15337            let next_out_of_line = decoder.next_out_of_line();
15338            let handles_before = decoder.remaining_handles();
15339            if let Some((inlined, num_bytes, num_handles)) =
15340                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15341            {
15342                let member_inline_size =
15343                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15344                if inlined != (member_inline_size <= 4) {
15345                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15346                }
15347                let inner_offset;
15348                let mut inner_depth = depth.clone();
15349                if inlined {
15350                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15351                    inner_offset = next_offset;
15352                } else {
15353                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15354                    inner_depth.increment()?;
15355                }
15356                let val_ref = self.uint16_member.get_or_insert_with(|| {
15357                    fidl::new_empty!(u16, fidl::encoding::DefaultFuchsiaResourceDialect)
15358                });
15359                fidl::decode!(
15360                    u16,
15361                    fidl::encoding::DefaultFuchsiaResourceDialect,
15362                    val_ref,
15363                    decoder,
15364                    inner_offset,
15365                    inner_depth
15366                )?;
15367                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15368                {
15369                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15370                }
15371                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15372                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15373                }
15374            }
15375
15376            next_offset += envelope_size;
15377            _next_ordinal_to_read += 1;
15378            if next_offset >= end_offset {
15379                return Ok(());
15380            }
15381
15382            // Decode unknown envelopes for gaps in ordinals.
15383            while _next_ordinal_to_read < 8 {
15384                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15385                _next_ordinal_to_read += 1;
15386                next_offset += envelope_size;
15387            }
15388
15389            let next_out_of_line = decoder.next_out_of_line();
15390            let handles_before = decoder.remaining_handles();
15391            if let Some((inlined, num_bytes, num_handles)) =
15392                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15393            {
15394                let member_inline_size =
15395                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15396                if inlined != (member_inline_size <= 4) {
15397                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15398                }
15399                let inner_offset;
15400                let mut inner_depth = depth.clone();
15401                if inlined {
15402                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15403                    inner_offset = next_offset;
15404                } else {
15405                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15406                    inner_depth.increment()?;
15407                }
15408                let val_ref = self.uint32_member.get_or_insert_with(|| {
15409                    fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect)
15410                });
15411                fidl::decode!(
15412                    u32,
15413                    fidl::encoding::DefaultFuchsiaResourceDialect,
15414                    val_ref,
15415                    decoder,
15416                    inner_offset,
15417                    inner_depth
15418                )?;
15419                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15420                {
15421                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15422                }
15423                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15424                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15425                }
15426            }
15427
15428            next_offset += envelope_size;
15429            _next_ordinal_to_read += 1;
15430            if next_offset >= end_offset {
15431                return Ok(());
15432            }
15433
15434            // Decode unknown envelopes for gaps in ordinals.
15435            while _next_ordinal_to_read < 9 {
15436                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15437                _next_ordinal_to_read += 1;
15438                next_offset += envelope_size;
15439            }
15440
15441            let next_out_of_line = decoder.next_out_of_line();
15442            let handles_before = decoder.remaining_handles();
15443            if let Some((inlined, num_bytes, num_handles)) =
15444                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15445            {
15446                let member_inline_size =
15447                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15448                if inlined != (member_inline_size <= 4) {
15449                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15450                }
15451                let inner_offset;
15452                let mut inner_depth = depth.clone();
15453                if inlined {
15454                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15455                    inner_offset = next_offset;
15456                } else {
15457                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15458                    inner_depth.increment()?;
15459                }
15460                let val_ref = self.uint64_member.get_or_insert_with(|| {
15461                    fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect)
15462                });
15463                fidl::decode!(
15464                    u64,
15465                    fidl::encoding::DefaultFuchsiaResourceDialect,
15466                    val_ref,
15467                    decoder,
15468                    inner_offset,
15469                    inner_depth
15470                )?;
15471                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15472                {
15473                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15474                }
15475                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15476                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15477                }
15478            }
15479
15480            next_offset += envelope_size;
15481            _next_ordinal_to_read += 1;
15482            if next_offset >= end_offset {
15483                return Ok(());
15484            }
15485
15486            // Decode unknown envelopes for gaps in ordinals.
15487            while _next_ordinal_to_read < 10 {
15488                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15489                _next_ordinal_to_read += 1;
15490                next_offset += envelope_size;
15491            }
15492
15493            let next_out_of_line = decoder.next_out_of_line();
15494            let handles_before = decoder.remaining_handles();
15495            if let Some((inlined, num_bytes, num_handles)) =
15496                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15497            {
15498                let member_inline_size =
15499                    <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15500                if inlined != (member_inline_size <= 4) {
15501                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15502                }
15503                let inner_offset;
15504                let mut inner_depth = depth.clone();
15505                if inlined {
15506                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15507                    inner_offset = next_offset;
15508                } else {
15509                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15510                    inner_depth.increment()?;
15511                }
15512                let val_ref = self.float32_member.get_or_insert_with(|| {
15513                    fidl::new_empty!(f32, fidl::encoding::DefaultFuchsiaResourceDialect)
15514                });
15515                fidl::decode!(
15516                    f32,
15517                    fidl::encoding::DefaultFuchsiaResourceDialect,
15518                    val_ref,
15519                    decoder,
15520                    inner_offset,
15521                    inner_depth
15522                )?;
15523                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15524                {
15525                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15526                }
15527                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15528                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15529                }
15530            }
15531
15532            next_offset += envelope_size;
15533            _next_ordinal_to_read += 1;
15534            if next_offset >= end_offset {
15535                return Ok(());
15536            }
15537
15538            // Decode unknown envelopes for gaps in ordinals.
15539            while _next_ordinal_to_read < 11 {
15540                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15541                _next_ordinal_to_read += 1;
15542                next_offset += envelope_size;
15543            }
15544
15545            let next_out_of_line = decoder.next_out_of_line();
15546            let handles_before = decoder.remaining_handles();
15547            if let Some((inlined, num_bytes, num_handles)) =
15548                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15549            {
15550                let member_inline_size =
15551                    <f64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15552                if inlined != (member_inline_size <= 4) {
15553                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15554                }
15555                let inner_offset;
15556                let mut inner_depth = depth.clone();
15557                if inlined {
15558                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15559                    inner_offset = next_offset;
15560                } else {
15561                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15562                    inner_depth.increment()?;
15563                }
15564                let val_ref = self.float64_member.get_or_insert_with(|| {
15565                    fidl::new_empty!(f64, fidl::encoding::DefaultFuchsiaResourceDialect)
15566                });
15567                fidl::decode!(
15568                    f64,
15569                    fidl::encoding::DefaultFuchsiaResourceDialect,
15570                    val_ref,
15571                    decoder,
15572                    inner_offset,
15573                    inner_depth
15574                )?;
15575                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15576                {
15577                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15578                }
15579                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15580                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15581                }
15582            }
15583
15584            next_offset += envelope_size;
15585            _next_ordinal_to_read += 1;
15586            if next_offset >= end_offset {
15587                return Ok(());
15588            }
15589
15590            // Decode unknown envelopes for gaps in ordinals.
15591            while _next_ordinal_to_read < 12 {
15592                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15593                _next_ordinal_to_read += 1;
15594                next_offset += envelope_size;
15595            }
15596
15597            let next_out_of_line = decoder.next_out_of_line();
15598            let handles_before = decoder.remaining_handles();
15599            if let Some((inlined, num_bytes, num_handles)) =
15600                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15601            {
15602                let member_inline_size =
15603                    <DefaultEnum as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15604                if inlined != (member_inline_size <= 4) {
15605                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15606                }
15607                let inner_offset;
15608                let mut inner_depth = depth.clone();
15609                if inlined {
15610                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15611                    inner_offset = next_offset;
15612                } else {
15613                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15614                    inner_depth.increment()?;
15615                }
15616                let val_ref = self.enum_member.get_or_insert_with(|| {
15617                    fidl::new_empty!(DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect)
15618                });
15619                fidl::decode!(
15620                    DefaultEnum,
15621                    fidl::encoding::DefaultFuchsiaResourceDialect,
15622                    val_ref,
15623                    decoder,
15624                    inner_offset,
15625                    inner_depth
15626                )?;
15627                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15628                {
15629                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15630                }
15631                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15632                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15633                }
15634            }
15635
15636            next_offset += envelope_size;
15637            _next_ordinal_to_read += 1;
15638            if next_offset >= end_offset {
15639                return Ok(());
15640            }
15641
15642            // Decode unknown envelopes for gaps in ordinals.
15643            while _next_ordinal_to_read < 13 {
15644                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15645                _next_ordinal_to_read += 1;
15646                next_offset += envelope_size;
15647            }
15648
15649            let next_out_of_line = decoder.next_out_of_line();
15650            let handles_before = decoder.remaining_handles();
15651            if let Some((inlined, num_bytes, num_handles)) =
15652                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15653            {
15654                let member_inline_size =
15655                    <DefaultBits as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15656                if inlined != (member_inline_size <= 4) {
15657                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15658                }
15659                let inner_offset;
15660                let mut inner_depth = depth.clone();
15661                if inlined {
15662                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15663                    inner_offset = next_offset;
15664                } else {
15665                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15666                    inner_depth.increment()?;
15667                }
15668                let val_ref = self.bits_member.get_or_insert_with(|| {
15669                    fidl::new_empty!(DefaultBits, fidl::encoding::DefaultFuchsiaResourceDialect)
15670                });
15671                fidl::decode!(
15672                    DefaultBits,
15673                    fidl::encoding::DefaultFuchsiaResourceDialect,
15674                    val_ref,
15675                    decoder,
15676                    inner_offset,
15677                    inner_depth
15678                )?;
15679                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15680                {
15681                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15682                }
15683                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15684                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15685                }
15686            }
15687
15688            next_offset += envelope_size;
15689            _next_ordinal_to_read += 1;
15690            if next_offset >= end_offset {
15691                return Ok(());
15692            }
15693
15694            // Decode unknown envelopes for gaps in ordinals.
15695            while _next_ordinal_to_read < 14 {
15696                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15697                _next_ordinal_to_read += 1;
15698                next_offset += envelope_size;
15699            }
15700
15701            let next_out_of_line = decoder.next_out_of_line();
15702            let handles_before = decoder.remaining_handles();
15703            if let Some((inlined, num_bytes, num_handles)) =
15704                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15705            {
15706                let member_inline_size = <fidl::encoding::HandleType<
15707                    fidl::Handle,
15708                    { fidl::ObjectType::NONE.into_raw() },
15709                    2147483648,
15710                > as fidl::encoding::TypeMarker>::inline_size(
15711                    decoder.context
15712                );
15713                if inlined != (member_inline_size <= 4) {
15714                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15715                }
15716                let inner_offset;
15717                let mut inner_depth = depth.clone();
15718                if inlined {
15719                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15720                    inner_offset = next_offset;
15721                } else {
15722                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15723                    inner_depth.increment()?;
15724                }
15725                let val_ref =
15726                self.handle_member.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect));
15727                fidl::decode!(fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
15728                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15729                {
15730                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15731                }
15732                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15733                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15734                }
15735            }
15736
15737            next_offset += envelope_size;
15738            _next_ordinal_to_read += 1;
15739            if next_offset >= end_offset {
15740                return Ok(());
15741            }
15742
15743            // Decode unknown envelopes for gaps in ordinals.
15744            while _next_ordinal_to_read < 15 {
15745                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15746                _next_ordinal_to_read += 1;
15747                next_offset += envelope_size;
15748            }
15749
15750            let next_out_of_line = decoder.next_out_of_line();
15751            let handles_before = decoder.remaining_handles();
15752            if let Some((inlined, num_bytes, num_handles)) =
15753                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15754            {
15755                let member_inline_size =
15756                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
15757                        decoder.context,
15758                    );
15759                if inlined != (member_inline_size <= 4) {
15760                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15761                }
15762                let inner_offset;
15763                let mut inner_depth = depth.clone();
15764                if inlined {
15765                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15766                    inner_offset = next_offset;
15767                } else {
15768                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15769                    inner_depth.increment()?;
15770                }
15771                let val_ref = self.string_member.get_or_insert_with(|| {
15772                    fidl::new_empty!(
15773                        fidl::encoding::UnboundedString,
15774                        fidl::encoding::DefaultFuchsiaResourceDialect
15775                    )
15776                });
15777                fidl::decode!(
15778                    fidl::encoding::UnboundedString,
15779                    fidl::encoding::DefaultFuchsiaResourceDialect,
15780                    val_ref,
15781                    decoder,
15782                    inner_offset,
15783                    inner_depth
15784                )?;
15785                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15786                {
15787                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15788                }
15789                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15790                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15791                }
15792            }
15793
15794            next_offset += envelope_size;
15795            _next_ordinal_to_read += 1;
15796            if next_offset >= end_offset {
15797                return Ok(());
15798            }
15799
15800            // Decode unknown envelopes for gaps in ordinals.
15801            while _next_ordinal_to_read < 16 {
15802                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15803                _next_ordinal_to_read += 1;
15804                next_offset += envelope_size;
15805            }
15806
15807            let next_out_of_line = decoder.next_out_of_line();
15808            let handles_before = decoder.remaining_handles();
15809            if let Some((inlined, num_bytes, num_handles)) =
15810                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15811            {
15812                let member_inline_size =
15813                    <ThisIsAStruct as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15814                if inlined != (member_inline_size <= 4) {
15815                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15816                }
15817                let inner_offset;
15818                let mut inner_depth = depth.clone();
15819                if inlined {
15820                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15821                    inner_offset = next_offset;
15822                } else {
15823                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15824                    inner_depth.increment()?;
15825                }
15826                let val_ref = self.struct_member.get_or_insert_with(|| {
15827                    fidl::new_empty!(ThisIsAStruct, fidl::encoding::DefaultFuchsiaResourceDialect)
15828                });
15829                fidl::decode!(
15830                    ThisIsAStruct,
15831                    fidl::encoding::DefaultFuchsiaResourceDialect,
15832                    val_ref,
15833                    decoder,
15834                    inner_offset,
15835                    inner_depth
15836                )?;
15837                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15838                {
15839                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15840                }
15841                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15842                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15843                }
15844            }
15845
15846            next_offset += envelope_size;
15847            _next_ordinal_to_read += 1;
15848            if next_offset >= end_offset {
15849                return Ok(());
15850            }
15851
15852            // Decode unknown envelopes for gaps in ordinals.
15853            while _next_ordinal_to_read < 17 {
15854                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15855                _next_ordinal_to_read += 1;
15856                next_offset += envelope_size;
15857            }
15858
15859            let next_out_of_line = decoder.next_out_of_line();
15860            let handles_before = decoder.remaining_handles();
15861            if let Some((inlined, num_bytes, num_handles)) =
15862                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15863            {
15864                let member_inline_size =
15865                    <ThisIsAUnion as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15866                if inlined != (member_inline_size <= 4) {
15867                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15868                }
15869                let inner_offset;
15870                let mut inner_depth = depth.clone();
15871                if inlined {
15872                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15873                    inner_offset = next_offset;
15874                } else {
15875                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15876                    inner_depth.increment()?;
15877                }
15878                let val_ref = self.union_member.get_or_insert_with(|| {
15879                    fidl::new_empty!(ThisIsAUnion, fidl::encoding::DefaultFuchsiaResourceDialect)
15880                });
15881                fidl::decode!(
15882                    ThisIsAUnion,
15883                    fidl::encoding::DefaultFuchsiaResourceDialect,
15884                    val_ref,
15885                    decoder,
15886                    inner_offset,
15887                    inner_depth
15888                )?;
15889                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15890                {
15891                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15892                }
15893                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15894                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15895                }
15896            }
15897
15898            next_offset += envelope_size;
15899            _next_ordinal_to_read += 1;
15900            if next_offset >= end_offset {
15901                return Ok(());
15902            }
15903
15904            // Decode unknown envelopes for gaps in ordinals.
15905            while _next_ordinal_to_read < 18 {
15906                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15907                _next_ordinal_to_read += 1;
15908                next_offset += envelope_size;
15909            }
15910
15911            let next_out_of_line = decoder.next_out_of_line();
15912            let handles_before = decoder.remaining_handles();
15913            if let Some((inlined, num_bytes, num_handles)) =
15914                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15915            {
15916                let member_inline_size =
15917                    <fidl::encoding::Array<u32, 3> as fidl::encoding::TypeMarker>::inline_size(
15918                        decoder.context,
15919                    );
15920                if inlined != (member_inline_size <= 4) {
15921                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15922                }
15923                let inner_offset;
15924                let mut inner_depth = depth.clone();
15925                if inlined {
15926                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15927                    inner_offset = next_offset;
15928                } else {
15929                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15930                    inner_depth.increment()?;
15931                }
15932                let val_ref =
15933                self.array_member.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect));
15934                fidl::decode!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
15935                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15936                {
15937                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15938                }
15939                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15940                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15941                }
15942            }
15943
15944            next_offset += envelope_size;
15945            _next_ordinal_to_read += 1;
15946            if next_offset >= end_offset {
15947                return Ok(());
15948            }
15949
15950            // Decode unknown envelopes for gaps in ordinals.
15951            while _next_ordinal_to_read < 19 {
15952                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
15953                _next_ordinal_to_read += 1;
15954                next_offset += envelope_size;
15955            }
15956
15957            let next_out_of_line = decoder.next_out_of_line();
15958            let handles_before = decoder.remaining_handles();
15959            if let Some((inlined, num_bytes, num_handles)) =
15960                fidl::encoding::decode_envelope_header(decoder, next_offset)?
15961            {
15962                let member_inline_size = <fidl::encoding::UnboundedVector<u32> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
15963                if inlined != (member_inline_size <= 4) {
15964                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
15965                }
15966                let inner_offset;
15967                let mut inner_depth = depth.clone();
15968                if inlined {
15969                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
15970                    inner_offset = next_offset;
15971                } else {
15972                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
15973                    inner_depth.increment()?;
15974                }
15975                let val_ref = self.vector_member.get_or_insert_with(|| {
15976                    fidl::new_empty!(
15977                        fidl::encoding::UnboundedVector<u32>,
15978                        fidl::encoding::DefaultFuchsiaResourceDialect
15979                    )
15980                });
15981                fidl::decode!(
15982                    fidl::encoding::UnboundedVector<u32>,
15983                    fidl::encoding::DefaultFuchsiaResourceDialect,
15984                    val_ref,
15985                    decoder,
15986                    inner_offset,
15987                    inner_depth
15988                )?;
15989                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
15990                {
15991                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
15992                }
15993                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
15994                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
15995                }
15996            }
15997
15998            next_offset += envelope_size;
15999            _next_ordinal_to_read += 1;
16000            if next_offset >= end_offset {
16001                return Ok(());
16002            }
16003
16004            // Decode unknown envelopes for gaps in ordinals.
16005            while _next_ordinal_to_read < 20 {
16006                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16007                _next_ordinal_to_read += 1;
16008                next_offset += envelope_size;
16009            }
16010
16011            let next_out_of_line = decoder.next_out_of_line();
16012            let handles_before = decoder.remaining_handles();
16013            if let Some((inlined, num_bytes, num_handles)) =
16014                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16015            {
16016                let member_inline_size =
16017                    <ThisIsATable as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16018                if inlined != (member_inline_size <= 4) {
16019                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16020                }
16021                let inner_offset;
16022                let mut inner_depth = depth.clone();
16023                if inlined {
16024                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16025                    inner_offset = next_offset;
16026                } else {
16027                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16028                    inner_depth.increment()?;
16029                }
16030                let val_ref = self.table_member.get_or_insert_with(|| {
16031                    fidl::new_empty!(ThisIsATable, fidl::encoding::DefaultFuchsiaResourceDialect)
16032                });
16033                fidl::decode!(
16034                    ThisIsATable,
16035                    fidl::encoding::DefaultFuchsiaResourceDialect,
16036                    val_ref,
16037                    decoder,
16038                    inner_offset,
16039                    inner_depth
16040                )?;
16041                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16042                {
16043                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16044                }
16045                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16046                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16047                }
16048            }
16049
16050            next_offset += envelope_size;
16051            _next_ordinal_to_read += 1;
16052            if next_offset >= end_offset {
16053                return Ok(());
16054            }
16055
16056            // Decode unknown envelopes for gaps in ordinals.
16057            while _next_ordinal_to_read < 21 {
16058                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16059                _next_ordinal_to_read += 1;
16060                next_offset += envelope_size;
16061            }
16062
16063            let next_out_of_line = decoder.next_out_of_line();
16064            let handles_before = decoder.remaining_handles();
16065            if let Some((inlined, num_bytes, num_handles)) =
16066                fidl::encoding::decode_envelope_header(decoder, next_offset)?
16067            {
16068                let member_inline_size =
16069                    <ThisIsAXunion as fidl::encoding::TypeMarker>::inline_size(decoder.context);
16070                if inlined != (member_inline_size <= 4) {
16071                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
16072                }
16073                let inner_offset;
16074                let mut inner_depth = depth.clone();
16075                if inlined {
16076                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
16077                    inner_offset = next_offset;
16078                } else {
16079                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16080                    inner_depth.increment()?;
16081                }
16082                let val_ref = self.xunion_member.get_or_insert_with(|| {
16083                    fidl::new_empty!(ThisIsAXunion, fidl::encoding::DefaultFuchsiaResourceDialect)
16084                });
16085                fidl::decode!(
16086                    ThisIsAXunion,
16087                    fidl::encoding::DefaultFuchsiaResourceDialect,
16088                    val_ref,
16089                    decoder,
16090                    inner_offset,
16091                    inner_depth
16092                )?;
16093                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
16094                {
16095                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
16096                }
16097                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16098                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16099                }
16100            }
16101
16102            next_offset += envelope_size;
16103
16104            // Decode the remaining unknown envelopes.
16105            while next_offset < end_offset {
16106                _next_ordinal_to_read += 1;
16107                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
16108                next_offset += envelope_size;
16109            }
16110
16111            Ok(())
16112        }
16113    }
16114
16115    impl fidl::encoding::ResourceTypeMarker for AllTypesXunion {
16116        type Borrowed<'a> = &'a mut Self;
16117        fn take_or_borrow<'a>(
16118            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
16119        ) -> Self::Borrowed<'a> {
16120            value
16121        }
16122    }
16123
16124    unsafe impl fidl::encoding::TypeMarker for AllTypesXunion {
16125        type Owned = Self;
16126
16127        #[inline(always)]
16128        fn inline_align(_context: fidl::encoding::Context) -> usize {
16129            8
16130        }
16131
16132        #[inline(always)]
16133        fn inline_size(_context: fidl::encoding::Context) -> usize {
16134            16
16135        }
16136    }
16137
16138    unsafe impl
16139        fidl::encoding::Encode<AllTypesXunion, fidl::encoding::DefaultFuchsiaResourceDialect>
16140        for &mut AllTypesXunion
16141    {
16142        #[inline]
16143        unsafe fn encode(
16144            self,
16145            encoder: &mut fidl::encoding::Encoder<
16146                '_,
16147                fidl::encoding::DefaultFuchsiaResourceDialect,
16148            >,
16149            offset: usize,
16150            _depth: fidl::encoding::Depth,
16151        ) -> fidl::Result<()> {
16152            encoder.debug_check_bounds::<AllTypesXunion>(offset);
16153            encoder.write_num::<u64>(self.ordinal(), offset);
16154            match self {
16155            AllTypesXunion::BoolMember(ref val) => {
16156                fidl::encoding::encode_in_envelope::<bool, fidl::encoding::DefaultFuchsiaResourceDialect>(
16157                    <bool as fidl::encoding::ValueTypeMarker>::borrow(val),
16158                    encoder, offset + 8, _depth
16159                )
16160            }
16161            AllTypesXunion::Int8Member(ref val) => {
16162                fidl::encoding::encode_in_envelope::<i8, fidl::encoding::DefaultFuchsiaResourceDialect>(
16163                    <i8 as fidl::encoding::ValueTypeMarker>::borrow(val),
16164                    encoder, offset + 8, _depth
16165                )
16166            }
16167            AllTypesXunion::Int16Member(ref val) => {
16168                fidl::encoding::encode_in_envelope::<i16, fidl::encoding::DefaultFuchsiaResourceDialect>(
16169                    <i16 as fidl::encoding::ValueTypeMarker>::borrow(val),
16170                    encoder, offset + 8, _depth
16171                )
16172            }
16173            AllTypesXunion::Int32Member(ref val) => {
16174                fidl::encoding::encode_in_envelope::<i32, fidl::encoding::DefaultFuchsiaResourceDialect>(
16175                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(val),
16176                    encoder, offset + 8, _depth
16177                )
16178            }
16179            AllTypesXunion::Int64Member(ref val) => {
16180                fidl::encoding::encode_in_envelope::<i64, fidl::encoding::DefaultFuchsiaResourceDialect>(
16181                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(val),
16182                    encoder, offset + 8, _depth
16183                )
16184            }
16185            AllTypesXunion::Uint8Member(ref val) => {
16186                fidl::encoding::encode_in_envelope::<u8, fidl::encoding::DefaultFuchsiaResourceDialect>(
16187                    <u8 as fidl::encoding::ValueTypeMarker>::borrow(val),
16188                    encoder, offset + 8, _depth
16189                )
16190            }
16191            AllTypesXunion::Uint16Member(ref val) => {
16192                fidl::encoding::encode_in_envelope::<u16, fidl::encoding::DefaultFuchsiaResourceDialect>(
16193                    <u16 as fidl::encoding::ValueTypeMarker>::borrow(val),
16194                    encoder, offset + 8, _depth
16195                )
16196            }
16197            AllTypesXunion::Uint32Member(ref val) => {
16198                fidl::encoding::encode_in_envelope::<u32, fidl::encoding::DefaultFuchsiaResourceDialect>(
16199                    <u32 as fidl::encoding::ValueTypeMarker>::borrow(val),
16200                    encoder, offset + 8, _depth
16201                )
16202            }
16203            AllTypesXunion::Uint64Member(ref val) => {
16204                fidl::encoding::encode_in_envelope::<u64, fidl::encoding::DefaultFuchsiaResourceDialect>(
16205                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(val),
16206                    encoder, offset + 8, _depth
16207                )
16208            }
16209            AllTypesXunion::Float32Member(ref val) => {
16210                fidl::encoding::encode_in_envelope::<f32, fidl::encoding::DefaultFuchsiaResourceDialect>(
16211                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(val),
16212                    encoder, offset + 8, _depth
16213                )
16214            }
16215            AllTypesXunion::Float64Member(ref val) => {
16216                fidl::encoding::encode_in_envelope::<f64, fidl::encoding::DefaultFuchsiaResourceDialect>(
16217                    <f64 as fidl::encoding::ValueTypeMarker>::borrow(val),
16218                    encoder, offset + 8, _depth
16219                )
16220            }
16221            AllTypesXunion::EnumMember(ref val) => {
16222                fidl::encoding::encode_in_envelope::<DefaultEnum, fidl::encoding::DefaultFuchsiaResourceDialect>(
16223                    <DefaultEnum as fidl::encoding::ValueTypeMarker>::borrow(val),
16224                    encoder, offset + 8, _depth
16225                )
16226            }
16227            AllTypesXunion::BitsMember(ref val) => {
16228                fidl::encoding::encode_in_envelope::<DefaultBits, fidl::encoding::DefaultFuchsiaResourceDialect>(
16229                    <DefaultBits as fidl::encoding::ValueTypeMarker>::borrow(val),
16230                    encoder, offset + 8, _depth
16231                )
16232            }
16233            AllTypesXunion::HandleMember(ref mut val) => {
16234                fidl::encoding::encode_in_envelope::<fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect>(
16235                    <fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
16236                    encoder, offset + 8, _depth
16237                )
16238            }
16239            AllTypesXunion::StringMember(ref val) => {
16240                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedString, fidl::encoding::DefaultFuchsiaResourceDialect>(
16241                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(val),
16242                    encoder, offset + 8, _depth
16243                )
16244            }
16245            AllTypesXunion::StructMember(ref val) => {
16246                fidl::encoding::encode_in_envelope::<ThisIsAStruct, fidl::encoding::DefaultFuchsiaResourceDialect>(
16247                    <ThisIsAStruct as fidl::encoding::ValueTypeMarker>::borrow(val),
16248                    encoder, offset + 8, _depth
16249                )
16250            }
16251            AllTypesXunion::UnionMember(ref val) => {
16252                fidl::encoding::encode_in_envelope::<ThisIsAUnion, fidl::encoding::DefaultFuchsiaResourceDialect>(
16253                    <ThisIsAUnion as fidl::encoding::ValueTypeMarker>::borrow(val),
16254                    encoder, offset + 8, _depth
16255                )
16256            }
16257            AllTypesXunion::ArrayMember(ref val) => {
16258                fidl::encoding::encode_in_envelope::<fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect>(
16259                    <fidl::encoding::Array<u32, 3> as fidl::encoding::ValueTypeMarker>::borrow(val),
16260                    encoder, offset + 8, _depth
16261                )
16262            }
16263            AllTypesXunion::VectorMember(ref val) => {
16264                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<u32>, fidl::encoding::DefaultFuchsiaResourceDialect>(
16265                    <fidl::encoding::UnboundedVector<u32> as fidl::encoding::ValueTypeMarker>::borrow(val),
16266                    encoder, offset + 8, _depth
16267                )
16268            }
16269            AllTypesXunion::TableMember(ref val) => {
16270                fidl::encoding::encode_in_envelope::<ThisIsATable, fidl::encoding::DefaultFuchsiaResourceDialect>(
16271                    <ThisIsATable as fidl::encoding::ValueTypeMarker>::borrow(val),
16272                    encoder, offset + 8, _depth
16273                )
16274            }
16275            AllTypesXunion::XunionMember(ref val) => {
16276                fidl::encoding::encode_in_envelope::<ThisIsAXunion, fidl::encoding::DefaultFuchsiaResourceDialect>(
16277                    <ThisIsAXunion as fidl::encoding::ValueTypeMarker>::borrow(val),
16278                    encoder, offset + 8, _depth
16279                )
16280            }
16281            AllTypesXunion::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
16282        }
16283        }
16284    }
16285
16286    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
16287        for AllTypesXunion
16288    {
16289        #[inline(always)]
16290        fn new_empty() -> Self {
16291            Self::__SourceBreaking { unknown_ordinal: 0 }
16292        }
16293
16294        #[inline]
16295        unsafe fn decode(
16296            &mut self,
16297            decoder: &mut fidl::encoding::Decoder<
16298                '_,
16299                fidl::encoding::DefaultFuchsiaResourceDialect,
16300            >,
16301            offset: usize,
16302            mut depth: fidl::encoding::Depth,
16303        ) -> fidl::Result<()> {
16304            decoder.debug_check_bounds::<Self>(offset);
16305            #[allow(unused_variables)]
16306            let next_out_of_line = decoder.next_out_of_line();
16307            let handles_before = decoder.remaining_handles();
16308            let (ordinal, inlined, num_bytes, num_handles) =
16309                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
16310
16311            let member_inline_size = match ordinal {
16312            1 => <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16313            2 => <i8 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16314            3 => <i16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16315            4 => <i32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16316            5 => <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16317            6 => <u8 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16318            7 => <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16319            8 => <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16320            9 => <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16321            10 => <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16322            11 => <f64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16323            12 => <DefaultEnum as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16324            13 => <DefaultBits as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16325            14 => <fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16326            15 => <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16327            16 => <ThisIsAStruct as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16328            17 => <ThisIsAUnion as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16329            18 => <fidl::encoding::Array<u32, 3> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16330            19 => <fidl::encoding::UnboundedVector<u32> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16331            20 => <ThisIsATable as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16332            21 => <ThisIsAXunion as fidl::encoding::TypeMarker>::inline_size(decoder.context),
16333            0 => return Err(fidl::Error::UnknownUnionTag),
16334            _ => num_bytes as usize,
16335        };
16336
16337            if inlined != (member_inline_size <= 4) {
16338                return Err(fidl::Error::InvalidInlineBitInEnvelope);
16339            }
16340            let _inner_offset;
16341            if inlined {
16342                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
16343                _inner_offset = offset + 8;
16344            } else {
16345                depth.increment()?;
16346                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
16347            }
16348            match ordinal {
16349                1 => {
16350                    #[allow(irrefutable_let_patterns)]
16351                    if let AllTypesXunion::BoolMember(_) = self {
16352                        // Do nothing, read the value into the object
16353                    } else {
16354                        // Initialize `self` to the right variant
16355                        *self = AllTypesXunion::BoolMember(fidl::new_empty!(
16356                            bool,
16357                            fidl::encoding::DefaultFuchsiaResourceDialect
16358                        ));
16359                    }
16360                    #[allow(irrefutable_let_patterns)]
16361                    if let AllTypesXunion::BoolMember(ref mut val) = self {
16362                        fidl::decode!(
16363                            bool,
16364                            fidl::encoding::DefaultFuchsiaResourceDialect,
16365                            val,
16366                            decoder,
16367                            _inner_offset,
16368                            depth
16369                        )?;
16370                    } else {
16371                        unreachable!()
16372                    }
16373                }
16374                2 => {
16375                    #[allow(irrefutable_let_patterns)]
16376                    if let AllTypesXunion::Int8Member(_) = self {
16377                        // Do nothing, read the value into the object
16378                    } else {
16379                        // Initialize `self` to the right variant
16380                        *self = AllTypesXunion::Int8Member(fidl::new_empty!(
16381                            i8,
16382                            fidl::encoding::DefaultFuchsiaResourceDialect
16383                        ));
16384                    }
16385                    #[allow(irrefutable_let_patterns)]
16386                    if let AllTypesXunion::Int8Member(ref mut val) = self {
16387                        fidl::decode!(
16388                            i8,
16389                            fidl::encoding::DefaultFuchsiaResourceDialect,
16390                            val,
16391                            decoder,
16392                            _inner_offset,
16393                            depth
16394                        )?;
16395                    } else {
16396                        unreachable!()
16397                    }
16398                }
16399                3 => {
16400                    #[allow(irrefutable_let_patterns)]
16401                    if let AllTypesXunion::Int16Member(_) = self {
16402                        // Do nothing, read the value into the object
16403                    } else {
16404                        // Initialize `self` to the right variant
16405                        *self = AllTypesXunion::Int16Member(fidl::new_empty!(
16406                            i16,
16407                            fidl::encoding::DefaultFuchsiaResourceDialect
16408                        ));
16409                    }
16410                    #[allow(irrefutable_let_patterns)]
16411                    if let AllTypesXunion::Int16Member(ref mut val) = self {
16412                        fidl::decode!(
16413                            i16,
16414                            fidl::encoding::DefaultFuchsiaResourceDialect,
16415                            val,
16416                            decoder,
16417                            _inner_offset,
16418                            depth
16419                        )?;
16420                    } else {
16421                        unreachable!()
16422                    }
16423                }
16424                4 => {
16425                    #[allow(irrefutable_let_patterns)]
16426                    if let AllTypesXunion::Int32Member(_) = self {
16427                        // Do nothing, read the value into the object
16428                    } else {
16429                        // Initialize `self` to the right variant
16430                        *self = AllTypesXunion::Int32Member(fidl::new_empty!(
16431                            i32,
16432                            fidl::encoding::DefaultFuchsiaResourceDialect
16433                        ));
16434                    }
16435                    #[allow(irrefutable_let_patterns)]
16436                    if let AllTypesXunion::Int32Member(ref mut val) = self {
16437                        fidl::decode!(
16438                            i32,
16439                            fidl::encoding::DefaultFuchsiaResourceDialect,
16440                            val,
16441                            decoder,
16442                            _inner_offset,
16443                            depth
16444                        )?;
16445                    } else {
16446                        unreachable!()
16447                    }
16448                }
16449                5 => {
16450                    #[allow(irrefutable_let_patterns)]
16451                    if let AllTypesXunion::Int64Member(_) = self {
16452                        // Do nothing, read the value into the object
16453                    } else {
16454                        // Initialize `self` to the right variant
16455                        *self = AllTypesXunion::Int64Member(fidl::new_empty!(
16456                            i64,
16457                            fidl::encoding::DefaultFuchsiaResourceDialect
16458                        ));
16459                    }
16460                    #[allow(irrefutable_let_patterns)]
16461                    if let AllTypesXunion::Int64Member(ref mut val) = self {
16462                        fidl::decode!(
16463                            i64,
16464                            fidl::encoding::DefaultFuchsiaResourceDialect,
16465                            val,
16466                            decoder,
16467                            _inner_offset,
16468                            depth
16469                        )?;
16470                    } else {
16471                        unreachable!()
16472                    }
16473                }
16474                6 => {
16475                    #[allow(irrefutable_let_patterns)]
16476                    if let AllTypesXunion::Uint8Member(_) = self {
16477                        // Do nothing, read the value into the object
16478                    } else {
16479                        // Initialize `self` to the right variant
16480                        *self = AllTypesXunion::Uint8Member(fidl::new_empty!(
16481                            u8,
16482                            fidl::encoding::DefaultFuchsiaResourceDialect
16483                        ));
16484                    }
16485                    #[allow(irrefutable_let_patterns)]
16486                    if let AllTypesXunion::Uint8Member(ref mut val) = self {
16487                        fidl::decode!(
16488                            u8,
16489                            fidl::encoding::DefaultFuchsiaResourceDialect,
16490                            val,
16491                            decoder,
16492                            _inner_offset,
16493                            depth
16494                        )?;
16495                    } else {
16496                        unreachable!()
16497                    }
16498                }
16499                7 => {
16500                    #[allow(irrefutable_let_patterns)]
16501                    if let AllTypesXunion::Uint16Member(_) = self {
16502                        // Do nothing, read the value into the object
16503                    } else {
16504                        // Initialize `self` to the right variant
16505                        *self = AllTypesXunion::Uint16Member(fidl::new_empty!(
16506                            u16,
16507                            fidl::encoding::DefaultFuchsiaResourceDialect
16508                        ));
16509                    }
16510                    #[allow(irrefutable_let_patterns)]
16511                    if let AllTypesXunion::Uint16Member(ref mut val) = self {
16512                        fidl::decode!(
16513                            u16,
16514                            fidl::encoding::DefaultFuchsiaResourceDialect,
16515                            val,
16516                            decoder,
16517                            _inner_offset,
16518                            depth
16519                        )?;
16520                    } else {
16521                        unreachable!()
16522                    }
16523                }
16524                8 => {
16525                    #[allow(irrefutable_let_patterns)]
16526                    if let AllTypesXunion::Uint32Member(_) = self {
16527                        // Do nothing, read the value into the object
16528                    } else {
16529                        // Initialize `self` to the right variant
16530                        *self = AllTypesXunion::Uint32Member(fidl::new_empty!(
16531                            u32,
16532                            fidl::encoding::DefaultFuchsiaResourceDialect
16533                        ));
16534                    }
16535                    #[allow(irrefutable_let_patterns)]
16536                    if let AllTypesXunion::Uint32Member(ref mut val) = self {
16537                        fidl::decode!(
16538                            u32,
16539                            fidl::encoding::DefaultFuchsiaResourceDialect,
16540                            val,
16541                            decoder,
16542                            _inner_offset,
16543                            depth
16544                        )?;
16545                    } else {
16546                        unreachable!()
16547                    }
16548                }
16549                9 => {
16550                    #[allow(irrefutable_let_patterns)]
16551                    if let AllTypesXunion::Uint64Member(_) = self {
16552                        // Do nothing, read the value into the object
16553                    } else {
16554                        // Initialize `self` to the right variant
16555                        *self = AllTypesXunion::Uint64Member(fidl::new_empty!(
16556                            u64,
16557                            fidl::encoding::DefaultFuchsiaResourceDialect
16558                        ));
16559                    }
16560                    #[allow(irrefutable_let_patterns)]
16561                    if let AllTypesXunion::Uint64Member(ref mut val) = self {
16562                        fidl::decode!(
16563                            u64,
16564                            fidl::encoding::DefaultFuchsiaResourceDialect,
16565                            val,
16566                            decoder,
16567                            _inner_offset,
16568                            depth
16569                        )?;
16570                    } else {
16571                        unreachable!()
16572                    }
16573                }
16574                10 => {
16575                    #[allow(irrefutable_let_patterns)]
16576                    if let AllTypesXunion::Float32Member(_) = self {
16577                        // Do nothing, read the value into the object
16578                    } else {
16579                        // Initialize `self` to the right variant
16580                        *self = AllTypesXunion::Float32Member(fidl::new_empty!(
16581                            f32,
16582                            fidl::encoding::DefaultFuchsiaResourceDialect
16583                        ));
16584                    }
16585                    #[allow(irrefutable_let_patterns)]
16586                    if let AllTypesXunion::Float32Member(ref mut val) = self {
16587                        fidl::decode!(
16588                            f32,
16589                            fidl::encoding::DefaultFuchsiaResourceDialect,
16590                            val,
16591                            decoder,
16592                            _inner_offset,
16593                            depth
16594                        )?;
16595                    } else {
16596                        unreachable!()
16597                    }
16598                }
16599                11 => {
16600                    #[allow(irrefutable_let_patterns)]
16601                    if let AllTypesXunion::Float64Member(_) = self {
16602                        // Do nothing, read the value into the object
16603                    } else {
16604                        // Initialize `self` to the right variant
16605                        *self = AllTypesXunion::Float64Member(fidl::new_empty!(
16606                            f64,
16607                            fidl::encoding::DefaultFuchsiaResourceDialect
16608                        ));
16609                    }
16610                    #[allow(irrefutable_let_patterns)]
16611                    if let AllTypesXunion::Float64Member(ref mut val) = self {
16612                        fidl::decode!(
16613                            f64,
16614                            fidl::encoding::DefaultFuchsiaResourceDialect,
16615                            val,
16616                            decoder,
16617                            _inner_offset,
16618                            depth
16619                        )?;
16620                    } else {
16621                        unreachable!()
16622                    }
16623                }
16624                12 => {
16625                    #[allow(irrefutable_let_patterns)]
16626                    if let AllTypesXunion::EnumMember(_) = self {
16627                        // Do nothing, read the value into the object
16628                    } else {
16629                        // Initialize `self` to the right variant
16630                        *self = AllTypesXunion::EnumMember(fidl::new_empty!(
16631                            DefaultEnum,
16632                            fidl::encoding::DefaultFuchsiaResourceDialect
16633                        ));
16634                    }
16635                    #[allow(irrefutable_let_patterns)]
16636                    if let AllTypesXunion::EnumMember(ref mut val) = self {
16637                        fidl::decode!(
16638                            DefaultEnum,
16639                            fidl::encoding::DefaultFuchsiaResourceDialect,
16640                            val,
16641                            decoder,
16642                            _inner_offset,
16643                            depth
16644                        )?;
16645                    } else {
16646                        unreachable!()
16647                    }
16648                }
16649                13 => {
16650                    #[allow(irrefutable_let_patterns)]
16651                    if let AllTypesXunion::BitsMember(_) = self {
16652                        // Do nothing, read the value into the object
16653                    } else {
16654                        // Initialize `self` to the right variant
16655                        *self = AllTypesXunion::BitsMember(fidl::new_empty!(
16656                            DefaultBits,
16657                            fidl::encoding::DefaultFuchsiaResourceDialect
16658                        ));
16659                    }
16660                    #[allow(irrefutable_let_patterns)]
16661                    if let AllTypesXunion::BitsMember(ref mut val) = self {
16662                        fidl::decode!(
16663                            DefaultBits,
16664                            fidl::encoding::DefaultFuchsiaResourceDialect,
16665                            val,
16666                            decoder,
16667                            _inner_offset,
16668                            depth
16669                        )?;
16670                    } else {
16671                        unreachable!()
16672                    }
16673                }
16674                14 => {
16675                    #[allow(irrefutable_let_patterns)]
16676                    if let AllTypesXunion::HandleMember(_) = self {
16677                        // Do nothing, read the value into the object
16678                    } else {
16679                        // Initialize `self` to the right variant
16680                        *self = AllTypesXunion::HandleMember(
16681                            fidl::new_empty!(fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect),
16682                        );
16683                    }
16684                    #[allow(irrefutable_let_patterns)]
16685                    if let AllTypesXunion::HandleMember(ref mut val) = self {
16686                        fidl::decode!(fidl::encoding::HandleType<fidl::Handle, { fidl::ObjectType::NONE.into_raw() }, 2147483648>, fidl::encoding::DefaultFuchsiaResourceDialect, val, decoder, _inner_offset, depth)?;
16687                    } else {
16688                        unreachable!()
16689                    }
16690                }
16691                15 => {
16692                    #[allow(irrefutable_let_patterns)]
16693                    if let AllTypesXunion::StringMember(_) = self {
16694                        // Do nothing, read the value into the object
16695                    } else {
16696                        // Initialize `self` to the right variant
16697                        *self = AllTypesXunion::StringMember(fidl::new_empty!(
16698                            fidl::encoding::UnboundedString,
16699                            fidl::encoding::DefaultFuchsiaResourceDialect
16700                        ));
16701                    }
16702                    #[allow(irrefutable_let_patterns)]
16703                    if let AllTypesXunion::StringMember(ref mut val) = self {
16704                        fidl::decode!(
16705                            fidl::encoding::UnboundedString,
16706                            fidl::encoding::DefaultFuchsiaResourceDialect,
16707                            val,
16708                            decoder,
16709                            _inner_offset,
16710                            depth
16711                        )?;
16712                    } else {
16713                        unreachable!()
16714                    }
16715                }
16716                16 => {
16717                    #[allow(irrefutable_let_patterns)]
16718                    if let AllTypesXunion::StructMember(_) = self {
16719                        // Do nothing, read the value into the object
16720                    } else {
16721                        // Initialize `self` to the right variant
16722                        *self = AllTypesXunion::StructMember(fidl::new_empty!(
16723                            ThisIsAStruct,
16724                            fidl::encoding::DefaultFuchsiaResourceDialect
16725                        ));
16726                    }
16727                    #[allow(irrefutable_let_patterns)]
16728                    if let AllTypesXunion::StructMember(ref mut val) = self {
16729                        fidl::decode!(
16730                            ThisIsAStruct,
16731                            fidl::encoding::DefaultFuchsiaResourceDialect,
16732                            val,
16733                            decoder,
16734                            _inner_offset,
16735                            depth
16736                        )?;
16737                    } else {
16738                        unreachable!()
16739                    }
16740                }
16741                17 => {
16742                    #[allow(irrefutable_let_patterns)]
16743                    if let AllTypesXunion::UnionMember(_) = self {
16744                        // Do nothing, read the value into the object
16745                    } else {
16746                        // Initialize `self` to the right variant
16747                        *self = AllTypesXunion::UnionMember(fidl::new_empty!(
16748                            ThisIsAUnion,
16749                            fidl::encoding::DefaultFuchsiaResourceDialect
16750                        ));
16751                    }
16752                    #[allow(irrefutable_let_patterns)]
16753                    if let AllTypesXunion::UnionMember(ref mut val) = self {
16754                        fidl::decode!(
16755                            ThisIsAUnion,
16756                            fidl::encoding::DefaultFuchsiaResourceDialect,
16757                            val,
16758                            decoder,
16759                            _inner_offset,
16760                            depth
16761                        )?;
16762                    } else {
16763                        unreachable!()
16764                    }
16765                }
16766                18 => {
16767                    #[allow(irrefutable_let_patterns)]
16768                    if let AllTypesXunion::ArrayMember(_) = self {
16769                        // Do nothing, read the value into the object
16770                    } else {
16771                        // Initialize `self` to the right variant
16772                        *self = AllTypesXunion::ArrayMember(
16773                            fidl::new_empty!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect),
16774                        );
16775                    }
16776                    #[allow(irrefutable_let_patterns)]
16777                    if let AllTypesXunion::ArrayMember(ref mut val) = self {
16778                        fidl::decode!(fidl::encoding::Array<u32, 3>, fidl::encoding::DefaultFuchsiaResourceDialect, val, decoder, _inner_offset, depth)?;
16779                    } else {
16780                        unreachable!()
16781                    }
16782                }
16783                19 => {
16784                    #[allow(irrefutable_let_patterns)]
16785                    if let AllTypesXunion::VectorMember(_) = self {
16786                        // Do nothing, read the value into the object
16787                    } else {
16788                        // Initialize `self` to the right variant
16789                        *self = AllTypesXunion::VectorMember(fidl::new_empty!(
16790                            fidl::encoding::UnboundedVector<u32>,
16791                            fidl::encoding::DefaultFuchsiaResourceDialect
16792                        ));
16793                    }
16794                    #[allow(irrefutable_let_patterns)]
16795                    if let AllTypesXunion::VectorMember(ref mut val) = self {
16796                        fidl::decode!(
16797                            fidl::encoding::UnboundedVector<u32>,
16798                            fidl::encoding::DefaultFuchsiaResourceDialect,
16799                            val,
16800                            decoder,
16801                            _inner_offset,
16802                            depth
16803                        )?;
16804                    } else {
16805                        unreachable!()
16806                    }
16807                }
16808                20 => {
16809                    #[allow(irrefutable_let_patterns)]
16810                    if let AllTypesXunion::TableMember(_) = self {
16811                        // Do nothing, read the value into the object
16812                    } else {
16813                        // Initialize `self` to the right variant
16814                        *self = AllTypesXunion::TableMember(fidl::new_empty!(
16815                            ThisIsATable,
16816                            fidl::encoding::DefaultFuchsiaResourceDialect
16817                        ));
16818                    }
16819                    #[allow(irrefutable_let_patterns)]
16820                    if let AllTypesXunion::TableMember(ref mut val) = self {
16821                        fidl::decode!(
16822                            ThisIsATable,
16823                            fidl::encoding::DefaultFuchsiaResourceDialect,
16824                            val,
16825                            decoder,
16826                            _inner_offset,
16827                            depth
16828                        )?;
16829                    } else {
16830                        unreachable!()
16831                    }
16832                }
16833                21 => {
16834                    #[allow(irrefutable_let_patterns)]
16835                    if let AllTypesXunion::XunionMember(_) = self {
16836                        // Do nothing, read the value into the object
16837                    } else {
16838                        // Initialize `self` to the right variant
16839                        *self = AllTypesXunion::XunionMember(fidl::new_empty!(
16840                            ThisIsAXunion,
16841                            fidl::encoding::DefaultFuchsiaResourceDialect
16842                        ));
16843                    }
16844                    #[allow(irrefutable_let_patterns)]
16845                    if let AllTypesXunion::XunionMember(ref mut val) = self {
16846                        fidl::decode!(
16847                            ThisIsAXunion,
16848                            fidl::encoding::DefaultFuchsiaResourceDialect,
16849                            val,
16850                            decoder,
16851                            _inner_offset,
16852                            depth
16853                        )?;
16854                    } else {
16855                        unreachable!()
16856                    }
16857                }
16858                #[allow(deprecated)]
16859                ordinal => {
16860                    for _ in 0..num_handles {
16861                        decoder.drop_next_handle()?;
16862                    }
16863                    *self = AllTypesXunion::__SourceBreaking { unknown_ordinal: ordinal };
16864                }
16865            }
16866            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
16867                return Err(fidl::Error::InvalidNumBytesInEnvelope);
16868            }
16869            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
16870                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
16871            }
16872            Ok(())
16873        }
16874    }
16875}
fidl_fidl_test_compatibility/fidl_fidl_test_compatibility.rs

fidl_fidl_test_compatibility/
fidl_fidl_test_compatibility.rs
