fidl_fuchsia_pkg_common/
fidl_fuchsia_pkg_common.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::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
8use futures::future::{self, MaybeDone, TryFutureExt};
9use zx_status;
10
11/// The maximum number of bytes for a `ResolutionContext`.
12///
13/// Note that this value must be less than or equal to
14/// `fuchsia.component.resolution::MAX_RESOLUTION_CONTEXT_SIZE`, since the
15/// component resolver is expected to copy or contain the context provided by
16/// the package resolver.
17pub const MAX_RESOLUTION_CONTEXT_SIZE: u32 = 8192;
18
19/// Error type for [`NeededBlobs.BlobWritten`].
20#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
21#[repr(u32)]
22pub enum BlobWrittenError {
23    /// Client called BlobWritten but blob was not readable in blobfs.
24    NotWritten = 1,
25    /// Client called BlobWritten for a blob it has not yet opened.
26    UnopenedBlob = 2,
27}
28
29impl BlobWrittenError {
30    #[inline]
31    pub fn from_primitive(prim: u32) -> Option<Self> {
32        match prim {
33            1 => Some(Self::NotWritten),
34            2 => Some(Self::UnopenedBlob),
35            _ => None,
36        }
37    }
38
39    #[inline]
40    pub const fn into_primitive(self) -> u32 {
41        self as u32
42    }
43}
44
45/// How the package served by [`PackageCache.Get`] should be protected from GC.
46#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
47#[repr(u32)]
48pub enum GcProtection {
49    /// Package will be protected from GC as long as there is an open connection to the directory.
50    OpenPackageTracking = 1,
51    /// Package will be protected from GC as long as it is in the Retained index, which is
52    /// controlled by the [`RetainedPackages`] protocol. Client is responsible for ensuring
53    /// the package is in the Retained index.
54    Retained = 2,
55}
56
57impl GcProtection {
58    #[inline]
59    pub fn from_primitive(prim: u32) -> Option<Self> {
60        match prim {
61            1 => Some(Self::OpenPackageTracking),
62            2 => Some(Self::Retained),
63            _ => None,
64        }
65    }
66
67    #[inline]
68    pub const fn into_primitive(self) -> u32 {
69        self as u32
70    }
71}
72
73#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
74#[repr(u32)]
75pub enum GetInfoError {
76    /// The URL is not a known eager package.
77    UnknownUrl = 1,
78    /// The CUP data associated with the eager package failed verification.
79    Verification = 2,
80    /// The URL is a known eager package, but there are no packages available.
81    NotAvailable = 3,
82}
83
84impl GetInfoError {
85    #[inline]
86    pub fn from_primitive(prim: u32) -> Option<Self> {
87        match prim {
88            1 => Some(Self::UnknownUrl),
89            2 => Some(Self::Verification),
90            3 => Some(Self::NotAvailable),
91            _ => None,
92        }
93    }
94
95    #[inline]
96    pub const fn into_primitive(self) -> u32 {
97        self as u32
98    }
99}
100
101/// Error type for [`PackageCache.GetSubpackage`].
102#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
103#[repr(u32)]
104pub enum GetSubpackageError {
105    /// The superpackage was not open.
106    SuperpackageClosed = 1,
107    /// The requested subpackage does not exist.
108    DoesNotExist = 2,
109    /// An unspecified error occurred.
110    Internal = 3,
111}
112
113impl GetSubpackageError {
114    #[inline]
115    pub fn from_primitive(prim: u32) -> Option<Self> {
116        match prim {
117            1 => Some(Self::SuperpackageClosed),
118            2 => Some(Self::DoesNotExist),
119            3 => Some(Self::Internal),
120            _ => None,
121        }
122    }
123
124    #[inline]
125    pub const fn into_primitive(self) -> u32 {
126        self as u32
127    }
128}
129
130/// Error type for [`NeededBlobs.OpenMetaBlob`] and [`NeededBlobs.OpenBlob`].
131#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
132#[repr(u32)]
133pub enum OpenBlobError {
134    /// There is insufficient storage space available to persist this blob.
135    OutOfSpace = 1,
136    /// This blob is already open for write by another cache operation.
137    ConcurrentWrite = 2,
138    /// An unspecified error occurred during underlying I/O.
139    UnspecifiedIo = 3,
140    /// An unspecified error occurred.
141    Internal = 4,
142}
143
144impl OpenBlobError {
145    #[inline]
146    pub fn from_primitive(prim: u32) -> Option<Self> {
147        match prim {
148            1 => Some(Self::OutOfSpace),
149            2 => Some(Self::ConcurrentWrite),
150            3 => Some(Self::UnspecifiedIo),
151            4 => Some(Self::Internal),
152            _ => None,
153        }
154    }
155
156    #[inline]
157    pub const fn into_primitive(self) -> u32 {
158        self as u32
159    }
160}
161
162/// Where the repository storage is written to.
163#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
164#[repr(u32)]
165pub enum RepositoryStorageType {
166    /// Ephemeral, or in-memory storage. This repository metadata will be lost
167    /// when the process or device is restarted. The default type.
168    Ephemeral = 1,
169    /// Persistent, where the repository metadata is written to mutable storage
170    /// and is available after a reboot.
171    Persistent = 2,
172}
173
174impl RepositoryStorageType {
175    #[inline]
176    pub fn from_primitive(prim: u32) -> Option<Self> {
177        match prim {
178            1 => Some(Self::Ephemeral),
179            2 => Some(Self::Persistent),
180            _ => None,
181        }
182    }
183
184    #[inline]
185    pub const fn into_primitive(self) -> u32 {
186        self as u32
187    }
188}
189
190/// Error codes for PackageResolver operations.
191#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
192#[repr(i32)]
193pub enum ResolveError {
194    /// The resolver encountered an otherwise unspecified error while handling the request.
195    Internal = 1,
196    /// The resolver does not have permission to fetch a package blob.
197    AccessDenied = 2,
198    /// Some unspecified error during I/O.
199    Io = 3,
200    /// The package blob does not exist.
201    BlobNotFound = 4,
202    /// The package does not exist.
203    PackageNotFound = 5,
204    /// The resolver does not know about the repo.
205    RepoNotFound = 6,
206    /// There is no space available to store the package or metadata.
207    NoSpace = 7,
208    /// The resolver is currently unable to fetch a package blob.
209    UnavailableBlob = 8,
210    /// The resolver is currently unable to fetch a repository's metadata.
211    UnavailableRepoMetadata = 9,
212    /// The `package_url` provided to resolver is invalid.
213    InvalidUrl = 10,
214    /// The `context` provided to resolver is invalid.
215    InvalidContext = 11,
216}
217
218impl ResolveError {
219    #[inline]
220    pub fn from_primitive(prim: i32) -> Option<Self> {
221        match prim {
222            1 => Some(Self::Internal),
223            2 => Some(Self::AccessDenied),
224            3 => Some(Self::Io),
225            4 => Some(Self::BlobNotFound),
226            5 => Some(Self::PackageNotFound),
227            6 => Some(Self::RepoNotFound),
228            7 => Some(Self::NoSpace),
229            8 => Some(Self::UnavailableBlob),
230            9 => Some(Self::UnavailableRepoMetadata),
231            10 => Some(Self::InvalidUrl),
232            11 => Some(Self::InvalidContext),
233            _ => None,
234        }
235    }
236
237    #[inline]
238    pub const fn into_primitive(self) -> i32 {
239        self as i32
240    }
241}
242
243/// Error type for [`PackageCache.SetUpgradableUrls`].
244#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
245pub enum SetUpgradableUrlsError {
246    /// One or more URLs are not set.
247    ///
248    /// Invalid URLs or base packages are ignored, all the other packages are still set,
249    /// package resolution and GC is unblocked.
250    PartialSet,
251    /// An unspecified error occurred.
252    Internal,
253    #[doc(hidden)]
254    __SourceBreaking { unknown_ordinal: u32 },
255}
256
257/// Pattern that matches an unknown `SetUpgradableUrlsError` member.
258#[macro_export]
259macro_rules! SetUpgradableUrlsErrorUnknown {
260    () => {
261        _
262    };
263}
264
265impl SetUpgradableUrlsError {
266    #[inline]
267    pub fn from_primitive(prim: u32) -> Option<Self> {
268        match prim {
269            1 => Some(Self::PartialSet),
270            2 => Some(Self::Internal),
271            _ => None,
272        }
273    }
274
275    #[inline]
276    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
277        match prim {
278            1 => Self::PartialSet,
279            2 => Self::Internal,
280            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
281        }
282    }
283
284    #[inline]
285    pub fn unknown() -> Self {
286        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
287    }
288
289    #[inline]
290    pub const fn into_primitive(self) -> u32 {
291        match self {
292            Self::PartialSet => 1,
293            Self::Internal => 2,
294            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
295        }
296    }
297
298    #[inline]
299    pub fn is_unknown(&self) -> bool {
300        match self {
301            Self::__SourceBreaking { unknown_ordinal: _ } => true,
302            _ => false,
303        }
304    }
305}
306
307#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
308#[repr(u32)]
309pub enum WriteError {
310    /// The URL is not a known eager package.
311    UnknownUrl = 1,
312    /// The CUP data associated with the eager package failed verification.
313    Verification = 2,
314    /// Downloading the eager package failed.
315    Download = 3,
316    /// Writing the CUP data to storage failed.
317    Storage = 4,
318}
319
320impl WriteError {
321    #[inline]
322    pub fn from_primitive(prim: u32) -> Option<Self> {
323        match prim {
324            1 => Some(Self::UnknownUrl),
325            2 => Some(Self::Verification),
326            3 => Some(Self::Download),
327            4 => Some(Self::Storage),
328            _ => None,
329        }
330    }
331
332    #[inline]
333    pub const fn into_primitive(self) -> u32 {
334        self as u32
335    }
336}
337
338/// A content-addressed merkle root that describes an artifact that is tracked by the
339/// packaging system.
340#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
341#[repr(C)]
342pub struct BlobId {
343    pub merkle_root: [u8; 32],
344}
345
346impl fidl::Persistable for BlobId {}
347
348#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
349pub struct BlobIdIteratorNextResponse {
350    pub blobs: Vec<BlobId>,
351}
352
353impl fidl::Persistable for BlobIdIteratorNextResponse {}
354
355/// A tuple of the content-addressed merkle root for an artifact, along with that
356/// artifact's length in bytes.
357#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
358#[repr(C)]
359pub struct BlobInfo {
360    pub blob_id: BlobId,
361    pub length: u64,
362}
363
364impl fidl::Persistable for BlobInfo {}
365
366#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
367pub struct BlobInfoIteratorNextResponse {
368    pub blobs: Vec<BlobInfo>,
369}
370
371impl fidl::Persistable for BlobInfoIteratorNextResponse {}
372
373#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
374pub struct CupGetInfoRequest {
375    /// The eager package URL, must be unpinned.
376    pub url: PackageUrl,
377}
378
379impl fidl::Persistable for CupGetInfoRequest {}
380
381#[derive(Clone, Debug, PartialEq)]
382pub struct CupWriteRequest {
383    /// The pinned eager package URL from Omaha, must appear in CUP data.
384    pub url: PackageUrl,
385    /// The CUP data from the update check.
386    pub cup: CupData,
387}
388
389impl fidl::Persistable for CupWriteRequest {}
390
391#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
392pub struct CupGetInfoResponse {
393    pub version: String,
394    pub channel: String,
395}
396
397impl fidl::Persistable for CupGetInfoResponse {}
398
399#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
400#[repr(C)]
401pub struct NeededBlobsBlobWrittenRequest {
402    pub blob_id: BlobId,
403}
404
405impl fidl::Persistable for NeededBlobsBlobWrittenRequest {}
406
407#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
408#[repr(C)]
409pub struct NeededBlobsOpenBlobRequest {
410    pub blob_id: BlobId,
411}
412
413impl fidl::Persistable for NeededBlobsOpenBlobRequest {}
414
415#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
416pub struct PackageCacheSetUpgradableUrlsRequest {
417    pub pinned_urls: Vec<PackageUrl>,
418}
419
420impl fidl::Persistable for PackageCacheSetUpgradableUrlsRequest {}
421
422/// A single entry in the package index.
423#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
424pub struct PackageIndexEntry {
425    pub package_url: PackageUrl,
426    pub meta_far_blob_id: BlobId,
427}
428
429impl fidl::Persistable for PackageIndexEntry {}
430
431#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
432pub struct PackageIndexIteratorNextResponse {
433    pub entries: Vec<PackageIndexEntry>,
434}
435
436impl fidl::Persistable for PackageIndexIteratorNextResponse {}
437
438#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
439pub struct PackageResolverGetHashRequest {
440    pub package_url: PackageUrl,
441}
442
443impl fidl::Persistable for PackageResolverGetHashRequest {}
444
445#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
446#[repr(C)]
447pub struct PackageResolverGetHashResponse {
448    pub meta_far_blob_id: BlobId,
449}
450
451impl fidl::Persistable for PackageResolverGetHashResponse {}
452
453#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
454pub struct PackageResolverResolveWithContextResponse {
455    pub resolved_context: ResolutionContext,
456}
457
458impl fidl::Persistable for PackageResolverResolveWithContextResponse {}
459
460#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
461pub struct PackageResolverResolveResponse {
462    pub resolved_context: ResolutionContext,
463}
464
465impl fidl::Persistable for PackageResolverResolveResponse {}
466
467/// A fuchsia-pkg:// URL indicating a package.
468/// https://fuchsia.dev/fuchsia-src/concepts/packages/package_url#package_identity
469#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
470pub struct PackageUrl {
471    pub url: String,
472}
473
474impl fidl::Persistable for PackageUrl {}
475
476#[derive(Clone, Debug, PartialEq)]
477pub struct RepositoryIteratorNextResponse {
478    pub repos: Vec<RepositoryConfig>,
479}
480
481impl fidl::Persistable for RepositoryIteratorNextResponse {}
482
483#[derive(Clone, Debug, PartialEq)]
484pub struct RepositoryManagerAddMirrorRequest {
485    pub repo_url: String,
486    pub mirror: MirrorConfig,
487}
488
489impl fidl::Persistable for RepositoryManagerAddMirrorRequest {}
490
491#[derive(Clone, Debug, PartialEq)]
492pub struct RepositoryManagerAddRequest {
493    pub repo: RepositoryConfig,
494}
495
496impl fidl::Persistable for RepositoryManagerAddRequest {}
497
498#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
499pub struct RepositoryManagerRemoveMirrorRequest {
500    pub repo_url: String,
501    pub mirror_url: String,
502}
503
504impl fidl::Persistable for RepositoryManagerRemoveMirrorRequest {}
505
506#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
507pub struct RepositoryManagerRemoveRequest {
508    pub repo_url: String,
509}
510
511impl fidl::Persistable for RepositoryManagerRemoveRequest {}
512
513/// A fuchsia-pkg:// URL indicating a repository.
514/// https://fuchsia.dev/fuchsia-src/concepts/packages/package_url#repository_identity
515#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
516pub struct RepositoryUrl {
517    pub url: String,
518}
519
520impl fidl::Persistable for RepositoryUrl {}
521
522/// A package resolution context, used when resolving package URLs relative to
523/// another package.
524#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
525pub struct ResolutionContext {
526    pub bytes: Vec<u8>,
527}
528
529impl fidl::Persistable for ResolutionContext {}
530
531#[derive(Clone, Debug, Default, PartialEq)]
532pub struct CupData {
533    /// Omaha request json
534    pub request: Option<Vec<u8>>,
535    /// The public key id
536    pub key_id: Option<u64>,
537    /// ECDSA nonce.
538    pub nonce: Option<[u8; 32]>,
539    /// Omaha response json
540    pub response: Option<Vec<u8>>,
541    /// DER encoded ECDSA signature
542    pub signature: Option<Vec<u8>>,
543    #[doc(hidden)]
544    pub __source_breaking: fidl::marker::SourceBreaking,
545}
546
547impl fidl::Persistable for CupData {}
548
549/// The configuration necessary to connect to a mirror.
550#[derive(Clone, Debug, Default, PartialEq)]
551pub struct MirrorConfig {
552    /// The base URL of the TUF metadata on this mirror. Required.
553    pub mirror_url: Option<String>,
554    /// Whether or not to automatically monitor the mirror for updates. Required.
555    pub subscribe: Option<bool>,
556    /// The URL where blobs from this mirror should be fetched.  Optional.
557    /// If absent presumed to be `mirror_url + "/blobs"`.
558    pub blob_mirror_url: Option<String>,
559    #[doc(hidden)]
560    pub __source_breaking: fidl::marker::SourceBreaking,
561}
562
563impl fidl::Persistable for MirrorConfig {}
564
565/// The configuration necessary to connect to a repository and its mirrors.
566#[derive(Clone, Debug, Default, PartialEq)]
567pub struct RepositoryConfig {
568    /// A fuchsia-pkg URL identifying the repository. Required.
569    ///
570    /// Example: fuchsia-pkg://example.com/
571    pub repo_url: Option<String>,
572    /// A vector of public keys that have signed the initial trusted root
573    /// metadata. Required.
574    ///
575    /// These keys must match one of the trusted keys known to the system.
576    pub root_keys: Option<Vec<RepositoryKeyConfig>>,
577    /// The repository mirrors that serve the package contents. Required.
578    pub mirrors: Option<Vec<MirrorConfig>>,
579    /// The initial trusted root metadata version. Optional, if absent presumed
580    /// to be 1.
581    ///
582    /// This value describes the initial root metadata version the resolver will
583    /// fetch to initialize trust, once it's signatures has been verified by the
584    /// `root_keys`. It will then walk the chain of N+1, N+2, and etc to the
585    /// latest version before the resolver fetches any targets.
586    ///
587    /// It is recommended that this `root_version` number and `root_keys ` are
588    /// kept reasonably in sync with the most recent published version of the
589    /// root metadata, as that avoids the risk of an old and unused root key
590    /// being used to compromise resolvers during the trust initialization.
591    pub root_version: Option<u32>,
592    /// The number of `root_keys` that need to have signed the root metadata for it
593    /// to be considered trusted. This value must be greater than or equal to 1.
594    /// Optional, if absent presumed to be 1.
595    pub root_threshold: Option<u32>,
596    /// Whether the package resolver should check attached storage for blobs and
597    /// repository metadata. Optional, if absent presumed to be false.
598    pub use_local_mirror: Option<bool>,
599    /// Controls how repository metadata is persisted across reboots. Optional, if absent presumed
600    /// to be EPHEMERAL.
601    pub storage_type: Option<RepositoryStorageType>,
602    #[doc(hidden)]
603    pub __source_breaking: fidl::marker::SourceBreaking,
604}
605
606impl fidl::Persistable for RepositoryConfig {}
607
608/// The keys used by the repository to authenticate its packages.
609///
610/// The only supported algorithm at the moment is ed25519.
611#[derive(Clone, Debug)]
612pub enum RepositoryKeyConfig {
613    /// The raw ed25519 public key as binary data.
614    Ed25519Key(Vec<u8>),
615    #[doc(hidden)]
616    __SourceBreaking { unknown_ordinal: u64 },
617}
618
619/// Pattern that matches an unknown `RepositoryKeyConfig` member.
620#[macro_export]
621macro_rules! RepositoryKeyConfigUnknown {
622    () => {
623        _
624    };
625}
626
627// Custom PartialEq so that unknown variants are not equal to themselves.
628impl PartialEq for RepositoryKeyConfig {
629    fn eq(&self, other: &Self) -> bool {
630        match (self, other) {
631            (Self::Ed25519Key(x), Self::Ed25519Key(y)) => *x == *y,
632            _ => false,
633        }
634    }
635}
636
637impl RepositoryKeyConfig {
638    #[inline]
639    pub fn ordinal(&self) -> u64 {
640        match *self {
641            Self::Ed25519Key(_) => 1,
642            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
643        }
644    }
645
646    #[inline]
647    pub fn unknown_variant_for_testing() -> Self {
648        Self::__SourceBreaking { unknown_ordinal: 0 }
649    }
650
651    #[inline]
652    pub fn is_unknown(&self) -> bool {
653        match self {
654            Self::__SourceBreaking { .. } => true,
655            _ => false,
656        }
657    }
658}
659
660impl fidl::Persistable for RepositoryKeyConfig {}
661
662mod internal {
663    use super::*;
664    unsafe impl fidl::encoding::TypeMarker for BlobWrittenError {
665        type Owned = Self;
666
667        #[inline(always)]
668        fn inline_align(_context: fidl::encoding::Context) -> usize {
669            std::mem::align_of::<u32>()
670        }
671
672        #[inline(always)]
673        fn inline_size(_context: fidl::encoding::Context) -> usize {
674            std::mem::size_of::<u32>()
675        }
676
677        #[inline(always)]
678        fn encode_is_copy() -> bool {
679            true
680        }
681
682        #[inline(always)]
683        fn decode_is_copy() -> bool {
684            false
685        }
686    }
687
688    impl fidl::encoding::ValueTypeMarker for BlobWrittenError {
689        type Borrowed<'a> = Self;
690        #[inline(always)]
691        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
692            *value
693        }
694    }
695
696    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
697        for BlobWrittenError
698    {
699        #[inline]
700        unsafe fn encode(
701            self,
702            encoder: &mut fidl::encoding::Encoder<'_, D>,
703            offset: usize,
704            _depth: fidl::encoding::Depth,
705        ) -> fidl::Result<()> {
706            encoder.debug_check_bounds::<Self>(offset);
707            encoder.write_num(self.into_primitive(), offset);
708            Ok(())
709        }
710    }
711
712    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BlobWrittenError {
713        #[inline(always)]
714        fn new_empty() -> Self {
715            Self::NotWritten
716        }
717
718        #[inline]
719        unsafe fn decode(
720            &mut self,
721            decoder: &mut fidl::encoding::Decoder<'_, D>,
722            offset: usize,
723            _depth: fidl::encoding::Depth,
724        ) -> fidl::Result<()> {
725            decoder.debug_check_bounds::<Self>(offset);
726            let prim = decoder.read_num::<u32>(offset);
727
728            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
729            Ok(())
730        }
731    }
732    unsafe impl fidl::encoding::TypeMarker for GcProtection {
733        type Owned = Self;
734
735        #[inline(always)]
736        fn inline_align(_context: fidl::encoding::Context) -> usize {
737            std::mem::align_of::<u32>()
738        }
739
740        #[inline(always)]
741        fn inline_size(_context: fidl::encoding::Context) -> usize {
742            std::mem::size_of::<u32>()
743        }
744
745        #[inline(always)]
746        fn encode_is_copy() -> bool {
747            true
748        }
749
750        #[inline(always)]
751        fn decode_is_copy() -> bool {
752            false
753        }
754    }
755
756    impl fidl::encoding::ValueTypeMarker for GcProtection {
757        type Borrowed<'a> = Self;
758        #[inline(always)]
759        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
760            *value
761        }
762    }
763
764    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for GcProtection {
765        #[inline]
766        unsafe fn encode(
767            self,
768            encoder: &mut fidl::encoding::Encoder<'_, D>,
769            offset: usize,
770            _depth: fidl::encoding::Depth,
771        ) -> fidl::Result<()> {
772            encoder.debug_check_bounds::<Self>(offset);
773            encoder.write_num(self.into_primitive(), offset);
774            Ok(())
775        }
776    }
777
778    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for GcProtection {
779        #[inline(always)]
780        fn new_empty() -> Self {
781            Self::OpenPackageTracking
782        }
783
784        #[inline]
785        unsafe fn decode(
786            &mut self,
787            decoder: &mut fidl::encoding::Decoder<'_, D>,
788            offset: usize,
789            _depth: fidl::encoding::Depth,
790        ) -> fidl::Result<()> {
791            decoder.debug_check_bounds::<Self>(offset);
792            let prim = decoder.read_num::<u32>(offset);
793
794            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
795            Ok(())
796        }
797    }
798    unsafe impl fidl::encoding::TypeMarker for GetInfoError {
799        type Owned = Self;
800
801        #[inline(always)]
802        fn inline_align(_context: fidl::encoding::Context) -> usize {
803            std::mem::align_of::<u32>()
804        }
805
806        #[inline(always)]
807        fn inline_size(_context: fidl::encoding::Context) -> usize {
808            std::mem::size_of::<u32>()
809        }
810
811        #[inline(always)]
812        fn encode_is_copy() -> bool {
813            true
814        }
815
816        #[inline(always)]
817        fn decode_is_copy() -> bool {
818            false
819        }
820    }
821
822    impl fidl::encoding::ValueTypeMarker for GetInfoError {
823        type Borrowed<'a> = Self;
824        #[inline(always)]
825        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
826            *value
827        }
828    }
829
830    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for GetInfoError {
831        #[inline]
832        unsafe fn encode(
833            self,
834            encoder: &mut fidl::encoding::Encoder<'_, D>,
835            offset: usize,
836            _depth: fidl::encoding::Depth,
837        ) -> fidl::Result<()> {
838            encoder.debug_check_bounds::<Self>(offset);
839            encoder.write_num(self.into_primitive(), offset);
840            Ok(())
841        }
842    }
843
844    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for GetInfoError {
845        #[inline(always)]
846        fn new_empty() -> Self {
847            Self::UnknownUrl
848        }
849
850        #[inline]
851        unsafe fn decode(
852            &mut self,
853            decoder: &mut fidl::encoding::Decoder<'_, D>,
854            offset: usize,
855            _depth: fidl::encoding::Depth,
856        ) -> fidl::Result<()> {
857            decoder.debug_check_bounds::<Self>(offset);
858            let prim = decoder.read_num::<u32>(offset);
859
860            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
861            Ok(())
862        }
863    }
864    unsafe impl fidl::encoding::TypeMarker for GetSubpackageError {
865        type Owned = Self;
866
867        #[inline(always)]
868        fn inline_align(_context: fidl::encoding::Context) -> usize {
869            std::mem::align_of::<u32>()
870        }
871
872        #[inline(always)]
873        fn inline_size(_context: fidl::encoding::Context) -> usize {
874            std::mem::size_of::<u32>()
875        }
876
877        #[inline(always)]
878        fn encode_is_copy() -> bool {
879            true
880        }
881
882        #[inline(always)]
883        fn decode_is_copy() -> bool {
884            false
885        }
886    }
887
888    impl fidl::encoding::ValueTypeMarker for GetSubpackageError {
889        type Borrowed<'a> = Self;
890        #[inline(always)]
891        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
892            *value
893        }
894    }
895
896    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
897        for GetSubpackageError
898    {
899        #[inline]
900        unsafe fn encode(
901            self,
902            encoder: &mut fidl::encoding::Encoder<'_, D>,
903            offset: usize,
904            _depth: fidl::encoding::Depth,
905        ) -> fidl::Result<()> {
906            encoder.debug_check_bounds::<Self>(offset);
907            encoder.write_num(self.into_primitive(), offset);
908            Ok(())
909        }
910    }
911
912    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for GetSubpackageError {
913        #[inline(always)]
914        fn new_empty() -> Self {
915            Self::SuperpackageClosed
916        }
917
918        #[inline]
919        unsafe fn decode(
920            &mut self,
921            decoder: &mut fidl::encoding::Decoder<'_, D>,
922            offset: usize,
923            _depth: fidl::encoding::Depth,
924        ) -> fidl::Result<()> {
925            decoder.debug_check_bounds::<Self>(offset);
926            let prim = decoder.read_num::<u32>(offset);
927
928            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
929            Ok(())
930        }
931    }
932    unsafe impl fidl::encoding::TypeMarker for OpenBlobError {
933        type Owned = Self;
934
935        #[inline(always)]
936        fn inline_align(_context: fidl::encoding::Context) -> usize {
937            std::mem::align_of::<u32>()
938        }
939
940        #[inline(always)]
941        fn inline_size(_context: fidl::encoding::Context) -> usize {
942            std::mem::size_of::<u32>()
943        }
944
945        #[inline(always)]
946        fn encode_is_copy() -> bool {
947            true
948        }
949
950        #[inline(always)]
951        fn decode_is_copy() -> bool {
952            false
953        }
954    }
955
956    impl fidl::encoding::ValueTypeMarker for OpenBlobError {
957        type Borrowed<'a> = Self;
958        #[inline(always)]
959        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
960            *value
961        }
962    }
963
964    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for OpenBlobError {
965        #[inline]
966        unsafe fn encode(
967            self,
968            encoder: &mut fidl::encoding::Encoder<'_, D>,
969            offset: usize,
970            _depth: fidl::encoding::Depth,
971        ) -> fidl::Result<()> {
972            encoder.debug_check_bounds::<Self>(offset);
973            encoder.write_num(self.into_primitive(), offset);
974            Ok(())
975        }
976    }
977
978    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for OpenBlobError {
979        #[inline(always)]
980        fn new_empty() -> Self {
981            Self::OutOfSpace
982        }
983
984        #[inline]
985        unsafe fn decode(
986            &mut self,
987            decoder: &mut fidl::encoding::Decoder<'_, D>,
988            offset: usize,
989            _depth: fidl::encoding::Depth,
990        ) -> fidl::Result<()> {
991            decoder.debug_check_bounds::<Self>(offset);
992            let prim = decoder.read_num::<u32>(offset);
993
994            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
995            Ok(())
996        }
997    }
998    unsafe impl fidl::encoding::TypeMarker for RepositoryStorageType {
999        type Owned = Self;
1000
1001        #[inline(always)]
1002        fn inline_align(_context: fidl::encoding::Context) -> usize {
1003            std::mem::align_of::<u32>()
1004        }
1005
1006        #[inline(always)]
1007        fn inline_size(_context: fidl::encoding::Context) -> usize {
1008            std::mem::size_of::<u32>()
1009        }
1010
1011        #[inline(always)]
1012        fn encode_is_copy() -> bool {
1013            true
1014        }
1015
1016        #[inline(always)]
1017        fn decode_is_copy() -> bool {
1018            false
1019        }
1020    }
1021
1022    impl fidl::encoding::ValueTypeMarker for RepositoryStorageType {
1023        type Borrowed<'a> = Self;
1024        #[inline(always)]
1025        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1026            *value
1027        }
1028    }
1029
1030    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1031        for RepositoryStorageType
1032    {
1033        #[inline]
1034        unsafe fn encode(
1035            self,
1036            encoder: &mut fidl::encoding::Encoder<'_, D>,
1037            offset: usize,
1038            _depth: fidl::encoding::Depth,
1039        ) -> fidl::Result<()> {
1040            encoder.debug_check_bounds::<Self>(offset);
1041            encoder.write_num(self.into_primitive(), offset);
1042            Ok(())
1043        }
1044    }
1045
1046    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RepositoryStorageType {
1047        #[inline(always)]
1048        fn new_empty() -> Self {
1049            Self::Ephemeral
1050        }
1051
1052        #[inline]
1053        unsafe fn decode(
1054            &mut self,
1055            decoder: &mut fidl::encoding::Decoder<'_, D>,
1056            offset: usize,
1057            _depth: fidl::encoding::Depth,
1058        ) -> fidl::Result<()> {
1059            decoder.debug_check_bounds::<Self>(offset);
1060            let prim = decoder.read_num::<u32>(offset);
1061
1062            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1063            Ok(())
1064        }
1065    }
1066    unsafe impl fidl::encoding::TypeMarker for ResolveError {
1067        type Owned = Self;
1068
1069        #[inline(always)]
1070        fn inline_align(_context: fidl::encoding::Context) -> usize {
1071            std::mem::align_of::<i32>()
1072        }
1073
1074        #[inline(always)]
1075        fn inline_size(_context: fidl::encoding::Context) -> usize {
1076            std::mem::size_of::<i32>()
1077        }
1078
1079        #[inline(always)]
1080        fn encode_is_copy() -> bool {
1081            true
1082        }
1083
1084        #[inline(always)]
1085        fn decode_is_copy() -> bool {
1086            false
1087        }
1088    }
1089
1090    impl fidl::encoding::ValueTypeMarker for ResolveError {
1091        type Borrowed<'a> = Self;
1092        #[inline(always)]
1093        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1094            *value
1095        }
1096    }
1097
1098    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ResolveError {
1099        #[inline]
1100        unsafe fn encode(
1101            self,
1102            encoder: &mut fidl::encoding::Encoder<'_, D>,
1103            offset: usize,
1104            _depth: fidl::encoding::Depth,
1105        ) -> fidl::Result<()> {
1106            encoder.debug_check_bounds::<Self>(offset);
1107            encoder.write_num(self.into_primitive(), offset);
1108            Ok(())
1109        }
1110    }
1111
1112    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ResolveError {
1113        #[inline(always)]
1114        fn new_empty() -> Self {
1115            Self::Internal
1116        }
1117
1118        #[inline]
1119        unsafe fn decode(
1120            &mut self,
1121            decoder: &mut fidl::encoding::Decoder<'_, D>,
1122            offset: usize,
1123            _depth: fidl::encoding::Depth,
1124        ) -> fidl::Result<()> {
1125            decoder.debug_check_bounds::<Self>(offset);
1126            let prim = decoder.read_num::<i32>(offset);
1127
1128            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1129            Ok(())
1130        }
1131    }
1132    unsafe impl fidl::encoding::TypeMarker for SetUpgradableUrlsError {
1133        type Owned = Self;
1134
1135        #[inline(always)]
1136        fn inline_align(_context: fidl::encoding::Context) -> usize {
1137            std::mem::align_of::<u32>()
1138        }
1139
1140        #[inline(always)]
1141        fn inline_size(_context: fidl::encoding::Context) -> usize {
1142            std::mem::size_of::<u32>()
1143        }
1144
1145        #[inline(always)]
1146        fn encode_is_copy() -> bool {
1147            false
1148        }
1149
1150        #[inline(always)]
1151        fn decode_is_copy() -> bool {
1152            false
1153        }
1154    }
1155
1156    impl fidl::encoding::ValueTypeMarker for SetUpgradableUrlsError {
1157        type Borrowed<'a> = Self;
1158        #[inline(always)]
1159        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1160            *value
1161        }
1162    }
1163
1164    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
1165        for SetUpgradableUrlsError
1166    {
1167        #[inline]
1168        unsafe fn encode(
1169            self,
1170            encoder: &mut fidl::encoding::Encoder<'_, D>,
1171            offset: usize,
1172            _depth: fidl::encoding::Depth,
1173        ) -> fidl::Result<()> {
1174            encoder.debug_check_bounds::<Self>(offset);
1175            encoder.write_num(self.into_primitive(), offset);
1176            Ok(())
1177        }
1178    }
1179
1180    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1181        for SetUpgradableUrlsError
1182    {
1183        #[inline(always)]
1184        fn new_empty() -> Self {
1185            Self::unknown()
1186        }
1187
1188        #[inline]
1189        unsafe fn decode(
1190            &mut self,
1191            decoder: &mut fidl::encoding::Decoder<'_, D>,
1192            offset: usize,
1193            _depth: fidl::encoding::Depth,
1194        ) -> fidl::Result<()> {
1195            decoder.debug_check_bounds::<Self>(offset);
1196            let prim = decoder.read_num::<u32>(offset);
1197
1198            *self = Self::from_primitive_allow_unknown(prim);
1199            Ok(())
1200        }
1201    }
1202    unsafe impl fidl::encoding::TypeMarker for WriteError {
1203        type Owned = Self;
1204
1205        #[inline(always)]
1206        fn inline_align(_context: fidl::encoding::Context) -> usize {
1207            std::mem::align_of::<u32>()
1208        }
1209
1210        #[inline(always)]
1211        fn inline_size(_context: fidl::encoding::Context) -> usize {
1212            std::mem::size_of::<u32>()
1213        }
1214
1215        #[inline(always)]
1216        fn encode_is_copy() -> bool {
1217            true
1218        }
1219
1220        #[inline(always)]
1221        fn decode_is_copy() -> bool {
1222            false
1223        }
1224    }
1225
1226    impl fidl::encoding::ValueTypeMarker for WriteError {
1227        type Borrowed<'a> = Self;
1228        #[inline(always)]
1229        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1230            *value
1231        }
1232    }
1233
1234    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for WriteError {
1235        #[inline]
1236        unsafe fn encode(
1237            self,
1238            encoder: &mut fidl::encoding::Encoder<'_, D>,
1239            offset: usize,
1240            _depth: fidl::encoding::Depth,
1241        ) -> fidl::Result<()> {
1242            encoder.debug_check_bounds::<Self>(offset);
1243            encoder.write_num(self.into_primitive(), offset);
1244            Ok(())
1245        }
1246    }
1247
1248    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for WriteError {
1249        #[inline(always)]
1250        fn new_empty() -> Self {
1251            Self::UnknownUrl
1252        }
1253
1254        #[inline]
1255        unsafe fn decode(
1256            &mut self,
1257            decoder: &mut fidl::encoding::Decoder<'_, D>,
1258            offset: usize,
1259            _depth: fidl::encoding::Depth,
1260        ) -> fidl::Result<()> {
1261            decoder.debug_check_bounds::<Self>(offset);
1262            let prim = decoder.read_num::<u32>(offset);
1263
1264            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
1265            Ok(())
1266        }
1267    }
1268
1269    impl fidl::encoding::ValueTypeMarker for BlobId {
1270        type Borrowed<'a> = &'a Self;
1271        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1272            value
1273        }
1274    }
1275
1276    unsafe impl fidl::encoding::TypeMarker for BlobId {
1277        type Owned = Self;
1278
1279        #[inline(always)]
1280        fn inline_align(_context: fidl::encoding::Context) -> usize {
1281            1
1282        }
1283
1284        #[inline(always)]
1285        fn inline_size(_context: fidl::encoding::Context) -> usize {
1286            32
1287        }
1288        #[inline(always)]
1289        fn encode_is_copy() -> bool {
1290            true
1291        }
1292
1293        #[inline(always)]
1294        fn decode_is_copy() -> bool {
1295            true
1296        }
1297    }
1298
1299    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BlobId, D> for &BlobId {
1300        #[inline]
1301        unsafe fn encode(
1302            self,
1303            encoder: &mut fidl::encoding::Encoder<'_, D>,
1304            offset: usize,
1305            _depth: fidl::encoding::Depth,
1306        ) -> fidl::Result<()> {
1307            encoder.debug_check_bounds::<BlobId>(offset);
1308            unsafe {
1309                // Copy the object into the buffer.
1310                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1311                (buf_ptr as *mut BlobId).write_unaligned((self as *const BlobId).read());
1312                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1313                // done second because the memcpy will write garbage to these bytes.
1314            }
1315            Ok(())
1316        }
1317    }
1318    unsafe impl<
1319            D: fidl::encoding::ResourceDialect,
1320            T0: fidl::encoding::Encode<fidl::encoding::Array<u8, 32>, D>,
1321        > fidl::encoding::Encode<BlobId, D> for (T0,)
1322    {
1323        #[inline]
1324        unsafe fn encode(
1325            self,
1326            encoder: &mut fidl::encoding::Encoder<'_, D>,
1327            offset: usize,
1328            depth: fidl::encoding::Depth,
1329        ) -> fidl::Result<()> {
1330            encoder.debug_check_bounds::<BlobId>(offset);
1331            // Zero out padding regions. There's no need to apply masks
1332            // because the unmasked parts will be overwritten by fields.
1333            // Write the fields.
1334            self.0.encode(encoder, offset + 0, depth)?;
1335            Ok(())
1336        }
1337    }
1338
1339    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BlobId {
1340        #[inline(always)]
1341        fn new_empty() -> Self {
1342            Self { merkle_root: fidl::new_empty!(fidl::encoding::Array<u8, 32>, D) }
1343        }
1344
1345        #[inline]
1346        unsafe fn decode(
1347            &mut self,
1348            decoder: &mut fidl::encoding::Decoder<'_, D>,
1349            offset: usize,
1350            _depth: fidl::encoding::Depth,
1351        ) -> fidl::Result<()> {
1352            decoder.debug_check_bounds::<Self>(offset);
1353            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1354            // Verify that padding bytes are zero.
1355            // Copy from the buffer into the object.
1356            unsafe {
1357                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 32);
1358            }
1359            Ok(())
1360        }
1361    }
1362
1363    impl fidl::encoding::ValueTypeMarker for BlobIdIteratorNextResponse {
1364        type Borrowed<'a> = &'a Self;
1365        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1366            value
1367        }
1368    }
1369
1370    unsafe impl fidl::encoding::TypeMarker for BlobIdIteratorNextResponse {
1371        type Owned = Self;
1372
1373        #[inline(always)]
1374        fn inline_align(_context: fidl::encoding::Context) -> usize {
1375            8
1376        }
1377
1378        #[inline(always)]
1379        fn inline_size(_context: fidl::encoding::Context) -> usize {
1380            16
1381        }
1382    }
1383
1384    unsafe impl<D: fidl::encoding::ResourceDialect>
1385        fidl::encoding::Encode<BlobIdIteratorNextResponse, D> for &BlobIdIteratorNextResponse
1386    {
1387        #[inline]
1388        unsafe fn encode(
1389            self,
1390            encoder: &mut fidl::encoding::Encoder<'_, D>,
1391            offset: usize,
1392            _depth: fidl::encoding::Depth,
1393        ) -> fidl::Result<()> {
1394            encoder.debug_check_bounds::<BlobIdIteratorNextResponse>(offset);
1395            // Delegate to tuple encoding.
1396            fidl::encoding::Encode::<BlobIdIteratorNextResponse, D>::encode(
1397                (
1398                    <fidl::encoding::UnboundedVector<BlobId> as fidl::encoding::ValueTypeMarker>::borrow(&self.blobs),
1399                ),
1400                encoder, offset, _depth
1401            )
1402        }
1403    }
1404    unsafe impl<
1405            D: fidl::encoding::ResourceDialect,
1406            T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<BlobId>, D>,
1407        > fidl::encoding::Encode<BlobIdIteratorNextResponse, D> for (T0,)
1408    {
1409        #[inline]
1410        unsafe fn encode(
1411            self,
1412            encoder: &mut fidl::encoding::Encoder<'_, D>,
1413            offset: usize,
1414            depth: fidl::encoding::Depth,
1415        ) -> fidl::Result<()> {
1416            encoder.debug_check_bounds::<BlobIdIteratorNextResponse>(offset);
1417            // Zero out padding regions. There's no need to apply masks
1418            // because the unmasked parts will be overwritten by fields.
1419            // Write the fields.
1420            self.0.encode(encoder, offset + 0, depth)?;
1421            Ok(())
1422        }
1423    }
1424
1425    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1426        for BlobIdIteratorNextResponse
1427    {
1428        #[inline(always)]
1429        fn new_empty() -> Self {
1430            Self { blobs: fidl::new_empty!(fidl::encoding::UnboundedVector<BlobId>, D) }
1431        }
1432
1433        #[inline]
1434        unsafe fn decode(
1435            &mut self,
1436            decoder: &mut fidl::encoding::Decoder<'_, D>,
1437            offset: usize,
1438            _depth: fidl::encoding::Depth,
1439        ) -> fidl::Result<()> {
1440            decoder.debug_check_bounds::<Self>(offset);
1441            // Verify that padding bytes are zero.
1442            fidl::decode!(
1443                fidl::encoding::UnboundedVector<BlobId>,
1444                D,
1445                &mut self.blobs,
1446                decoder,
1447                offset + 0,
1448                _depth
1449            )?;
1450            Ok(())
1451        }
1452    }
1453
1454    impl fidl::encoding::ValueTypeMarker for BlobInfo {
1455        type Borrowed<'a> = &'a Self;
1456        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1457            value
1458        }
1459    }
1460
1461    unsafe impl fidl::encoding::TypeMarker for BlobInfo {
1462        type Owned = Self;
1463
1464        #[inline(always)]
1465        fn inline_align(_context: fidl::encoding::Context) -> usize {
1466            8
1467        }
1468
1469        #[inline(always)]
1470        fn inline_size(_context: fidl::encoding::Context) -> usize {
1471            40
1472        }
1473        #[inline(always)]
1474        fn encode_is_copy() -> bool {
1475            true
1476        }
1477
1478        #[inline(always)]
1479        fn decode_is_copy() -> bool {
1480            true
1481        }
1482    }
1483
1484    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<BlobInfo, D> for &BlobInfo {
1485        #[inline]
1486        unsafe fn encode(
1487            self,
1488            encoder: &mut fidl::encoding::Encoder<'_, D>,
1489            offset: usize,
1490            _depth: fidl::encoding::Depth,
1491        ) -> fidl::Result<()> {
1492            encoder.debug_check_bounds::<BlobInfo>(offset);
1493            unsafe {
1494                // Copy the object into the buffer.
1495                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1496                (buf_ptr as *mut BlobInfo).write_unaligned((self as *const BlobInfo).read());
1497                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1498                // done second because the memcpy will write garbage to these bytes.
1499            }
1500            Ok(())
1501        }
1502    }
1503    unsafe impl<
1504            D: fidl::encoding::ResourceDialect,
1505            T0: fidl::encoding::Encode<BlobId, D>,
1506            T1: fidl::encoding::Encode<u64, D>,
1507        > fidl::encoding::Encode<BlobInfo, D> for (T0, T1)
1508    {
1509        #[inline]
1510        unsafe fn encode(
1511            self,
1512            encoder: &mut fidl::encoding::Encoder<'_, D>,
1513            offset: usize,
1514            depth: fidl::encoding::Depth,
1515        ) -> fidl::Result<()> {
1516            encoder.debug_check_bounds::<BlobInfo>(offset);
1517            // Zero out padding regions. There's no need to apply masks
1518            // because the unmasked parts will be overwritten by fields.
1519            // Write the fields.
1520            self.0.encode(encoder, offset + 0, depth)?;
1521            self.1.encode(encoder, offset + 32, depth)?;
1522            Ok(())
1523        }
1524    }
1525
1526    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for BlobInfo {
1527        #[inline(always)]
1528        fn new_empty() -> Self {
1529            Self { blob_id: fidl::new_empty!(BlobId, D), length: fidl::new_empty!(u64, D) }
1530        }
1531
1532        #[inline]
1533        unsafe fn decode(
1534            &mut self,
1535            decoder: &mut fidl::encoding::Decoder<'_, D>,
1536            offset: usize,
1537            _depth: fidl::encoding::Depth,
1538        ) -> fidl::Result<()> {
1539            decoder.debug_check_bounds::<Self>(offset);
1540            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
1541            // Verify that padding bytes are zero.
1542            // Copy from the buffer into the object.
1543            unsafe {
1544                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 40);
1545            }
1546            Ok(())
1547        }
1548    }
1549
1550    impl fidl::encoding::ValueTypeMarker for BlobInfoIteratorNextResponse {
1551        type Borrowed<'a> = &'a Self;
1552        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1553            value
1554        }
1555    }
1556
1557    unsafe impl fidl::encoding::TypeMarker for BlobInfoIteratorNextResponse {
1558        type Owned = Self;
1559
1560        #[inline(always)]
1561        fn inline_align(_context: fidl::encoding::Context) -> usize {
1562            8
1563        }
1564
1565        #[inline(always)]
1566        fn inline_size(_context: fidl::encoding::Context) -> usize {
1567            16
1568        }
1569    }
1570
1571    unsafe impl<D: fidl::encoding::ResourceDialect>
1572        fidl::encoding::Encode<BlobInfoIteratorNextResponse, D> for &BlobInfoIteratorNextResponse
1573    {
1574        #[inline]
1575        unsafe fn encode(
1576            self,
1577            encoder: &mut fidl::encoding::Encoder<'_, D>,
1578            offset: usize,
1579            _depth: fidl::encoding::Depth,
1580        ) -> fidl::Result<()> {
1581            encoder.debug_check_bounds::<BlobInfoIteratorNextResponse>(offset);
1582            // Delegate to tuple encoding.
1583            fidl::encoding::Encode::<BlobInfoIteratorNextResponse, D>::encode(
1584                (
1585                    <fidl::encoding::UnboundedVector<BlobInfo> as fidl::encoding::ValueTypeMarker>::borrow(&self.blobs),
1586                ),
1587                encoder, offset, _depth
1588            )
1589        }
1590    }
1591    unsafe impl<
1592            D: fidl::encoding::ResourceDialect,
1593            T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<BlobInfo>, D>,
1594        > fidl::encoding::Encode<BlobInfoIteratorNextResponse, D> for (T0,)
1595    {
1596        #[inline]
1597        unsafe fn encode(
1598            self,
1599            encoder: &mut fidl::encoding::Encoder<'_, D>,
1600            offset: usize,
1601            depth: fidl::encoding::Depth,
1602        ) -> fidl::Result<()> {
1603            encoder.debug_check_bounds::<BlobInfoIteratorNextResponse>(offset);
1604            // Zero out padding regions. There's no need to apply masks
1605            // because the unmasked parts will be overwritten by fields.
1606            // Write the fields.
1607            self.0.encode(encoder, offset + 0, depth)?;
1608            Ok(())
1609        }
1610    }
1611
1612    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1613        for BlobInfoIteratorNextResponse
1614    {
1615        #[inline(always)]
1616        fn new_empty() -> Self {
1617            Self { blobs: fidl::new_empty!(fidl::encoding::UnboundedVector<BlobInfo>, D) }
1618        }
1619
1620        #[inline]
1621        unsafe fn decode(
1622            &mut self,
1623            decoder: &mut fidl::encoding::Decoder<'_, D>,
1624            offset: usize,
1625            _depth: fidl::encoding::Depth,
1626        ) -> fidl::Result<()> {
1627            decoder.debug_check_bounds::<Self>(offset);
1628            // Verify that padding bytes are zero.
1629            fidl::decode!(
1630                fidl::encoding::UnboundedVector<BlobInfo>,
1631                D,
1632                &mut self.blobs,
1633                decoder,
1634                offset + 0,
1635                _depth
1636            )?;
1637            Ok(())
1638        }
1639    }
1640
1641    impl fidl::encoding::ValueTypeMarker for CupGetInfoRequest {
1642        type Borrowed<'a> = &'a Self;
1643        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1644            value
1645        }
1646    }
1647
1648    unsafe impl fidl::encoding::TypeMarker for CupGetInfoRequest {
1649        type Owned = Self;
1650
1651        #[inline(always)]
1652        fn inline_align(_context: fidl::encoding::Context) -> usize {
1653            8
1654        }
1655
1656        #[inline(always)]
1657        fn inline_size(_context: fidl::encoding::Context) -> usize {
1658            16
1659        }
1660    }
1661
1662    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CupGetInfoRequest, D>
1663        for &CupGetInfoRequest
1664    {
1665        #[inline]
1666        unsafe fn encode(
1667            self,
1668            encoder: &mut fidl::encoding::Encoder<'_, D>,
1669            offset: usize,
1670            _depth: fidl::encoding::Depth,
1671        ) -> fidl::Result<()> {
1672            encoder.debug_check_bounds::<CupGetInfoRequest>(offset);
1673            // Delegate to tuple encoding.
1674            fidl::encoding::Encode::<CupGetInfoRequest, D>::encode(
1675                (<PackageUrl as fidl::encoding::ValueTypeMarker>::borrow(&self.url),),
1676                encoder,
1677                offset,
1678                _depth,
1679            )
1680        }
1681    }
1682    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<PackageUrl, D>>
1683        fidl::encoding::Encode<CupGetInfoRequest, D> for (T0,)
1684    {
1685        #[inline]
1686        unsafe fn encode(
1687            self,
1688            encoder: &mut fidl::encoding::Encoder<'_, D>,
1689            offset: usize,
1690            depth: fidl::encoding::Depth,
1691        ) -> fidl::Result<()> {
1692            encoder.debug_check_bounds::<CupGetInfoRequest>(offset);
1693            // Zero out padding regions. There's no need to apply masks
1694            // because the unmasked parts will be overwritten by fields.
1695            // Write the fields.
1696            self.0.encode(encoder, offset + 0, depth)?;
1697            Ok(())
1698        }
1699    }
1700
1701    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CupGetInfoRequest {
1702        #[inline(always)]
1703        fn new_empty() -> Self {
1704            Self { url: fidl::new_empty!(PackageUrl, D) }
1705        }
1706
1707        #[inline]
1708        unsafe fn decode(
1709            &mut self,
1710            decoder: &mut fidl::encoding::Decoder<'_, D>,
1711            offset: usize,
1712            _depth: fidl::encoding::Depth,
1713        ) -> fidl::Result<()> {
1714            decoder.debug_check_bounds::<Self>(offset);
1715            // Verify that padding bytes are zero.
1716            fidl::decode!(PackageUrl, D, &mut self.url, decoder, offset + 0, _depth)?;
1717            Ok(())
1718        }
1719    }
1720
1721    impl fidl::encoding::ValueTypeMarker for CupWriteRequest {
1722        type Borrowed<'a> = &'a Self;
1723        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1724            value
1725        }
1726    }
1727
1728    unsafe impl fidl::encoding::TypeMarker for CupWriteRequest {
1729        type Owned = Self;
1730
1731        #[inline(always)]
1732        fn inline_align(_context: fidl::encoding::Context) -> usize {
1733            8
1734        }
1735
1736        #[inline(always)]
1737        fn inline_size(_context: fidl::encoding::Context) -> usize {
1738            32
1739        }
1740    }
1741
1742    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CupWriteRequest, D>
1743        for &CupWriteRequest
1744    {
1745        #[inline]
1746        unsafe fn encode(
1747            self,
1748            encoder: &mut fidl::encoding::Encoder<'_, D>,
1749            offset: usize,
1750            _depth: fidl::encoding::Depth,
1751        ) -> fidl::Result<()> {
1752            encoder.debug_check_bounds::<CupWriteRequest>(offset);
1753            // Delegate to tuple encoding.
1754            fidl::encoding::Encode::<CupWriteRequest, D>::encode(
1755                (
1756                    <PackageUrl as fidl::encoding::ValueTypeMarker>::borrow(&self.url),
1757                    <CupData as fidl::encoding::ValueTypeMarker>::borrow(&self.cup),
1758                ),
1759                encoder,
1760                offset,
1761                _depth,
1762            )
1763        }
1764    }
1765    unsafe impl<
1766            D: fidl::encoding::ResourceDialect,
1767            T0: fidl::encoding::Encode<PackageUrl, D>,
1768            T1: fidl::encoding::Encode<CupData, D>,
1769        > fidl::encoding::Encode<CupWriteRequest, D> for (T0, T1)
1770    {
1771        #[inline]
1772        unsafe fn encode(
1773            self,
1774            encoder: &mut fidl::encoding::Encoder<'_, D>,
1775            offset: usize,
1776            depth: fidl::encoding::Depth,
1777        ) -> fidl::Result<()> {
1778            encoder.debug_check_bounds::<CupWriteRequest>(offset);
1779            // Zero out padding regions. There's no need to apply masks
1780            // because the unmasked parts will be overwritten by fields.
1781            // Write the fields.
1782            self.0.encode(encoder, offset + 0, depth)?;
1783            self.1.encode(encoder, offset + 16, depth)?;
1784            Ok(())
1785        }
1786    }
1787
1788    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CupWriteRequest {
1789        #[inline(always)]
1790        fn new_empty() -> Self {
1791            Self { url: fidl::new_empty!(PackageUrl, D), cup: fidl::new_empty!(CupData, D) }
1792        }
1793
1794        #[inline]
1795        unsafe fn decode(
1796            &mut self,
1797            decoder: &mut fidl::encoding::Decoder<'_, D>,
1798            offset: usize,
1799            _depth: fidl::encoding::Depth,
1800        ) -> fidl::Result<()> {
1801            decoder.debug_check_bounds::<Self>(offset);
1802            // Verify that padding bytes are zero.
1803            fidl::decode!(PackageUrl, D, &mut self.url, decoder, offset + 0, _depth)?;
1804            fidl::decode!(CupData, D, &mut self.cup, decoder, offset + 16, _depth)?;
1805            Ok(())
1806        }
1807    }
1808
1809    impl fidl::encoding::ValueTypeMarker for CupGetInfoResponse {
1810        type Borrowed<'a> = &'a Self;
1811        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1812            value
1813        }
1814    }
1815
1816    unsafe impl fidl::encoding::TypeMarker for CupGetInfoResponse {
1817        type Owned = Self;
1818
1819        #[inline(always)]
1820        fn inline_align(_context: fidl::encoding::Context) -> usize {
1821            8
1822        }
1823
1824        #[inline(always)]
1825        fn inline_size(_context: fidl::encoding::Context) -> usize {
1826            32
1827        }
1828    }
1829
1830    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CupGetInfoResponse, D>
1831        for &CupGetInfoResponse
1832    {
1833        #[inline]
1834        unsafe fn encode(
1835            self,
1836            encoder: &mut fidl::encoding::Encoder<'_, D>,
1837            offset: usize,
1838            _depth: fidl::encoding::Depth,
1839        ) -> fidl::Result<()> {
1840            encoder.debug_check_bounds::<CupGetInfoResponse>(offset);
1841            // Delegate to tuple encoding.
1842            fidl::encoding::Encode::<CupGetInfoResponse, D>::encode(
1843                (
1844                    <fidl::encoding::BoundedString<64> as fidl::encoding::ValueTypeMarker>::borrow(
1845                        &self.version,
1846                    ),
1847                    <fidl::encoding::BoundedString<128> as fidl::encoding::ValueTypeMarker>::borrow(
1848                        &self.channel,
1849                    ),
1850                ),
1851                encoder,
1852                offset,
1853                _depth,
1854            )
1855        }
1856    }
1857    unsafe impl<
1858            D: fidl::encoding::ResourceDialect,
1859            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<64>, D>,
1860            T1: fidl::encoding::Encode<fidl::encoding::BoundedString<128>, D>,
1861        > fidl::encoding::Encode<CupGetInfoResponse, D> for (T0, T1)
1862    {
1863        #[inline]
1864        unsafe fn encode(
1865            self,
1866            encoder: &mut fidl::encoding::Encoder<'_, D>,
1867            offset: usize,
1868            depth: fidl::encoding::Depth,
1869        ) -> fidl::Result<()> {
1870            encoder.debug_check_bounds::<CupGetInfoResponse>(offset);
1871            // Zero out padding regions. There's no need to apply masks
1872            // because the unmasked parts will be overwritten by fields.
1873            // Write the fields.
1874            self.0.encode(encoder, offset + 0, depth)?;
1875            self.1.encode(encoder, offset + 16, depth)?;
1876            Ok(())
1877        }
1878    }
1879
1880    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CupGetInfoResponse {
1881        #[inline(always)]
1882        fn new_empty() -> Self {
1883            Self {
1884                version: fidl::new_empty!(fidl::encoding::BoundedString<64>, D),
1885                channel: fidl::new_empty!(fidl::encoding::BoundedString<128>, D),
1886            }
1887        }
1888
1889        #[inline]
1890        unsafe fn decode(
1891            &mut self,
1892            decoder: &mut fidl::encoding::Decoder<'_, D>,
1893            offset: usize,
1894            _depth: fidl::encoding::Depth,
1895        ) -> fidl::Result<()> {
1896            decoder.debug_check_bounds::<Self>(offset);
1897            // Verify that padding bytes are zero.
1898            fidl::decode!(
1899                fidl::encoding::BoundedString<64>,
1900                D,
1901                &mut self.version,
1902                decoder,
1903                offset + 0,
1904                _depth
1905            )?;
1906            fidl::decode!(
1907                fidl::encoding::BoundedString<128>,
1908                D,
1909                &mut self.channel,
1910                decoder,
1911                offset + 16,
1912                _depth
1913            )?;
1914            Ok(())
1915        }
1916    }
1917
1918    impl fidl::encoding::ValueTypeMarker for NeededBlobsBlobWrittenRequest {
1919        type Borrowed<'a> = &'a Self;
1920        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
1921            value
1922        }
1923    }
1924
1925    unsafe impl fidl::encoding::TypeMarker for NeededBlobsBlobWrittenRequest {
1926        type Owned = Self;
1927
1928        #[inline(always)]
1929        fn inline_align(_context: fidl::encoding::Context) -> usize {
1930            1
1931        }
1932
1933        #[inline(always)]
1934        fn inline_size(_context: fidl::encoding::Context) -> usize {
1935            32
1936        }
1937        #[inline(always)]
1938        fn encode_is_copy() -> bool {
1939            true
1940        }
1941
1942        #[inline(always)]
1943        fn decode_is_copy() -> bool {
1944            true
1945        }
1946    }
1947
1948    unsafe impl<D: fidl::encoding::ResourceDialect>
1949        fidl::encoding::Encode<NeededBlobsBlobWrittenRequest, D>
1950        for &NeededBlobsBlobWrittenRequest
1951    {
1952        #[inline]
1953        unsafe fn encode(
1954            self,
1955            encoder: &mut fidl::encoding::Encoder<'_, D>,
1956            offset: usize,
1957            _depth: fidl::encoding::Depth,
1958        ) -> fidl::Result<()> {
1959            encoder.debug_check_bounds::<NeededBlobsBlobWrittenRequest>(offset);
1960            unsafe {
1961                // Copy the object into the buffer.
1962                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
1963                (buf_ptr as *mut NeededBlobsBlobWrittenRequest)
1964                    .write_unaligned((self as *const NeededBlobsBlobWrittenRequest).read());
1965                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
1966                // done second because the memcpy will write garbage to these bytes.
1967            }
1968            Ok(())
1969        }
1970    }
1971    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<BlobId, D>>
1972        fidl::encoding::Encode<NeededBlobsBlobWrittenRequest, D> for (T0,)
1973    {
1974        #[inline]
1975        unsafe fn encode(
1976            self,
1977            encoder: &mut fidl::encoding::Encoder<'_, D>,
1978            offset: usize,
1979            depth: fidl::encoding::Depth,
1980        ) -> fidl::Result<()> {
1981            encoder.debug_check_bounds::<NeededBlobsBlobWrittenRequest>(offset);
1982            // Zero out padding regions. There's no need to apply masks
1983            // because the unmasked parts will be overwritten by fields.
1984            // Write the fields.
1985            self.0.encode(encoder, offset + 0, depth)?;
1986            Ok(())
1987        }
1988    }
1989
1990    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
1991        for NeededBlobsBlobWrittenRequest
1992    {
1993        #[inline(always)]
1994        fn new_empty() -> Self {
1995            Self { blob_id: fidl::new_empty!(BlobId, D) }
1996        }
1997
1998        #[inline]
1999        unsafe fn decode(
2000            &mut self,
2001            decoder: &mut fidl::encoding::Decoder<'_, D>,
2002            offset: usize,
2003            _depth: fidl::encoding::Depth,
2004        ) -> fidl::Result<()> {
2005            decoder.debug_check_bounds::<Self>(offset);
2006            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2007            // Verify that padding bytes are zero.
2008            // Copy from the buffer into the object.
2009            unsafe {
2010                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 32);
2011            }
2012            Ok(())
2013        }
2014    }
2015
2016    impl fidl::encoding::ValueTypeMarker for NeededBlobsOpenBlobRequest {
2017        type Borrowed<'a> = &'a Self;
2018        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2019            value
2020        }
2021    }
2022
2023    unsafe impl fidl::encoding::TypeMarker for NeededBlobsOpenBlobRequest {
2024        type Owned = Self;
2025
2026        #[inline(always)]
2027        fn inline_align(_context: fidl::encoding::Context) -> usize {
2028            1
2029        }
2030
2031        #[inline(always)]
2032        fn inline_size(_context: fidl::encoding::Context) -> usize {
2033            32
2034        }
2035        #[inline(always)]
2036        fn encode_is_copy() -> bool {
2037            true
2038        }
2039
2040        #[inline(always)]
2041        fn decode_is_copy() -> bool {
2042            true
2043        }
2044    }
2045
2046    unsafe impl<D: fidl::encoding::ResourceDialect>
2047        fidl::encoding::Encode<NeededBlobsOpenBlobRequest, D> for &NeededBlobsOpenBlobRequest
2048    {
2049        #[inline]
2050        unsafe fn encode(
2051            self,
2052            encoder: &mut fidl::encoding::Encoder<'_, D>,
2053            offset: usize,
2054            _depth: fidl::encoding::Depth,
2055        ) -> fidl::Result<()> {
2056            encoder.debug_check_bounds::<NeededBlobsOpenBlobRequest>(offset);
2057            unsafe {
2058                // Copy the object into the buffer.
2059                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2060                (buf_ptr as *mut NeededBlobsOpenBlobRequest)
2061                    .write_unaligned((self as *const NeededBlobsOpenBlobRequest).read());
2062                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
2063                // done second because the memcpy will write garbage to these bytes.
2064            }
2065            Ok(())
2066        }
2067    }
2068    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<BlobId, D>>
2069        fidl::encoding::Encode<NeededBlobsOpenBlobRequest, D> for (T0,)
2070    {
2071        #[inline]
2072        unsafe fn encode(
2073            self,
2074            encoder: &mut fidl::encoding::Encoder<'_, D>,
2075            offset: usize,
2076            depth: fidl::encoding::Depth,
2077        ) -> fidl::Result<()> {
2078            encoder.debug_check_bounds::<NeededBlobsOpenBlobRequest>(offset);
2079            // Zero out padding regions. There's no need to apply masks
2080            // because the unmasked parts will be overwritten by fields.
2081            // Write the fields.
2082            self.0.encode(encoder, offset + 0, depth)?;
2083            Ok(())
2084        }
2085    }
2086
2087    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2088        for NeededBlobsOpenBlobRequest
2089    {
2090        #[inline(always)]
2091        fn new_empty() -> Self {
2092            Self { blob_id: fidl::new_empty!(BlobId, D) }
2093        }
2094
2095        #[inline]
2096        unsafe fn decode(
2097            &mut self,
2098            decoder: &mut fidl::encoding::Decoder<'_, D>,
2099            offset: usize,
2100            _depth: fidl::encoding::Depth,
2101        ) -> fidl::Result<()> {
2102            decoder.debug_check_bounds::<Self>(offset);
2103            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2104            // Verify that padding bytes are zero.
2105            // Copy from the buffer into the object.
2106            unsafe {
2107                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 32);
2108            }
2109            Ok(())
2110        }
2111    }
2112
2113    impl fidl::encoding::ValueTypeMarker for PackageCacheSetUpgradableUrlsRequest {
2114        type Borrowed<'a> = &'a Self;
2115        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2116            value
2117        }
2118    }
2119
2120    unsafe impl fidl::encoding::TypeMarker for PackageCacheSetUpgradableUrlsRequest {
2121        type Owned = Self;
2122
2123        #[inline(always)]
2124        fn inline_align(_context: fidl::encoding::Context) -> usize {
2125            8
2126        }
2127
2128        #[inline(always)]
2129        fn inline_size(_context: fidl::encoding::Context) -> usize {
2130            16
2131        }
2132    }
2133
2134    unsafe impl<D: fidl::encoding::ResourceDialect>
2135        fidl::encoding::Encode<PackageCacheSetUpgradableUrlsRequest, D>
2136        for &PackageCacheSetUpgradableUrlsRequest
2137    {
2138        #[inline]
2139        unsafe fn encode(
2140            self,
2141            encoder: &mut fidl::encoding::Encoder<'_, D>,
2142            offset: usize,
2143            _depth: fidl::encoding::Depth,
2144        ) -> fidl::Result<()> {
2145            encoder.debug_check_bounds::<PackageCacheSetUpgradableUrlsRequest>(offset);
2146            // Delegate to tuple encoding.
2147            fidl::encoding::Encode::<PackageCacheSetUpgradableUrlsRequest, D>::encode(
2148                (
2149                    <fidl::encoding::UnboundedVector<PackageUrl> as fidl::encoding::ValueTypeMarker>::borrow(&self.pinned_urls),
2150                ),
2151                encoder, offset, _depth
2152            )
2153        }
2154    }
2155    unsafe impl<
2156            D: fidl::encoding::ResourceDialect,
2157            T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<PackageUrl>, D>,
2158        > fidl::encoding::Encode<PackageCacheSetUpgradableUrlsRequest, D> for (T0,)
2159    {
2160        #[inline]
2161        unsafe fn encode(
2162            self,
2163            encoder: &mut fidl::encoding::Encoder<'_, D>,
2164            offset: usize,
2165            depth: fidl::encoding::Depth,
2166        ) -> fidl::Result<()> {
2167            encoder.debug_check_bounds::<PackageCacheSetUpgradableUrlsRequest>(offset);
2168            // Zero out padding regions. There's no need to apply masks
2169            // because the unmasked parts will be overwritten by fields.
2170            // Write the fields.
2171            self.0.encode(encoder, offset + 0, depth)?;
2172            Ok(())
2173        }
2174    }
2175
2176    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2177        for PackageCacheSetUpgradableUrlsRequest
2178    {
2179        #[inline(always)]
2180        fn new_empty() -> Self {
2181            Self { pinned_urls: fidl::new_empty!(fidl::encoding::UnboundedVector<PackageUrl>, D) }
2182        }
2183
2184        #[inline]
2185        unsafe fn decode(
2186            &mut self,
2187            decoder: &mut fidl::encoding::Decoder<'_, D>,
2188            offset: usize,
2189            _depth: fidl::encoding::Depth,
2190        ) -> fidl::Result<()> {
2191            decoder.debug_check_bounds::<Self>(offset);
2192            // Verify that padding bytes are zero.
2193            fidl::decode!(
2194                fidl::encoding::UnboundedVector<PackageUrl>,
2195                D,
2196                &mut self.pinned_urls,
2197                decoder,
2198                offset + 0,
2199                _depth
2200            )?;
2201            Ok(())
2202        }
2203    }
2204
2205    impl fidl::encoding::ValueTypeMarker for PackageIndexEntry {
2206        type Borrowed<'a> = &'a Self;
2207        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2208            value
2209        }
2210    }
2211
2212    unsafe impl fidl::encoding::TypeMarker for PackageIndexEntry {
2213        type Owned = Self;
2214
2215        #[inline(always)]
2216        fn inline_align(_context: fidl::encoding::Context) -> usize {
2217            8
2218        }
2219
2220        #[inline(always)]
2221        fn inline_size(_context: fidl::encoding::Context) -> usize {
2222            48
2223        }
2224    }
2225
2226    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PackageIndexEntry, D>
2227        for &PackageIndexEntry
2228    {
2229        #[inline]
2230        unsafe fn encode(
2231            self,
2232            encoder: &mut fidl::encoding::Encoder<'_, D>,
2233            offset: usize,
2234            _depth: fidl::encoding::Depth,
2235        ) -> fidl::Result<()> {
2236            encoder.debug_check_bounds::<PackageIndexEntry>(offset);
2237            // Delegate to tuple encoding.
2238            fidl::encoding::Encode::<PackageIndexEntry, D>::encode(
2239                (
2240                    <PackageUrl as fidl::encoding::ValueTypeMarker>::borrow(&self.package_url),
2241                    <BlobId as fidl::encoding::ValueTypeMarker>::borrow(&self.meta_far_blob_id),
2242                ),
2243                encoder,
2244                offset,
2245                _depth,
2246            )
2247        }
2248    }
2249    unsafe impl<
2250            D: fidl::encoding::ResourceDialect,
2251            T0: fidl::encoding::Encode<PackageUrl, D>,
2252            T1: fidl::encoding::Encode<BlobId, D>,
2253        > fidl::encoding::Encode<PackageIndexEntry, D> for (T0, T1)
2254    {
2255        #[inline]
2256        unsafe fn encode(
2257            self,
2258            encoder: &mut fidl::encoding::Encoder<'_, D>,
2259            offset: usize,
2260            depth: fidl::encoding::Depth,
2261        ) -> fidl::Result<()> {
2262            encoder.debug_check_bounds::<PackageIndexEntry>(offset);
2263            // Zero out padding regions. There's no need to apply masks
2264            // because the unmasked parts will be overwritten by fields.
2265            // Write the fields.
2266            self.0.encode(encoder, offset + 0, depth)?;
2267            self.1.encode(encoder, offset + 16, depth)?;
2268            Ok(())
2269        }
2270    }
2271
2272    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PackageIndexEntry {
2273        #[inline(always)]
2274        fn new_empty() -> Self {
2275            Self {
2276                package_url: fidl::new_empty!(PackageUrl, D),
2277                meta_far_blob_id: fidl::new_empty!(BlobId, D),
2278            }
2279        }
2280
2281        #[inline]
2282        unsafe fn decode(
2283            &mut self,
2284            decoder: &mut fidl::encoding::Decoder<'_, D>,
2285            offset: usize,
2286            _depth: fidl::encoding::Depth,
2287        ) -> fidl::Result<()> {
2288            decoder.debug_check_bounds::<Self>(offset);
2289            // Verify that padding bytes are zero.
2290            fidl::decode!(PackageUrl, D, &mut self.package_url, decoder, offset + 0, _depth)?;
2291            fidl::decode!(BlobId, D, &mut self.meta_far_blob_id, decoder, offset + 16, _depth)?;
2292            Ok(())
2293        }
2294    }
2295
2296    impl fidl::encoding::ValueTypeMarker for PackageIndexIteratorNextResponse {
2297        type Borrowed<'a> = &'a Self;
2298        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2299            value
2300        }
2301    }
2302
2303    unsafe impl fidl::encoding::TypeMarker for PackageIndexIteratorNextResponse {
2304        type Owned = Self;
2305
2306        #[inline(always)]
2307        fn inline_align(_context: fidl::encoding::Context) -> usize {
2308            8
2309        }
2310
2311        #[inline(always)]
2312        fn inline_size(_context: fidl::encoding::Context) -> usize {
2313            16
2314        }
2315    }
2316
2317    unsafe impl<D: fidl::encoding::ResourceDialect>
2318        fidl::encoding::Encode<PackageIndexIteratorNextResponse, D>
2319        for &PackageIndexIteratorNextResponse
2320    {
2321        #[inline]
2322        unsafe fn encode(
2323            self,
2324            encoder: &mut fidl::encoding::Encoder<'_, D>,
2325            offset: usize,
2326            _depth: fidl::encoding::Depth,
2327        ) -> fidl::Result<()> {
2328            encoder.debug_check_bounds::<PackageIndexIteratorNextResponse>(offset);
2329            // Delegate to tuple encoding.
2330            fidl::encoding::Encode::<PackageIndexIteratorNextResponse, D>::encode(
2331                (
2332                    <fidl::encoding::UnboundedVector<PackageIndexEntry> as fidl::encoding::ValueTypeMarker>::borrow(&self.entries),
2333                ),
2334                encoder, offset, _depth
2335            )
2336        }
2337    }
2338    unsafe impl<
2339            D: fidl::encoding::ResourceDialect,
2340            T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<PackageIndexEntry>, D>,
2341        > fidl::encoding::Encode<PackageIndexIteratorNextResponse, D> for (T0,)
2342    {
2343        #[inline]
2344        unsafe fn encode(
2345            self,
2346            encoder: &mut fidl::encoding::Encoder<'_, D>,
2347            offset: usize,
2348            depth: fidl::encoding::Depth,
2349        ) -> fidl::Result<()> {
2350            encoder.debug_check_bounds::<PackageIndexIteratorNextResponse>(offset);
2351            // Zero out padding regions. There's no need to apply masks
2352            // because the unmasked parts will be overwritten by fields.
2353            // Write the fields.
2354            self.0.encode(encoder, offset + 0, depth)?;
2355            Ok(())
2356        }
2357    }
2358
2359    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2360        for PackageIndexIteratorNextResponse
2361    {
2362        #[inline(always)]
2363        fn new_empty() -> Self {
2364            Self {
2365                entries: fidl::new_empty!(fidl::encoding::UnboundedVector<PackageIndexEntry>, D),
2366            }
2367        }
2368
2369        #[inline]
2370        unsafe fn decode(
2371            &mut self,
2372            decoder: &mut fidl::encoding::Decoder<'_, D>,
2373            offset: usize,
2374            _depth: fidl::encoding::Depth,
2375        ) -> fidl::Result<()> {
2376            decoder.debug_check_bounds::<Self>(offset);
2377            // Verify that padding bytes are zero.
2378            fidl::decode!(
2379                fidl::encoding::UnboundedVector<PackageIndexEntry>,
2380                D,
2381                &mut self.entries,
2382                decoder,
2383                offset + 0,
2384                _depth
2385            )?;
2386            Ok(())
2387        }
2388    }
2389
2390    impl fidl::encoding::ValueTypeMarker for PackageResolverGetHashRequest {
2391        type Borrowed<'a> = &'a Self;
2392        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2393            value
2394        }
2395    }
2396
2397    unsafe impl fidl::encoding::TypeMarker for PackageResolverGetHashRequest {
2398        type Owned = Self;
2399
2400        #[inline(always)]
2401        fn inline_align(_context: fidl::encoding::Context) -> usize {
2402            8
2403        }
2404
2405        #[inline(always)]
2406        fn inline_size(_context: fidl::encoding::Context) -> usize {
2407            16
2408        }
2409    }
2410
2411    unsafe impl<D: fidl::encoding::ResourceDialect>
2412        fidl::encoding::Encode<PackageResolverGetHashRequest, D>
2413        for &PackageResolverGetHashRequest
2414    {
2415        #[inline]
2416        unsafe fn encode(
2417            self,
2418            encoder: &mut fidl::encoding::Encoder<'_, D>,
2419            offset: usize,
2420            _depth: fidl::encoding::Depth,
2421        ) -> fidl::Result<()> {
2422            encoder.debug_check_bounds::<PackageResolverGetHashRequest>(offset);
2423            // Delegate to tuple encoding.
2424            fidl::encoding::Encode::<PackageResolverGetHashRequest, D>::encode(
2425                (<PackageUrl as fidl::encoding::ValueTypeMarker>::borrow(&self.package_url),),
2426                encoder,
2427                offset,
2428                _depth,
2429            )
2430        }
2431    }
2432    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<PackageUrl, D>>
2433        fidl::encoding::Encode<PackageResolverGetHashRequest, D> for (T0,)
2434    {
2435        #[inline]
2436        unsafe fn encode(
2437            self,
2438            encoder: &mut fidl::encoding::Encoder<'_, D>,
2439            offset: usize,
2440            depth: fidl::encoding::Depth,
2441        ) -> fidl::Result<()> {
2442            encoder.debug_check_bounds::<PackageResolverGetHashRequest>(offset);
2443            // Zero out padding regions. There's no need to apply masks
2444            // because the unmasked parts will be overwritten by fields.
2445            // Write the fields.
2446            self.0.encode(encoder, offset + 0, depth)?;
2447            Ok(())
2448        }
2449    }
2450
2451    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2452        for PackageResolverGetHashRequest
2453    {
2454        #[inline(always)]
2455        fn new_empty() -> Self {
2456            Self { package_url: fidl::new_empty!(PackageUrl, D) }
2457        }
2458
2459        #[inline]
2460        unsafe fn decode(
2461            &mut self,
2462            decoder: &mut fidl::encoding::Decoder<'_, D>,
2463            offset: usize,
2464            _depth: fidl::encoding::Depth,
2465        ) -> fidl::Result<()> {
2466            decoder.debug_check_bounds::<Self>(offset);
2467            // Verify that padding bytes are zero.
2468            fidl::decode!(PackageUrl, D, &mut self.package_url, decoder, offset + 0, _depth)?;
2469            Ok(())
2470        }
2471    }
2472
2473    impl fidl::encoding::ValueTypeMarker for PackageResolverGetHashResponse {
2474        type Borrowed<'a> = &'a Self;
2475        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2476            value
2477        }
2478    }
2479
2480    unsafe impl fidl::encoding::TypeMarker for PackageResolverGetHashResponse {
2481        type Owned = Self;
2482
2483        #[inline(always)]
2484        fn inline_align(_context: fidl::encoding::Context) -> usize {
2485            1
2486        }
2487
2488        #[inline(always)]
2489        fn inline_size(_context: fidl::encoding::Context) -> usize {
2490            32
2491        }
2492        #[inline(always)]
2493        fn encode_is_copy() -> bool {
2494            true
2495        }
2496
2497        #[inline(always)]
2498        fn decode_is_copy() -> bool {
2499            true
2500        }
2501    }
2502
2503    unsafe impl<D: fidl::encoding::ResourceDialect>
2504        fidl::encoding::Encode<PackageResolverGetHashResponse, D>
2505        for &PackageResolverGetHashResponse
2506    {
2507        #[inline]
2508        unsafe fn encode(
2509            self,
2510            encoder: &mut fidl::encoding::Encoder<'_, D>,
2511            offset: usize,
2512            _depth: fidl::encoding::Depth,
2513        ) -> fidl::Result<()> {
2514            encoder.debug_check_bounds::<PackageResolverGetHashResponse>(offset);
2515            unsafe {
2516                // Copy the object into the buffer.
2517                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
2518                (buf_ptr as *mut PackageResolverGetHashResponse)
2519                    .write_unaligned((self as *const PackageResolverGetHashResponse).read());
2520                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
2521                // done second because the memcpy will write garbage to these bytes.
2522            }
2523            Ok(())
2524        }
2525    }
2526    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<BlobId, D>>
2527        fidl::encoding::Encode<PackageResolverGetHashResponse, D> for (T0,)
2528    {
2529        #[inline]
2530        unsafe fn encode(
2531            self,
2532            encoder: &mut fidl::encoding::Encoder<'_, D>,
2533            offset: usize,
2534            depth: fidl::encoding::Depth,
2535        ) -> fidl::Result<()> {
2536            encoder.debug_check_bounds::<PackageResolverGetHashResponse>(offset);
2537            // Zero out padding regions. There's no need to apply masks
2538            // because the unmasked parts will be overwritten by fields.
2539            // Write the fields.
2540            self.0.encode(encoder, offset + 0, depth)?;
2541            Ok(())
2542        }
2543    }
2544
2545    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2546        for PackageResolverGetHashResponse
2547    {
2548        #[inline(always)]
2549        fn new_empty() -> Self {
2550            Self { meta_far_blob_id: fidl::new_empty!(BlobId, D) }
2551        }
2552
2553        #[inline]
2554        unsafe fn decode(
2555            &mut self,
2556            decoder: &mut fidl::encoding::Decoder<'_, D>,
2557            offset: usize,
2558            _depth: fidl::encoding::Depth,
2559        ) -> fidl::Result<()> {
2560            decoder.debug_check_bounds::<Self>(offset);
2561            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
2562            // Verify that padding bytes are zero.
2563            // Copy from the buffer into the object.
2564            unsafe {
2565                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 32);
2566            }
2567            Ok(())
2568        }
2569    }
2570
2571    impl fidl::encoding::ValueTypeMarker for PackageResolverResolveWithContextResponse {
2572        type Borrowed<'a> = &'a Self;
2573        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2574            value
2575        }
2576    }
2577
2578    unsafe impl fidl::encoding::TypeMarker for PackageResolverResolveWithContextResponse {
2579        type Owned = Self;
2580
2581        #[inline(always)]
2582        fn inline_align(_context: fidl::encoding::Context) -> usize {
2583            8
2584        }
2585
2586        #[inline(always)]
2587        fn inline_size(_context: fidl::encoding::Context) -> usize {
2588            16
2589        }
2590    }
2591
2592    unsafe impl<D: fidl::encoding::ResourceDialect>
2593        fidl::encoding::Encode<PackageResolverResolveWithContextResponse, D>
2594        for &PackageResolverResolveWithContextResponse
2595    {
2596        #[inline]
2597        unsafe fn encode(
2598            self,
2599            encoder: &mut fidl::encoding::Encoder<'_, D>,
2600            offset: usize,
2601            _depth: fidl::encoding::Depth,
2602        ) -> fidl::Result<()> {
2603            encoder.debug_check_bounds::<PackageResolverResolveWithContextResponse>(offset);
2604            // Delegate to tuple encoding.
2605            fidl::encoding::Encode::<PackageResolverResolveWithContextResponse, D>::encode(
2606                (<ResolutionContext as fidl::encoding::ValueTypeMarker>::borrow(
2607                    &self.resolved_context,
2608                ),),
2609                encoder,
2610                offset,
2611                _depth,
2612            )
2613        }
2614    }
2615    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ResolutionContext, D>>
2616        fidl::encoding::Encode<PackageResolverResolveWithContextResponse, D> for (T0,)
2617    {
2618        #[inline]
2619        unsafe fn encode(
2620            self,
2621            encoder: &mut fidl::encoding::Encoder<'_, D>,
2622            offset: usize,
2623            depth: fidl::encoding::Depth,
2624        ) -> fidl::Result<()> {
2625            encoder.debug_check_bounds::<PackageResolverResolveWithContextResponse>(offset);
2626            // Zero out padding regions. There's no need to apply masks
2627            // because the unmasked parts will be overwritten by fields.
2628            // Write the fields.
2629            self.0.encode(encoder, offset + 0, depth)?;
2630            Ok(())
2631        }
2632    }
2633
2634    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2635        for PackageResolverResolveWithContextResponse
2636    {
2637        #[inline(always)]
2638        fn new_empty() -> Self {
2639            Self { resolved_context: fidl::new_empty!(ResolutionContext, D) }
2640        }
2641
2642        #[inline]
2643        unsafe fn decode(
2644            &mut self,
2645            decoder: &mut fidl::encoding::Decoder<'_, D>,
2646            offset: usize,
2647            _depth: fidl::encoding::Depth,
2648        ) -> fidl::Result<()> {
2649            decoder.debug_check_bounds::<Self>(offset);
2650            // Verify that padding bytes are zero.
2651            fidl::decode!(
2652                ResolutionContext,
2653                D,
2654                &mut self.resolved_context,
2655                decoder,
2656                offset + 0,
2657                _depth
2658            )?;
2659            Ok(())
2660        }
2661    }
2662
2663    impl fidl::encoding::ValueTypeMarker for PackageResolverResolveResponse {
2664        type Borrowed<'a> = &'a Self;
2665        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2666            value
2667        }
2668    }
2669
2670    unsafe impl fidl::encoding::TypeMarker for PackageResolverResolveResponse {
2671        type Owned = Self;
2672
2673        #[inline(always)]
2674        fn inline_align(_context: fidl::encoding::Context) -> usize {
2675            8
2676        }
2677
2678        #[inline(always)]
2679        fn inline_size(_context: fidl::encoding::Context) -> usize {
2680            16
2681        }
2682    }
2683
2684    unsafe impl<D: fidl::encoding::ResourceDialect>
2685        fidl::encoding::Encode<PackageResolverResolveResponse, D>
2686        for &PackageResolverResolveResponse
2687    {
2688        #[inline]
2689        unsafe fn encode(
2690            self,
2691            encoder: &mut fidl::encoding::Encoder<'_, D>,
2692            offset: usize,
2693            _depth: fidl::encoding::Depth,
2694        ) -> fidl::Result<()> {
2695            encoder.debug_check_bounds::<PackageResolverResolveResponse>(offset);
2696            // Delegate to tuple encoding.
2697            fidl::encoding::Encode::<PackageResolverResolveResponse, D>::encode(
2698                (<ResolutionContext as fidl::encoding::ValueTypeMarker>::borrow(
2699                    &self.resolved_context,
2700                ),),
2701                encoder,
2702                offset,
2703                _depth,
2704            )
2705        }
2706    }
2707    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ResolutionContext, D>>
2708        fidl::encoding::Encode<PackageResolverResolveResponse, D> for (T0,)
2709    {
2710        #[inline]
2711        unsafe fn encode(
2712            self,
2713            encoder: &mut fidl::encoding::Encoder<'_, D>,
2714            offset: usize,
2715            depth: fidl::encoding::Depth,
2716        ) -> fidl::Result<()> {
2717            encoder.debug_check_bounds::<PackageResolverResolveResponse>(offset);
2718            // Zero out padding regions. There's no need to apply masks
2719            // because the unmasked parts will be overwritten by fields.
2720            // Write the fields.
2721            self.0.encode(encoder, offset + 0, depth)?;
2722            Ok(())
2723        }
2724    }
2725
2726    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2727        for PackageResolverResolveResponse
2728    {
2729        #[inline(always)]
2730        fn new_empty() -> Self {
2731            Self { resolved_context: fidl::new_empty!(ResolutionContext, D) }
2732        }
2733
2734        #[inline]
2735        unsafe fn decode(
2736            &mut self,
2737            decoder: &mut fidl::encoding::Decoder<'_, D>,
2738            offset: usize,
2739            _depth: fidl::encoding::Depth,
2740        ) -> fidl::Result<()> {
2741            decoder.debug_check_bounds::<Self>(offset);
2742            // Verify that padding bytes are zero.
2743            fidl::decode!(
2744                ResolutionContext,
2745                D,
2746                &mut self.resolved_context,
2747                decoder,
2748                offset + 0,
2749                _depth
2750            )?;
2751            Ok(())
2752        }
2753    }
2754
2755    impl fidl::encoding::ValueTypeMarker for PackageUrl {
2756        type Borrowed<'a> = &'a Self;
2757        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2758            value
2759        }
2760    }
2761
2762    unsafe impl fidl::encoding::TypeMarker for PackageUrl {
2763        type Owned = Self;
2764
2765        #[inline(always)]
2766        fn inline_align(_context: fidl::encoding::Context) -> usize {
2767            8
2768        }
2769
2770        #[inline(always)]
2771        fn inline_size(_context: fidl::encoding::Context) -> usize {
2772            16
2773        }
2774    }
2775
2776    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PackageUrl, D>
2777        for &PackageUrl
2778    {
2779        #[inline]
2780        unsafe fn encode(
2781            self,
2782            encoder: &mut fidl::encoding::Encoder<'_, D>,
2783            offset: usize,
2784            _depth: fidl::encoding::Depth,
2785        ) -> fidl::Result<()> {
2786            encoder.debug_check_bounds::<PackageUrl>(offset);
2787            // Delegate to tuple encoding.
2788            fidl::encoding::Encode::<PackageUrl, D>::encode(
2789                (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
2790                    &self.url,
2791                ),),
2792                encoder,
2793                offset,
2794                _depth,
2795            )
2796        }
2797    }
2798    unsafe impl<
2799            D: fidl::encoding::ResourceDialect,
2800            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
2801        > fidl::encoding::Encode<PackageUrl, D> for (T0,)
2802    {
2803        #[inline]
2804        unsafe fn encode(
2805            self,
2806            encoder: &mut fidl::encoding::Encoder<'_, D>,
2807            offset: usize,
2808            depth: fidl::encoding::Depth,
2809        ) -> fidl::Result<()> {
2810            encoder.debug_check_bounds::<PackageUrl>(offset);
2811            // Zero out padding regions. There's no need to apply masks
2812            // because the unmasked parts will be overwritten by fields.
2813            // Write the fields.
2814            self.0.encode(encoder, offset + 0, depth)?;
2815            Ok(())
2816        }
2817    }
2818
2819    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PackageUrl {
2820        #[inline(always)]
2821        fn new_empty() -> Self {
2822            Self { url: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
2823        }
2824
2825        #[inline]
2826        unsafe fn decode(
2827            &mut self,
2828            decoder: &mut fidl::encoding::Decoder<'_, D>,
2829            offset: usize,
2830            _depth: fidl::encoding::Depth,
2831        ) -> fidl::Result<()> {
2832            decoder.debug_check_bounds::<Self>(offset);
2833            // Verify that padding bytes are zero.
2834            fidl::decode!(
2835                fidl::encoding::BoundedString<4096>,
2836                D,
2837                &mut self.url,
2838                decoder,
2839                offset + 0,
2840                _depth
2841            )?;
2842            Ok(())
2843        }
2844    }
2845
2846    impl fidl::encoding::ValueTypeMarker for RepositoryIteratorNextResponse {
2847        type Borrowed<'a> = &'a Self;
2848        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2849            value
2850        }
2851    }
2852
2853    unsafe impl fidl::encoding::TypeMarker for RepositoryIteratorNextResponse {
2854        type Owned = Self;
2855
2856        #[inline(always)]
2857        fn inline_align(_context: fidl::encoding::Context) -> usize {
2858            8
2859        }
2860
2861        #[inline(always)]
2862        fn inline_size(_context: fidl::encoding::Context) -> usize {
2863            16
2864        }
2865    }
2866
2867    unsafe impl<D: fidl::encoding::ResourceDialect>
2868        fidl::encoding::Encode<RepositoryIteratorNextResponse, D>
2869        for &RepositoryIteratorNextResponse
2870    {
2871        #[inline]
2872        unsafe fn encode(
2873            self,
2874            encoder: &mut fidl::encoding::Encoder<'_, D>,
2875            offset: usize,
2876            _depth: fidl::encoding::Depth,
2877        ) -> fidl::Result<()> {
2878            encoder.debug_check_bounds::<RepositoryIteratorNextResponse>(offset);
2879            // Delegate to tuple encoding.
2880            fidl::encoding::Encode::<RepositoryIteratorNextResponse, D>::encode(
2881                (
2882                    <fidl::encoding::UnboundedVector<RepositoryConfig> as fidl::encoding::ValueTypeMarker>::borrow(&self.repos),
2883                ),
2884                encoder, offset, _depth
2885            )
2886        }
2887    }
2888    unsafe impl<
2889            D: fidl::encoding::ResourceDialect,
2890            T0: fidl::encoding::Encode<fidl::encoding::UnboundedVector<RepositoryConfig>, D>,
2891        > fidl::encoding::Encode<RepositoryIteratorNextResponse, D> for (T0,)
2892    {
2893        #[inline]
2894        unsafe fn encode(
2895            self,
2896            encoder: &mut fidl::encoding::Encoder<'_, D>,
2897            offset: usize,
2898            depth: fidl::encoding::Depth,
2899        ) -> fidl::Result<()> {
2900            encoder.debug_check_bounds::<RepositoryIteratorNextResponse>(offset);
2901            // Zero out padding regions. There's no need to apply masks
2902            // because the unmasked parts will be overwritten by fields.
2903            // Write the fields.
2904            self.0.encode(encoder, offset + 0, depth)?;
2905            Ok(())
2906        }
2907    }
2908
2909    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
2910        for RepositoryIteratorNextResponse
2911    {
2912        #[inline(always)]
2913        fn new_empty() -> Self {
2914            Self { repos: fidl::new_empty!(fidl::encoding::UnboundedVector<RepositoryConfig>, D) }
2915        }
2916
2917        #[inline]
2918        unsafe fn decode(
2919            &mut self,
2920            decoder: &mut fidl::encoding::Decoder<'_, D>,
2921            offset: usize,
2922            _depth: fidl::encoding::Depth,
2923        ) -> fidl::Result<()> {
2924            decoder.debug_check_bounds::<Self>(offset);
2925            // Verify that padding bytes are zero.
2926            fidl::decode!(
2927                fidl::encoding::UnboundedVector<RepositoryConfig>,
2928                D,
2929                &mut self.repos,
2930                decoder,
2931                offset + 0,
2932                _depth
2933            )?;
2934            Ok(())
2935        }
2936    }
2937
2938    impl fidl::encoding::ValueTypeMarker for RepositoryManagerAddMirrorRequest {
2939        type Borrowed<'a> = &'a Self;
2940        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
2941            value
2942        }
2943    }
2944
2945    unsafe impl fidl::encoding::TypeMarker for RepositoryManagerAddMirrorRequest {
2946        type Owned = Self;
2947
2948        #[inline(always)]
2949        fn inline_align(_context: fidl::encoding::Context) -> usize {
2950            8
2951        }
2952
2953        #[inline(always)]
2954        fn inline_size(_context: fidl::encoding::Context) -> usize {
2955            32
2956        }
2957    }
2958
2959    unsafe impl<D: fidl::encoding::ResourceDialect>
2960        fidl::encoding::Encode<RepositoryManagerAddMirrorRequest, D>
2961        for &RepositoryManagerAddMirrorRequest
2962    {
2963        #[inline]
2964        unsafe fn encode(
2965            self,
2966            encoder: &mut fidl::encoding::Encoder<'_, D>,
2967            offset: usize,
2968            _depth: fidl::encoding::Depth,
2969        ) -> fidl::Result<()> {
2970            encoder.debug_check_bounds::<RepositoryManagerAddMirrorRequest>(offset);
2971            // Delegate to tuple encoding.
2972            fidl::encoding::Encode::<RepositoryManagerAddMirrorRequest, D>::encode(
2973                (
2974                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
2975                        &self.repo_url,
2976                    ),
2977                    <MirrorConfig as fidl::encoding::ValueTypeMarker>::borrow(&self.mirror),
2978                ),
2979                encoder,
2980                offset,
2981                _depth,
2982            )
2983        }
2984    }
2985    unsafe impl<
2986            D: fidl::encoding::ResourceDialect,
2987            T0: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
2988            T1: fidl::encoding::Encode<MirrorConfig, D>,
2989        > fidl::encoding::Encode<RepositoryManagerAddMirrorRequest, D> for (T0, T1)
2990    {
2991        #[inline]
2992        unsafe fn encode(
2993            self,
2994            encoder: &mut fidl::encoding::Encoder<'_, D>,
2995            offset: usize,
2996            depth: fidl::encoding::Depth,
2997        ) -> fidl::Result<()> {
2998            encoder.debug_check_bounds::<RepositoryManagerAddMirrorRequest>(offset);
2999            // Zero out padding regions. There's no need to apply masks
3000            // because the unmasked parts will be overwritten by fields.
3001            // Write the fields.
3002            self.0.encode(encoder, offset + 0, depth)?;
3003            self.1.encode(encoder, offset + 16, depth)?;
3004            Ok(())
3005        }
3006    }
3007
3008    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3009        for RepositoryManagerAddMirrorRequest
3010    {
3011        #[inline(always)]
3012        fn new_empty() -> Self {
3013            Self {
3014                repo_url: fidl::new_empty!(fidl::encoding::UnboundedString, D),
3015                mirror: fidl::new_empty!(MirrorConfig, D),
3016            }
3017        }
3018
3019        #[inline]
3020        unsafe fn decode(
3021            &mut self,
3022            decoder: &mut fidl::encoding::Decoder<'_, D>,
3023            offset: usize,
3024            _depth: fidl::encoding::Depth,
3025        ) -> fidl::Result<()> {
3026            decoder.debug_check_bounds::<Self>(offset);
3027            // Verify that padding bytes are zero.
3028            fidl::decode!(
3029                fidl::encoding::UnboundedString,
3030                D,
3031                &mut self.repo_url,
3032                decoder,
3033                offset + 0,
3034                _depth
3035            )?;
3036            fidl::decode!(MirrorConfig, D, &mut self.mirror, decoder, offset + 16, _depth)?;
3037            Ok(())
3038        }
3039    }
3040
3041    impl fidl::encoding::ValueTypeMarker for RepositoryManagerAddRequest {
3042        type Borrowed<'a> = &'a Self;
3043        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3044            value
3045        }
3046    }
3047
3048    unsafe impl fidl::encoding::TypeMarker for RepositoryManagerAddRequest {
3049        type Owned = Self;
3050
3051        #[inline(always)]
3052        fn inline_align(_context: fidl::encoding::Context) -> usize {
3053            8
3054        }
3055
3056        #[inline(always)]
3057        fn inline_size(_context: fidl::encoding::Context) -> usize {
3058            16
3059        }
3060    }
3061
3062    unsafe impl<D: fidl::encoding::ResourceDialect>
3063        fidl::encoding::Encode<RepositoryManagerAddRequest, D> for &RepositoryManagerAddRequest
3064    {
3065        #[inline]
3066        unsafe fn encode(
3067            self,
3068            encoder: &mut fidl::encoding::Encoder<'_, D>,
3069            offset: usize,
3070            _depth: fidl::encoding::Depth,
3071        ) -> fidl::Result<()> {
3072            encoder.debug_check_bounds::<RepositoryManagerAddRequest>(offset);
3073            // Delegate to tuple encoding.
3074            fidl::encoding::Encode::<RepositoryManagerAddRequest, D>::encode(
3075                (<RepositoryConfig as fidl::encoding::ValueTypeMarker>::borrow(&self.repo),),
3076                encoder,
3077                offset,
3078                _depth,
3079            )
3080        }
3081    }
3082    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<RepositoryConfig, D>>
3083        fidl::encoding::Encode<RepositoryManagerAddRequest, D> for (T0,)
3084    {
3085        #[inline]
3086        unsafe fn encode(
3087            self,
3088            encoder: &mut fidl::encoding::Encoder<'_, D>,
3089            offset: usize,
3090            depth: fidl::encoding::Depth,
3091        ) -> fidl::Result<()> {
3092            encoder.debug_check_bounds::<RepositoryManagerAddRequest>(offset);
3093            // Zero out padding regions. There's no need to apply masks
3094            // because the unmasked parts will be overwritten by fields.
3095            // Write the fields.
3096            self.0.encode(encoder, offset + 0, depth)?;
3097            Ok(())
3098        }
3099    }
3100
3101    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3102        for RepositoryManagerAddRequest
3103    {
3104        #[inline(always)]
3105        fn new_empty() -> Self {
3106            Self { repo: fidl::new_empty!(RepositoryConfig, D) }
3107        }
3108
3109        #[inline]
3110        unsafe fn decode(
3111            &mut self,
3112            decoder: &mut fidl::encoding::Decoder<'_, D>,
3113            offset: usize,
3114            _depth: fidl::encoding::Depth,
3115        ) -> fidl::Result<()> {
3116            decoder.debug_check_bounds::<Self>(offset);
3117            // Verify that padding bytes are zero.
3118            fidl::decode!(RepositoryConfig, D, &mut self.repo, decoder, offset + 0, _depth)?;
3119            Ok(())
3120        }
3121    }
3122
3123    impl fidl::encoding::ValueTypeMarker for RepositoryManagerRemoveMirrorRequest {
3124        type Borrowed<'a> = &'a Self;
3125        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3126            value
3127        }
3128    }
3129
3130    unsafe impl fidl::encoding::TypeMarker for RepositoryManagerRemoveMirrorRequest {
3131        type Owned = Self;
3132
3133        #[inline(always)]
3134        fn inline_align(_context: fidl::encoding::Context) -> usize {
3135            8
3136        }
3137
3138        #[inline(always)]
3139        fn inline_size(_context: fidl::encoding::Context) -> usize {
3140            32
3141        }
3142    }
3143
3144    unsafe impl<D: fidl::encoding::ResourceDialect>
3145        fidl::encoding::Encode<RepositoryManagerRemoveMirrorRequest, D>
3146        for &RepositoryManagerRemoveMirrorRequest
3147    {
3148        #[inline]
3149        unsafe fn encode(
3150            self,
3151            encoder: &mut fidl::encoding::Encoder<'_, D>,
3152            offset: usize,
3153            _depth: fidl::encoding::Depth,
3154        ) -> fidl::Result<()> {
3155            encoder.debug_check_bounds::<RepositoryManagerRemoveMirrorRequest>(offset);
3156            // Delegate to tuple encoding.
3157            fidl::encoding::Encode::<RepositoryManagerRemoveMirrorRequest, D>::encode(
3158                (
3159                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
3160                        &self.repo_url,
3161                    ),
3162                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
3163                        &self.mirror_url,
3164                    ),
3165                ),
3166                encoder,
3167                offset,
3168                _depth,
3169            )
3170        }
3171    }
3172    unsafe impl<
3173            D: fidl::encoding::ResourceDialect,
3174            T0: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
3175            T1: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
3176        > fidl::encoding::Encode<RepositoryManagerRemoveMirrorRequest, D> for (T0, T1)
3177    {
3178        #[inline]
3179        unsafe fn encode(
3180            self,
3181            encoder: &mut fidl::encoding::Encoder<'_, D>,
3182            offset: usize,
3183            depth: fidl::encoding::Depth,
3184        ) -> fidl::Result<()> {
3185            encoder.debug_check_bounds::<RepositoryManagerRemoveMirrorRequest>(offset);
3186            // Zero out padding regions. There's no need to apply masks
3187            // because the unmasked parts will be overwritten by fields.
3188            // Write the fields.
3189            self.0.encode(encoder, offset + 0, depth)?;
3190            self.1.encode(encoder, offset + 16, depth)?;
3191            Ok(())
3192        }
3193    }
3194
3195    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3196        for RepositoryManagerRemoveMirrorRequest
3197    {
3198        #[inline(always)]
3199        fn new_empty() -> Self {
3200            Self {
3201                repo_url: fidl::new_empty!(fidl::encoding::UnboundedString, D),
3202                mirror_url: fidl::new_empty!(fidl::encoding::UnboundedString, D),
3203            }
3204        }
3205
3206        #[inline]
3207        unsafe fn decode(
3208            &mut self,
3209            decoder: &mut fidl::encoding::Decoder<'_, D>,
3210            offset: usize,
3211            _depth: fidl::encoding::Depth,
3212        ) -> fidl::Result<()> {
3213            decoder.debug_check_bounds::<Self>(offset);
3214            // Verify that padding bytes are zero.
3215            fidl::decode!(
3216                fidl::encoding::UnboundedString,
3217                D,
3218                &mut self.repo_url,
3219                decoder,
3220                offset + 0,
3221                _depth
3222            )?;
3223            fidl::decode!(
3224                fidl::encoding::UnboundedString,
3225                D,
3226                &mut self.mirror_url,
3227                decoder,
3228                offset + 16,
3229                _depth
3230            )?;
3231            Ok(())
3232        }
3233    }
3234
3235    impl fidl::encoding::ValueTypeMarker for RepositoryManagerRemoveRequest {
3236        type Borrowed<'a> = &'a Self;
3237        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3238            value
3239        }
3240    }
3241
3242    unsafe impl fidl::encoding::TypeMarker for RepositoryManagerRemoveRequest {
3243        type Owned = Self;
3244
3245        #[inline(always)]
3246        fn inline_align(_context: fidl::encoding::Context) -> usize {
3247            8
3248        }
3249
3250        #[inline(always)]
3251        fn inline_size(_context: fidl::encoding::Context) -> usize {
3252            16
3253        }
3254    }
3255
3256    unsafe impl<D: fidl::encoding::ResourceDialect>
3257        fidl::encoding::Encode<RepositoryManagerRemoveRequest, D>
3258        for &RepositoryManagerRemoveRequest
3259    {
3260        #[inline]
3261        unsafe fn encode(
3262            self,
3263            encoder: &mut fidl::encoding::Encoder<'_, D>,
3264            offset: usize,
3265            _depth: fidl::encoding::Depth,
3266        ) -> fidl::Result<()> {
3267            encoder.debug_check_bounds::<RepositoryManagerRemoveRequest>(offset);
3268            // Delegate to tuple encoding.
3269            fidl::encoding::Encode::<RepositoryManagerRemoveRequest, D>::encode(
3270                (<fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow(
3271                    &self.repo_url,
3272                ),),
3273                encoder,
3274                offset,
3275                _depth,
3276            )
3277        }
3278    }
3279    unsafe impl<
3280            D: fidl::encoding::ResourceDialect,
3281            T0: fidl::encoding::Encode<fidl::encoding::UnboundedString, D>,
3282        > fidl::encoding::Encode<RepositoryManagerRemoveRequest, D> for (T0,)
3283    {
3284        #[inline]
3285        unsafe fn encode(
3286            self,
3287            encoder: &mut fidl::encoding::Encoder<'_, D>,
3288            offset: usize,
3289            depth: fidl::encoding::Depth,
3290        ) -> fidl::Result<()> {
3291            encoder.debug_check_bounds::<RepositoryManagerRemoveRequest>(offset);
3292            // Zero out padding regions. There's no need to apply masks
3293            // because the unmasked parts will be overwritten by fields.
3294            // Write the fields.
3295            self.0.encode(encoder, offset + 0, depth)?;
3296            Ok(())
3297        }
3298    }
3299
3300    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
3301        for RepositoryManagerRemoveRequest
3302    {
3303        #[inline(always)]
3304        fn new_empty() -> Self {
3305            Self { repo_url: fidl::new_empty!(fidl::encoding::UnboundedString, D) }
3306        }
3307
3308        #[inline]
3309        unsafe fn decode(
3310            &mut self,
3311            decoder: &mut fidl::encoding::Decoder<'_, D>,
3312            offset: usize,
3313            _depth: fidl::encoding::Depth,
3314        ) -> fidl::Result<()> {
3315            decoder.debug_check_bounds::<Self>(offset);
3316            // Verify that padding bytes are zero.
3317            fidl::decode!(
3318                fidl::encoding::UnboundedString,
3319                D,
3320                &mut self.repo_url,
3321                decoder,
3322                offset + 0,
3323                _depth
3324            )?;
3325            Ok(())
3326        }
3327    }
3328
3329    impl fidl::encoding::ValueTypeMarker for RepositoryUrl {
3330        type Borrowed<'a> = &'a Self;
3331        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3332            value
3333        }
3334    }
3335
3336    unsafe impl fidl::encoding::TypeMarker for RepositoryUrl {
3337        type Owned = Self;
3338
3339        #[inline(always)]
3340        fn inline_align(_context: fidl::encoding::Context) -> usize {
3341            8
3342        }
3343
3344        #[inline(always)]
3345        fn inline_size(_context: fidl::encoding::Context) -> usize {
3346            16
3347        }
3348    }
3349
3350    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RepositoryUrl, D>
3351        for &RepositoryUrl
3352    {
3353        #[inline]
3354        unsafe fn encode(
3355            self,
3356            encoder: &mut fidl::encoding::Encoder<'_, D>,
3357            offset: usize,
3358            _depth: fidl::encoding::Depth,
3359        ) -> fidl::Result<()> {
3360            encoder.debug_check_bounds::<RepositoryUrl>(offset);
3361            // Delegate to tuple encoding.
3362            fidl::encoding::Encode::<RepositoryUrl, D>::encode(
3363                (<fidl::encoding::BoundedString<4096> as fidl::encoding::ValueTypeMarker>::borrow(
3364                    &self.url,
3365                ),),
3366                encoder,
3367                offset,
3368                _depth,
3369            )
3370        }
3371    }
3372    unsafe impl<
3373            D: fidl::encoding::ResourceDialect,
3374            T0: fidl::encoding::Encode<fidl::encoding::BoundedString<4096>, D>,
3375        > fidl::encoding::Encode<RepositoryUrl, D> for (T0,)
3376    {
3377        #[inline]
3378        unsafe fn encode(
3379            self,
3380            encoder: &mut fidl::encoding::Encoder<'_, D>,
3381            offset: usize,
3382            depth: fidl::encoding::Depth,
3383        ) -> fidl::Result<()> {
3384            encoder.debug_check_bounds::<RepositoryUrl>(offset);
3385            // Zero out padding regions. There's no need to apply masks
3386            // because the unmasked parts will be overwritten by fields.
3387            // Write the fields.
3388            self.0.encode(encoder, offset + 0, depth)?;
3389            Ok(())
3390        }
3391    }
3392
3393    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RepositoryUrl {
3394        #[inline(always)]
3395        fn new_empty() -> Self {
3396            Self { url: fidl::new_empty!(fidl::encoding::BoundedString<4096>, D) }
3397        }
3398
3399        #[inline]
3400        unsafe fn decode(
3401            &mut self,
3402            decoder: &mut fidl::encoding::Decoder<'_, D>,
3403            offset: usize,
3404            _depth: fidl::encoding::Depth,
3405        ) -> fidl::Result<()> {
3406            decoder.debug_check_bounds::<Self>(offset);
3407            // Verify that padding bytes are zero.
3408            fidl::decode!(
3409                fidl::encoding::BoundedString<4096>,
3410                D,
3411                &mut self.url,
3412                decoder,
3413                offset + 0,
3414                _depth
3415            )?;
3416            Ok(())
3417        }
3418    }
3419
3420    impl fidl::encoding::ValueTypeMarker for ResolutionContext {
3421        type Borrowed<'a> = &'a Self;
3422        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3423            value
3424        }
3425    }
3426
3427    unsafe impl fidl::encoding::TypeMarker for ResolutionContext {
3428        type Owned = Self;
3429
3430        #[inline(always)]
3431        fn inline_align(_context: fidl::encoding::Context) -> usize {
3432            8
3433        }
3434
3435        #[inline(always)]
3436        fn inline_size(_context: fidl::encoding::Context) -> usize {
3437            16
3438        }
3439    }
3440
3441    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ResolutionContext, D>
3442        for &ResolutionContext
3443    {
3444        #[inline]
3445        unsafe fn encode(
3446            self,
3447            encoder: &mut fidl::encoding::Encoder<'_, D>,
3448            offset: usize,
3449            _depth: fidl::encoding::Depth,
3450        ) -> fidl::Result<()> {
3451            encoder.debug_check_bounds::<ResolutionContext>(offset);
3452            // Delegate to tuple encoding.
3453            fidl::encoding::Encode::<ResolutionContext, D>::encode(
3454                (<fidl::encoding::Vector<u8, 8192> as fidl::encoding::ValueTypeMarker>::borrow(
3455                    &self.bytes,
3456                ),),
3457                encoder,
3458                offset,
3459                _depth,
3460            )
3461        }
3462    }
3463    unsafe impl<
3464            D: fidl::encoding::ResourceDialect,
3465            T0: fidl::encoding::Encode<fidl::encoding::Vector<u8, 8192>, D>,
3466        > fidl::encoding::Encode<ResolutionContext, D> for (T0,)
3467    {
3468        #[inline]
3469        unsafe fn encode(
3470            self,
3471            encoder: &mut fidl::encoding::Encoder<'_, D>,
3472            offset: usize,
3473            depth: fidl::encoding::Depth,
3474        ) -> fidl::Result<()> {
3475            encoder.debug_check_bounds::<ResolutionContext>(offset);
3476            // Zero out padding regions. There's no need to apply masks
3477            // because the unmasked parts will be overwritten by fields.
3478            // Write the fields.
3479            self.0.encode(encoder, offset + 0, depth)?;
3480            Ok(())
3481        }
3482    }
3483
3484    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ResolutionContext {
3485        #[inline(always)]
3486        fn new_empty() -> Self {
3487            Self { bytes: fidl::new_empty!(fidl::encoding::Vector<u8, 8192>, D) }
3488        }
3489
3490        #[inline]
3491        unsafe fn decode(
3492            &mut self,
3493            decoder: &mut fidl::encoding::Decoder<'_, D>,
3494            offset: usize,
3495            _depth: fidl::encoding::Depth,
3496        ) -> fidl::Result<()> {
3497            decoder.debug_check_bounds::<Self>(offset);
3498            // Verify that padding bytes are zero.
3499            fidl::decode!(fidl::encoding::Vector<u8, 8192>, D, &mut self.bytes, decoder, offset + 0, _depth)?;
3500            Ok(())
3501        }
3502    }
3503
3504    impl CupData {
3505        #[inline(always)]
3506        fn max_ordinal_present(&self) -> u64 {
3507            if let Some(_) = self.signature {
3508                return 5;
3509            }
3510            if let Some(_) = self.response {
3511                return 4;
3512            }
3513            if let Some(_) = self.nonce {
3514                return 3;
3515            }
3516            if let Some(_) = self.key_id {
3517                return 2;
3518            }
3519            if let Some(_) = self.request {
3520                return 1;
3521            }
3522            0
3523        }
3524    }
3525
3526    impl fidl::encoding::ValueTypeMarker for CupData {
3527        type Borrowed<'a> = &'a Self;
3528        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3529            value
3530        }
3531    }
3532
3533    unsafe impl fidl::encoding::TypeMarker for CupData {
3534        type Owned = Self;
3535
3536        #[inline(always)]
3537        fn inline_align(_context: fidl::encoding::Context) -> usize {
3538            8
3539        }
3540
3541        #[inline(always)]
3542        fn inline_size(_context: fidl::encoding::Context) -> usize {
3543            16
3544        }
3545    }
3546
3547    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CupData, D> for &CupData {
3548        unsafe fn encode(
3549            self,
3550            encoder: &mut fidl::encoding::Encoder<'_, D>,
3551            offset: usize,
3552            mut depth: fidl::encoding::Depth,
3553        ) -> fidl::Result<()> {
3554            encoder.debug_check_bounds::<CupData>(offset);
3555            // Vector header
3556            let max_ordinal: u64 = self.max_ordinal_present();
3557            encoder.write_num(max_ordinal, offset);
3558            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
3559            // Calling encoder.out_of_line_offset(0) is not allowed.
3560            if max_ordinal == 0 {
3561                return Ok(());
3562            }
3563            depth.increment()?;
3564            let envelope_size = 8;
3565            let bytes_len = max_ordinal as usize * envelope_size;
3566            #[allow(unused_variables)]
3567            let offset = encoder.out_of_line_offset(bytes_len);
3568            let mut _prev_end_offset: usize = 0;
3569            if 1 > max_ordinal {
3570                return Ok(());
3571            }
3572
3573            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3574            // are envelope_size bytes.
3575            let cur_offset: usize = (1 - 1) * envelope_size;
3576
3577            // Zero reserved fields.
3578            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3579
3580            // Safety:
3581            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3582            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3583            //   envelope_size bytes, there is always sufficient room.
3584            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 65536>, D>(
3585                self.request.as_ref().map(
3586                    <fidl::encoding::Vector<u8, 65536> as fidl::encoding::ValueTypeMarker>::borrow,
3587                ),
3588                encoder,
3589                offset + cur_offset,
3590                depth,
3591            )?;
3592
3593            _prev_end_offset = cur_offset + envelope_size;
3594            if 2 > max_ordinal {
3595                return Ok(());
3596            }
3597
3598            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3599            // are envelope_size bytes.
3600            let cur_offset: usize = (2 - 1) * envelope_size;
3601
3602            // Zero reserved fields.
3603            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3604
3605            // Safety:
3606            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3607            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3608            //   envelope_size bytes, there is always sufficient room.
3609            fidl::encoding::encode_in_envelope_optional::<u64, D>(
3610                self.key_id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
3611                encoder,
3612                offset + cur_offset,
3613                depth,
3614            )?;
3615
3616            _prev_end_offset = cur_offset + envelope_size;
3617            if 3 > max_ordinal {
3618                return Ok(());
3619            }
3620
3621            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3622            // are envelope_size bytes.
3623            let cur_offset: usize = (3 - 1) * envelope_size;
3624
3625            // Zero reserved fields.
3626            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3627
3628            // Safety:
3629            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3630            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3631            //   envelope_size bytes, there is always sufficient room.
3632            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Array<u8, 32>, D>(
3633                self.nonce.as_ref().map(
3634                    <fidl::encoding::Array<u8, 32> as fidl::encoding::ValueTypeMarker>::borrow,
3635                ),
3636                encoder,
3637                offset + cur_offset,
3638                depth,
3639            )?;
3640
3641            _prev_end_offset = cur_offset + envelope_size;
3642            if 4 > max_ordinal {
3643                return Ok(());
3644            }
3645
3646            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3647            // are envelope_size bytes.
3648            let cur_offset: usize = (4 - 1) * envelope_size;
3649
3650            // Zero reserved fields.
3651            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3652
3653            // Safety:
3654            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3655            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3656            //   envelope_size bytes, there is always sufficient room.
3657            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 65536>, D>(
3658                self.response.as_ref().map(
3659                    <fidl::encoding::Vector<u8, 65536> as fidl::encoding::ValueTypeMarker>::borrow,
3660                ),
3661                encoder,
3662                offset + cur_offset,
3663                depth,
3664            )?;
3665
3666            _prev_end_offset = cur_offset + envelope_size;
3667            if 5 > max_ordinal {
3668                return Ok(());
3669            }
3670
3671            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
3672            // are envelope_size bytes.
3673            let cur_offset: usize = (5 - 1) * envelope_size;
3674
3675            // Zero reserved fields.
3676            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
3677
3678            // Safety:
3679            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
3680            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
3681            //   envelope_size bytes, there is always sufficient room.
3682            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<u8, 72>, D>(
3683                self.signature.as_ref().map(
3684                    <fidl::encoding::Vector<u8, 72> as fidl::encoding::ValueTypeMarker>::borrow,
3685                ),
3686                encoder,
3687                offset + cur_offset,
3688                depth,
3689            )?;
3690
3691            _prev_end_offset = cur_offset + envelope_size;
3692
3693            Ok(())
3694        }
3695    }
3696
3697    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CupData {
3698        #[inline(always)]
3699        fn new_empty() -> Self {
3700            Self::default()
3701        }
3702
3703        unsafe fn decode(
3704            &mut self,
3705            decoder: &mut fidl::encoding::Decoder<'_, D>,
3706            offset: usize,
3707            mut depth: fidl::encoding::Depth,
3708        ) -> fidl::Result<()> {
3709            decoder.debug_check_bounds::<Self>(offset);
3710            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
3711                None => return Err(fidl::Error::NotNullable),
3712                Some(len) => len,
3713            };
3714            // Calling decoder.out_of_line_offset(0) is not allowed.
3715            if len == 0 {
3716                return Ok(());
3717            };
3718            depth.increment()?;
3719            let envelope_size = 8;
3720            let bytes_len = len * envelope_size;
3721            let offset = decoder.out_of_line_offset(bytes_len)?;
3722            // Decode the envelope for each type.
3723            let mut _next_ordinal_to_read = 0;
3724            let mut next_offset = offset;
3725            let end_offset = offset + bytes_len;
3726            _next_ordinal_to_read += 1;
3727            if next_offset >= end_offset {
3728                return Ok(());
3729            }
3730
3731            // Decode unknown envelopes for gaps in ordinals.
3732            while _next_ordinal_to_read < 1 {
3733                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3734                _next_ordinal_to_read += 1;
3735                next_offset += envelope_size;
3736            }
3737
3738            let next_out_of_line = decoder.next_out_of_line();
3739            let handles_before = decoder.remaining_handles();
3740            if let Some((inlined, num_bytes, num_handles)) =
3741                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3742            {
3743                let member_inline_size =
3744                    <fidl::encoding::Vector<u8, 65536> as fidl::encoding::TypeMarker>::inline_size(
3745                        decoder.context,
3746                    );
3747                if inlined != (member_inline_size <= 4) {
3748                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3749                }
3750                let inner_offset;
3751                let mut inner_depth = depth.clone();
3752                if inlined {
3753                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3754                    inner_offset = next_offset;
3755                } else {
3756                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3757                    inner_depth.increment()?;
3758                }
3759                let val_ref = self
3760                    .request
3761                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 65536>, D));
3762                fidl::decode!(fidl::encoding::Vector<u8, 65536>, D, val_ref, decoder, inner_offset, inner_depth)?;
3763                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3764                {
3765                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3766                }
3767                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3768                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3769                }
3770            }
3771
3772            next_offset += envelope_size;
3773            _next_ordinal_to_read += 1;
3774            if next_offset >= end_offset {
3775                return Ok(());
3776            }
3777
3778            // Decode unknown envelopes for gaps in ordinals.
3779            while _next_ordinal_to_read < 2 {
3780                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3781                _next_ordinal_to_read += 1;
3782                next_offset += envelope_size;
3783            }
3784
3785            let next_out_of_line = decoder.next_out_of_line();
3786            let handles_before = decoder.remaining_handles();
3787            if let Some((inlined, num_bytes, num_handles)) =
3788                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3789            {
3790                let member_inline_size =
3791                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
3792                if inlined != (member_inline_size <= 4) {
3793                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3794                }
3795                let inner_offset;
3796                let mut inner_depth = depth.clone();
3797                if inlined {
3798                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3799                    inner_offset = next_offset;
3800                } else {
3801                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3802                    inner_depth.increment()?;
3803                }
3804                let val_ref = self.key_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
3805                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
3806                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3807                {
3808                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3809                }
3810                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3811                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3812                }
3813            }
3814
3815            next_offset += envelope_size;
3816            _next_ordinal_to_read += 1;
3817            if next_offset >= end_offset {
3818                return Ok(());
3819            }
3820
3821            // Decode unknown envelopes for gaps in ordinals.
3822            while _next_ordinal_to_read < 3 {
3823                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3824                _next_ordinal_to_read += 1;
3825                next_offset += envelope_size;
3826            }
3827
3828            let next_out_of_line = decoder.next_out_of_line();
3829            let handles_before = decoder.remaining_handles();
3830            if let Some((inlined, num_bytes, num_handles)) =
3831                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3832            {
3833                let member_inline_size =
3834                    <fidl::encoding::Array<u8, 32> as fidl::encoding::TypeMarker>::inline_size(
3835                        decoder.context,
3836                    );
3837                if inlined != (member_inline_size <= 4) {
3838                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3839                }
3840                let inner_offset;
3841                let mut inner_depth = depth.clone();
3842                if inlined {
3843                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3844                    inner_offset = next_offset;
3845                } else {
3846                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3847                    inner_depth.increment()?;
3848                }
3849                let val_ref = self
3850                    .nonce
3851                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Array<u8, 32>, D));
3852                fidl::decode!(fidl::encoding::Array<u8, 32>, D, val_ref, decoder, inner_offset, inner_depth)?;
3853                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3854                {
3855                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3856                }
3857                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3858                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3859                }
3860            }
3861
3862            next_offset += envelope_size;
3863            _next_ordinal_to_read += 1;
3864            if next_offset >= end_offset {
3865                return Ok(());
3866            }
3867
3868            // Decode unknown envelopes for gaps in ordinals.
3869            while _next_ordinal_to_read < 4 {
3870                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3871                _next_ordinal_to_read += 1;
3872                next_offset += envelope_size;
3873            }
3874
3875            let next_out_of_line = decoder.next_out_of_line();
3876            let handles_before = decoder.remaining_handles();
3877            if let Some((inlined, num_bytes, num_handles)) =
3878                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3879            {
3880                let member_inline_size =
3881                    <fidl::encoding::Vector<u8, 65536> as fidl::encoding::TypeMarker>::inline_size(
3882                        decoder.context,
3883                    );
3884                if inlined != (member_inline_size <= 4) {
3885                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3886                }
3887                let inner_offset;
3888                let mut inner_depth = depth.clone();
3889                if inlined {
3890                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3891                    inner_offset = next_offset;
3892                } else {
3893                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3894                    inner_depth.increment()?;
3895                }
3896                let val_ref = self
3897                    .response
3898                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 65536>, D));
3899                fidl::decode!(fidl::encoding::Vector<u8, 65536>, D, val_ref, decoder, inner_offset, inner_depth)?;
3900                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3901                {
3902                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3903                }
3904                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3905                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3906                }
3907            }
3908
3909            next_offset += envelope_size;
3910            _next_ordinal_to_read += 1;
3911            if next_offset >= end_offset {
3912                return Ok(());
3913            }
3914
3915            // Decode unknown envelopes for gaps in ordinals.
3916            while _next_ordinal_to_read < 5 {
3917                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3918                _next_ordinal_to_read += 1;
3919                next_offset += envelope_size;
3920            }
3921
3922            let next_out_of_line = decoder.next_out_of_line();
3923            let handles_before = decoder.remaining_handles();
3924            if let Some((inlined, num_bytes, num_handles)) =
3925                fidl::encoding::decode_envelope_header(decoder, next_offset)?
3926            {
3927                let member_inline_size =
3928                    <fidl::encoding::Vector<u8, 72> as fidl::encoding::TypeMarker>::inline_size(
3929                        decoder.context,
3930                    );
3931                if inlined != (member_inline_size <= 4) {
3932                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
3933                }
3934                let inner_offset;
3935                let mut inner_depth = depth.clone();
3936                if inlined {
3937                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
3938                    inner_offset = next_offset;
3939                } else {
3940                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
3941                    inner_depth.increment()?;
3942                }
3943                let val_ref = self
3944                    .signature
3945                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<u8, 72>, D));
3946                fidl::decode!(fidl::encoding::Vector<u8, 72>, D, val_ref, decoder, inner_offset, inner_depth)?;
3947                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
3948                {
3949                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
3950                }
3951                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
3952                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
3953                }
3954            }
3955
3956            next_offset += envelope_size;
3957
3958            // Decode the remaining unknown envelopes.
3959            while next_offset < end_offset {
3960                _next_ordinal_to_read += 1;
3961                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
3962                next_offset += envelope_size;
3963            }
3964
3965            Ok(())
3966        }
3967    }
3968
3969    impl MirrorConfig {
3970        #[inline(always)]
3971        fn max_ordinal_present(&self) -> u64 {
3972            if let Some(_) = self.blob_mirror_url {
3973                return 4;
3974            }
3975            if let Some(_) = self.subscribe {
3976                return 2;
3977            }
3978            if let Some(_) = self.mirror_url {
3979                return 1;
3980            }
3981            0
3982        }
3983    }
3984
3985    impl fidl::encoding::ValueTypeMarker for MirrorConfig {
3986        type Borrowed<'a> = &'a Self;
3987        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
3988            value
3989        }
3990    }
3991
3992    unsafe impl fidl::encoding::TypeMarker for MirrorConfig {
3993        type Owned = Self;
3994
3995        #[inline(always)]
3996        fn inline_align(_context: fidl::encoding::Context) -> usize {
3997            8
3998        }
3999
4000        #[inline(always)]
4001        fn inline_size(_context: fidl::encoding::Context) -> usize {
4002            16
4003        }
4004    }
4005
4006    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<MirrorConfig, D>
4007        for &MirrorConfig
4008    {
4009        unsafe fn encode(
4010            self,
4011            encoder: &mut fidl::encoding::Encoder<'_, D>,
4012            offset: usize,
4013            mut depth: fidl::encoding::Depth,
4014        ) -> fidl::Result<()> {
4015            encoder.debug_check_bounds::<MirrorConfig>(offset);
4016            // Vector header
4017            let max_ordinal: u64 = self.max_ordinal_present();
4018            encoder.write_num(max_ordinal, offset);
4019            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4020            // Calling encoder.out_of_line_offset(0) is not allowed.
4021            if max_ordinal == 0 {
4022                return Ok(());
4023            }
4024            depth.increment()?;
4025            let envelope_size = 8;
4026            let bytes_len = max_ordinal as usize * envelope_size;
4027            #[allow(unused_variables)]
4028            let offset = encoder.out_of_line_offset(bytes_len);
4029            let mut _prev_end_offset: usize = 0;
4030            if 1 > max_ordinal {
4031                return Ok(());
4032            }
4033
4034            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4035            // are envelope_size bytes.
4036            let cur_offset: usize = (1 - 1) * envelope_size;
4037
4038            // Zero reserved fields.
4039            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4040
4041            // Safety:
4042            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4043            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4044            //   envelope_size bytes, there is always sufficient room.
4045            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
4046                self.mirror_url.as_ref().map(
4047                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
4048                ),
4049                encoder,
4050                offset + cur_offset,
4051                depth,
4052            )?;
4053
4054            _prev_end_offset = cur_offset + envelope_size;
4055            if 2 > max_ordinal {
4056                return Ok(());
4057            }
4058
4059            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4060            // are envelope_size bytes.
4061            let cur_offset: usize = (2 - 1) * envelope_size;
4062
4063            // Zero reserved fields.
4064            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4065
4066            // Safety:
4067            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4068            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4069            //   envelope_size bytes, there is always sufficient room.
4070            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4071                self.subscribe.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4072                encoder,
4073                offset + cur_offset,
4074                depth,
4075            )?;
4076
4077            _prev_end_offset = cur_offset + envelope_size;
4078            if 4 > max_ordinal {
4079                return Ok(());
4080            }
4081
4082            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4083            // are envelope_size bytes.
4084            let cur_offset: usize = (4 - 1) * envelope_size;
4085
4086            // Zero reserved fields.
4087            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4088
4089            // Safety:
4090            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4091            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4092            //   envelope_size bytes, there is always sufficient room.
4093            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
4094                self.blob_mirror_url.as_ref().map(
4095                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
4096                ),
4097                encoder,
4098                offset + cur_offset,
4099                depth,
4100            )?;
4101
4102            _prev_end_offset = cur_offset + envelope_size;
4103
4104            Ok(())
4105        }
4106    }
4107
4108    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for MirrorConfig {
4109        #[inline(always)]
4110        fn new_empty() -> Self {
4111            Self::default()
4112        }
4113
4114        unsafe fn decode(
4115            &mut self,
4116            decoder: &mut fidl::encoding::Decoder<'_, D>,
4117            offset: usize,
4118            mut depth: fidl::encoding::Depth,
4119        ) -> fidl::Result<()> {
4120            decoder.debug_check_bounds::<Self>(offset);
4121            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4122                None => return Err(fidl::Error::NotNullable),
4123                Some(len) => len,
4124            };
4125            // Calling decoder.out_of_line_offset(0) is not allowed.
4126            if len == 0 {
4127                return Ok(());
4128            };
4129            depth.increment()?;
4130            let envelope_size = 8;
4131            let bytes_len = len * envelope_size;
4132            let offset = decoder.out_of_line_offset(bytes_len)?;
4133            // Decode the envelope for each type.
4134            let mut _next_ordinal_to_read = 0;
4135            let mut next_offset = offset;
4136            let end_offset = offset + bytes_len;
4137            _next_ordinal_to_read += 1;
4138            if next_offset >= end_offset {
4139                return Ok(());
4140            }
4141
4142            // Decode unknown envelopes for gaps in ordinals.
4143            while _next_ordinal_to_read < 1 {
4144                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4145                _next_ordinal_to_read += 1;
4146                next_offset += envelope_size;
4147            }
4148
4149            let next_out_of_line = decoder.next_out_of_line();
4150            let handles_before = decoder.remaining_handles();
4151            if let Some((inlined, num_bytes, num_handles)) =
4152                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4153            {
4154                let member_inline_size =
4155                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
4156                        decoder.context,
4157                    );
4158                if inlined != (member_inline_size <= 4) {
4159                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4160                }
4161                let inner_offset;
4162                let mut inner_depth = depth.clone();
4163                if inlined {
4164                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4165                    inner_offset = next_offset;
4166                } else {
4167                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4168                    inner_depth.increment()?;
4169                }
4170                let val_ref = self
4171                    .mirror_url
4172                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
4173                fidl::decode!(
4174                    fidl::encoding::UnboundedString,
4175                    D,
4176                    val_ref,
4177                    decoder,
4178                    inner_offset,
4179                    inner_depth
4180                )?;
4181                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4182                {
4183                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4184                }
4185                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4186                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4187                }
4188            }
4189
4190            next_offset += envelope_size;
4191            _next_ordinal_to_read += 1;
4192            if next_offset >= end_offset {
4193                return Ok(());
4194            }
4195
4196            // Decode unknown envelopes for gaps in ordinals.
4197            while _next_ordinal_to_read < 2 {
4198                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4199                _next_ordinal_to_read += 1;
4200                next_offset += envelope_size;
4201            }
4202
4203            let next_out_of_line = decoder.next_out_of_line();
4204            let handles_before = decoder.remaining_handles();
4205            if let Some((inlined, num_bytes, num_handles)) =
4206                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4207            {
4208                let member_inline_size =
4209                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4210                if inlined != (member_inline_size <= 4) {
4211                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4212                }
4213                let inner_offset;
4214                let mut inner_depth = depth.clone();
4215                if inlined {
4216                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4217                    inner_offset = next_offset;
4218                } else {
4219                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4220                    inner_depth.increment()?;
4221                }
4222                let val_ref = self.subscribe.get_or_insert_with(|| fidl::new_empty!(bool, D));
4223                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4224                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4225                {
4226                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4227                }
4228                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4229                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4230                }
4231            }
4232
4233            next_offset += envelope_size;
4234            _next_ordinal_to_read += 1;
4235            if next_offset >= end_offset {
4236                return Ok(());
4237            }
4238
4239            // Decode unknown envelopes for gaps in ordinals.
4240            while _next_ordinal_to_read < 4 {
4241                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4242                _next_ordinal_to_read += 1;
4243                next_offset += envelope_size;
4244            }
4245
4246            let next_out_of_line = decoder.next_out_of_line();
4247            let handles_before = decoder.remaining_handles();
4248            if let Some((inlined, num_bytes, num_handles)) =
4249                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4250            {
4251                let member_inline_size =
4252                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
4253                        decoder.context,
4254                    );
4255                if inlined != (member_inline_size <= 4) {
4256                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4257                }
4258                let inner_offset;
4259                let mut inner_depth = depth.clone();
4260                if inlined {
4261                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4262                    inner_offset = next_offset;
4263                } else {
4264                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4265                    inner_depth.increment()?;
4266                }
4267                let val_ref = self
4268                    .blob_mirror_url
4269                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
4270                fidl::decode!(
4271                    fidl::encoding::UnboundedString,
4272                    D,
4273                    val_ref,
4274                    decoder,
4275                    inner_offset,
4276                    inner_depth
4277                )?;
4278                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4279                {
4280                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4281                }
4282                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4283                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4284                }
4285            }
4286
4287            next_offset += envelope_size;
4288
4289            // Decode the remaining unknown envelopes.
4290            while next_offset < end_offset {
4291                _next_ordinal_to_read += 1;
4292                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4293                next_offset += envelope_size;
4294            }
4295
4296            Ok(())
4297        }
4298    }
4299
4300    impl RepositoryConfig {
4301        #[inline(always)]
4302        fn max_ordinal_present(&self) -> u64 {
4303            if let Some(_) = self.storage_type {
4304                return 8;
4305            }
4306            if let Some(_) = self.use_local_mirror {
4307                return 7;
4308            }
4309            if let Some(_) = self.root_threshold {
4310                return 6;
4311            }
4312            if let Some(_) = self.root_version {
4313                return 5;
4314            }
4315            if let Some(_) = self.mirrors {
4316                return 3;
4317            }
4318            if let Some(_) = self.root_keys {
4319                return 2;
4320            }
4321            if let Some(_) = self.repo_url {
4322                return 1;
4323            }
4324            0
4325        }
4326    }
4327
4328    impl fidl::encoding::ValueTypeMarker for RepositoryConfig {
4329        type Borrowed<'a> = &'a Self;
4330        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4331            value
4332        }
4333    }
4334
4335    unsafe impl fidl::encoding::TypeMarker for RepositoryConfig {
4336        type Owned = Self;
4337
4338        #[inline(always)]
4339        fn inline_align(_context: fidl::encoding::Context) -> usize {
4340            8
4341        }
4342
4343        #[inline(always)]
4344        fn inline_size(_context: fidl::encoding::Context) -> usize {
4345            16
4346        }
4347    }
4348
4349    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RepositoryConfig, D>
4350        for &RepositoryConfig
4351    {
4352        unsafe fn encode(
4353            self,
4354            encoder: &mut fidl::encoding::Encoder<'_, D>,
4355            offset: usize,
4356            mut depth: fidl::encoding::Depth,
4357        ) -> fidl::Result<()> {
4358            encoder.debug_check_bounds::<RepositoryConfig>(offset);
4359            // Vector header
4360            let max_ordinal: u64 = self.max_ordinal_present();
4361            encoder.write_num(max_ordinal, offset);
4362            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
4363            // Calling encoder.out_of_line_offset(0) is not allowed.
4364            if max_ordinal == 0 {
4365                return Ok(());
4366            }
4367            depth.increment()?;
4368            let envelope_size = 8;
4369            let bytes_len = max_ordinal as usize * envelope_size;
4370            #[allow(unused_variables)]
4371            let offset = encoder.out_of_line_offset(bytes_len);
4372            let mut _prev_end_offset: usize = 0;
4373            if 1 > max_ordinal {
4374                return Ok(());
4375            }
4376
4377            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4378            // are envelope_size bytes.
4379            let cur_offset: usize = (1 - 1) * envelope_size;
4380
4381            // Zero reserved fields.
4382            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4383
4384            // Safety:
4385            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4386            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4387            //   envelope_size bytes, there is always sufficient room.
4388            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
4389                self.repo_url.as_ref().map(
4390                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
4391                ),
4392                encoder,
4393                offset + cur_offset,
4394                depth,
4395            )?;
4396
4397            _prev_end_offset = cur_offset + envelope_size;
4398            if 2 > max_ordinal {
4399                return Ok(());
4400            }
4401
4402            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4403            // are envelope_size bytes.
4404            let cur_offset: usize = (2 - 1) * envelope_size;
4405
4406            // Zero reserved fields.
4407            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4408
4409            // Safety:
4410            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4411            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4412            //   envelope_size bytes, there is always sufficient room.
4413            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<RepositoryKeyConfig>, D>(
4414            self.root_keys.as_ref().map(<fidl::encoding::UnboundedVector<RepositoryKeyConfig> as fidl::encoding::ValueTypeMarker>::borrow),
4415            encoder, offset + cur_offset, depth
4416        )?;
4417
4418            _prev_end_offset = cur_offset + envelope_size;
4419            if 3 > max_ordinal {
4420                return Ok(());
4421            }
4422
4423            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4424            // are envelope_size bytes.
4425            let cur_offset: usize = (3 - 1) * envelope_size;
4426
4427            // Zero reserved fields.
4428            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4429
4430            // Safety:
4431            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4432            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4433            //   envelope_size bytes, there is always sufficient room.
4434            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<MirrorConfig>, D>(
4435            self.mirrors.as_ref().map(<fidl::encoding::UnboundedVector<MirrorConfig> as fidl::encoding::ValueTypeMarker>::borrow),
4436            encoder, offset + cur_offset, depth
4437        )?;
4438
4439            _prev_end_offset = cur_offset + envelope_size;
4440            if 5 > max_ordinal {
4441                return Ok(());
4442            }
4443
4444            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4445            // are envelope_size bytes.
4446            let cur_offset: usize = (5 - 1) * envelope_size;
4447
4448            // Zero reserved fields.
4449            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4450
4451            // Safety:
4452            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4453            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4454            //   envelope_size bytes, there is always sufficient room.
4455            fidl::encoding::encode_in_envelope_optional::<u32, D>(
4456                self.root_version.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4457                encoder,
4458                offset + cur_offset,
4459                depth,
4460            )?;
4461
4462            _prev_end_offset = cur_offset + envelope_size;
4463            if 6 > max_ordinal {
4464                return Ok(());
4465            }
4466
4467            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4468            // are envelope_size bytes.
4469            let cur_offset: usize = (6 - 1) * envelope_size;
4470
4471            // Zero reserved fields.
4472            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4473
4474            // Safety:
4475            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4476            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4477            //   envelope_size bytes, there is always sufficient room.
4478            fidl::encoding::encode_in_envelope_optional::<u32, D>(
4479                self.root_threshold.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
4480                encoder,
4481                offset + cur_offset,
4482                depth,
4483            )?;
4484
4485            _prev_end_offset = cur_offset + envelope_size;
4486            if 7 > max_ordinal {
4487                return Ok(());
4488            }
4489
4490            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4491            // are envelope_size bytes.
4492            let cur_offset: usize = (7 - 1) * envelope_size;
4493
4494            // Zero reserved fields.
4495            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4496
4497            // Safety:
4498            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4499            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4500            //   envelope_size bytes, there is always sufficient room.
4501            fidl::encoding::encode_in_envelope_optional::<bool, D>(
4502                self.use_local_mirror
4503                    .as_ref()
4504                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
4505                encoder,
4506                offset + cur_offset,
4507                depth,
4508            )?;
4509
4510            _prev_end_offset = cur_offset + envelope_size;
4511            if 8 > max_ordinal {
4512                return Ok(());
4513            }
4514
4515            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
4516            // are envelope_size bytes.
4517            let cur_offset: usize = (8 - 1) * envelope_size;
4518
4519            // Zero reserved fields.
4520            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);
4521
4522            // Safety:
4523            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
4524            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
4525            //   envelope_size bytes, there is always sufficient room.
4526            fidl::encoding::encode_in_envelope_optional::<RepositoryStorageType, D>(
4527                self.storage_type
4528                    .as_ref()
4529                    .map(<RepositoryStorageType as fidl::encoding::ValueTypeMarker>::borrow),
4530                encoder,
4531                offset + cur_offset,
4532                depth,
4533            )?;
4534
4535            _prev_end_offset = cur_offset + envelope_size;
4536
4537            Ok(())
4538        }
4539    }
4540
4541    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RepositoryConfig {
4542        #[inline(always)]
4543        fn new_empty() -> Self {
4544            Self::default()
4545        }
4546
4547        unsafe fn decode(
4548            &mut self,
4549            decoder: &mut fidl::encoding::Decoder<'_, D>,
4550            offset: usize,
4551            mut depth: fidl::encoding::Depth,
4552        ) -> fidl::Result<()> {
4553            decoder.debug_check_bounds::<Self>(offset);
4554            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
4555                None => return Err(fidl::Error::NotNullable),
4556                Some(len) => len,
4557            };
4558            // Calling decoder.out_of_line_offset(0) is not allowed.
4559            if len == 0 {
4560                return Ok(());
4561            };
4562            depth.increment()?;
4563            let envelope_size = 8;
4564            let bytes_len = len * envelope_size;
4565            let offset = decoder.out_of_line_offset(bytes_len)?;
4566            // Decode the envelope for each type.
4567            let mut _next_ordinal_to_read = 0;
4568            let mut next_offset = offset;
4569            let end_offset = offset + bytes_len;
4570            _next_ordinal_to_read += 1;
4571            if next_offset >= end_offset {
4572                return Ok(());
4573            }
4574
4575            // Decode unknown envelopes for gaps in ordinals.
4576            while _next_ordinal_to_read < 1 {
4577                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4578                _next_ordinal_to_read += 1;
4579                next_offset += envelope_size;
4580            }
4581
4582            let next_out_of_line = decoder.next_out_of_line();
4583            let handles_before = decoder.remaining_handles();
4584            if let Some((inlined, num_bytes, num_handles)) =
4585                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4586            {
4587                let member_inline_size =
4588                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
4589                        decoder.context,
4590                    );
4591                if inlined != (member_inline_size <= 4) {
4592                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4593                }
4594                let inner_offset;
4595                let mut inner_depth = depth.clone();
4596                if inlined {
4597                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4598                    inner_offset = next_offset;
4599                } else {
4600                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4601                    inner_depth.increment()?;
4602                }
4603                let val_ref = self
4604                    .repo_url
4605                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
4606                fidl::decode!(
4607                    fidl::encoding::UnboundedString,
4608                    D,
4609                    val_ref,
4610                    decoder,
4611                    inner_offset,
4612                    inner_depth
4613                )?;
4614                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4615                {
4616                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4617                }
4618                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4619                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4620                }
4621            }
4622
4623            next_offset += envelope_size;
4624            _next_ordinal_to_read += 1;
4625            if next_offset >= end_offset {
4626                return Ok(());
4627            }
4628
4629            // Decode unknown envelopes for gaps in ordinals.
4630            while _next_ordinal_to_read < 2 {
4631                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4632                _next_ordinal_to_read += 1;
4633                next_offset += envelope_size;
4634            }
4635
4636            let next_out_of_line = decoder.next_out_of_line();
4637            let handles_before = decoder.remaining_handles();
4638            if let Some((inlined, num_bytes, num_handles)) =
4639                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4640            {
4641                let member_inline_size = <fidl::encoding::UnboundedVector<RepositoryKeyConfig> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4642                if inlined != (member_inline_size <= 4) {
4643                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4644                }
4645                let inner_offset;
4646                let mut inner_depth = depth.clone();
4647                if inlined {
4648                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4649                    inner_offset = next_offset;
4650                } else {
4651                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4652                    inner_depth.increment()?;
4653                }
4654                let val_ref = self.root_keys.get_or_insert_with(|| {
4655                    fidl::new_empty!(fidl::encoding::UnboundedVector<RepositoryKeyConfig>, D)
4656                });
4657                fidl::decode!(
4658                    fidl::encoding::UnboundedVector<RepositoryKeyConfig>,
4659                    D,
4660                    val_ref,
4661                    decoder,
4662                    inner_offset,
4663                    inner_depth
4664                )?;
4665                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4666                {
4667                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4668                }
4669                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4670                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4671                }
4672            }
4673
4674            next_offset += envelope_size;
4675            _next_ordinal_to_read += 1;
4676            if next_offset >= end_offset {
4677                return Ok(());
4678            }
4679
4680            // Decode unknown envelopes for gaps in ordinals.
4681            while _next_ordinal_to_read < 3 {
4682                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4683                _next_ordinal_to_read += 1;
4684                next_offset += envelope_size;
4685            }
4686
4687            let next_out_of_line = decoder.next_out_of_line();
4688            let handles_before = decoder.remaining_handles();
4689            if let Some((inlined, num_bytes, num_handles)) =
4690                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4691            {
4692                let member_inline_size = <fidl::encoding::UnboundedVector<MirrorConfig> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4693                if inlined != (member_inline_size <= 4) {
4694                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4695                }
4696                let inner_offset;
4697                let mut inner_depth = depth.clone();
4698                if inlined {
4699                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4700                    inner_offset = next_offset;
4701                } else {
4702                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4703                    inner_depth.increment()?;
4704                }
4705                let val_ref = self.mirrors.get_or_insert_with(|| {
4706                    fidl::new_empty!(fidl::encoding::UnboundedVector<MirrorConfig>, D)
4707                });
4708                fidl::decode!(
4709                    fidl::encoding::UnboundedVector<MirrorConfig>,
4710                    D,
4711                    val_ref,
4712                    decoder,
4713                    inner_offset,
4714                    inner_depth
4715                )?;
4716                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4717                {
4718                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4719                }
4720                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4721                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4722                }
4723            }
4724
4725            next_offset += envelope_size;
4726            _next_ordinal_to_read += 1;
4727            if next_offset >= end_offset {
4728                return Ok(());
4729            }
4730
4731            // Decode unknown envelopes for gaps in ordinals.
4732            while _next_ordinal_to_read < 5 {
4733                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4734                _next_ordinal_to_read += 1;
4735                next_offset += envelope_size;
4736            }
4737
4738            let next_out_of_line = decoder.next_out_of_line();
4739            let handles_before = decoder.remaining_handles();
4740            if let Some((inlined, num_bytes, num_handles)) =
4741                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4742            {
4743                let member_inline_size =
4744                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4745                if inlined != (member_inline_size <= 4) {
4746                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4747                }
4748                let inner_offset;
4749                let mut inner_depth = depth.clone();
4750                if inlined {
4751                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4752                    inner_offset = next_offset;
4753                } else {
4754                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4755                    inner_depth.increment()?;
4756                }
4757                let val_ref = self.root_version.get_or_insert_with(|| fidl::new_empty!(u32, D));
4758                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4759                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4760                {
4761                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4762                }
4763                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4764                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4765                }
4766            }
4767
4768            next_offset += envelope_size;
4769            _next_ordinal_to_read += 1;
4770            if next_offset >= end_offset {
4771                return Ok(());
4772            }
4773
4774            // Decode unknown envelopes for gaps in ordinals.
4775            while _next_ordinal_to_read < 6 {
4776                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4777                _next_ordinal_to_read += 1;
4778                next_offset += envelope_size;
4779            }
4780
4781            let next_out_of_line = decoder.next_out_of_line();
4782            let handles_before = decoder.remaining_handles();
4783            if let Some((inlined, num_bytes, num_handles)) =
4784                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4785            {
4786                let member_inline_size =
4787                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4788                if inlined != (member_inline_size <= 4) {
4789                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4790                }
4791                let inner_offset;
4792                let mut inner_depth = depth.clone();
4793                if inlined {
4794                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4795                    inner_offset = next_offset;
4796                } else {
4797                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4798                    inner_depth.increment()?;
4799                }
4800                let val_ref = self.root_threshold.get_or_insert_with(|| fidl::new_empty!(u32, D));
4801                fidl::decode!(u32, D, val_ref, decoder, inner_offset, inner_depth)?;
4802                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4803                {
4804                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4805                }
4806                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4807                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4808                }
4809            }
4810
4811            next_offset += envelope_size;
4812            _next_ordinal_to_read += 1;
4813            if next_offset >= end_offset {
4814                return Ok(());
4815            }
4816
4817            // Decode unknown envelopes for gaps in ordinals.
4818            while _next_ordinal_to_read < 7 {
4819                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4820                _next_ordinal_to_read += 1;
4821                next_offset += envelope_size;
4822            }
4823
4824            let next_out_of_line = decoder.next_out_of_line();
4825            let handles_before = decoder.remaining_handles();
4826            if let Some((inlined, num_bytes, num_handles)) =
4827                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4828            {
4829                let member_inline_size =
4830                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
4831                if inlined != (member_inline_size <= 4) {
4832                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4833                }
4834                let inner_offset;
4835                let mut inner_depth = depth.clone();
4836                if inlined {
4837                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4838                    inner_offset = next_offset;
4839                } else {
4840                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4841                    inner_depth.increment()?;
4842                }
4843                let val_ref =
4844                    self.use_local_mirror.get_or_insert_with(|| fidl::new_empty!(bool, D));
4845                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
4846                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4847                {
4848                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4849                }
4850                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4851                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4852                }
4853            }
4854
4855            next_offset += envelope_size;
4856            _next_ordinal_to_read += 1;
4857            if next_offset >= end_offset {
4858                return Ok(());
4859            }
4860
4861            // Decode unknown envelopes for gaps in ordinals.
4862            while _next_ordinal_to_read < 8 {
4863                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4864                _next_ordinal_to_read += 1;
4865                next_offset += envelope_size;
4866            }
4867
4868            let next_out_of_line = decoder.next_out_of_line();
4869            let handles_before = decoder.remaining_handles();
4870            if let Some((inlined, num_bytes, num_handles)) =
4871                fidl::encoding::decode_envelope_header(decoder, next_offset)?
4872            {
4873                let member_inline_size =
4874                    <RepositoryStorageType as fidl::encoding::TypeMarker>::inline_size(
4875                        decoder.context,
4876                    );
4877                if inlined != (member_inline_size <= 4) {
4878                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
4879                }
4880                let inner_offset;
4881                let mut inner_depth = depth.clone();
4882                if inlined {
4883                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
4884                    inner_offset = next_offset;
4885                } else {
4886                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
4887                    inner_depth.increment()?;
4888                }
4889                let val_ref = self
4890                    .storage_type
4891                    .get_or_insert_with(|| fidl::new_empty!(RepositoryStorageType, D));
4892                fidl::decode!(
4893                    RepositoryStorageType,
4894                    D,
4895                    val_ref,
4896                    decoder,
4897                    inner_offset,
4898                    inner_depth
4899                )?;
4900                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
4901                {
4902                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
4903                }
4904                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
4905                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
4906                }
4907            }
4908
4909            next_offset += envelope_size;
4910
4911            // Decode the remaining unknown envelopes.
4912            while next_offset < end_offset {
4913                _next_ordinal_to_read += 1;
4914                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
4915                next_offset += envelope_size;
4916            }
4917
4918            Ok(())
4919        }
4920    }
4921
4922    impl fidl::encoding::ValueTypeMarker for RepositoryKeyConfig {
4923        type Borrowed<'a> = &'a Self;
4924        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
4925            value
4926        }
4927    }
4928
4929    unsafe impl fidl::encoding::TypeMarker for RepositoryKeyConfig {
4930        type Owned = Self;
4931
4932        #[inline(always)]
4933        fn inline_align(_context: fidl::encoding::Context) -> usize {
4934            8
4935        }
4936
4937        #[inline(always)]
4938        fn inline_size(_context: fidl::encoding::Context) -> usize {
4939            16
4940        }
4941    }
4942
4943    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RepositoryKeyConfig, D>
4944        for &RepositoryKeyConfig
4945    {
4946        #[inline]
4947        unsafe fn encode(
4948            self,
4949            encoder: &mut fidl::encoding::Encoder<'_, D>,
4950            offset: usize,
4951            _depth: fidl::encoding::Depth,
4952        ) -> fidl::Result<()> {
4953            encoder.debug_check_bounds::<RepositoryKeyConfig>(offset);
4954            encoder.write_num::<u64>(self.ordinal(), offset);
4955            match self {
4956            RepositoryKeyConfig::Ed25519Key(ref val) => {
4957                fidl::encoding::encode_in_envelope::<fidl::encoding::UnboundedVector<u8>, D>(
4958                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow(val),
4959                    encoder, offset + 8, _depth
4960                )
4961            }
4962            RepositoryKeyConfig::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
4963        }
4964        }
4965    }
4966
4967    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RepositoryKeyConfig {
4968        #[inline(always)]
4969        fn new_empty() -> Self {
4970            Self::__SourceBreaking { unknown_ordinal: 0 }
4971        }
4972
4973        #[inline]
4974        unsafe fn decode(
4975            &mut self,
4976            decoder: &mut fidl::encoding::Decoder<'_, D>,
4977            offset: usize,
4978            mut depth: fidl::encoding::Depth,
4979        ) -> fidl::Result<()> {
4980            decoder.debug_check_bounds::<Self>(offset);
4981            #[allow(unused_variables)]
4982            let next_out_of_line = decoder.next_out_of_line();
4983            let handles_before = decoder.remaining_handles();
4984            let (ordinal, inlined, num_bytes, num_handles) =
4985                fidl::encoding::decode_union_inline_portion(decoder, offset)?;
4986
4987            let member_inline_size = match ordinal {
4988                1 => {
4989                    <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(
4990                        decoder.context,
4991                    )
4992                }
4993                0 => return Err(fidl::Error::UnknownUnionTag),
4994                _ => num_bytes as usize,
4995            };
4996
4997            if inlined != (member_inline_size <= 4) {
4998                return Err(fidl::Error::InvalidInlineBitInEnvelope);
4999            }
5000            let _inner_offset;
5001            if inlined {
5002                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
5003                _inner_offset = offset + 8;
5004            } else {
5005                depth.increment()?;
5006                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
5007            }
5008            match ordinal {
5009                1 => {
5010                    #[allow(irrefutable_let_patterns)]
5011                    if let RepositoryKeyConfig::Ed25519Key(_) = self {
5012                        // Do nothing, read the value into the object
5013                    } else {
5014                        // Initialize `self` to the right variant
5015                        *self = RepositoryKeyConfig::Ed25519Key(fidl::new_empty!(
5016                            fidl::encoding::UnboundedVector<u8>,
5017                            D
5018                        ));
5019                    }
5020                    #[allow(irrefutable_let_patterns)]
5021                    if let RepositoryKeyConfig::Ed25519Key(ref mut val) = self {
5022                        fidl::decode!(
5023                            fidl::encoding::UnboundedVector<u8>,
5024                            D,
5025                            val,
5026                            decoder,
5027                            _inner_offset,
5028                            depth
5029                        )?;
5030                    } else {
5031                        unreachable!()
5032                    }
5033                }
5034                #[allow(deprecated)]
5035                ordinal => {
5036                    for _ in 0..num_handles {
5037                        decoder.drop_next_handle()?;
5038                    }
5039                    *self = RepositoryKeyConfig::__SourceBreaking { unknown_ordinal: ordinal };
5040                }
5041            }
5042            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
5043                return Err(fidl::Error::InvalidNumBytesInEnvelope);
5044            }
5045            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
5046                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
5047            }
5048            Ok(())
5049        }
5050    }
5051}