fidl_fuchsia_web/

fidl_fuchsia_web.rs

// WARNING: This file is machine generated by fidlgen.

#![warn(clippy::all)]
#![allow(unused_parens, unused_mut, unused_imports, nonstandard_style)]

use bitflags::bitflags;
use fidl::client::QueryResponseFut;
use fidl::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
use fidl::endpoints::{ControlHandle as _, Responder as _};
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

pub type CookieName = String;

/// Unique identifier of a navigation. Can be used to correlate different phases for the
/// same navigation. Guaranteed to be unique for all navigations in the same [`Context`].
pub type NavigationId = u64;

pub type Url = String;

pub type UrlHostName = String;

pub type UrlSchemeAndHostName = String;

pub type UrlSchemeName = String;

pub const MAX_HEADERS_COUNT: i32 = 4096;

pub const MAX_HOST_LENGTH: i32 = 255;

pub const MAX_RULE_COUNT: i32 = 4096;

pub const MAX_SCHEME_AND_HOST_LENGTH: i32 = 513;

pub const MAX_URL_LENGTH: i32 = 65536;

pub const MAX_URL_SCHEME_NAME_LENGTH: i32 = 255;

bitflags! {
    /// Feature flags that allow augmenting Context behavior. Some features require additional services
    /// in the service directory provided during context initialization. See
    /// [`CreateContextParams.service_directory`].
    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct ContextFeatureFlags: u64 {
        /// Enables network access. Requires the following services:
        /// - [`fuchsia.net.interfaces/State`]
        /// - [`fuchsia.net.name/Lookup`]
        /// - [`fuchsia.posix.socket/Provider`]
        const NETWORK = 1;
        /// Enables audio input and output. Requires the following services:
        /// - [`fuchsia.media/Audio`]
        /// - [`fuchsia.media/AudioDeviceEnumerator`]
        /// - [`fuchsia.media/SessionAudioConsumerFactory`]
        const AUDIO = 2;
        /// Enables GPU-accelerated rendering of the web content. Requires the following services:
        /// - [`fuchsia.vulkan.loader/Loader`]
        /// The following service is required in order to collect Vulkan trace data.
        /// - [`fuchsia.tracing.provider.Registry`]
        const VULKAN = 4;
        /// Enables hardware video decoding.
        /// [`ContextFeatureFlags.VULKAN`] must be enabled as well.
        /// Requires the following service:
        /// - [`fuchsia.mediacodec/CodecFactory`]
        const HARDWARE_VIDEO_DECODER = 8;
        /// Disables video codecs that cannot be decoded in hardware.
        /// Software decoders will only be used as fallbacks for hardware decoders, such as when
        /// insufficient resources are available.
        /// Requires [`ContextFeatureFlags.HARDWARE_VIDEO_DECODER`].
        const HARDWARE_VIDEO_DECODER_ONLY = 16;
        /// Enables Widevine CDM modules for EME API.
        /// [`ContextFeatureFlags.VULKAN`] must be enabled as well.
        /// Requires [`fuchsia.media.drm/Widevine`] service. Requires that a `cdm_data_directory` be
        /// specified in [`CreateContextParams`].
        const WIDEVINE_CDM = 32;
        /// Allows embedders to render web content without graphical output or Scenic.
        /// Not compatible with [`ContextFeatureFlags.VULKAN`].
        const HEADLESS = 64;
        /// Report telemetry data to the [`fuchsia.legacymetrics/MetricsRecorder`].
        const LEGACYMETRICS = 128;
        /// Enables input events for keyboard keypresses.
        /// Requires [`fuchsia.ui.input3/Keyboard`], from which the events are obtained.
        const KEYBOARD = 256;
        /// Enables the use of onscreen virtual keyboards. The implementation will manage the state of
        /// the keyboard in response to input/focus events in web content.
        /// Requires the [`fuchsia.input.virtualkeyboard/ControllerCreator`] service and
        /// [`ContextFeatureFlags.KEYBOARD`].
        const VIRTUAL_KEYBOARD = 512;
        /// Disables dynamic generation of machine-code from scripts (e.g. JavaScript) and other
        /// technologies (e.g. WebAssembly). This should typically result in scripts being executed
        /// by an interpreter, with associated loss in performance. Other technologies relying on
        /// dynamic code generation may be provided in a limited form where feasible, or unavailable
        /// if interpreting would render them unusable (as is likely the case for WebAssembly).
        /// [`fuchsia.kernel/VmexResource`] is not required if this option is set.
        const DISABLE_DYNAMIC_CODE_GENERATION = 1024;
    }
}

impl ContextFeatureFlags {
    #[deprecated = "Strict bits should not use `has_unknown_bits`"]
    #[inline(always)]
    pub fn has_unknown_bits(&self) -> bool {
        false
    }

    #[deprecated = "Strict bits should not use `get_unknown_bits`"]
    #[inline(always)]
    pub fn get_unknown_bits(&self) -> u64 {
        0
    }
}

bitflags! {
    /// Identifies the types of input events which may be handled by a View.
    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct InputTypes: u64 {
        /// Keyboard events.
        const KEY = 1;
        /// Mouse button events, for any button.
        const MOUSE_CLICK = 2;
        /// Mouse scroll wheel events.
        const MOUSE_WHEEL = 4;
        /// Mouse movement events.
        const MOUSE_MOVE = 8;
        /// Single tapping with one finger.
        const GESTURE_TAP = 16;
        /// Pinching (for zooming).
        const GESTURE_PINCH = 32;
        /// Dragging a finger (for scrolling).
        const GESTURE_DRAG = 64;
        /// Matches all input types.
        const ALL = 9223372036854775808;
    }
}

impl InputTypes {
    #[deprecated = "Strict bits should not use `has_unknown_bits`"]
    #[inline(always)]
    pub fn has_unknown_bits(&self) -> bool {
        false
    }

    #[deprecated = "Strict bits should not use `get_unknown_bits`"]
    #[inline(always)]
    pub fn get_unknown_bits(&self) -> u64 {
        0
    }
}

bitflags! {
    /// Flags clients can set when connecting a [`NavigationEventListener`] to indicates interest in
    /// optional features.
    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct NavigationEventListenerFlags: u64 {
        /// Enables `favicon` field in [`NavigationState`].
        const FAVICON = 1;
    }
}

impl NavigationEventListenerFlags {
    #[deprecated = "Strict bits should not use `has_unknown_bits`"]
    #[inline(always)]
    pub fn has_unknown_bits(&self) -> bool {
        false
    }

    #[deprecated = "Strict bits should not use `get_unknown_bits`"]
    #[inline(always)]
    pub fn get_unknown_bits(&self) -> u64 {
        0
    }
}

bitflags! {
    /// Identifies a navigation phase.
    #[derive(Clone, Copy, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct NavigationPhase: u32 {
        /// Navigation is being started.
        const START = 1;
        /// Navigation was redirected.
        const REDIRECT = 2;
        /// Navigation response is being processed. At this point navigation hasn't been committed
        /// yet, so it is not too late to cancel it.
        const PROCESS_RESPONSE = 4;
        /// Navigation has failed.
        const FAIL = 8;
    }
}

impl NavigationPhase {
    #[deprecated = "Strict bits should not use `has_unknown_bits`"]
    #[inline(always)]
    pub fn has_unknown_bits(&self) -> bool {
        false
    }

    #[deprecated = "Strict bits should not use `get_unknown_bits`"]
    #[inline(always)]
    pub fn get_unknown_bits(&self) -> u32 {
        0
    }
}

/// Controls whether [`Frame.ConfigureInputTypes()`] should allow or deny processing of the
/// specified [`InputTypes`].
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(i32)]
pub enum AllowInputState {
    Allow = 1,
    Deny = 2,
}

impl AllowInputState {
    #[inline]
    pub fn from_primitive(prim: i32) -> Option<Self> {
        match prim {
            1 => Some(Self::Allow),
            2 => Some(Self::Deny),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> i32 {
        self as i32
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

/// Specifies the policy for automatic (non user-initiated) playback of video and audio content.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(i32)]
pub enum AutoplayPolicy {
    /// All media is permitted to autoplay.
    Allow = 1,
    /// Allow autoplay when the document has received a user activation. This can be the result of
    /// user action or [`LoadUrlParams.was_user_activated`] being set.
    RequireUserActivation = 2,
}

impl AutoplayPolicy {
    #[inline]
    pub fn from_primitive(prim: i32) -> Option<Self> {
        match prim {
            1 => Some(Self::Allow),
            2 => Some(Self::RequireUserActivation),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> i32 {
        self as i32
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(i32)]
pub enum ConsoleLogLevel {
    /// No logging.
    None = 100,
    /// Outputs messages from `console.debug()` and above levels.
    Debug = -1,
    /// Outputs messages from `console.log()`, `console.info()` and above levels.
    Info = 0,
    /// Outputs messages from `console.warn()` and `console.error()`.
    Warn = 1,
    /// Outputs messages from `console.error()`.
    Error = 2,
}

impl ConsoleLogLevel {
    #[inline]
    pub fn from_primitive(prim: i32) -> Option<Self> {
        match prim {
            100 => Some(Self::None),
            -1 => Some(Self::Debug),
            0 => Some(Self::Info),
            1 => Some(Self::Warn),
            2 => Some(Self::Error),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> i32 {
        self as i32
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(i32)]
pub enum ContextError {
    /// The remote debugging service was not opened.
    RemoteDebuggingPortNotOpened = 1,
}

impl ContextError {
    #[inline]
    pub fn from_primitive(prim: i32) -> Option<Self> {
        match prim {
            1 => Some(Self::RemoteDebuggingPortNotOpened),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> i32 {
        self as i32
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

/// Indicates the reason for the error when `page_type` is set to [`PageType.ERROR`].
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum ErrorDetail {
    /// Page has failed to load. No content is rendered.
    LoadFailed,
    /// Tried to navigate to a site blocked by the explicit content filter. The corresponding
    /// error page is rendered, see
    /// [`CreateFrameParams.explicit_sites_filter_error_page`].
    ExplicitContentBlocked,
    /// The renderer process has crashed. No content is rendered.
    Crash,
    #[doc(hidden)]
    __SourceBreaking { unknown_ordinal: u32 },
}

/// Pattern that matches an unknown `ErrorDetail` member.
#[macro_export]
macro_rules! ErrorDetailUnknown {
    () => {
        _
    };
}

impl ErrorDetail {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::LoadFailed),
            1 => Some(Self::ExplicitContentBlocked),
            2 => Some(Self::Crash),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
        match prim {
            0 => Self::LoadFailed,
            1 => Self::ExplicitContentBlocked,
            2 => Self::Crash,
            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
        }
    }

    #[inline]
    pub fn unknown() -> Self {
        Self::__SourceBreaking { unknown_ordinal: 0xffffffff }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        match self {
            Self::LoadFailed => 0,
            Self::ExplicitContentBlocked => 1,
            Self::Crash => 2,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

    #[inline]
    pub fn is_unknown(&self) -> bool {
        match self {
            Self::__SourceBreaking { unknown_ordinal: _ } => true,
            _ => false,
        }
    }
}

/// Represents the return status of a [`Frame`] method.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(i32)]
pub enum FrameError {
    /// An internal error occurred.
    InternalError = 1,
    /// The provided buffer is not UTF-8 encoded.
    BufferNotUtf8 = 2,
    /// The Frame's URL does not match any of the origins provided by the caller.
    InvalidOrigin = 3,
    /// The required `data` property is missing from a [`WebMessage`].
    NoDataInMessage = 4,
}

impl FrameError {
    #[inline]
    pub fn from_primitive(prim: i32) -> Option<Self> {
        match prim {
            1 => Some(Self::InternalError),
            2 => Some(Self::BufferNotUtf8),
            3 => Some(Self::InvalidOrigin),
            4 => Some(Self::NoDataInMessage),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> i32 {
        self as i32
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

/// Characterizes the origin of a [`NavigationController.LoadUrl`] request.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum LoadUrlReason {
    /// Navigation was initiated by the user following a link.
    Link = 0,
    /// Navigation was initiated by a user-provided URL.
    Typed = 1,
}

impl LoadUrlReason {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::Link),
            1 => Some(Self::Typed),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

/// Represents the return status of a [`NavigationController`] method.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(i32)]
pub enum NavigationControllerError {
    /// The provided URL is invalid.
    InvalidUrl = 1,
    /// At least one of the provided headers was invalid.
    InvalidHeader = 2,
}

impl NavigationControllerError {
    #[inline]
    pub fn from_primitive(prim: i32) -> Option<Self> {
        match prim {
            1 => Some(Self::InvalidUrl),
            2 => Some(Self::InvalidHeader),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> i32 {
        self as i32
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

/// Characterizes the page type in a [`NavigationState`].
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum PageType {
    /// Regular web page.
    Normal = 0,
    /// Error page.
    Error = 1,
}

impl PageType {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::Normal),
            1 => Some(Self::Error),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

/// A state for a web permission.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u8)]
pub enum PermissionState {
    /// Permission is denied.
    Denied = 1,
    /// Permission is granted.
    Granted = 2,
}

impl PermissionState {
    #[inline]
    pub fn from_primitive(prim: u8) -> Option<Self> {
        match prim {
            1 => Some(Self::Denied),
            2 => Some(Self::Granted),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u8 {
        self as u8
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

/// Identifies a type of permission that may be granted to a web origin.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u16)]
pub enum PermissionType {
    /// Permission to access microphone(s).
    Microphone = 1,
    /// Permission to access camera(s).
    Camera = 2,
    /// Permission to use device identifier(s) for EME.
    ProtectedMediaIdentifier = 3,
    /// Permission to use persistent storage.
    PersistentStorage = 4,
}

impl PermissionType {
    #[inline]
    pub fn from_primitive(prim: u16) -> Option<Self> {
        match prim {
            1 => Some(Self::Microphone),
            2 => Some(Self::Camera),
            3 => Some(Self::ProtectedMediaIdentifier),
            4 => Some(Self::PersistentStorage),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u16 {
        self as u16
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

/// Characterizes the type of reload.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(u32)]
pub enum ReloadType {
    /// Reloads the current entry, bypassing the cache for the main resource.
    PartialCache = 0,
    /// Reloads the current entry, bypassing the cache entirely.
    NoCache = 1,
}

impl ReloadType {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::PartialCache),
            1 => Some(Self::NoCache),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> u32 {
        self as u32
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
#[repr(i32)]
pub enum UrlRequestAction {
    /// Allow the request to be processed.
    Allow = 1,
    /// Block the request.
    Deny = 2,
}

impl UrlRequestAction {
    #[inline]
    pub fn from_primitive(prim: i32) -> Option<Self> {
        match prim {
            1 => Some(Self::Allow),
            2 => Some(Self::Deny),
            _ => None,
        }
    }

    #[inline]
    pub const fn into_primitive(self) -> i32 {
        self as i32
    }

    #[deprecated = "Strict enums should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ContextCreateFrameRequest {
    pub frame: fidl::endpoints::ServerEnd<FrameMarker>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ContextCreateFrameRequest {}

#[derive(Debug, PartialEq)]
pub struct ContextCreateFrameWithParamsRequest {
    pub params: CreateFrameParams,
    pub frame: fidl::endpoints::ServerEnd<FrameMarker>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for ContextCreateFrameWithParamsRequest
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct ContextGetCookieManagerRequest {
    pub manager: fidl::endpoints::ServerEnd<CookieManagerMarker>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for ContextGetCookieManagerRequest
{
}

#[derive(Debug, PartialEq)]
pub struct ContextProviderCreateRequest {
    pub params: CreateContextParams,
    pub context: fidl::endpoints::ServerEnd<ContextMarker>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for ContextProviderCreateRequest
{
}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct ContextGetRemoteDebuggingPortResponse {
    pub port: u16,
}

impl fidl::Persistable for ContextGetRemoteDebuggingPortResponse {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CookieManagerGetCookieListRequest {
    pub url: Option<String>,
    pub name: Option<String>,
    pub cookies: fidl::endpoints::ServerEnd<CookiesIteratorMarker>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for CookieManagerGetCookieListRequest
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct CookieManagerObserveCookieChangesRequest {
    pub url: Option<String>,
    pub name: Option<String>,
    pub changes: fidl::endpoints::ServerEnd<CookiesIteratorMarker>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for CookieManagerObserveCookieChangesRequest
{
}

#[derive(Debug, PartialEq)]
pub struct CookiesIteratorGetNextResponse {
    pub changed_cookies: Vec<Cookie>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for CookiesIteratorGetNextResponse
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DebugEnableDevToolsRequest {
    pub listener: fidl::endpoints::ClientEnd<DevToolsListenerMarker>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for DebugEnableDevToolsRequest
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct DevToolsListenerOnContextDevToolsAvailableRequest {
    pub listener: fidl::endpoints::ServerEnd<DevToolsPerContextListenerMarker>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for DevToolsListenerOnContextDevToolsAvailableRequest
{
}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct DevToolsPerContextListenerOnHttpPortOpenRequest {
    pub port: u16,
}

impl fidl::Persistable for DevToolsPerContextListenerOnHttpPortOpenRequest {}

#[derive(Debug, PartialEq)]
pub struct FrameAddBeforeLoadJavaScriptRequest {
    pub id: u64,
    pub origins: Vec<String>,
    pub script: fidl_fuchsia_mem::Buffer,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for FrameAddBeforeLoadJavaScriptRequest
{
}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FrameConfigureInputTypesRequest {
    pub types: InputTypes,
    pub allow: AllowInputState,
}

impl fidl::Persistable for FrameConfigureInputTypesRequest {}

#[derive(Debug, PartialEq)]
pub struct FrameCreateView2Request {
    pub args: CreateView2Args,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for FrameCreateView2Request {}

#[derive(Debug, PartialEq)]
pub struct FrameCreateViewRequest {
    pub view_token: fidl_fuchsia_ui_views::ViewToken,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for FrameCreateViewRequest {}

#[derive(Debug, PartialEq)]
pub struct FrameCreateViewWithViewRefRequest {
    pub view_token: fidl_fuchsia_ui_views::ViewToken,
    pub view_ref_control: fidl_fuchsia_ui_views::ViewRefControl,
    pub view_ref: fidl_fuchsia_ui_views::ViewRef,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for FrameCreateViewWithViewRefRequest
{
}

#[derive(Debug, PartialEq)]
pub struct FrameExecuteJavaScriptNoResultRequest {
    pub origins: Vec<String>,
    pub script: fidl_fuchsia_mem::Buffer,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for FrameExecuteJavaScriptNoResultRequest
{
}

#[derive(Debug, PartialEq)]
pub struct FrameExecuteJavaScriptRequest {
    pub origins: Vec<String>,
    pub script: fidl_fuchsia_mem::Buffer,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for FrameExecuteJavaScriptRequest
{
}

#[derive(Clone, Debug, PartialEq)]
pub struct FrameForceContentDimensionsRequest {
    pub web_dips: Option<Box<fidl_fuchsia_ui_gfx::Vec2>>,
}

impl fidl::Persistable for FrameForceContentDimensionsRequest {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FrameGetMediaPlayerRequest {
    pub player: fidl::endpoints::ServerEnd<fidl_fuchsia_media_sessions2::PlayerMarker>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for FrameGetMediaPlayerRequest
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FrameGetNavigationControllerRequest {
    pub controller: fidl::endpoints::ServerEnd<NavigationControllerMarker>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for FrameGetNavigationControllerRequest
{
}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct FrameGetPrivateMemorySizeResponse {
    pub size_bytes: u64,
}

impl fidl::Persistable for FrameGetPrivateMemorySizeResponse {}

#[derive(Debug, PartialEq)]
pub struct FrameHostCreateFrameWithParamsRequest {
    pub params: CreateFrameParams,
    pub frame: fidl::endpoints::ServerEnd<FrameMarker>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for FrameHostCreateFrameWithParamsRequest
{
}

#[derive(Debug, PartialEq)]
pub struct FramePostMessageRequest {
    pub target_origin: String,
    pub message: WebMessage,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for FramePostMessageRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(C)]
pub struct FrameRemoveBeforeLoadJavaScriptRequest {
    pub id: u64,
}

impl fidl::Persistable for FrameRemoveBeforeLoadJavaScriptRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FrameSetBlockMediaLoadingRequest {
    pub blocked: bool,
}

impl fidl::Persistable for FrameSetBlockMediaLoadingRequest {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FrameSetConsoleLogSinkRequest {
    pub sink: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_logger::LogSinkMarker>>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for FrameSetConsoleLogSinkRequest
{
}

#[derive(Clone, Debug, PartialEq)]
pub struct FrameSetContentAreaSettingsRequest {
    pub settings: ContentAreaSettings,
}

impl fidl::Persistable for FrameSetContentAreaSettingsRequest {}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FrameSetJavaScriptLogLevelRequest {
    pub level: ConsoleLogLevel,
}

impl fidl::Persistable for FrameSetJavaScriptLogLevelRequest {}

#[derive(Clone, Debug, PartialEq)]
pub struct FrameSetMediaSettingsRequest {
    pub settings: FrameMediaSettings,
}

impl fidl::Persistable for FrameSetMediaSettingsRequest {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FrameSetNavigationEventListener2Request {
    pub listener: Option<fidl::endpoints::ClientEnd<NavigationEventListenerMarker>>,
    pub flags: NavigationEventListenerFlags,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for FrameSetNavigationEventListener2Request
{
}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FrameSetNavigationEventListenerRequest {
    pub listener: Option<fidl::endpoints::ClientEnd<NavigationEventListenerMarker>>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for FrameSetNavigationEventListenerRequest
{
}

#[derive(Debug, PartialEq)]
pub struct FrameSetNavigationPolicyProviderRequest {
    pub params: NavigationPolicyProviderParams,
    pub provider: fidl::endpoints::ClientEnd<NavigationPolicyProviderMarker>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for FrameSetNavigationPolicyProviderRequest
{
}

#[derive(Clone, Debug, PartialEq)]
pub struct FrameSetPermissionStateRequest {
    pub permission: PermissionDescriptor,
    pub web_origin: String,
    pub state: PermissionState,
}

impl fidl::Persistable for FrameSetPermissionStateRequest {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct FrameSetPopupFrameCreationListenerRequest {
    pub listener: Option<fidl::endpoints::ClientEnd<PopupFrameCreationListenerMarker>>,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for FrameSetPopupFrameCreationListenerRequest
{
}

#[derive(Clone, Debug, PartialEq)]
pub struct FrameSetUrlRequestRewriteRulesRequest {
    pub rules: Vec<UrlRequestRewriteRule>,
}

impl fidl::Persistable for FrameSetUrlRequestRewriteRulesRequest {}

#[derive(Debug, PartialEq)]
pub struct FrameExecuteJavaScriptResponse {
    pub result: fidl_fuchsia_mem::Buffer,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for FrameExecuteJavaScriptResponse
{
}

#[derive(Debug, PartialEq)]
pub struct MessagePortPostMessageRequest {
    pub message: WebMessage,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for MessagePortPostMessageRequest
{
}

#[derive(Debug, PartialEq)]
pub struct MessagePortReceiveMessageResponse {
    pub message: WebMessage,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for MessagePortReceiveMessageResponse
{
}

#[derive(Debug, PartialEq)]
pub struct NavigationControllerLoadUrlRequest {
    pub url: String,
    pub params: LoadUrlParams,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for NavigationControllerLoadUrlRequest
{
}

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NavigationControllerReloadRequest {
    pub type_: ReloadType,
}

impl fidl::Persistable for NavigationControllerReloadRequest {}

#[derive(Debug, PartialEq)]
pub struct NavigationEventListenerOnNavigationStateChangedRequest {
    pub change: NavigationState,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for NavigationEventListenerOnNavigationStateChangedRequest
{
}

#[derive(Clone, Debug, PartialEq)]
pub struct NavigationPolicyProviderEvaluateRequestedNavigationRequest {
    pub requested_navigation: RequestedNavigation,
}

impl fidl::Persistable for NavigationPolicyProviderEvaluateRequestedNavigationRequest {}

#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NavigationPolicyProviderEvaluateRequestedNavigationResponse {
    pub decision: NavigationDecision,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for NavigationPolicyProviderEvaluateRequestedNavigationResponse
{
}

/// Empty struct used in NavigationDecision for actions that don't hav any arguments.
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct NoArgumentsAction;

impl fidl::Persistable for NoArgumentsAction {}

#[derive(Debug, PartialEq)]
pub struct PopupFrameCreationListenerOnPopupFrameCreatedRequest {
    pub frame: fidl::endpoints::ClientEnd<FrameMarker>,
    pub info: PopupFrameCreationInfo,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect>
    for PopupFrameCreationListenerOnPopupFrameCreatedRequest
{
}

/// Settings for the web content in the Frame. Popup Frames created by the Frame will have their
/// settings initialized to the Frame's current settings.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ContentAreaSettings {
    /// Specifies whether scrollbars are hidden for the Frame. If omitted, the default is false.
    pub hide_scrollbars: Option<bool>,
    /// Specifies the autoplay policy for the Frame. If omitted, the default policy is
    /// `REQUIRE_USER_ACTIVATION`.
    pub autoplay_policy: Option<AutoplayPolicy>,
    /// Specifies the color theme reported to web content via the `prefers-color-scheme` media
    /// query.
    /// Valid inputs are `LIGHT`, `DARK`, and `DEFAULT`. If omitted, the default is LIGHT theme.
    /// Specifying `DEFAULT` means using the system settings, and requires that the [`Context`] have
    /// the [`fuchsia.settings.Display`] service. If the service is not available, the [`Frame`]
    /// will disconnect with `ZX_ERR_INVALID_ARGS`.
    pub theme: Option<fidl_fuchsia_settings::ThemeType>,
    /// Sets scale factor (zoom level) that should be applied to web content rendered in this
    /// frame. Values above 1.0 make all web content (including text and images) larger, while
    /// values below 1.0 will make it smaller. In other words, values above 1.0 are used to zoom in
    /// and values below 1.0 zoom out. The overall ratio between physical pixel and CSS pixel is a
    /// product of the scale set with this method and the scale provided by Scenic (see
    /// [`fuchsia.ui.gfx.Metrics`]). That product is visible to the web content as
    /// `window.devicePixelRatio`. If omitted, the default is 1.0.
    ///
    /// This setting does not have any effect on the size of the view on the screen and the
    /// resolution at which the view is rendered. Native (non-web) UI elements, such as default
    /// scroll bars and default mouse cursor, are not scaled. User may zoom the page further when
    /// pinch-zoom is enabled (see [`InputTypes.GESTURE_PINCH`]).
    pub page_scale: Option<f32>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for ContentAreaSettings {}

/// Defines a provider which hosts resources from a [`fuchsia.io/Directory`]. Content can `GET`
/// resource files via the provider, but not enumerate directories. Resources can be accessed by
/// their URLs: `fuchsia-dir://<provider-name>/<path/to/resource>`
///
/// By default the MIME types of files are determined automatically by "sniffing" the contents of
/// the files. No content encoding will be declared, which browsers will interpret as meaning
/// `"text/plain"`.
///
/// Content type and encoding metadata may optionally be specified explicitly by metadata files,
/// which reside alongside the file. Metadata is expressed in JSON files, named after the files
/// they describe with a `"._metadata"` suffix.
///
/// For example, the file `"index.html"` would have the a metadata file called
/// `"index.html._metadata"`, with the following contents:
/// ```
/// {
///   "charset": "utf-8",
///   "mime": "text/html"
/// }
/// ```
#[derive(Debug, Default, PartialEq)]
pub struct ContentDirectoryProvider {
    /// Name of the provider. Must be non-empty and composed solely of alphanumerics, dots, and
    /// dashes.
    pub name: Option<String>,
    /// Directory containing the files served by this provider.
    pub directory: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for ContentDirectoryProvider {}

#[derive(Debug, Default, PartialEq)]
pub struct Cookie {
    /// A table with fields to identify a cookie.
    pub id: Option<CookieId>,
    /// The cookie value.
    /// RFC6265 does not specify an upper limit on cookie size, but recommends
    /// that at least 4096 bytes are supported.
    pub value: Option<String>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for Cookie {}

#[derive(Clone, Debug, Default, PartialEq)]
pub struct CookieId {
    /// An RFC2616 "token" chosen by the site to identify the cookie.
    pub name: Option<String>,
    /// The RFC1034 "subdomain" to which this cookie is scoped.
    /// e.g. "example.com" allows access from all *.example.com sub-domains.
    pub domain: Option<String>,
    /// The URL "path" prefix to which this cookie is scoped.
    /// e.g. "/" allows access from all paths.
    pub path: Option<String>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for CookieId {}

/// Parameters specifying the configuration for a new [`Context`].
#[derive(Debug, Default, PartialEq)]
pub struct CreateContextParams {
    /// Service directory to be used by the context.
    ///
    /// The following services must be present in the service directory:
    ///
    /// - [`fuchsia.buildinfo/Provider`]
    /// - [`fuchsia.device/NameProvider`]
    /// - [`fuchsia.fonts/Provider`]
    /// - [`fuchsia.hwinfo.Product`]
    /// - [`fuchsia.intl/PropertyProvider`]
    /// - [`fuchsia.kernel/VmexResource`] (unless [`ContextFeatureFlags.DISABLE_DYNAMIC_CODE_GENERATION`] is set)
    /// - [`fuchsia.logger/LogSink`]
    /// - [`fuchsia.memorypressure/Provider`]
    /// - [`fuchsia.process/Launcher`]
    /// - [`fuchsia.sysmem/Allocator`]
    ///
    /// The following services are recommended to be present in order to allow CPU scheduling
    /// profiles to be applied to threads to tune their performance, especially for media rendering.
    /// - [`fuchsia.media.ProfileProvider`] (requirement will be removed in 2025)
    /// - [`fuchsia.scheduler.RoleManager`]
    ///
    /// The following services must be present in order to render web content in a Scenic view
    /// using [`Frame.CreateView`], [`Frame.CreateViewWithViewRef`] or [`Frame.CreateView2`]]:
    /// - [`fuchsia.accessibility.semantics/SemanticsManager`]
    /// - [`fuchsia.ui.composition/Allocator`]
    /// - [`fuchsia.ui.composition/Flatland`]
    /// - [`fuchsia.ui.scenic/Scenic`]
    ///
    /// The following service must be present in order to collect diagnostic tracing data.
    /// - [`fuchsia.tracing.perfetto.ProducerConnector`]
    pub service_directory: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>>,
    /// Handle to the directory that will contain the [`Context`]'s persistent data. If it is left
    /// unset, then the created [`Context`] will be stateless, with all of its data discarded upon
    /// [`Context`] destruction.
    ///
    /// If set, `data_directory` must not be shared with any other [`Context`].
    pub data_directory: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>>,
    /// Optional string describing the embedding product to append to the User-Agent string.
    /// See the specification for the
    /// [HTTP User-Agent header](https://tools.ietf.org/html/rfc7231#section-5.5.3).
    /// Requires that `user_agent_version` is also specified.
    pub user_agent_product: Option<String>,
    /// Optional version for the embedding product to append to the User-Agent string.
    ///
    /// Requires that `user_agent_product` is also specified.
    pub user_agent_version: Option<String>,
    /// Enables Frames to be created with remote debugging enabled using the DevTools protocol. If
    /// `port` is 0, then an ephemeral port will be used, which can be queried via the
    /// [`Context.GetRemoteDebuggingPort`] API.
    ///
    /// Because remote debugging uses TCP, it is not valid to set a remote
    /// debugging port without having also set [`ContextFeatureFlags.NETWORK`]
    /// for the context.
    pub remote_debugging_port: Option<u16>,
    /// List of providers whose contents will be served by `fuchsia-dir://` URLs.
    pub content_directories: Option<Vec<ContentDirectoryProvider>>,
    /// Optional features that should be enabled for this context. Some features may also require
    /// additional services in `service_directory`.
    pub features: Option<ContextFeatureFlags>,
    /// Enables PlayReady CDM for the Context using the specified string as a key system
    /// string. The string should be a reverse domain name, as required by
    /// [EME API](https://www.w3.org/TR/encrypted-media/#key-system).
    ///
    /// - Requires [`fuchsia.media.drm/PlayReady`] service.
    /// - Requires that a `cdm_data_directory` be specified in [`CreateContextParams`].
    pub playready_key_system: Option<String>,
    /// Treat given insecure origins as secure origins. For the definition of secure contexts, see
    /// [Secure Contexts](https://w3c.github.io/webappsec-secure-contexts/) and
    /// [origin trustworthiness](https://www.w3.org/TR/powerful-features/#is-origin-trustworthy).
    ///
    /// Example value: `{"http://a.com", "http://b.com"}`.
    pub unsafely_treat_insecure_origins_as_secure: Option<Vec<String>>,
    /// Specifies a set of header names for which [Cross-Origin Resource Sharing
    /// (CORS)](https://www.w3.org/TR/cors/) checks should not be enforced.
    pub cors_exempt_headers: Option<Vec<Vec<u8>>>,
    /// Specifies the storage to use to persistent content licensing related data (e.g.
    /// provisioning data, persistent session data). By default these data will be placed under the
    /// `data_directory`, if specified.
    ///
    /// If neither `data_directory` nor `cdm_data_directory` are specified, then content licensing
    /// features requiring persistent storage (e.g. persistent licensing sessions) will not be
    /// available to the [`Context`].
    ///
    /// Note that not all content licensing systems support persistent sessions, regardless of
    /// whether persistent storage is provided.
    pub cdm_data_directory: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>>,
    /// Specifies a target maximum size for `cdm_data_directory` contents, in bytes. If the amount
    /// of persisted CDM data exceeds this threshold, then the [`Context`] will attempt to purge
    /// some data to meet the specified quota.
    pub cdm_data_quota_bytes: Option<u64>,
    /// Specifies a target maximum size for `data_directory` contents, in bytes.
    /// The [`Context`] will attempt to limit browsing state (e.g. cookies, LocalStorage) to
    /// not exceed the specified size.
    pub data_quota_bytes: Option<u64>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for CreateContextParams {}

/// Parameters specifying the configuration for a new [`Frame`].
#[derive(Debug, Default, PartialEq)]
pub struct CreateFrameParams {
    /// Set to true to enable remote debugging. The [`Frame`] will be closed with
    /// `ERR_INVALID_ARGS` if `remote_debugging_port` was not set in
    /// [`CreateContextParams`].
    pub enable_remote_debugging: Option<bool>,
    /// Set to give the Frame a name to help distinguish it in debug contexts , such as system log
    /// output. For example, the name may be added to messages from web content when they are logged
    /// to the system logger. The name does not affect user- or web-visible behavior.
    /// Popup Frames created by the Frame will have a name derived from the parent Frame's name.
    pub debug_name: Option<String>,
    /// Enables automatic blocking of navigations to explicit sites, and specifies the error page
    /// content, in HTML, to be loaded in the Frame when a navigation is canceled by the filter.
    /// Applies to navigations in all frames within the Frame.
    /// When navigation of the main document is canceled, the Frame's [`NavigationState.PageType`]
    /// is `ERROR`.
    /// If set to an empty buffer, a default error message will be displayed.
    /// If set and such filtering is not supported, the [`Frame`] will disconnect with
    /// `ZX_ERR_NOT_SUPPORTED`.
    pub explicit_sites_filter_error_page: Option<fidl_fuchsia_mem::Data>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for CreateFrameParams {}

/// Args for Frame.CreateView2(), see above.
#[derive(Debug, Default, PartialEq)]
pub struct CreateView2Args {
    /// Non-optional. This token is provided to attach the client's Flatland view to the parent's
    /// viewport.
    pub view_creation_token: Option<fidl_fuchsia_ui_views::ViewCreationToken>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for CreateView2Args {}

/// Used to represent a favicon for a page. An empty table (all fields are unset) is used to indicate
/// that the page doesn't have a favicon.
#[derive(Debug, Default, PartialEq)]
pub struct Favicon {
    /// The image content encoded as an RGBA bitmap with premultiplied alpha channel. The data is
    /// densely packed, so the stride is always `4 * width` and the total size is
    /// `4 * width * height`.
    pub data: Option<fidl_fuchsia_mem::Buffer>,
    /// The width of the image.
    pub width: Option<u32>,
    /// The height of the image.
    pub height: Option<u32>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for Favicon {}

#[derive(Clone, Debug, Default, PartialEq)]
pub struct FrameCloseRequest {
    /// Optional.
    pub timeout: Option<i64>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for FrameCloseRequest {}

#[derive(Clone, Debug, Default, PartialEq)]
pub struct FrameMediaSettings {
    /// The [`fuchsia.media/AudioRenderUsage`] to set for every [`fuchsia.media/AudioRenderer`]
    /// instance created by the [`Frame`]. If not set, the usage is `COMMUNICATION` for WebRTC
    /// streams and `MEDIA` for all other streams.
    pub renderer_usage: Option<fidl_fuchsia_media::AudioRenderUsage>,
    /// When set, enables usage of [`fuchsia.media/AudioConsumer`] for audio playback. In that
    /// case the specified value is passed to [`fuchsia.media/SessionAudioConsumerFactory`].
    pub audio_consumer_session_id: Option<u64>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for FrameMediaSettings {}

/// Additional parameters for modifying the behavior of [`NavigationController.LoadUrl`].
#[derive(Debug, Default, PartialEq)]
pub struct LoadUrlParams {
    /// Provides a hint to the browser UI about how [`NavigationController.LoadUrl`] was triggered.
    pub type_: Option<LoadUrlReason>,
    /// The URL that linked to the resource being requested.
    pub referrer_url: Option<String>,
    /// Should be set to true to propagate user activation to the frame. User activation implies
    /// that the user is interacting with the web frame. It enables some web features that are not
    /// available otherwise. For example, autoplay will work only when this flag is set to true.
    pub was_user_activated: Option<bool>,
    /// Custom HTTP headers. RFC7540 does not specify a limit on the number nor
    /// size of headers.
    pub headers: Option<Vec<fidl_fuchsia_net_http::Header>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for LoadUrlParams {}

/// Used to specify which navigation events should be delegated to [`NavigationPolicyProvider`].
#[derive(Clone, Debug, Default, PartialEq)]
pub struct NavigationPolicyProviderParams {
    /// Specifies the set of navigation phases in the main frame that should be evaluated.
    pub main_frame_phases: Option<NavigationPhase>,
    /// Specifies the set of navigation phases in subframes that should be evaluated.
    pub subframe_phases: Option<NavigationPhase>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for NavigationPolicyProviderParams {}

/// Contains information about the [`Frame`]'s navigation state.
#[derive(Debug, Default, PartialEq)]
pub struct NavigationState {
    /// The page's URL.
    pub url: Option<String>,
    /// The user-visible page title. While W3C style recommendation is that HTML
    /// TITLE tags not exceed 64 characters in length, there is no actual limit.
    pub title: Option<String>,
    /// Indicates whether this was a navigation to an error page.
    pub page_type: Option<PageType>,
    /// Indicates if there is a following navigation.
    pub can_go_forward: Option<bool>,
    /// Indicates if there is a previous navigation.
    pub can_go_back: Option<bool>,
    /// Indicates that the main document's statically declared resources have been loaded.
    pub is_main_document_loaded: Option<bool>,
    /// Current favicon for the page. The field is set only when the `FAVICON` flag is set for the
    /// `NavigationEventListener` and the favicon has changed.
    pub favicon: Option<Favicon>,
    /// Indicates type of the error when `page_type` is set to `ERROR`.
    pub error_detail: Option<ErrorDetail>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for NavigationState {}

/// Describes a web permission. In the future, it may be extended with type-specific fields.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct PermissionDescriptor {
    pub type_: Option<PermissionType>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for PermissionDescriptor {}

/// Specifies additional information about a newly created popup frame.
#[derive(Debug, Default, PartialEq)]
pub struct PopupFrameCreationInfo {
    /// The URL to which the popup frame was initially navigated.
    pub initial_url: Option<String>,
    /// Set if the popup frame was created in response to UI interaction from the user (e.g. a
    /// link was clicked).
    pub initiated_by_user: Option<bool>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for PopupFrameCreationInfo {}

#[derive(Clone, Debug, Default, PartialEq)]
pub struct RequestedNavigation {
    /// Unique ID of the navigation.
    pub id: Option<u64>,
    /// Current navigation phase. Exactly one bit will be set.
    pub phase: Option<NavigationPhase>,
    /// Whether the navigation is taking place in the main frame versus in a subframe.
    pub is_main_frame: Option<bool>,
    /// Whether the navigation happened without changing the document.
    pub is_same_document: Option<bool>,
    /// Whether the navigation is a POST request.
    pub is_http_post: Option<bool>,
    /// The current target URL of the navigation. This may change for the same navigation after
    /// encountering a server redirect.
    pub url: Option<String>,
    /// Whether the navigation was initiated by a user gesture.
    pub has_gesture: Option<bool>,
    /// Whether the navigation has encountered a server redirect or not.
    pub was_server_redirect: Option<bool>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for RequestedNavigation {}

/// Adds `headers` to the URL request. If a header is already present in the original URL request,
/// it will be overwritten.
/// - `headers` must be set.
/// - Each [`fuchsia.net.http/Header`] in `headers` must have a valid HTTP header name and value,
///   per [RFC 7230 section  3.2](https://tools.ietf.org/html/rfc7230#section-3.2).
#[derive(Clone, Debug, Default, PartialEq)]
pub struct UrlRequestRewriteAddHeaders {
    pub headers: Option<Vec<fidl_fuchsia_net_http::Header>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for UrlRequestRewriteAddHeaders {}

/// Appends `query` to the URL's query. If the URL request already has a query, `query` will be
/// appended to it, preceded by `&`. Otherwise, the URL's query will be set to `query`.
/// - `query` must be set.
/// - `query` must be a valid [URL-query string](https://url.spec.whatwg.org/#url-query-string).
#[derive(Clone, Debug, Default, PartialEq)]
pub struct UrlRequestRewriteAppendToQuery {
    pub query: Option<String>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for UrlRequestRewriteAppendToQuery {}

/// If `query_pattern` is in the URL's query, removes `header_name` from the list of headers. If
/// `query_pattern` is not set, removes `header_name` from the list of headers unconditionally.
/// - `header_name` must be set.
/// - `header_name` must be a valid HTTP header name, per
///   [RFC 7230 section 3.2](https://tools.ietf.org/html/rfc7230#section-3.2).
#[derive(Clone, Debug, Default, PartialEq)]
pub struct UrlRequestRewriteRemoveHeader {
    pub query_pattern: Option<String>,
    pub header_name: Option<Vec<u8>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for UrlRequestRewriteRemoveHeader {}

/// If the URL in the URL request ends with `url_ends_with`, rewrites the URL to `new_url`.
/// - `url_ends_with` and `new_url` must be set.
/// - `url_ends_with` must be a valid
///   [path-relative-URL string](https://url.spec.whatwg.org/#path-relative-url-string).
/// - `new_url` must be a [valid URL string](https://url.spec.whatwg.org/#valid-url-string).
#[derive(Clone, Debug, Default, PartialEq)]
pub struct UrlRequestRewriteReplaceUrl {
    pub url_ends_with: Option<String>,
    pub new_url: Option<String>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for UrlRequestRewriteReplaceUrl {}

#[derive(Clone, Debug, Default, PartialEq)]
pub struct UrlRequestRewriteRule {
    /// Set of hosts to apply the rules to. If not set, the rule will apply to every request,
    /// independent of host.
    pub hosts_filter: Option<Vec<String>>,
    /// Set of schemes to apply the rules to. If not set, the rule will apply to every request,
    /// independent of scheme.
    pub schemes_filter: Option<Vec<String>>,
    /// URL request rewrites to apply.
    pub rewrites: Option<Vec<UrlRequestRewrite>>,
    /// Specifies the action to take for requests matching the filter criteria.
    /// Requests are allowed by default.
    pub action: Option<UrlRequestAction>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for UrlRequestRewriteRule {}

/// If `pattern` is found in the URL's query, replaces it with `substitution`.
/// - `pattern` and `substitution` must be set.
/// - `substitution` must be a valid
///   [URL-query string](https://url.spec.whatwg.org/#url-query-string).
#[derive(Clone, Debug, Default, PartialEq)]
pub struct UrlRequestRewriteSubstituteQueryPattern {
    pub pattern: Option<String>,
    pub substitution: Option<String>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for UrlRequestRewriteSubstituteQueryPattern {}

#[derive(Debug, Default, PartialEq)]
pub struct WebMessage {
    /// The message payload, encoded as an UTF-8 string. This is a required property.
    pub data: Option<fidl_fuchsia_mem::Buffer>,
    /// Optional list of objects transferred into the [`MessagePort`] from the FIDL client.
    pub incoming_transfer: Option<Vec<IncomingTransferable>>,
    /// Optional list of objects transferred out of the [`MessagePort`] to the FIDL client.
    pub outgoing_transfer: Option<Vec<OutgoingTransferable>>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for WebMessage {}

#[derive(Debug)]
pub enum IncomingTransferable {
    MessagePort(fidl::endpoints::ClientEnd<MessagePortMarker>),
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u64,
    },
}

/// Pattern that matches an unknown `IncomingTransferable` member.
#[macro_export]
macro_rules! IncomingTransferableUnknown {
    () => {
        _
    };
}

// Custom PartialEq so that unknown variants are not equal to themselves.
impl PartialEq for IncomingTransferable {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Self::MessagePort(x), Self::MessagePort(y)) => *x == *y,
            _ => false,
        }
    }
}

impl IncomingTransferable {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::MessagePort(_) => 1,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

    #[inline]
    pub fn unknown_variant_for_testing() -> Self {
        Self::__SourceBreaking { unknown_ordinal: 0 }
    }

    #[inline]
    pub fn is_unknown(&self) -> bool {
        match self {
            Self::__SourceBreaking { .. } => true,
            _ => false,
        }
    }
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for IncomingTransferable {}

/// Navigation action that should be taken in response to a navigation request. Returned from
/// [`NavigationPolicyProvider.EvaluateRequestedNavigation`].
#[derive(Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum NavigationDecision {
    /// Navigation should proceed normally.
    Proceed(NoArgumentsAction),
    /// Navigation should be aborted. The frame should stay on the current page.
    Abort(NoArgumentsAction),
}

impl NavigationDecision {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Proceed(_) => 1,
            Self::Abort(_) => 2,
        }
    }

    #[deprecated = "Strict unions should not use `is_unknown`"]
    #[inline]
    pub fn is_unknown(&self) -> bool {
        false
    }
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for NavigationDecision {}

#[derive(Debug)]
pub enum OutgoingTransferable {
    MessagePort(fidl::endpoints::ServerEnd<MessagePortMarker>),
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u64,
    },
}

/// Pattern that matches an unknown `OutgoingTransferable` member.
#[macro_export]
macro_rules! OutgoingTransferableUnknown {
    () => {
        _
    };
}

// Custom PartialEq so that unknown variants are not equal to themselves.
impl PartialEq for OutgoingTransferable {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Self::MessagePort(x), Self::MessagePort(y)) => *x == *y,
            _ => false,
        }
    }
}

impl OutgoingTransferable {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::MessagePort(_) => 1,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

    #[inline]
    pub fn unknown_variant_for_testing() -> Self {
        Self::__SourceBreaking { unknown_ordinal: 0 }
    }

    #[inline]
    pub fn is_unknown(&self) -> bool {
        match self {
            Self::__SourceBreaking { .. } => true,
            _ => false,
        }
    }
}

impl fidl::Standalone<fidl::encoding::DefaultFuchsiaResourceDialect> for OutgoingTransferable {}

#[derive(Clone, Debug)]
pub enum UrlRequestRewrite {
    /// Adds a set of headers to a URL request.
    AddHeaders(UrlRequestRewriteAddHeaders),
    /// Removes a header based on the presence of a pattern in the URL's query.
    RemoveHeader(UrlRequestRewriteRemoveHeader),
    /// Substitutes a pattern in the URL's query.
    SubstituteQueryPattern(UrlRequestRewriteSubstituteQueryPattern),
    /// Replaces a URL if the original URL ends with a pattern.
    ReplaceUrl(UrlRequestRewriteReplaceUrl),
    /// Appends to the URL's query.
    AppendToQuery(UrlRequestRewriteAppendToQuery),
    #[doc(hidden)]
    __SourceBreaking { unknown_ordinal: u64 },
}

/// Pattern that matches an unknown `UrlRequestRewrite` member.
#[macro_export]
macro_rules! UrlRequestRewriteUnknown {
    () => {
        _
    };
}

// Custom PartialEq so that unknown variants are not equal to themselves.
impl PartialEq for UrlRequestRewrite {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Self::AddHeaders(x), Self::AddHeaders(y)) => *x == *y,
            (Self::RemoveHeader(x), Self::RemoveHeader(y)) => *x == *y,
            (Self::SubstituteQueryPattern(x), Self::SubstituteQueryPattern(y)) => *x == *y,
            (Self::ReplaceUrl(x), Self::ReplaceUrl(y)) => *x == *y,
            (Self::AppendToQuery(x), Self::AppendToQuery(y)) => *x == *y,
            _ => false,
        }
    }
}

impl UrlRequestRewrite {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::AddHeaders(_) => 1,
            Self::RemoveHeader(_) => 2,
            Self::SubstituteQueryPattern(_) => 3,
            Self::ReplaceUrl(_) => 4,
            Self::AppendToQuery(_) => 5,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

    #[inline]
    pub fn unknown_variant_for_testing() -> Self {
        Self::__SourceBreaking { unknown_ordinal: 0 }
    }

    #[inline]
    pub fn is_unknown(&self) -> bool {
        match self {
            Self::__SourceBreaking { .. } => true,
            _ => false,
        }
    }
}

impl fidl::Persistable for UrlRequestRewrite {}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct ContextMarker;

impl fidl::endpoints::ProtocolMarker for ContextMarker {
    type Proxy = ContextProxy;
    type RequestStream = ContextRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ContextSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.web.Context";
}
impl fidl::endpoints::DiscoverableProtocolMarker for ContextMarker {}
pub type ContextGetRemoteDebuggingPortResult = Result<u16, ContextError>;

pub trait ContextProxyInterface: Send + Sync {
    fn r#create_frame(
        &self,
        frame: fidl::endpoints::ServerEnd<FrameMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#create_frame_with_params(
        &self,
        params: CreateFrameParams,
        frame: fidl::endpoints::ServerEnd<FrameMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#get_cookie_manager(
        &self,
        manager: fidl::endpoints::ServerEnd<CookieManagerMarker>,
    ) -> Result<(), fidl::Error>;
    type GetRemoteDebuggingPortResponseFut: std::future::Future<Output = Result<ContextGetRemoteDebuggingPortResult, fidl::Error>>
        + Send;
    fn r#get_remote_debugging_port(&self) -> Self::GetRemoteDebuggingPortResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ContextSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ContextSynchronousProxy {
    type Proxy = ContextProxy;
    type Protocol = ContextMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl ContextSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <ContextMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<ContextEvent, fidl::Error> {
        ContextEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Creates a new [`Frame`] under this [`Context`]. Destruction of a [`Context`] triggers the
    /// destruction of all of its associated [`Frame`]. [`Frame`] can be transferred to another
    /// component but cannot be shared across multiple components.
    ///
    /// - `frame`: An interface request that will be bound to the created [`Frame`].
    pub fn r#create_frame(
        &self,
        mut frame: fidl::endpoints::ServerEnd<FrameMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ContextCreateFrameRequest>(
            (frame,),
            0x5440a38db7cd7d8f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Similar to [`Context.CreateFrame`], with extra parameters.
    ///
    /// - `params`: The configuration used to create the [`Frame`].
    ///   This method will fail with `ZX_ERR_INVALID_ARGS` if the table is not clonable.
    /// - `frame`: An interface request that will be bound to the created [`Frame`].
    pub fn r#create_frame_with_params(
        &self,
        mut params: CreateFrameParams,
        mut frame: fidl::endpoints::ServerEnd<FrameMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ContextCreateFrameWithParamsRequest>(
            (&mut params, frame),
            0x2c968a330787be96,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Used to observe cookies for sites hosted under this Context.
    pub fn r#get_cookie_manager(
        &self,
        mut manager: fidl::endpoints::ServerEnd<CookieManagerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ContextGetCookieManagerRequest>(
            (manager,),
            0x7396cda568e3fca,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Waits until debugging is available on one or more Frames, and returns the DevTools port
    /// number. Multiple calls may be queued to received the port number.
    ///
    /// If an error occurred, the [`ContextError`] will be set to this value:
    /// - `REMOTE_DEBUGGING_PORT_NOT_OPENED`: `remote_debugging_port` was not set in
    ///   [`CreateContextParams`] or the remote debugging service failed to start.
    pub fn r#get_remote_debugging_port(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<ContextGetRemoteDebuggingPortResult, fidl::Error> {
        let _response =
            self.client.send_query::<fidl::encoding::EmptyPayload, fidl::encoding::ResultType<
                ContextGetRemoteDebuggingPortResponse,
                ContextError,
            >>(
                (),
                0x4ac6a26fe972f29,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.map(|x| x.port))
    }
}

#[derive(Debug, Clone)]
pub struct ContextProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for ContextProxy {
    type Protocol = ContextMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl ContextProxy {
    /// Create a new Proxy for fuchsia.web/Context.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ContextMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> ContextEventStream {
        ContextEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Creates a new [`Frame`] under this [`Context`]. Destruction of a [`Context`] triggers the
    /// destruction of all of its associated [`Frame`]. [`Frame`] can be transferred to another
    /// component but cannot be shared across multiple components.
    ///
    /// - `frame`: An interface request that will be bound to the created [`Frame`].
    pub fn r#create_frame(
        &self,
        mut frame: fidl::endpoints::ServerEnd<FrameMarker>,
    ) -> Result<(), fidl::Error> {
        ContextProxyInterface::r#create_frame(self, frame)
    }

    /// Similar to [`Context.CreateFrame`], with extra parameters.
    ///
    /// - `params`: The configuration used to create the [`Frame`].
    ///   This method will fail with `ZX_ERR_INVALID_ARGS` if the table is not clonable.
    /// - `frame`: An interface request that will be bound to the created [`Frame`].
    pub fn r#create_frame_with_params(
        &self,
        mut params: CreateFrameParams,
        mut frame: fidl::endpoints::ServerEnd<FrameMarker>,
    ) -> Result<(), fidl::Error> {
        ContextProxyInterface::r#create_frame_with_params(self, params, frame)
    }

    /// Used to observe cookies for sites hosted under this Context.
    pub fn r#get_cookie_manager(
        &self,
        mut manager: fidl::endpoints::ServerEnd<CookieManagerMarker>,
    ) -> Result<(), fidl::Error> {
        ContextProxyInterface::r#get_cookie_manager(self, manager)
    }

    /// Waits until debugging is available on one or more Frames, and returns the DevTools port
    /// number. Multiple calls may be queued to received the port number.
    ///
    /// If an error occurred, the [`ContextError`] will be set to this value:
    /// - `REMOTE_DEBUGGING_PORT_NOT_OPENED`: `remote_debugging_port` was not set in
    ///   [`CreateContextParams`] or the remote debugging service failed to start.
    pub fn r#get_remote_debugging_port(
        &self,
    ) -> fidl::client::QueryResponseFut<
        ContextGetRemoteDebuggingPortResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        ContextProxyInterface::r#get_remote_debugging_port(self)
    }
}

impl ContextProxyInterface for ContextProxy {
    fn r#create_frame(
        &self,
        mut frame: fidl::endpoints::ServerEnd<FrameMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ContextCreateFrameRequest>(
            (frame,),
            0x5440a38db7cd7d8f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#create_frame_with_params(
        &self,
        mut params: CreateFrameParams,
        mut frame: fidl::endpoints::ServerEnd<FrameMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ContextCreateFrameWithParamsRequest>(
            (&mut params, frame),
            0x2c968a330787be96,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#get_cookie_manager(
        &self,
        mut manager: fidl::endpoints::ServerEnd<CookieManagerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ContextGetCookieManagerRequest>(
            (manager,),
            0x7396cda568e3fca,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type GetRemoteDebuggingPortResponseFut = fidl::client::QueryResponseFut<
        ContextGetRemoteDebuggingPortResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#get_remote_debugging_port(&self) -> Self::GetRemoteDebuggingPortResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<ContextGetRemoteDebuggingPortResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<ContextGetRemoteDebuggingPortResponse, ContextError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x4ac6a26fe972f29,
            >(_buf?)?;
            Ok(_response.map(|x| x.port))
        }
        self.client.send_query_and_decode::<
            fidl::encoding::EmptyPayload,
            ContextGetRemoteDebuggingPortResult,
        >(
            (),
            0x4ac6a26fe972f29,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct ContextEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for ContextEventStream {}

impl futures::stream::FusedStream for ContextEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for ContextEventStream {
    type Item = Result<ContextEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(ContextEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum ContextEvent {}

impl ContextEvent {
    /// Decodes a message buffer as a [`ContextEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<ContextEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <ContextMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.web/Context.
pub struct ContextRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for ContextRequestStream {}

impl futures::stream::FusedStream for ContextRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for ContextRequestStream {
    type Protocol = ContextMarker;
    type ControlHandle = ContextControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        ContextControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for ContextRequestStream {
    type Item = Result<ContextRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled ContextRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))))
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x5440a38db7cd7d8f => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            ContextCreateFrameRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ContextCreateFrameRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ContextControlHandle { inner: this.inner.clone() };
                        Ok(ContextRequest::CreateFrame { frame: req.frame, control_handle })
                    }
                    0x2c968a330787be96 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            ContextCreateFrameWithParamsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ContextCreateFrameWithParamsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ContextControlHandle { inner: this.inner.clone() };
                        Ok(ContextRequest::CreateFrameWithParams {
                            params: req.params,
                            frame: req.frame,

                            control_handle,
                        })
                    }
                    0x7396cda568e3fca => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            ContextGetCookieManagerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ContextGetCookieManagerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ContextControlHandle { inner: this.inner.clone() };
                        Ok(ContextRequest::GetCookieManager {
                            manager: req.manager,

                            control_handle,
                        })
                    }
                    0x4ac6a26fe972f29 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = ContextControlHandle { inner: this.inner.clone() };
                        Ok(ContextRequest::GetRemoteDebuggingPort {
                            responder: ContextGetRemoteDebuggingPortResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <ContextMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Manages browsing state (e.g. LocalStorage, cookies, etc) associated with a set of [`Frame`].
#[derive(Debug)]
pub enum ContextRequest {
    /// Creates a new [`Frame`] under this [`Context`]. Destruction of a [`Context`] triggers the
    /// destruction of all of its associated [`Frame`]. [`Frame`] can be transferred to another
    /// component but cannot be shared across multiple components.
    ///
    /// - `frame`: An interface request that will be bound to the created [`Frame`].
    CreateFrame {
        frame: fidl::endpoints::ServerEnd<FrameMarker>,
        control_handle: ContextControlHandle,
    },
    /// Similar to [`Context.CreateFrame`], with extra parameters.
    ///
    /// - `params`: The configuration used to create the [`Frame`].
    ///   This method will fail with `ZX_ERR_INVALID_ARGS` if the table is not clonable.
    /// - `frame`: An interface request that will be bound to the created [`Frame`].
    CreateFrameWithParams {
        params: CreateFrameParams,
        frame: fidl::endpoints::ServerEnd<FrameMarker>,
        control_handle: ContextControlHandle,
    },
    /// Used to observe cookies for sites hosted under this Context.
    GetCookieManager {
        manager: fidl::endpoints::ServerEnd<CookieManagerMarker>,
        control_handle: ContextControlHandle,
    },
    /// Waits until debugging is available on one or more Frames, and returns the DevTools port
    /// number. Multiple calls may be queued to received the port number.
    ///
    /// If an error occurred, the [`ContextError`] will be set to this value:
    /// - `REMOTE_DEBUGGING_PORT_NOT_OPENED`: `remote_debugging_port` was not set in
    ///   [`CreateContextParams`] or the remote debugging service failed to start.
    GetRemoteDebuggingPort { responder: ContextGetRemoteDebuggingPortResponder },
}

impl ContextRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_create_frame(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<FrameMarker>, ContextControlHandle)> {
        if let ContextRequest::CreateFrame { frame, control_handle } = self {
            Some((frame, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_frame_with_params(
        self,
    ) -> Option<(CreateFrameParams, fidl::endpoints::ServerEnd<FrameMarker>, ContextControlHandle)>
    {
        if let ContextRequest::CreateFrameWithParams { params, frame, control_handle } = self {
            Some((params, frame, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_cookie_manager(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<CookieManagerMarker>, ContextControlHandle)> {
        if let ContextRequest::GetCookieManager { manager, control_handle } = self {
            Some((manager, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_remote_debugging_port(
        self,
    ) -> Option<(ContextGetRemoteDebuggingPortResponder)> {
        if let ContextRequest::GetRemoteDebuggingPort { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ContextRequest::CreateFrame { .. } => "create_frame",
            ContextRequest::CreateFrameWithParams { .. } => "create_frame_with_params",
            ContextRequest::GetCookieManager { .. } => "get_cookie_manager",
            ContextRequest::GetRemoteDebuggingPort { .. } => "get_remote_debugging_port",
        }
    }
}

#[derive(Debug, Clone)]
pub struct ContextControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::ControlHandle for ContextControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl ContextControlHandle {}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct ContextGetRemoteDebuggingPortResponder {
    control_handle: std::mem::ManuallyDrop<ContextControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`ContextControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for ContextGetRemoteDebuggingPortResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for ContextGetRemoteDebuggingPortResponder {
    type ControlHandle = ContextControlHandle;

    fn control_handle(&self) -> &ContextControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl ContextGetRemoteDebuggingPortResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<u16, ContextError>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<u16, ContextError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<u16, ContextError>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            ContextGetRemoteDebuggingPortResponse,
            ContextError,
        >>(
            result.map(|port| (port,)),
            self.tx_id,
            0x4ac6a26fe972f29,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct ContextProviderMarker;

impl fidl::endpoints::ProtocolMarker for ContextProviderMarker {
    type Proxy = ContextProviderProxy;
    type RequestStream = ContextProviderRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = ContextProviderSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.web.ContextProvider";
}
impl fidl::endpoints::DiscoverableProtocolMarker for ContextProviderMarker {}

pub trait ContextProviderProxyInterface: Send + Sync {
    fn r#create(
        &self,
        params: CreateContextParams,
        context: fidl::endpoints::ServerEnd<ContextMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct ContextProviderSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for ContextProviderSynchronousProxy {
    type Proxy = ContextProviderProxy;
    type Protocol = ContextProviderMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl ContextProviderSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <ContextProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<ContextProviderEvent, fidl::Error> {
        ContextProviderEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Creates a new browser [`Context`] whose state is wholly independent and isolated from other
    /// [`Context`](`Contexts`).
    ///
    /// - `params`: The configuration used to create the [`Context`].
    /// - `context`: An interface request which will receive a bound [`Context`]
    ///   service.
    pub fn r#create(
        &self,
        mut params: CreateContextParams,
        mut context: fidl::endpoints::ServerEnd<ContextMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ContextProviderCreateRequest>(
            (&mut params, context),
            0x6ee6fa35978eb98d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Clone)]
pub struct ContextProviderProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for ContextProviderProxy {
    type Protocol = ContextProviderMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl ContextProviderProxy {
    /// Create a new Proxy for fuchsia.web/ContextProvider.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <ContextProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> ContextProviderEventStream {
        ContextProviderEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Creates a new browser [`Context`] whose state is wholly independent and isolated from other
    /// [`Context`](`Contexts`).
    ///
    /// - `params`: The configuration used to create the [`Context`].
    /// - `context`: An interface request which will receive a bound [`Context`]
    ///   service.
    pub fn r#create(
        &self,
        mut params: CreateContextParams,
        mut context: fidl::endpoints::ServerEnd<ContextMarker>,
    ) -> Result<(), fidl::Error> {
        ContextProviderProxyInterface::r#create(self, params, context)
    }
}

impl ContextProviderProxyInterface for ContextProviderProxy {
    fn r#create(
        &self,
        mut params: CreateContextParams,
        mut context: fidl::endpoints::ServerEnd<ContextMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<ContextProviderCreateRequest>(
            (&mut params, context),
            0x6ee6fa35978eb98d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

pub struct ContextProviderEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for ContextProviderEventStream {}

impl futures::stream::FusedStream for ContextProviderEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for ContextProviderEventStream {
    type Item = Result<ContextProviderEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(ContextProviderEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum ContextProviderEvent {}

impl ContextProviderEvent {
    /// Decodes a message buffer as a [`ContextProviderEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<ContextProviderEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <ContextProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.web/ContextProvider.
pub struct ContextProviderRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for ContextProviderRequestStream {}

impl futures::stream::FusedStream for ContextProviderRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for ContextProviderRequestStream {
    type Protocol = ContextProviderMarker;
    type ControlHandle = ContextProviderControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        ContextProviderControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for ContextProviderRequestStream {
    type Item = Result<ContextProviderRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled ContextProviderRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))))
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x6ee6fa35978eb98d => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            ContextProviderCreateRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<ContextProviderCreateRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            ContextProviderControlHandle { inner: this.inner.clone() };
                        Ok(ContextProviderRequest::Create {
                            params: req.params,
                            context: req.context,

                            control_handle,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <ContextProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// The top-level service interface which allows for the creation of Context resources.
#[derive(Debug)]
pub enum ContextProviderRequest {
    /// Creates a new browser [`Context`] whose state is wholly independent and isolated from other
    /// [`Context`](`Contexts`).
    ///
    /// - `params`: The configuration used to create the [`Context`].
    /// - `context`: An interface request which will receive a bound [`Context`]
    ///   service.
    Create {
        params: CreateContextParams,
        context: fidl::endpoints::ServerEnd<ContextMarker>,
        control_handle: ContextProviderControlHandle,
    },
}

impl ContextProviderRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_create(
        self,
    ) -> Option<(
        CreateContextParams,
        fidl::endpoints::ServerEnd<ContextMarker>,
        ContextProviderControlHandle,
    )> {
        if let ContextProviderRequest::Create { params, context, control_handle } = self {
            Some((params, context, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            ContextProviderRequest::Create { .. } => "create",
        }
    }
}

#[derive(Debug, Clone)]
pub struct ContextProviderControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::ControlHandle for ContextProviderControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl ContextProviderControlHandle {}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct CookieManagerMarker;

impl fidl::endpoints::ProtocolMarker for CookieManagerMarker {
    type Proxy = CookieManagerProxy;
    type RequestStream = CookieManagerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = CookieManagerSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) CookieManager";
}

pub trait CookieManagerProxyInterface: Send + Sync {
    fn r#observe_cookie_changes(
        &self,
        url: Option<&str>,
        name: Option<&str>,
        changes: fidl::endpoints::ServerEnd<CookiesIteratorMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#get_cookie_list(
        &self,
        url: Option<&str>,
        name: Option<&str>,
        cookies: fidl::endpoints::ServerEnd<CookiesIteratorMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct CookieManagerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for CookieManagerSynchronousProxy {
    type Proxy = CookieManagerProxy;
    type Protocol = CookieManagerMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl CookieManagerSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <CookieManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<CookieManagerEvent, fidl::Error> {
        CookieManagerEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Observe changes to all cookies named `name` that would be sent in a request to `url`.
    ///
    /// If neither `url` nor `name` are set then all cookies are observed. If only `url` is set
    /// then all cookies for that URL are observed. If both are set then only cookies matching both
    /// fields are observed.
    ///
    /// `changes` iterates over a stream of cookie changes. Additions or updates are expressed as
    /// complete cookies, while deletions are expressed as cookies with no `value` set.
    pub fn r#observe_cookie_changes(
        &self,
        mut url: Option<&str>,
        mut name: Option<&str>,
        mut changes: fidl::endpoints::ServerEnd<CookiesIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<CookieManagerObserveCookieChangesRequest>(
            (url, name, changes),
            0x49d8259726088b2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Returns a list of Cookies, optionally limited to those matching `url`, and optionally
    /// `name`. `cookies` iterates over the matching cookies, including their `value`s.
    pub fn r#get_cookie_list(
        &self,
        mut url: Option<&str>,
        mut name: Option<&str>,
        mut cookies: fidl::endpoints::ServerEnd<CookiesIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<CookieManagerGetCookieListRequest>(
            (url, name, cookies),
            0x391d79f54044f334,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Clone)]
pub struct CookieManagerProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for CookieManagerProxy {
    type Protocol = CookieManagerMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl CookieManagerProxy {
    /// Create a new Proxy for fuchsia.web/CookieManager.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <CookieManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> CookieManagerEventStream {
        CookieManagerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Observe changes to all cookies named `name` that would be sent in a request to `url`.
    ///
    /// If neither `url` nor `name` are set then all cookies are observed. If only `url` is set
    /// then all cookies for that URL are observed. If both are set then only cookies matching both
    /// fields are observed.
    ///
    /// `changes` iterates over a stream of cookie changes. Additions or updates are expressed as
    /// complete cookies, while deletions are expressed as cookies with no `value` set.
    pub fn r#observe_cookie_changes(
        &self,
        mut url: Option<&str>,
        mut name: Option<&str>,
        mut changes: fidl::endpoints::ServerEnd<CookiesIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        CookieManagerProxyInterface::r#observe_cookie_changes(self, url, name, changes)
    }

    /// Returns a list of Cookies, optionally limited to those matching `url`, and optionally
    /// `name`. `cookies` iterates over the matching cookies, including their `value`s.
    pub fn r#get_cookie_list(
        &self,
        mut url: Option<&str>,
        mut name: Option<&str>,
        mut cookies: fidl::endpoints::ServerEnd<CookiesIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        CookieManagerProxyInterface::r#get_cookie_list(self, url, name, cookies)
    }
}

impl CookieManagerProxyInterface for CookieManagerProxy {
    fn r#observe_cookie_changes(
        &self,
        mut url: Option<&str>,
        mut name: Option<&str>,
        mut changes: fidl::endpoints::ServerEnd<CookiesIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<CookieManagerObserveCookieChangesRequest>(
            (url, name, changes),
            0x49d8259726088b2,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#get_cookie_list(
        &self,
        mut url: Option<&str>,
        mut name: Option<&str>,
        mut cookies: fidl::endpoints::ServerEnd<CookiesIteratorMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<CookieManagerGetCookieListRequest>(
            (url, name, cookies),
            0x391d79f54044f334,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

pub struct CookieManagerEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for CookieManagerEventStream {}

impl futures::stream::FusedStream for CookieManagerEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for CookieManagerEventStream {
    type Item = Result<CookieManagerEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(CookieManagerEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum CookieManagerEvent {}

impl CookieManagerEvent {
    /// Decodes a message buffer as a [`CookieManagerEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<CookieManagerEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <CookieManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.web/CookieManager.
pub struct CookieManagerRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for CookieManagerRequestStream {}

impl futures::stream::FusedStream for CookieManagerRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for CookieManagerRequestStream {
    type Protocol = CookieManagerMarker;
    type ControlHandle = CookieManagerControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        CookieManagerControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for CookieManagerRequestStream {
    type Item = Result<CookieManagerRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled CookieManagerRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))))
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x49d8259726088b2 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            CookieManagerObserveCookieChangesRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CookieManagerObserveCookieChangesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            CookieManagerControlHandle { inner: this.inner.clone() };
                        Ok(CookieManagerRequest::ObserveCookieChanges {
                            url: req.url,
                            name: req.name,
                            changes: req.changes,

                            control_handle,
                        })
                    }
                    0x391d79f54044f334 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            CookieManagerGetCookieListRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<CookieManagerGetCookieListRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            CookieManagerControlHandle { inner: this.inner.clone() };
                        Ok(CookieManagerRequest::GetCookieList {
                            url: req.url,
                            name: req.name,
                            cookies: req.cookies,

                            control_handle,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <CookieManagerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Provides methods for monitoring and accessing browser cookie state.
#[derive(Debug)]
pub enum CookieManagerRequest {
    /// Observe changes to all cookies named `name` that would be sent in a request to `url`.
    ///
    /// If neither `url` nor `name` are set then all cookies are observed. If only `url` is set
    /// then all cookies for that URL are observed. If both are set then only cookies matching both
    /// fields are observed.
    ///
    /// `changes` iterates over a stream of cookie changes. Additions or updates are expressed as
    /// complete cookies, while deletions are expressed as cookies with no `value` set.
    ObserveCookieChanges {
        url: Option<String>,
        name: Option<String>,
        changes: fidl::endpoints::ServerEnd<CookiesIteratorMarker>,
        control_handle: CookieManagerControlHandle,
    },
    /// Returns a list of Cookies, optionally limited to those matching `url`, and optionally
    /// `name`. `cookies` iterates over the matching cookies, including their `value`s.
    GetCookieList {
        url: Option<String>,
        name: Option<String>,
        cookies: fidl::endpoints::ServerEnd<CookiesIteratorMarker>,
        control_handle: CookieManagerControlHandle,
    },
}

impl CookieManagerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_observe_cookie_changes(
        self,
    ) -> Option<(
        Option<String>,
        Option<String>,
        fidl::endpoints::ServerEnd<CookiesIteratorMarker>,
        CookieManagerControlHandle,
    )> {
        if let CookieManagerRequest::ObserveCookieChanges { url, name, changes, control_handle } =
            self
        {
            Some((url, name, changes, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_cookie_list(
        self,
    ) -> Option<(
        Option<String>,
        Option<String>,
        fidl::endpoints::ServerEnd<CookiesIteratorMarker>,
        CookieManagerControlHandle,
    )> {
        if let CookieManagerRequest::GetCookieList { url, name, cookies, control_handle } = self {
            Some((url, name, cookies, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            CookieManagerRequest::ObserveCookieChanges { .. } => "observe_cookie_changes",
            CookieManagerRequest::GetCookieList { .. } => "get_cookie_list",
        }
    }
}

#[derive(Debug, Clone)]
pub struct CookieManagerControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::ControlHandle for CookieManagerControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl CookieManagerControlHandle {}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct CookiesIteratorMarker;

impl fidl::endpoints::ProtocolMarker for CookiesIteratorMarker {
    type Proxy = CookiesIteratorProxy;
    type RequestStream = CookiesIteratorRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = CookiesIteratorSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) CookiesIterator";
}

pub trait CookiesIteratorProxyInterface: Send + Sync {
    type GetNextResponseFut: std::future::Future<Output = Result<Vec<Cookie>, fidl::Error>> + Send;
    fn r#get_next(&self) -> Self::GetNextResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct CookiesIteratorSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for CookiesIteratorSynchronousProxy {
    type Proxy = CookiesIteratorProxy;
    type Protocol = CookiesIteratorMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl CookiesIteratorSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <CookiesIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<CookiesIteratorEvent, fidl::Error> {
        CookiesIteratorEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Fetches the next batch of cookies, or of changes to cookies.
    /// RFC6265 does not specify an upper-bound on the number of cookies which
    /// may be stored.
    pub fn r#get_next(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<Vec<Cookie>, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, CookiesIteratorGetNextResponse>(
                (),
                0x61b55ebf67ec457d,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.changed_cookies)
    }
}

#[derive(Debug, Clone)]
pub struct CookiesIteratorProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for CookiesIteratorProxy {
    type Protocol = CookiesIteratorMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl CookiesIteratorProxy {
    /// Create a new Proxy for fuchsia.web/CookiesIterator.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <CookiesIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> CookiesIteratorEventStream {
        CookiesIteratorEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Fetches the next batch of cookies, or of changes to cookies.
    /// RFC6265 does not specify an upper-bound on the number of cookies which
    /// may be stored.
    pub fn r#get_next(
        &self,
    ) -> fidl::client::QueryResponseFut<Vec<Cookie>, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        CookiesIteratorProxyInterface::r#get_next(self)
    }
}

impl CookiesIteratorProxyInterface for CookiesIteratorProxy {
    type GetNextResponseFut =
        fidl::client::QueryResponseFut<Vec<Cookie>, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_next(&self) -> Self::GetNextResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<Vec<Cookie>, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                CookiesIteratorGetNextResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x61b55ebf67ec457d,
            >(_buf?)?;
            Ok(_response.changed_cookies)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, Vec<Cookie>>(
            (),
            0x61b55ebf67ec457d,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct CookiesIteratorEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for CookiesIteratorEventStream {}

impl futures::stream::FusedStream for CookiesIteratorEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for CookiesIteratorEventStream {
    type Item = Result<CookiesIteratorEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(CookiesIteratorEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum CookiesIteratorEvent {}

impl CookiesIteratorEvent {
    /// Decodes a message buffer as a [`CookiesIteratorEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<CookiesIteratorEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <CookiesIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.web/CookiesIterator.
pub struct CookiesIteratorRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for CookiesIteratorRequestStream {}

impl futures::stream::FusedStream for CookiesIteratorRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for CookiesIteratorRequestStream {
    type Protocol = CookiesIteratorMarker;
    type ControlHandle = CookiesIteratorControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        CookiesIteratorControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for CookiesIteratorRequestStream {
    type Item = Result<CookiesIteratorRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled CookiesIteratorRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))))
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x61b55ebf67ec457d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            CookiesIteratorControlHandle { inner: this.inner.clone() };
                        Ok(CookiesIteratorRequest::GetNext {
                            responder: CookiesIteratorGetNextResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <CookiesIteratorMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Used to iterator over a set of cookies, or a stream of changes to cookies.
#[derive(Debug)]
pub enum CookiesIteratorRequest {
    /// Fetches the next batch of cookies, or of changes to cookies.
    /// RFC6265 does not specify an upper-bound on the number of cookies which
    /// may be stored.
    GetNext { responder: CookiesIteratorGetNextResponder },
}

impl CookiesIteratorRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_get_next(self) -> Option<(CookiesIteratorGetNextResponder)> {
        if let CookiesIteratorRequest::GetNext { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            CookiesIteratorRequest::GetNext { .. } => "get_next",
        }
    }
}

#[derive(Debug, Clone)]
pub struct CookiesIteratorControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::ControlHandle for CookiesIteratorControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl CookiesIteratorControlHandle {}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct CookiesIteratorGetNextResponder {
    control_handle: std::mem::ManuallyDrop<CookiesIteratorControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`CookiesIteratorControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for CookiesIteratorGetNextResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for CookiesIteratorGetNextResponder {
    type ControlHandle = CookiesIteratorControlHandle;

    fn control_handle(&self) -> &CookiesIteratorControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl CookiesIteratorGetNextResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut changed_cookies: Vec<Cookie>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(changed_cookies);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut changed_cookies: Vec<Cookie>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(changed_cookies);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut changed_cookies: Vec<Cookie>) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<CookiesIteratorGetNextResponse>(
            (changed_cookies.as_mut(),),
            self.tx_id,
            0x61b55ebf67ec457d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct DebugMarker;

impl fidl::endpoints::ProtocolMarker for DebugMarker {
    type Proxy = DebugProxy;
    type RequestStream = DebugRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DebugSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.web.Debug";
}
impl fidl::endpoints::DiscoverableProtocolMarker for DebugMarker {}

pub trait DebugProxyInterface: Send + Sync {
    type EnableDevToolsResponseFut: std::future::Future<Output = Result<(), fidl::Error>> + Send;
    fn r#enable_dev_tools(
        &self,
        listener: fidl::endpoints::ClientEnd<DevToolsListenerMarker>,
    ) -> Self::EnableDevToolsResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DebugSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DebugSynchronousProxy {
    type Proxy = DebugProxy;
    type Protocol = DebugMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl DebugSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <DebugMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<DebugEvent, fidl::Error> {
        DebugEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Enables the DevTools service on every subsequent [`Context`] creation and delivers
    /// subsequent DevTools events to the supplied `listener`. The callback indicates when the
    /// WebEngine is in a debuggable state. Events will be sent to every `listener` registered with
    /// this method.
    ///
    /// Because DevTools debugging is exposed using TCP as its transport, only
    /// [`Context`]s created with access to network capabilities will report
    /// themselves as available for debugging.
    pub fn r#enable_dev_tools(
        &self,
        mut listener: fidl::endpoints::ClientEnd<DevToolsListenerMarker>,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response =
            self.client.send_query::<DebugEnableDevToolsRequest, fidl::encoding::EmptyPayload>(
                (listener,),
                0x44b5e1f4e4c548e4,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }
}

#[derive(Debug, Clone)]
pub struct DebugProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for DebugProxy {
    type Protocol = DebugMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl DebugProxy {
    /// Create a new Proxy for fuchsia.web/Debug.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <DebugMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> DebugEventStream {
        DebugEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Enables the DevTools service on every subsequent [`Context`] creation and delivers
    /// subsequent DevTools events to the supplied `listener`. The callback indicates when the
    /// WebEngine is in a debuggable state. Events will be sent to every `listener` registered with
    /// this method.
    ///
    /// Because DevTools debugging is exposed using TCP as its transport, only
    /// [`Context`]s created with access to network capabilities will report
    /// themselves as available for debugging.
    pub fn r#enable_dev_tools(
        &self,
        mut listener: fidl::endpoints::ClientEnd<DevToolsListenerMarker>,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        DebugProxyInterface::r#enable_dev_tools(self, listener)
    }
}

impl DebugProxyInterface for DebugProxy {
    type EnableDevToolsResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#enable_dev_tools(
        &self,
        mut listener: fidl::endpoints::ClientEnd<DevToolsListenerMarker>,
    ) -> Self::EnableDevToolsResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x44b5e1f4e4c548e4,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<DebugEnableDevToolsRequest, ()>(
            (listener,),
            0x44b5e1f4e4c548e4,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct DebugEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for DebugEventStream {}

impl futures::stream::FusedStream for DebugEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for DebugEventStream {
    type Item = Result<DebugEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(DebugEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum DebugEvent {}

impl DebugEvent {
    /// Decodes a message buffer as a [`DebugEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<DebugEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <DebugMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.web/Debug.
pub struct DebugRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for DebugRequestStream {}

impl futures::stream::FusedStream for DebugRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for DebugRequestStream {
    type Protocol = DebugMarker;
    type ControlHandle = DebugControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        DebugControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for DebugRequestStream {
    type Item = Result<DebugRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled DebugRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))))
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x44b5e1f4e4c548e4 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            DebugEnableDevToolsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DebugEnableDevToolsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = DebugControlHandle { inner: this.inner.clone() };
                        Ok(DebugRequest::EnableDevTools {
                            listener: req.listener,

                            responder: DebugEnableDevToolsResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name: <DebugMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// The debug service which allows to enable the DevTools service on Contexts.
#[derive(Debug)]
pub enum DebugRequest {
    /// Enables the DevTools service on every subsequent [`Context`] creation and delivers
    /// subsequent DevTools events to the supplied `listener`. The callback indicates when the
    /// WebEngine is in a debuggable state. Events will be sent to every `listener` registered with
    /// this method.
    ///
    /// Because DevTools debugging is exposed using TCP as its transport, only
    /// [`Context`]s created with access to network capabilities will report
    /// themselves as available for debugging.
    EnableDevTools {
        listener: fidl::endpoints::ClientEnd<DevToolsListenerMarker>,
        responder: DebugEnableDevToolsResponder,
    },
}

impl DebugRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_enable_dev_tools(
        self,
    ) -> Option<(fidl::endpoints::ClientEnd<DevToolsListenerMarker>, DebugEnableDevToolsResponder)>
    {
        if let DebugRequest::EnableDevTools { listener, responder } = self {
            Some((listener, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DebugRequest::EnableDevTools { .. } => "enable_dev_tools",
        }
    }
}

#[derive(Debug, Clone)]
pub struct DebugControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::ControlHandle for DebugControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl DebugControlHandle {}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct DebugEnableDevToolsResponder {
    control_handle: std::mem::ManuallyDrop<DebugControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`DebugControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for DebugEnableDevToolsResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for DebugEnableDevToolsResponder {
    type ControlHandle = DebugControlHandle;

    fn control_handle(&self) -> &DebugControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl DebugEnableDevToolsResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self) -> Result<(), fidl::Error> {
        let _result = self.send_raw();
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
        let _result = self.send_raw();
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            self.tx_id,
            0x44b5e1f4e4c548e4,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct DevToolsListenerMarker;

impl fidl::endpoints::ProtocolMarker for DevToolsListenerMarker {
    type Proxy = DevToolsListenerProxy;
    type RequestStream = DevToolsListenerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DevToolsListenerSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) DevToolsListener";
}

pub trait DevToolsListenerProxyInterface: Send + Sync {
    fn r#on_context_dev_tools_available(
        &self,
        listener: fidl::endpoints::ServerEnd<DevToolsPerContextListenerMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DevToolsListenerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DevToolsListenerSynchronousProxy {
    type Proxy = DevToolsListenerProxy;
    type Protocol = DevToolsListenerMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl DevToolsListenerSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <DevToolsListenerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<DevToolsListenerEvent, fidl::Error> {
        DevToolsListenerEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Called when the DevTools service is available on a new [`Context`].
    ///
    /// - `listener`: Channel over which DevTools events for the new [`Context`] will
    ///   be delivered. This channel will disconnect when the [`Context`] is destroyed.
    pub fn r#on_context_dev_tools_available(
        &self,
        mut listener: fidl::endpoints::ServerEnd<DevToolsPerContextListenerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DevToolsListenerOnContextDevToolsAvailableRequest>(
            (listener,),
            0x4b259fb4d7e49e87,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Clone)]
pub struct DevToolsListenerProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for DevToolsListenerProxy {
    type Protocol = DevToolsListenerMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl DevToolsListenerProxy {
    /// Create a new Proxy for fuchsia.web/DevToolsListener.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <DevToolsListenerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> DevToolsListenerEventStream {
        DevToolsListenerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Called when the DevTools service is available on a new [`Context`].
    ///
    /// - `listener`: Channel over which DevTools events for the new [`Context`] will
    ///   be delivered. This channel will disconnect when the [`Context`] is destroyed.
    pub fn r#on_context_dev_tools_available(
        &self,
        mut listener: fidl::endpoints::ServerEnd<DevToolsPerContextListenerMarker>,
    ) -> Result<(), fidl::Error> {
        DevToolsListenerProxyInterface::r#on_context_dev_tools_available(self, listener)
    }
}

impl DevToolsListenerProxyInterface for DevToolsListenerProxy {
    fn r#on_context_dev_tools_available(
        &self,
        mut listener: fidl::endpoints::ServerEnd<DevToolsPerContextListenerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<DevToolsListenerOnContextDevToolsAvailableRequest>(
            (listener,),
            0x4b259fb4d7e49e87,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

pub struct DevToolsListenerEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for DevToolsListenerEventStream {}

impl futures::stream::FusedStream for DevToolsListenerEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for DevToolsListenerEventStream {
    type Item = Result<DevToolsListenerEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(DevToolsListenerEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum DevToolsListenerEvent {}

impl DevToolsListenerEvent {
    /// Decodes a message buffer as a [`DevToolsListenerEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<DevToolsListenerEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <DevToolsListenerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.web/DevToolsListener.
pub struct DevToolsListenerRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for DevToolsListenerRequestStream {}

impl futures::stream::FusedStream for DevToolsListenerRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for DevToolsListenerRequestStream {
    type Protocol = DevToolsListenerMarker;
    type ControlHandle = DevToolsListenerControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        DevToolsListenerControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for DevToolsListenerRequestStream {
    type Item = Result<DevToolsListenerRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled DevToolsListenerRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))))
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x4b259fb4d7e49e87 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            DevToolsListenerOnContextDevToolsAvailableRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DevToolsListenerOnContextDevToolsAvailableRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle =
                            DevToolsListenerControlHandle { inner: this.inner.clone() };
                        Ok(DevToolsListenerRequest::OnContextDevToolsAvailable {
                            listener: req.listener,

                            control_handle,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <DevToolsListenerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Interface used to observe DevTools service availability events.
#[derive(Debug)]
pub enum DevToolsListenerRequest {
    /// Called when the DevTools service is available on a new [`Context`].
    ///
    /// - `listener`: Channel over which DevTools events for the new [`Context`] will
    ///   be delivered. This channel will disconnect when the [`Context`] is destroyed.
    OnContextDevToolsAvailable {
        listener: fidl::endpoints::ServerEnd<DevToolsPerContextListenerMarker>,
        control_handle: DevToolsListenerControlHandle,
    },
}

impl DevToolsListenerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_context_dev_tools_available(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<DevToolsPerContextListenerMarker>,
        DevToolsListenerControlHandle,
    )> {
        if let DevToolsListenerRequest::OnContextDevToolsAvailable { listener, control_handle } =
            self
        {
            Some((listener, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DevToolsListenerRequest::OnContextDevToolsAvailable { .. } => {
                "on_context_dev_tools_available"
            }
        }
    }
}

#[derive(Debug, Clone)]
pub struct DevToolsListenerControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::ControlHandle for DevToolsListenerControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl DevToolsListenerControlHandle {}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct DevToolsPerContextListenerMarker;

impl fidl::endpoints::ProtocolMarker for DevToolsPerContextListenerMarker {
    type Proxy = DevToolsPerContextListenerProxy;
    type RequestStream = DevToolsPerContextListenerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = DevToolsPerContextListenerSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) DevToolsPerContextListener";
}

pub trait DevToolsPerContextListenerProxyInterface: Send + Sync {
    fn r#on_http_port_open(&self, port: u16) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct DevToolsPerContextListenerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for DevToolsPerContextListenerSynchronousProxy {
    type Proxy = DevToolsPerContextListenerProxy;
    type Protocol = DevToolsPerContextListenerMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl DevToolsPerContextListenerSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <DevToolsPerContextListenerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<DevToolsPerContextListenerEvent, fidl::Error> {
        DevToolsPerContextListenerEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Called when the DevTools service starts accepting TCP connections on `port`. `port` will
    /// remain open until the [`Context`] is destroyed.
    ///
    /// - `port`: The port used by the service.
    pub fn r#on_http_port_open(&self, mut port: u16) -> Result<(), fidl::Error> {
        self.client.send::<DevToolsPerContextListenerOnHttpPortOpenRequest>(
            (port,),
            0x5e330939b035553b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Clone)]
pub struct DevToolsPerContextListenerProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for DevToolsPerContextListenerProxy {
    type Protocol = DevToolsPerContextListenerMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl DevToolsPerContextListenerProxy {
    /// Create a new Proxy for fuchsia.web/DevToolsPerContextListener.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <DevToolsPerContextListenerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> DevToolsPerContextListenerEventStream {
        DevToolsPerContextListenerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Called when the DevTools service starts accepting TCP connections on `port`. `port` will
    /// remain open until the [`Context`] is destroyed.
    ///
    /// - `port`: The port used by the service.
    pub fn r#on_http_port_open(&self, mut port: u16) -> Result<(), fidl::Error> {
        DevToolsPerContextListenerProxyInterface::r#on_http_port_open(self, port)
    }
}

impl DevToolsPerContextListenerProxyInterface for DevToolsPerContextListenerProxy {
    fn r#on_http_port_open(&self, mut port: u16) -> Result<(), fidl::Error> {
        self.client.send::<DevToolsPerContextListenerOnHttpPortOpenRequest>(
            (port,),
            0x5e330939b035553b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

pub struct DevToolsPerContextListenerEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for DevToolsPerContextListenerEventStream {}

impl futures::stream::FusedStream for DevToolsPerContextListenerEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for DevToolsPerContextListenerEventStream {
    type Item = Result<DevToolsPerContextListenerEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(DevToolsPerContextListenerEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum DevToolsPerContextListenerEvent {}

impl DevToolsPerContextListenerEvent {
    /// Decodes a message buffer as a [`DevToolsPerContextListenerEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<DevToolsPerContextListenerEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <DevToolsPerContextListenerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            })
        }
    }
}

/// A Stream of incoming requests for fuchsia.web/DevToolsPerContextListener.
pub struct DevToolsPerContextListenerRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for DevToolsPerContextListenerRequestStream {}

impl futures::stream::FusedStream for DevToolsPerContextListenerRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for DevToolsPerContextListenerRequestStream {
    type Protocol = DevToolsPerContextListenerMarker;
    type ControlHandle = DevToolsPerContextListenerControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        DevToolsPerContextListenerControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for DevToolsPerContextListenerRequestStream {
    type Item = Result<DevToolsPerContextListenerRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled DevToolsPerContextListenerRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))))
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                0x5e330939b035553b => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(DevToolsPerContextListenerOnHttpPortOpenRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<DevToolsPerContextListenerOnHttpPortOpenRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = DevToolsPerContextListenerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(DevToolsPerContextListenerRequest::OnHttpPortOpen {port: req.port,

                        control_handle,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <DevToolsPerContextListenerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// Interface supplied by the debugging component to observe the DevTools service opening event.
#[derive(Debug)]
pub enum DevToolsPerContextListenerRequest {
    /// Called when the DevTools service starts accepting TCP connections on `port`. `port` will
    /// remain open until the [`Context`] is destroyed.
    ///
    /// - `port`: The port used by the service.
    OnHttpPortOpen { port: u16, control_handle: DevToolsPerContextListenerControlHandle },
}

impl DevToolsPerContextListenerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_http_port_open(self) -> Option<(u16, DevToolsPerContextListenerControlHandle)> {
        if let DevToolsPerContextListenerRequest::OnHttpPortOpen { port, control_handle } = self {
            Some((port, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            DevToolsPerContextListenerRequest::OnHttpPortOpen { .. } => "on_http_port_open",
        }
    }
}

#[derive(Debug, Clone)]
pub struct DevToolsPerContextListenerControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::ControlHandle for DevToolsPerContextListenerControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl DevToolsPerContextListenerControlHandle {}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct FrameMarker;

impl fidl::endpoints::ProtocolMarker for FrameMarker {
    type Proxy = FrameProxy;
    type RequestStream = FrameRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = FrameSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) Frame";
}
pub type FrameExecuteJavaScriptResult = Result<fidl_fuchsia_mem::Buffer, FrameError>;
pub type FrameExecuteJavaScriptNoResultResult = Result<(), FrameError>;
pub type FrameAddBeforeLoadJavaScriptResult = Result<(), FrameError>;
pub type FramePostMessageResult = Result<(), FrameError>;

pub trait FrameProxyInterface: Send + Sync {
    fn r#create_view(
        &self,
        view_token: fidl_fuchsia_ui_views::ViewToken,
    ) -> Result<(), fidl::Error>;
    fn r#create_view_with_view_ref(
        &self,
        view_token: fidl_fuchsia_ui_views::ViewToken,
        view_ref_control: fidl_fuchsia_ui_views::ViewRefControl,
        view_ref: fidl_fuchsia_ui_views::ViewRef,
    ) -> Result<(), fidl::Error>;
    fn r#create_view2(&self, args: CreateView2Args) -> Result<(), fidl::Error>;
    fn r#enable_headless_rendering(&self) -> Result<(), fidl::Error>;
    fn r#disable_headless_rendering(&self) -> Result<(), fidl::Error>;
    fn r#get_media_player(
        &self,
        player: fidl::endpoints::ServerEnd<fidl_fuchsia_media_sessions2::PlayerMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#get_navigation_controller(
        &self,
        controller: fidl::endpoints::ServerEnd<NavigationControllerMarker>,
    ) -> Result<(), fidl::Error>;
    type ExecuteJavaScriptResponseFut: std::future::Future<Output = Result<FrameExecuteJavaScriptResult, fidl::Error>>
        + Send;
    fn r#execute_java_script(
        &self,
        origins: &[String],
        script: fidl_fuchsia_mem::Buffer,
    ) -> Self::ExecuteJavaScriptResponseFut;
    type ExecuteJavaScriptNoResultResponseFut: std::future::Future<Output = Result<FrameExecuteJavaScriptNoResultResult, fidl::Error>>
        + Send;
    fn r#execute_java_script_no_result(
        &self,
        origins: &[String],
        script: fidl_fuchsia_mem::Buffer,
    ) -> Self::ExecuteJavaScriptNoResultResponseFut;
    type AddBeforeLoadJavaScriptResponseFut: std::future::Future<Output = Result<FrameAddBeforeLoadJavaScriptResult, fidl::Error>>
        + Send;
    fn r#add_before_load_java_script(
        &self,
        id: u64,
        origins: &[String],
        script: fidl_fuchsia_mem::Buffer,
    ) -> Self::AddBeforeLoadJavaScriptResponseFut;
    fn r#remove_before_load_java_script(&self, id: u64) -> Result<(), fidl::Error>;
    type PostMessageResponseFut: std::future::Future<Output = Result<FramePostMessageResult, fidl::Error>>
        + Send;
    fn r#post_message(
        &self,
        target_origin: &str,
        message: WebMessage,
    ) -> Self::PostMessageResponseFut;
    fn r#set_navigation_event_listener(
        &self,
        listener: Option<fidl::endpoints::ClientEnd<NavigationEventListenerMarker>>,
    ) -> Result<(), fidl::Error>;
    fn r#set_navigation_event_listener2(
        &self,
        listener: Option<fidl::endpoints::ClientEnd<NavigationEventListenerMarker>>,
        flags: NavigationEventListenerFlags,
    ) -> Result<(), fidl::Error>;
    fn r#set_java_script_log_level(&self, level: ConsoleLogLevel) -> Result<(), fidl::Error>;
    fn r#set_console_log_sink(
        &self,
        sink: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_logger::LogSinkMarker>>,
    ) -> Result<(), fidl::Error>;
    fn r#configure_input_types(
        &self,
        types: InputTypes,
        allow: AllowInputState,
    ) -> Result<(), fidl::Error>;
    fn r#set_popup_frame_creation_listener(
        &self,
        listener: Option<fidl::endpoints::ClientEnd<PopupFrameCreationListenerMarker>>,
    ) -> Result<(), fidl::Error>;
    type SetUrlRequestRewriteRulesResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
        + Send;
    fn r#set_url_request_rewrite_rules(
        &self,
        rules: &[UrlRequestRewriteRule],
    ) -> Self::SetUrlRequestRewriteRulesResponseFut;
    fn r#set_media_settings(&self, settings: &FrameMediaSettings) -> Result<(), fidl::Error>;
    fn r#force_content_dimensions(
        &self,
        web_dips: Option<&fidl_fuchsia_ui_gfx::Vec2>,
    ) -> Result<(), fidl::Error>;
    fn r#set_permission_state(
        &self,
        permission: &PermissionDescriptor,
        web_origin: &str,
        state: PermissionState,
    ) -> Result<(), fidl::Error>;
    fn r#set_block_media_loading(&self, blocked: bool) -> Result<(), fidl::Error>;
    type GetPrivateMemorySizeResponseFut: std::future::Future<Output = Result<u64, fidl::Error>>
        + Send;
    fn r#get_private_memory_size(&self) -> Self::GetPrivateMemorySizeResponseFut;
    fn r#set_navigation_policy_provider(
        &self,
        params: &NavigationPolicyProviderParams,
        provider: fidl::endpoints::ClientEnd<NavigationPolicyProviderMarker>,
    ) -> Result<(), fidl::Error>;
    fn r#set_content_area_settings(
        &self,
        settings: &ContentAreaSettings,
    ) -> Result<(), fidl::Error>;
    fn r#reset_content_area_settings(&self) -> Result<(), fidl::Error>;
    fn r#close(&self, payload: &FrameCloseRequest) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct FrameSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for FrameSynchronousProxy {
    type Proxy = FrameProxy;
    type Protocol = FrameMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl FrameSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <FrameMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<FrameEvent, fidl::Error> {
        FrameEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Creates a new view using the specified `view_token`. Caller should pass the other end of
    /// the token to [`fuchsia.ui.gfx/ViewHolderArgs`] to attach the new view to a view tree.
    ///
    /// See the description of [`CreateContextParams.service_directory`] for additional services
    /// that must be present when using this method.
    pub fn r#create_view(
        &self,
        mut view_token: fidl_fuchsia_ui_views::ViewToken,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FrameCreateViewRequest>(
            (&mut view_token,),
            0x6a27859439133264,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Creates a new view using the specified `view_token`. Caller should pass the other end of
    /// the token to [`fuchsia.ui.gfx/ViewHolderArgs`] to attach the new view to a view tree.
    /// `view_ref` can be cloned before passing it to this method, which will allow clients to
    /// track the view.
    ///
    /// `view_ref_control` must not have the `ZX_RIGHT_DUPLICATE` set, or view creation will fail
    /// and `view_token` will be closed.
    ///
    /// See the description of [`CreateContextParams.service_directory`] for additional services
    /// that must be present when using this method.
    pub fn r#create_view_with_view_ref(
        &self,
        mut view_token: fidl_fuchsia_ui_views::ViewToken,
        mut view_ref_control: fidl_fuchsia_ui_views::ViewRefControl,
        mut view_ref: fidl_fuchsia_ui_views::ViewRef,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FrameCreateViewWithViewRefRequest>(
            (&mut view_token, &mut view_ref_control, &mut view_ref),
            0x1eb17ab2442326ac,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Creates a new Flatland view using the specified `view_creation_token` defined under `args`.
    /// Caller should pass the other end of the token to
    /// [`fuchsia.ui.composition/Flatland.CreateViewport`] to attach the new Flatland view to its
    /// graph.
    pub fn r#create_view2(&self, mut args: CreateView2Args) -> Result<(), fidl::Error> {
        self.client.send::<FrameCreateView2Request>(
            (&mut args,),
            0x1be7e9512962eb37,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Enables headless rendering of the Frame.
    ///
    /// This is used when content depends on layout and/or animation events firing normally.
    /// May only be used on a Context created with [`ContextFeatureFlags.HEADLESS`].
    pub fn r#enable_headless_rendering(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x72a81aaae7a80d2b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Stops headless rendering of the Frame.
    ///
    /// May only be used on a Context created with [`ContextFeatureFlags.HEADLESS`].
    pub fn r#disable_headless_rendering(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x5ca38a3d1f7f543a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Returns a [`fuchsia.media.sessions2/Player`] interface through which media (i.e.
    /// video/audio) playback in the frame may be observed, and/or controlled. Only one
    /// [`fuchsia.media.sessions2/Player`] may be active at a time, for each [`Frame`].
    pub fn r#get_media_player(
        &self,
        mut player: fidl::endpoints::ServerEnd<fidl_fuchsia_media_sessions2::PlayerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FrameGetMediaPlayerRequest>(
            (player,),
            0xaafb639fc0b9eb9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Returns an interface through which the [`Frame`] may be navigated to a desired URL,
    /// reloaded, etc.
    ///
    /// - `controller`: An asynchronous interface request for the [`Frame`]'s
    ///   [`NavigationController`].
    pub fn r#get_navigation_controller(
        &self,
        mut controller: fidl::endpoints::ServerEnd<NavigationControllerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FrameGetNavigationControllerRequest>(
            (controller,),
            0x4521cfe95217a688,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Executes a UTF-8 encoded `script` in the [`Frame`] if the [`Frame`]'s URL has an origin
    /// which matches entries in `origins`.
    ///
    /// At least one `origins` entry must be specified. If a wildcard `"*"` is specified in
    /// `origins`, then the script will be evaluated unconditionally.
    ///
    /// Returns the result of executing `script`, as a JSON-encoded string.
    ///
    /// Note that scripts share the same execution context as the document,
    /// meaning that document may modify variables, classes, or objects set by
    /// the script in arbitrary or unpredictable ways.
    ///
    /// If an error occurred, the FrameError will be set to one of these values:
    /// - `BUFFER_NOT_UTF8`: `script` is not UTF-8 encoded.
    /// - `INVALID_ORIGIN`: The [`Frame`]'s current URL does not match any of the values in
    ///   `origins` or `origins` is an empty vector.
    pub fn r#execute_java_script(
        &self,
        mut origins: &[String],
        mut script: fidl_fuchsia_mem::Buffer,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<FrameExecuteJavaScriptResult, fidl::Error> {
        let _response = self.client.send_query::<
            FrameExecuteJavaScriptRequest,
            fidl::encoding::ResultType<FrameExecuteJavaScriptResponse, FrameError>,
        >(
            (origins, &mut script,),
            0x79abdd4907000542,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x.result))
    }

    /// Variant of [`Frame.ExecuteJavaScript`] which executes the supplied script without returning
    /// a result.
    pub fn r#execute_java_script_no_result(
        &self,
        mut origins: &[String],
        mut script: fidl_fuchsia_mem::Buffer,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<FrameExecuteJavaScriptNoResultResult, fidl::Error> {
        let _response = self.client.send_query::<
            FrameExecuteJavaScriptNoResultRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, FrameError>,
        >(
            (origins, &mut script,),
            0x16b8491520cbcd63,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Executes a UTF-8 encoded `script` for every subsequent page load where the [`Frame`]'s URL
    /// has an origin reflected in `origins`. The script is executed early, prior to the execution
    /// of the document's scripts.
    ///
    /// Scripts are identified by a client-managed identifier `id`. Any script previously injected
    /// using the same `id` will be replaced.
    ///
    /// The order in which multiple bindings are executed is the same as the order in which the
    /// bindings were added. If a script is added which clobbers an existing script of the same
    /// `id`, the previous script's precedence in the injection order will be preserved.
    ///
    /// At least one `origins` entry must be specified. If a wildcard `"*"` is specified in
    /// `origins`, then the script will be evaluated unconditionally.
    ///
    /// If an error occurred, the [`FrameError`] will be set to one of these values:
    /// - `BUFFER_NOT_UTF8`: `script` is not UTF-8 encoded.
    /// - `INVALID_ORIGIN`: `origins` is an empty vector.
    pub fn r#add_before_load_java_script(
        &self,
        mut id: u64,
        mut origins: &[String],
        mut script: fidl_fuchsia_mem::Buffer,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<FrameAddBeforeLoadJavaScriptResult, fidl::Error> {
        let _response = self.client.send_query::<
            FrameAddBeforeLoadJavaScriptRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, FrameError>,
        >(
            (id, origins, &mut script,),
            0x540ac0da59d823e,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Removes a previously added JavaScript snippet identified by `id`. This is a no-op if there
    /// is no JavaScript snippet identified by `id`.
    pub fn r#remove_before_load_java_script(&self, mut id: u64) -> Result<(), fidl::Error> {
        self.client.send::<FrameRemoveBeforeLoadJavaScriptRequest>(
            (id,),
            0x17d92b855b61d23a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Posts a message to the frame's onMessage handler.
    ///
    /// `target_origin` restricts message delivery to the specified origin. If `target_origin` is
    /// `"*"`, then the message will be sent to the document regardless of its origin.
    /// See the
    /// [HTML spec](https://html.spec.whatwg.org/multipage/web-messaging.html#posting-messages)
    /// section 9.4.3 for more details on how the target origin policy is applied.
    ///
    /// If an error occurred, the [`FrameError`] will be set to one of these values:
    /// - `INTERNAL_ERROR`: The WebEngine failed to create a message pipe.
    /// - `BUFFER_NOT_UTF8`: The script in `message`'s `data` property is not UTF-8 encoded.
    /// - `INVALID_ORIGIN`: `origins` is an empty vector.
    /// - `NO_DATA_IN_MESSAGE`: The `data` property is missing in `message`.
    pub fn r#post_message(
        &self,
        mut target_origin: &str,
        mut message: WebMessage,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<FramePostMessageResult, fidl::Error> {
        let _response = self.client.send_query::<
            FramePostMessageRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, FrameError>,
        >(
            (target_origin, &mut message,),
            0x751d686eb7caa341,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Sets the listener for handling page navigation events.
    ///
    /// - `listener`: The observer to use. Unregisters any existing listener if null.
    pub fn r#set_navigation_event_listener(
        &self,
        mut listener: Option<fidl::endpoints::ClientEnd<NavigationEventListenerMarker>>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FrameSetNavigationEventListenerRequest>(
            (listener,),
            0x965ba0fa20e0a56,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets the listener for handling page navigation events. The listener will receive the
    /// current navigation state immediately. After that, it's notified whenever the state changes.
    ///
    /// - `listener`: The observer to use. Unregisters any existing listener if null.
    /// - `flags`: Flags for optional features that should be enabled for the listener.
    pub fn r#set_navigation_event_listener2(
        &self,
        mut listener: Option<fidl::endpoints::ClientEnd<NavigationEventListenerMarker>>,
        mut flags: NavigationEventListenerFlags,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FrameSetNavigationEventListener2Request>(
            (listener, flags),
            0x5f8b40607f1f578f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// If set to a value other than [`ConsoleLogLevel.NONE`], allows web content to log messages
    /// to the [`fuchsia.logger/LogSink`] configured for this [`Frame`], via the
    /// `console` object (e.g. using `debug()`, `log()`, `info()`, `warn()` and
    /// `error()`).
    /// The default value is [`ConsoleLogLevel.NONE`].
    ///
    /// As the system log may be persisted, it is recommended that [`ConsoleLogLevel.NONE`] be used
    /// in Incognito and other private browsing modes.
    ///
    /// Log lines are written to the [`fuchsia.logger/LogsSink`] configured
    /// for this [`fuchsia.web/Frame`], with severities mapped as follows:
    /// - `debug()`, `log()` and `info()` are logged at [`fuchsia.logger/LogLevelFilter.INFO`]
    ///   severity.
    /// - `warn()` is logged at [`fuchsia.logger/LogLevelFilter.WARN`] severity.
    /// - `error()` is logged at [`fuchsia.logger/LogLevelFilter.ERROR`] severity.
    pub fn r#set_java_script_log_level(
        &self,
        mut level: ConsoleLogLevel,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FrameSetJavaScriptLogLevelRequest>(
            (level,),
            0x74824b11a71c4b5b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Specifies where to emit `console` log output to. By default log output will be routed to a
    /// [`fuchsia.logger/LogSink`] obtained via the [`fuchsia.web/Context`]'s service directory.
    ///
    /// - `sink`: The [`fuchsia.logger/LogSink`] to use to emit logs. Passing a `null` handle
    ///   resets logging to use the default [`fuchsia.logger/LogSink`].
    pub fn r#set_console_log_sink(
        &self,
        mut sink: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_logger::LogSinkMarker>>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FrameSetConsoleLogSinkRequest>(
            (sink,),
            0x18f5cbc19fa4687b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Enables or disables the processing of the specified `types` of user inputs.
    /// `allow` specifies whether to enable or disable the specified `types`.
    /// All input types are enabled by default.
    pub fn r#configure_input_types(
        &self,
        mut types: InputTypes,
        mut allow: AllowInputState,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FrameConfigureInputTypesRequest>(
            (types, allow),
            0x38e08fe763c6bef6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets the listener for handling popup frame opened by web content. If no listener is
    /// present, then any new popup frame will be blocked.
    ///
    /// - `listener`: The listener to use. Unregisters any existing listener if null.
    pub fn r#set_popup_frame_creation_listener(
        &self,
        mut listener: Option<fidl::endpoints::ClientEnd<PopupFrameCreationListenerMarker>>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FrameSetPopupFrameCreationListenerRequest>(
            (listener,),
            0x34ddec4e9f11e2aa,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Supplies a set of [`UrlRequestRewriteRule`] to apply on every subsequent URL request.
    /// - `rules` are cumulative and applied in order.
    /// - `rules` are only applied on the first URL request in a redirect chain.
    /// - `rules` will be validated before being applied. If `rules` are invalid, the [`Frame`]
    ///   will be closed with `ERR_INVALID_ARGS`.
    /// - [`Frame.SetUrlRequestRewriteRules`] must not be called again until its acknowledgement
    ///   callback has been processed. If this happens, the [`Frame`] will be closed with
    ///   `ERR_BAD_STATE`.
    pub fn r#set_url_request_rewrite_rules(
        &self,
        mut rules: &[UrlRequestRewriteRule],
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self
            .client
            .send_query::<FrameSetUrlRequestRewriteRulesRequest, fidl::encoding::EmptyPayload>(
                (rules,),
                0x2e3f797350ab3281,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response)
    }

    /// Sets [`fuchsia.media/FrameMediaSettings`] for the frame. The specified parameters are
    /// applied to audio streams that started after this message is processed. Should be called
    /// before the Frame is navigated to content in order to ensure that the settings applied to
    /// all media streams. Due to request pipelining, this means doing so before calling
    /// [`Frame.GetNavigationController()`] and [`NavigationController.LoadUrl()`].
    pub fn r#set_media_settings(
        &self,
        mut settings: &FrameMediaSettings,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FrameSetMediaSettingsRequest>(
            (settings,),
            0x7da879b6d284c143,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Overrides the dimensions reported to web content. The devicePixelRatio reported to
    /// web content will be adjusted in response to changes in the pixel size of the View,
    /// rather than changing the size reported to the content. Call with null `web_dips` to
    /// remove any prior forced content dimensions.
    pub fn r#force_content_dimensions(
        &self,
        mut web_dips: Option<&fidl_fuchsia_ui_gfx::Vec2>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FrameForceContentDimensionsRequest>(
            (web_dips,),
            0x8c7024c7149c901,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets the permission state for the specified `permission` and `web_origin`. By default, all
    /// permissions are denied.
    pub fn r#set_permission_state(
        &self,
        mut permission: &PermissionDescriptor,
        mut web_origin: &str,
        mut state: PermissionState,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FrameSetPermissionStateRequest>(
            (permission, web_origin, state),
            0x19574e92a7033f4f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets whether to block all HTMLMediaElements in the frame from fetching and loading media
    /// resources.
    ///
    /// May be used, for example, to prevent loading media in frames that are not visible.
    ///
    /// While media loading is blocked, elements with `autoplay` set to `true` will not start
    /// playback. The promises returned by calls to `play()` will remain unresolved until loading is
    /// unblocked by a call to this method.
    ///
    /// When media loading is unblocked, elements will begin fetching, resource, loading, and
    /// playing as appropriate.
    ///
    /// Any elements that have begun fetching or loading media resources for the current source
    /// before media loading was blocked will continue to fetch, load, and start playback as
    /// appropriate. This includes calls to `play()` even after media loading is blocked.
    pub fn r#set_block_media_loading(&self, mut blocked: bool) -> Result<(), fidl::Error> {
        self.client.send::<FrameSetBlockMediaLoadingRequest>(
            (blocked,),
            0x211071458fc9cf4f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Returns the amount of private (non-shared) physical memory used by the Frame's main
    /// document. The returned size might not reflect the memory usage of embedded iframes.
    pub fn r#get_private_memory_size(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<u64, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, FrameGetPrivateMemorySizeResponse>(
                (),
                0x6ad4d43da6c129b0,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.size_bytes)
    }

    /// Sets the navigation policy provider for the [`Frame`]. When set, the [`Frame`] sends
    /// [`NavigationPolicyProvider.EvaluateRequestedNavigation`] when processing navigation
    /// requests. `params` defines when the message is sent. After sending the
    /// `EvaluateRequestedNavigation` message, the [`Frame`] blocks the corresponding navigation
    /// until it receives a response.
    ///
    /// Should be called before `GetNavigationController` to ensure that it is applied to all
    /// navigations including the first [`NavigationController.LoadURL`] request.
    pub fn r#set_navigation_policy_provider(
        &self,
        mut params: &NavigationPolicyProviderParams,
        mut provider: fidl::endpoints::ClientEnd<NavigationPolicyProviderMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FrameSetNavigationPolicyProviderRequest>(
            (params, provider),
            0x602ce35195d66654,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Sets various settings for how web content should be run in the Frame. May be called at any
    /// time, including after the URL has loaded. Each call changes only the specified fields,
    /// overwriting any prior value.
    ///
    /// This method will fail with `ZX_ERR_NOT_SUPPORTED` if any value in [`ContentAreaSettings`]
    /// is not supported by the Frame.
    pub fn r#set_content_area_settings(
        &self,
        mut settings: &ContentAreaSettings,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FrameSetContentAreaSettingsRequest>(
            (settings,),
            0x851f4de50c3c27e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Reset the Frame's [`ContentAreaSettings`] to default values.
    pub fn r#reset_content_area_settings(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x6807e04f16f8ee5d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Request graceful or immediate teardown of the Frame content and notification of completion
    /// via Frame epitaph.
    ///
    /// Graceful teardown allows unload and cleanup tasks in the implementation and web content
    /// (e.g., `unload` event handlers) to run for up to the specified period of time. Immediate
    /// teardown only runs the minimum cleanup tasks in the implementation and does not allow web
    /// content to run event handlers.
    ///
    /// * If `timeout` is zero, an immediate teardown is initiated. The channel will close with
    ///   `ZX_OK`. This is equivalent to the caller closing the Frame channel.
    ///
    /// * If `timeout` is non-zero, a graceful teardown is initiated. The channel will close with
    ///   `ZX_OK` if the Frame closes within the specified `timeout` and with `ZX_ERR_TIMED_OUT`
    ///   otherwise.
    ///
    /// * If `timeout` is not specified, a reasonable implementation-specific timeout is applied.
    ///
    /// Subsequent calls to `Close()` will override any previously specified `Close()` timeout.
    pub fn r#close(&self, mut payload: &FrameCloseRequest) -> Result<(), fidl::Error> {
        self.client.send::<FrameCloseRequest>(
            payload,
            0x442e84138e65351,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Clone)]
pub struct FrameProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for FrameProxy {
    type Protocol = FrameMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl FrameProxy {
    /// Create a new Proxy for fuchsia.web/Frame.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <FrameMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> FrameEventStream {
        FrameEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Creates a new view using the specified `view_token`. Caller should pass the other end of
    /// the token to [`fuchsia.ui.gfx/ViewHolderArgs`] to attach the new view to a view tree.
    ///
    /// See the description of [`CreateContextParams.service_directory`] for additional services
    /// that must be present when using this method.
    pub fn r#create_view(
        &self,
        mut view_token: fidl_fuchsia_ui_views::ViewToken,
    ) -> Result<(), fidl::Error> {
        FrameProxyInterface::r#create_view(self, view_token)
    }

    /// Creates a new view using the specified `view_token`. Caller should pass the other end of
    /// the token to [`fuchsia.ui.gfx/ViewHolderArgs`] to attach the new view to a view tree.
    /// `view_ref` can be cloned before passing it to this method, which will allow clients to
    /// track the view.
    ///
    /// `view_ref_control` must not have the `ZX_RIGHT_DUPLICATE` set, or view creation will fail
    /// and `view_token` will be closed.
    ///
    /// See the description of [`CreateContextParams.service_directory`] for additional services
    /// that must be present when using this method.
    pub fn r#create_view_with_view_ref(
        &self,
        mut view_token: fidl_fuchsia_ui_views::ViewToken,
        mut view_ref_control: fidl_fuchsia_ui_views::ViewRefControl,
        mut view_ref: fidl_fuchsia_ui_views::ViewRef,
    ) -> Result<(), fidl::Error> {
        FrameProxyInterface::r#create_view_with_view_ref(
            self,
            view_token,
            view_ref_control,
            view_ref,
        )
    }

    /// Creates a new Flatland view using the specified `view_creation_token` defined under `args`.
    /// Caller should pass the other end of the token to
    /// [`fuchsia.ui.composition/Flatland.CreateViewport`] to attach the new Flatland view to its
    /// graph.
    pub fn r#create_view2(&self, mut args: CreateView2Args) -> Result<(), fidl::Error> {
        FrameProxyInterface::r#create_view2(self, args)
    }

    /// Enables headless rendering of the Frame.
    ///
    /// This is used when content depends on layout and/or animation events firing normally.
    /// May only be used on a Context created with [`ContextFeatureFlags.HEADLESS`].
    pub fn r#enable_headless_rendering(&self) -> Result<(), fidl::Error> {
        FrameProxyInterface::r#enable_headless_rendering(self)
    }

    /// Stops headless rendering of the Frame.
    ///
    /// May only be used on a Context created with [`ContextFeatureFlags.HEADLESS`].
    pub fn r#disable_headless_rendering(&self) -> Result<(), fidl::Error> {
        FrameProxyInterface::r#disable_headless_rendering(self)
    }

    /// Returns a [`fuchsia.media.sessions2/Player`] interface through which media (i.e.
    /// video/audio) playback in the frame may be observed, and/or controlled. Only one
    /// [`fuchsia.media.sessions2/Player`] may be active at a time, for each [`Frame`].
    pub fn r#get_media_player(
        &self,
        mut player: fidl::endpoints::ServerEnd<fidl_fuchsia_media_sessions2::PlayerMarker>,
    ) -> Result<(), fidl::Error> {
        FrameProxyInterface::r#get_media_player(self, player)
    }

    /// Returns an interface through which the [`Frame`] may be navigated to a desired URL,
    /// reloaded, etc.
    ///
    /// - `controller`: An asynchronous interface request for the [`Frame`]'s
    ///   [`NavigationController`].
    pub fn r#get_navigation_controller(
        &self,
        mut controller: fidl::endpoints::ServerEnd<NavigationControllerMarker>,
    ) -> Result<(), fidl::Error> {
        FrameProxyInterface::r#get_navigation_controller(self, controller)
    }

    /// Executes a UTF-8 encoded `script` in the [`Frame`] if the [`Frame`]'s URL has an origin
    /// which matches entries in `origins`.
    ///
    /// At least one `origins` entry must be specified. If a wildcard `"*"` is specified in
    /// `origins`, then the script will be evaluated unconditionally.
    ///
    /// Returns the result of executing `script`, as a JSON-encoded string.
    ///
    /// Note that scripts share the same execution context as the document,
    /// meaning that document may modify variables, classes, or objects set by
    /// the script in arbitrary or unpredictable ways.
    ///
    /// If an error occurred, the FrameError will be set to one of these values:
    /// - `BUFFER_NOT_UTF8`: `script` is not UTF-8 encoded.
    /// - `INVALID_ORIGIN`: The [`Frame`]'s current URL does not match any of the values in
    ///   `origins` or `origins` is an empty vector.
    pub fn r#execute_java_script(
        &self,
        mut origins: &[String],
        mut script: fidl_fuchsia_mem::Buffer,
    ) -> fidl::client::QueryResponseFut<
        FrameExecuteJavaScriptResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FrameProxyInterface::r#execute_java_script(self, origins, script)
    }

    /// Variant of [`Frame.ExecuteJavaScript`] which executes the supplied script without returning
    /// a result.
    pub fn r#execute_java_script_no_result(
        &self,
        mut origins: &[String],
        mut script: fidl_fuchsia_mem::Buffer,
    ) -> fidl::client::QueryResponseFut<
        FrameExecuteJavaScriptNoResultResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FrameProxyInterface::r#execute_java_script_no_result(self, origins, script)
    }

    /// Executes a UTF-8 encoded `script` for every subsequent page load where the [`Frame`]'s URL
    /// has an origin reflected in `origins`. The script is executed early, prior to the execution
    /// of the document's scripts.
    ///
    /// Scripts are identified by a client-managed identifier `id`. Any script previously injected
    /// using the same `id` will be replaced.
    ///
    /// The order in which multiple bindings are executed is the same as the order in which the
    /// bindings were added. If a script is added which clobbers an existing script of the same
    /// `id`, the previous script's precedence in the injection order will be preserved.
    ///
    /// At least one `origins` entry must be specified. If a wildcard `"*"` is specified in
    /// `origins`, then the script will be evaluated unconditionally.
    ///
    /// If an error occurred, the [`FrameError`] will be set to one of these values:
    /// - `BUFFER_NOT_UTF8`: `script` is not UTF-8 encoded.
    /// - `INVALID_ORIGIN`: `origins` is an empty vector.
    pub fn r#add_before_load_java_script(
        &self,
        mut id: u64,
        mut origins: &[String],
        mut script: fidl_fuchsia_mem::Buffer,
    ) -> fidl::client::QueryResponseFut<
        FrameAddBeforeLoadJavaScriptResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FrameProxyInterface::r#add_before_load_java_script(self, id, origins, script)
    }

    /// Removes a previously added JavaScript snippet identified by `id`. This is a no-op if there
    /// is no JavaScript snippet identified by `id`.
    pub fn r#remove_before_load_java_script(&self, mut id: u64) -> Result<(), fidl::Error> {
        FrameProxyInterface::r#remove_before_load_java_script(self, id)
    }

    /// Posts a message to the frame's onMessage handler.
    ///
    /// `target_origin` restricts message delivery to the specified origin. If `target_origin` is
    /// `"*"`, then the message will be sent to the document regardless of its origin.
    /// See the
    /// [HTML spec](https://html.spec.whatwg.org/multipage/web-messaging.html#posting-messages)
    /// section 9.4.3 for more details on how the target origin policy is applied.
    ///
    /// If an error occurred, the [`FrameError`] will be set to one of these values:
    /// - `INTERNAL_ERROR`: The WebEngine failed to create a message pipe.
    /// - `BUFFER_NOT_UTF8`: The script in `message`'s `data` property is not UTF-8 encoded.
    /// - `INVALID_ORIGIN`: `origins` is an empty vector.
    /// - `NO_DATA_IN_MESSAGE`: The `data` property is missing in `message`.
    pub fn r#post_message(
        &self,
        mut target_origin: &str,
        mut message: WebMessage,
    ) -> fidl::client::QueryResponseFut<
        FramePostMessageResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        FrameProxyInterface::r#post_message(self, target_origin, message)
    }

    /// Sets the listener for handling page navigation events.
    ///
    /// - `listener`: The observer to use. Unregisters any existing listener if null.
    pub fn r#set_navigation_event_listener(
        &self,
        mut listener: Option<fidl::endpoints::ClientEnd<NavigationEventListenerMarker>>,
    ) -> Result<(), fidl::Error> {
        FrameProxyInterface::r#set_navigation_event_listener(self, listener)
    }

    /// Sets the listener for handling page navigation events. The listener will receive the
    /// current navigation state immediately. After that, it's notified whenever the state changes.
    ///
    /// - `listener`: The observer to use. Unregisters any existing listener if null.
    /// - `flags`: Flags for optional features that should be enabled for the listener.
    pub fn r#set_navigation_event_listener2(
        &self,
        mut listener: Option<fidl::endpoints::ClientEnd<NavigationEventListenerMarker>>,
        mut flags: NavigationEventListenerFlags,
    ) -> Result<(), fidl::Error> {
        FrameProxyInterface::r#set_navigation_event_listener2(self, listener, flags)
    }

    /// If set to a value other than [`ConsoleLogLevel.NONE`], allows web content to log messages
    /// to the [`fuchsia.logger/LogSink`] configured for this [`Frame`], via the
    /// `console` object (e.g. using `debug()`, `log()`, `info()`, `warn()` and
    /// `error()`).
    /// The default value is [`ConsoleLogLevel.NONE`].
    ///
    /// As the system log may be persisted, it is recommended that [`ConsoleLogLevel.NONE`] be used
    /// in Incognito and other private browsing modes.
    ///
    /// Log lines are written to the [`fuchsia.logger/LogsSink`] configured
    /// for this [`fuchsia.web/Frame`], with severities mapped as follows:
    /// - `debug()`, `log()` and `info()` are logged at [`fuchsia.logger/LogLevelFilter.INFO`]
    ///   severity.
    /// - `warn()` is logged at [`fuchsia.logger/LogLevelFilter.WARN`] severity.
    /// - `error()` is logged at [`fuchsia.logger/LogLevelFilter.ERROR`] severity.
    pub fn r#set_java_script_log_level(
        &self,
        mut level: ConsoleLogLevel,
    ) -> Result<(), fidl::Error> {
        FrameProxyInterface::r#set_java_script_log_level(self, level)
    }

    /// Specifies where to emit `console` log output to. By default log output will be routed to a
    /// [`fuchsia.logger/LogSink`] obtained via the [`fuchsia.web/Context`]'s service directory.
    ///
    /// - `sink`: The [`fuchsia.logger/LogSink`] to use to emit logs. Passing a `null` handle
    ///   resets logging to use the default [`fuchsia.logger/LogSink`].
    pub fn r#set_console_log_sink(
        &self,
        mut sink: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_logger::LogSinkMarker>>,
    ) -> Result<(), fidl::Error> {
        FrameProxyInterface::r#set_console_log_sink(self, sink)
    }

    /// Enables or disables the processing of the specified `types` of user inputs.
    /// `allow` specifies whether to enable or disable the specified `types`.
    /// All input types are enabled by default.
    pub fn r#configure_input_types(
        &self,
        mut types: InputTypes,
        mut allow: AllowInputState,
    ) -> Result<(), fidl::Error> {
        FrameProxyInterface::r#configure_input_types(self, types, allow)
    }

    /// Sets the listener for handling popup frame opened by web content. If no listener is
    /// present, then any new popup frame will be blocked.
    ///
    /// - `listener`: The listener to use. Unregisters any existing listener if null.
    pub fn r#set_popup_frame_creation_listener(
        &self,
        mut listener: Option<fidl::endpoints::ClientEnd<PopupFrameCreationListenerMarker>>,
    ) -> Result<(), fidl::Error> {
        FrameProxyInterface::r#set_popup_frame_creation_listener(self, listener)
    }

    /// Supplies a set of [`UrlRequestRewriteRule`] to apply on every subsequent URL request.
    /// - `rules` are cumulative and applied in order.
    /// - `rules` are only applied on the first URL request in a redirect chain.
    /// - `rules` will be validated before being applied. If `rules` are invalid, the [`Frame`]
    ///   will be closed with `ERR_INVALID_ARGS`.
    /// - [`Frame.SetUrlRequestRewriteRules`] must not be called again until its acknowledgement
    ///   callback has been processed. If this happens, the [`Frame`] will be closed with
    ///   `ERR_BAD_STATE`.
    pub fn r#set_url_request_rewrite_rules(
        &self,
        mut rules: &[UrlRequestRewriteRule],
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        FrameProxyInterface::r#set_url_request_rewrite_rules(self, rules)
    }

    /// Sets [`fuchsia.media/FrameMediaSettings`] for the frame. The specified parameters are
    /// applied to audio streams that started after this message is processed. Should be called
    /// before the Frame is navigated to content in order to ensure that the settings applied to
    /// all media streams. Due to request pipelining, this means doing so before calling
    /// [`Frame.GetNavigationController()`] and [`NavigationController.LoadUrl()`].
    pub fn r#set_media_settings(
        &self,
        mut settings: &FrameMediaSettings,
    ) -> Result<(), fidl::Error> {
        FrameProxyInterface::r#set_media_settings(self, settings)
    }

    /// Overrides the dimensions reported to web content. The devicePixelRatio reported to
    /// web content will be adjusted in response to changes in the pixel size of the View,
    /// rather than changing the size reported to the content. Call with null `web_dips` to
    /// remove any prior forced content dimensions.
    pub fn r#force_content_dimensions(
        &self,
        mut web_dips: Option<&fidl_fuchsia_ui_gfx::Vec2>,
    ) -> Result<(), fidl::Error> {
        FrameProxyInterface::r#force_content_dimensions(self, web_dips)
    }

    /// Sets the permission state for the specified `permission` and `web_origin`. By default, all
    /// permissions are denied.
    pub fn r#set_permission_state(
        &self,
        mut permission: &PermissionDescriptor,
        mut web_origin: &str,
        mut state: PermissionState,
    ) -> Result<(), fidl::Error> {
        FrameProxyInterface::r#set_permission_state(self, permission, web_origin, state)
    }

    /// Sets whether to block all HTMLMediaElements in the frame from fetching and loading media
    /// resources.
    ///
    /// May be used, for example, to prevent loading media in frames that are not visible.
    ///
    /// While media loading is blocked, elements with `autoplay` set to `true` will not start
    /// playback. The promises returned by calls to `play()` will remain unresolved until loading is
    /// unblocked by a call to this method.
    ///
    /// When media loading is unblocked, elements will begin fetching, resource, loading, and
    /// playing as appropriate.
    ///
    /// Any elements that have begun fetching or loading media resources for the current source
    /// before media loading was blocked will continue to fetch, load, and start playback as
    /// appropriate. This includes calls to `play()` even after media loading is blocked.
    pub fn r#set_block_media_loading(&self, mut blocked: bool) -> Result<(), fidl::Error> {
        FrameProxyInterface::r#set_block_media_loading(self, blocked)
    }

    /// Returns the amount of private (non-shared) physical memory used by the Frame's main
    /// document. The returned size might not reflect the memory usage of embedded iframes.
    pub fn r#get_private_memory_size(
        &self,
    ) -> fidl::client::QueryResponseFut<u64, fidl::encoding::DefaultFuchsiaResourceDialect> {
        FrameProxyInterface::r#get_private_memory_size(self)
    }

    /// Sets the navigation policy provider for the [`Frame`]. When set, the [`Frame`] sends
    /// [`NavigationPolicyProvider.EvaluateRequestedNavigation`] when processing navigation
    /// requests. `params` defines when the message is sent. After sending the
    /// `EvaluateRequestedNavigation` message, the [`Frame`] blocks the corresponding navigation
    /// until it receives a response.
    ///
    /// Should be called before `GetNavigationController` to ensure that it is applied to all
    /// navigations including the first [`NavigationController.LoadURL`] request.
    pub fn r#set_navigation_policy_provider(
        &self,
        mut params: &NavigationPolicyProviderParams,
        mut provider: fidl::endpoints::ClientEnd<NavigationPolicyProviderMarker>,
    ) -> Result<(), fidl::Error> {
        FrameProxyInterface::r#set_navigation_policy_provider(self, params, provider)
    }

    /// Sets various settings for how web content should be run in the Frame. May be called at any
    /// time, including after the URL has loaded. Each call changes only the specified fields,
    /// overwriting any prior value.
    ///
    /// This method will fail with `ZX_ERR_NOT_SUPPORTED` if any value in [`ContentAreaSettings`]
    /// is not supported by the Frame.
    pub fn r#set_content_area_settings(
        &self,
        mut settings: &ContentAreaSettings,
    ) -> Result<(), fidl::Error> {
        FrameProxyInterface::r#set_content_area_settings(self, settings)
    }

    /// Reset the Frame's [`ContentAreaSettings`] to default values.
    pub fn r#reset_content_area_settings(&self) -> Result<(), fidl::Error> {
        FrameProxyInterface::r#reset_content_area_settings(self)
    }

    /// Request graceful or immediate teardown of the Frame content and notification of completion
    /// via Frame epitaph.
    ///
    /// Graceful teardown allows unload and cleanup tasks in the implementation and web content
    /// (e.g., `unload` event handlers) to run for up to the specified period of time. Immediate
    /// teardown only runs the minimum cleanup tasks in the implementation and does not allow web
    /// content to run event handlers.
    ///
    /// * If `timeout` is zero, an immediate teardown is initiated. The channel will close with
    ///   `ZX_OK`. This is equivalent to the caller closing the Frame channel.
    ///
    /// * If `timeout` is non-zero, a graceful teardown is initiated. The channel will close with
    ///   `ZX_OK` if the Frame closes within the specified `timeout` and with `ZX_ERR_TIMED_OUT`
    ///   otherwise.
    ///
    /// * If `timeout` is not specified, a reasonable implementation-specific timeout is applied.
    ///
    /// Subsequent calls to `Close()` will override any previously specified `Close()` timeout.
    pub fn r#close(&self, mut payload: &FrameCloseRequest) -> Result<(), fidl::Error> {
        FrameProxyInterface::r#close(self, payload)
    }
}

impl FrameProxyInterface for FrameProxy {
    fn r#create_view(
        &self,
        mut view_token: fidl_fuchsia_ui_views::ViewToken,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FrameCreateViewRequest>(
            (&mut view_token,),
            0x6a27859439133264,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#create_view_with_view_ref(
        &self,
        mut view_token: fidl_fuchsia_ui_views::ViewToken,
        mut view_ref_control: fidl_fuchsia_ui_views::ViewRefControl,
        mut view_ref: fidl_fuchsia_ui_views::ViewRef,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FrameCreateViewWithViewRefRequest>(
            (&mut view_token, &mut view_ref_control, &mut view_ref),
            0x1eb17ab2442326ac,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#create_view2(&self, mut args: CreateView2Args) -> Result<(), fidl::Error> {
        self.client.send::<FrameCreateView2Request>(
            (&mut args,),
            0x1be7e9512962eb37,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#enable_headless_rendering(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x72a81aaae7a80d2b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#disable_headless_rendering(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x5ca38a3d1f7f543a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#get_media_player(
        &self,
        mut player: fidl::endpoints::ServerEnd<fidl_fuchsia_media_sessions2::PlayerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FrameGetMediaPlayerRequest>(
            (player,),
            0xaafb639fc0b9eb9,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#get_navigation_controller(
        &self,
        mut controller: fidl::endpoints::ServerEnd<NavigationControllerMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FrameGetNavigationControllerRequest>(
            (controller,),
            0x4521cfe95217a688,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type ExecuteJavaScriptResponseFut = fidl::client::QueryResponseFut<
        FrameExecuteJavaScriptResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#execute_java_script(
        &self,
        mut origins: &[String],
        mut script: fidl_fuchsia_mem::Buffer,
    ) -> Self::ExecuteJavaScriptResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<FrameExecuteJavaScriptResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<FrameExecuteJavaScriptResponse, FrameError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x79abdd4907000542,
            >(_buf?)?;
            Ok(_response.map(|x| x.result))
        }
        self.client
            .send_query_and_decode::<FrameExecuteJavaScriptRequest, FrameExecuteJavaScriptResult>(
                (origins, &mut script),
                0x79abdd4907000542,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type ExecuteJavaScriptNoResultResponseFut = fidl::client::QueryResponseFut<
        FrameExecuteJavaScriptNoResultResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#execute_java_script_no_result(
        &self,
        mut origins: &[String],
        mut script: fidl_fuchsia_mem::Buffer,
    ) -> Self::ExecuteJavaScriptNoResultResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<FrameExecuteJavaScriptNoResultResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, FrameError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x16b8491520cbcd63,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            FrameExecuteJavaScriptNoResultRequest,
            FrameExecuteJavaScriptNoResultResult,
        >(
            (origins, &mut script,),
            0x16b8491520cbcd63,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    type AddBeforeLoadJavaScriptResponseFut = fidl::client::QueryResponseFut<
        FrameAddBeforeLoadJavaScriptResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#add_before_load_java_script(
        &self,
        mut id: u64,
        mut origins: &[String],
        mut script: fidl_fuchsia_mem::Buffer,
    ) -> Self::AddBeforeLoadJavaScriptResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<FrameAddBeforeLoadJavaScriptResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, FrameError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x540ac0da59d823e,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            FrameAddBeforeLoadJavaScriptRequest,
            FrameAddBeforeLoadJavaScriptResult,
        >(
            (id, origins, &mut script,),
            0x540ac0da59d823e,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#remove_before_load_java_script(&self, mut id: u64) -> Result<(), fidl::Error> {
        self.client.send::<FrameRemoveBeforeLoadJavaScriptRequest>(
            (id,),
            0x17d92b855b61d23a,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type PostMessageResponseFut = fidl::client::QueryResponseFut<
        FramePostMessageResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#post_message(
        &self,
        mut target_origin: &str,
        mut message: WebMessage,
    ) -> Self::PostMessageResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<FramePostMessageResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, FrameError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x751d686eb7caa341,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<FramePostMessageRequest, FramePostMessageResult>(
            (target_origin, &mut message),
            0x751d686eb7caa341,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#set_navigation_event_listener(
        &self,
        mut listener: Option<fidl::endpoints::ClientEnd<NavigationEventListenerMarker>>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FrameSetNavigationEventListenerRequest>(
            (listener,),
            0x965ba0fa20e0a56,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_navigation_event_listener2(
        &self,
        mut listener: Option<fidl::endpoints::ClientEnd<NavigationEventListenerMarker>>,
        mut flags: NavigationEventListenerFlags,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FrameSetNavigationEventListener2Request>(
            (listener, flags),
            0x5f8b40607f1f578f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_java_script_log_level(&self, mut level: ConsoleLogLevel) -> Result<(), fidl::Error> {
        self.client.send::<FrameSetJavaScriptLogLevelRequest>(
            (level,),
            0x74824b11a71c4b5b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_console_log_sink(
        &self,
        mut sink: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_logger::LogSinkMarker>>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FrameSetConsoleLogSinkRequest>(
            (sink,),
            0x18f5cbc19fa4687b,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#configure_input_types(
        &self,
        mut types: InputTypes,
        mut allow: AllowInputState,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FrameConfigureInputTypesRequest>(
            (types, allow),
            0x38e08fe763c6bef6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_popup_frame_creation_listener(
        &self,
        mut listener: Option<fidl::endpoints::ClientEnd<PopupFrameCreationListenerMarker>>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FrameSetPopupFrameCreationListenerRequest>(
            (listener,),
            0x34ddec4e9f11e2aa,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type SetUrlRequestRewriteRulesResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#set_url_request_rewrite_rules(
        &self,
        mut rules: &[UrlRequestRewriteRule],
    ) -> Self::SetUrlRequestRewriteRulesResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2e3f797350ab3281,
            >(_buf?)?;
            Ok(_response)
        }
        self.client.send_query_and_decode::<FrameSetUrlRequestRewriteRulesRequest, ()>(
            (rules,),
            0x2e3f797350ab3281,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#set_media_settings(&self, mut settings: &FrameMediaSettings) -> Result<(), fidl::Error> {
        self.client.send::<FrameSetMediaSettingsRequest>(
            (settings,),
            0x7da879b6d284c143,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#force_content_dimensions(
        &self,
        mut web_dips: Option<&fidl_fuchsia_ui_gfx::Vec2>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FrameForceContentDimensionsRequest>(
            (web_dips,),
            0x8c7024c7149c901,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_permission_state(
        &self,
        mut permission: &PermissionDescriptor,
        mut web_origin: &str,
        mut state: PermissionState,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FrameSetPermissionStateRequest>(
            (permission, web_origin, state),
            0x19574e92a7033f4f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_block_media_loading(&self, mut blocked: bool) -> Result<(), fidl::Error> {
        self.client.send::<FrameSetBlockMediaLoadingRequest>(
            (blocked,),
            0x211071458fc9cf4f,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    type GetPrivateMemorySizeResponseFut =
        fidl::client::QueryResponseFut<u64, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#get_private_memory_size(&self) -> Self::GetPrivateMemorySizeResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<u64, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                FrameGetPrivateMemorySizeResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6ad4d43da6c129b0,
            >(_buf?)?;
            Ok(_response.size_bytes)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, u64>(
            (),
            0x6ad4d43da6c129b0,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#set_navigation_policy_provider(
        &self,
        mut params: &NavigationPolicyProviderParams,
        mut provider: fidl::endpoints::ClientEnd<NavigationPolicyProviderMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FrameSetNavigationPolicyProviderRequest>(
            (params, provider),
            0x602ce35195d66654,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#set_content_area_settings(
        &self,
        mut settings: &ContentAreaSettings,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FrameSetContentAreaSettingsRequest>(
            (settings,),
            0x851f4de50c3c27e,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#reset_content_area_settings(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x6807e04f16f8ee5d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#close(&self, mut payload: &FrameCloseRequest) -> Result<(), fidl::Error> {
        self.client.send::<FrameCloseRequest>(
            payload,
            0x442e84138e65351,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

pub struct FrameEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for FrameEventStream {}

impl futures::stream::FusedStream for FrameEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for FrameEventStream {
    type Item = Result<FrameEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(FrameEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum FrameEvent {}

impl FrameEvent {
    /// Decodes a message buffer as a [`FrameEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<FrameEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <FrameMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.web/Frame.
pub struct FrameRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for FrameRequestStream {}

impl futures::stream::FusedStream for FrameRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for FrameRequestStream {
    type Protocol = FrameMarker;
    type ControlHandle = FrameControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        FrameControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for FrameRequestStream {
    type Item = Result<FrameRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled FrameRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))))
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x6a27859439133264 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FrameCreateViewRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FrameCreateViewRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FrameControlHandle { inner: this.inner.clone() };
                        Ok(FrameRequest::CreateView { view_token: req.view_token, control_handle })
                    }
                    0x1eb17ab2442326ac => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FrameCreateViewWithViewRefRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FrameCreateViewWithViewRefRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FrameControlHandle { inner: this.inner.clone() };
                        Ok(FrameRequest::CreateViewWithViewRef {
                            view_token: req.view_token,
                            view_ref_control: req.view_ref_control,
                            view_ref: req.view_ref,

                            control_handle,
                        })
                    }
                    0x1be7e9512962eb37 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FrameCreateView2Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FrameCreateView2Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FrameControlHandle { inner: this.inner.clone() };
                        Ok(FrameRequest::CreateView2 { args: req.args, control_handle })
                    }
                    0x72a81aaae7a80d2b => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FrameControlHandle { inner: this.inner.clone() };
                        Ok(FrameRequest::EnableHeadlessRendering { control_handle })
                    }
                    0x5ca38a3d1f7f543a => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FrameControlHandle { inner: this.inner.clone() };
                        Ok(FrameRequest::DisableHeadlessRendering { control_handle })
                    }
                    0xaafb639fc0b9eb9 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FrameGetMediaPlayerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FrameGetMediaPlayerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FrameControlHandle { inner: this.inner.clone() };
                        Ok(FrameRequest::GetMediaPlayer { player: req.player, control_handle })
                    }
                    0x4521cfe95217a688 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FrameGetNavigationControllerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FrameGetNavigationControllerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FrameControlHandle { inner: this.inner.clone() };
                        Ok(FrameRequest::GetNavigationController {
                            controller: req.controller,

                            control_handle,
                        })
                    }
                    0x79abdd4907000542 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            FrameExecuteJavaScriptRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FrameExecuteJavaScriptRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FrameControlHandle { inner: this.inner.clone() };
                        Ok(FrameRequest::ExecuteJavaScript {
                            origins: req.origins,
                            script: req.script,

                            responder: FrameExecuteJavaScriptResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x16b8491520cbcd63 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            FrameExecuteJavaScriptNoResultRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FrameExecuteJavaScriptNoResultRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FrameControlHandle { inner: this.inner.clone() };
                        Ok(FrameRequest::ExecuteJavaScriptNoResult {
                            origins: req.origins,
                            script: req.script,

                            responder: FrameExecuteJavaScriptNoResultResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x540ac0da59d823e => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            FrameAddBeforeLoadJavaScriptRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FrameAddBeforeLoadJavaScriptRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FrameControlHandle { inner: this.inner.clone() };
                        Ok(FrameRequest::AddBeforeLoadJavaScript {
                            id: req.id,
                            origins: req.origins,
                            script: req.script,

                            responder: FrameAddBeforeLoadJavaScriptResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x17d92b855b61d23a => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FrameRemoveBeforeLoadJavaScriptRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FrameRemoveBeforeLoadJavaScriptRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FrameControlHandle { inner: this.inner.clone() };
                        Ok(FrameRequest::RemoveBeforeLoadJavaScript { id: req.id, control_handle })
                    }
                    0x751d686eb7caa341 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            FramePostMessageRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FramePostMessageRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FrameControlHandle { inner: this.inner.clone() };
                        Ok(FrameRequest::PostMessage {
                            target_origin: req.target_origin,
                            message: req.message,

                            responder: FramePostMessageResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x965ba0fa20e0a56 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FrameSetNavigationEventListenerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FrameSetNavigationEventListenerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FrameControlHandle { inner: this.inner.clone() };
                        Ok(FrameRequest::SetNavigationEventListener {
                            listener: req.listener,

                            control_handle,
                        })
                    }
                    0x5f8b40607f1f578f => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FrameSetNavigationEventListener2Request,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FrameSetNavigationEventListener2Request>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FrameControlHandle { inner: this.inner.clone() };
                        Ok(FrameRequest::SetNavigationEventListener2 {
                            listener: req.listener,
                            flags: req.flags,

                            control_handle,
                        })
                    }
                    0x74824b11a71c4b5b => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FrameSetJavaScriptLogLevelRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FrameSetJavaScriptLogLevelRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FrameControlHandle { inner: this.inner.clone() };
                        Ok(FrameRequest::SetJavaScriptLogLevel { level: req.level, control_handle })
                    }
                    0x18f5cbc19fa4687b => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FrameSetConsoleLogSinkRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FrameSetConsoleLogSinkRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FrameControlHandle { inner: this.inner.clone() };
                        Ok(FrameRequest::SetConsoleLogSink { sink: req.sink, control_handle })
                    }
                    0x38e08fe763c6bef6 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FrameConfigureInputTypesRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FrameConfigureInputTypesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FrameControlHandle { inner: this.inner.clone() };
                        Ok(FrameRequest::ConfigureInputTypes {
                            types: req.types,
                            allow: req.allow,

                            control_handle,
                        })
                    }
                    0x34ddec4e9f11e2aa => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FrameSetPopupFrameCreationListenerRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FrameSetPopupFrameCreationListenerRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FrameControlHandle { inner: this.inner.clone() };
                        Ok(FrameRequest::SetPopupFrameCreationListener {
                            listener: req.listener,

                            control_handle,
                        })
                    }
                    0x2e3f797350ab3281 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            FrameSetUrlRequestRewriteRulesRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FrameSetUrlRequestRewriteRulesRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FrameControlHandle { inner: this.inner.clone() };
                        Ok(FrameRequest::SetUrlRequestRewriteRules {
                            rules: req.rules,

                            responder: FrameSetUrlRequestRewriteRulesResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x7da879b6d284c143 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FrameSetMediaSettingsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FrameSetMediaSettingsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FrameControlHandle { inner: this.inner.clone() };
                        Ok(FrameRequest::SetMediaSettings {
                            settings: req.settings,

                            control_handle,
                        })
                    }
                    0x8c7024c7149c901 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FrameForceContentDimensionsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FrameForceContentDimensionsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FrameControlHandle { inner: this.inner.clone() };
                        Ok(FrameRequest::ForceContentDimensions {
                            web_dips: req.web_dips,

                            control_handle,
                        })
                    }
                    0x19574e92a7033f4f => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FrameSetPermissionStateRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FrameSetPermissionStateRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FrameControlHandle { inner: this.inner.clone() };
                        Ok(FrameRequest::SetPermissionState {
                            permission: req.permission,
                            web_origin: req.web_origin,
                            state: req.state,

                            control_handle,
                        })
                    }
                    0x211071458fc9cf4f => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FrameSetBlockMediaLoadingRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FrameSetBlockMediaLoadingRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FrameControlHandle { inner: this.inner.clone() };
                        Ok(FrameRequest::SetBlockMediaLoading {
                            blocked: req.blocked,

                            control_handle,
                        })
                    }
                    0x6ad4d43da6c129b0 => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FrameControlHandle { inner: this.inner.clone() };
                        Ok(FrameRequest::GetPrivateMemorySize {
                            responder: FrameGetPrivateMemorySizeResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x602ce35195d66654 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FrameSetNavigationPolicyProviderRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FrameSetNavigationPolicyProviderRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FrameControlHandle { inner: this.inner.clone() };
                        Ok(FrameRequest::SetNavigationPolicyProvider {
                            params: req.params,
                            provider: req.provider,

                            control_handle,
                        })
                    }
                    0x851f4de50c3c27e => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FrameSetContentAreaSettingsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FrameSetContentAreaSettingsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FrameControlHandle { inner: this.inner.clone() };
                        Ok(FrameRequest::SetContentAreaSettings {
                            settings: req.settings,

                            control_handle,
                        })
                    }
                    0x6807e04f16f8ee5d => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FrameControlHandle { inner: this.inner.clone() };
                        Ok(FrameRequest::ResetContentAreaSettings { control_handle })
                    }
                    0x442e84138e65351 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FrameCloseRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FrameCloseRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FrameControlHandle { inner: this.inner.clone() };
                        Ok(FrameRequest::Close { payload: req, control_handle })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name: <FrameMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

#[derive(Debug)]
pub enum FrameRequest {
    /// Creates a new view using the specified `view_token`. Caller should pass the other end of
    /// the token to [`fuchsia.ui.gfx/ViewHolderArgs`] to attach the new view to a view tree.
    ///
    /// See the description of [`CreateContextParams.service_directory`] for additional services
    /// that must be present when using this method.
    CreateView { view_token: fidl_fuchsia_ui_views::ViewToken, control_handle: FrameControlHandle },
    /// Creates a new view using the specified `view_token`. Caller should pass the other end of
    /// the token to [`fuchsia.ui.gfx/ViewHolderArgs`] to attach the new view to a view tree.
    /// `view_ref` can be cloned before passing it to this method, which will allow clients to
    /// track the view.
    ///
    /// `view_ref_control` must not have the `ZX_RIGHT_DUPLICATE` set, or view creation will fail
    /// and `view_token` will be closed.
    ///
    /// See the description of [`CreateContextParams.service_directory`] for additional services
    /// that must be present when using this method.
    CreateViewWithViewRef {
        view_token: fidl_fuchsia_ui_views::ViewToken,
        view_ref_control: fidl_fuchsia_ui_views::ViewRefControl,
        view_ref: fidl_fuchsia_ui_views::ViewRef,
        control_handle: FrameControlHandle,
    },
    /// Creates a new Flatland view using the specified `view_creation_token` defined under `args`.
    /// Caller should pass the other end of the token to
    /// [`fuchsia.ui.composition/Flatland.CreateViewport`] to attach the new Flatland view to its
    /// graph.
    CreateView2 { args: CreateView2Args, control_handle: FrameControlHandle },
    /// Enables headless rendering of the Frame.
    ///
    /// This is used when content depends on layout and/or animation events firing normally.
    /// May only be used on a Context created with [`ContextFeatureFlags.HEADLESS`].
    EnableHeadlessRendering { control_handle: FrameControlHandle },
    /// Stops headless rendering of the Frame.
    ///
    /// May only be used on a Context created with [`ContextFeatureFlags.HEADLESS`].
    DisableHeadlessRendering { control_handle: FrameControlHandle },
    /// Returns a [`fuchsia.media.sessions2/Player`] interface through which media (i.e.
    /// video/audio) playback in the frame may be observed, and/or controlled. Only one
    /// [`fuchsia.media.sessions2/Player`] may be active at a time, for each [`Frame`].
    GetMediaPlayer {
        player: fidl::endpoints::ServerEnd<fidl_fuchsia_media_sessions2::PlayerMarker>,
        control_handle: FrameControlHandle,
    },
    /// Returns an interface through which the [`Frame`] may be navigated to a desired URL,
    /// reloaded, etc.
    ///
    /// - `controller`: An asynchronous interface request for the [`Frame`]'s
    ///   [`NavigationController`].
    GetNavigationController {
        controller: fidl::endpoints::ServerEnd<NavigationControllerMarker>,
        control_handle: FrameControlHandle,
    },
    /// Executes a UTF-8 encoded `script` in the [`Frame`] if the [`Frame`]'s URL has an origin
    /// which matches entries in `origins`.
    ///
    /// At least one `origins` entry must be specified. If a wildcard `"*"` is specified in
    /// `origins`, then the script will be evaluated unconditionally.
    ///
    /// Returns the result of executing `script`, as a JSON-encoded string.
    ///
    /// Note that scripts share the same execution context as the document,
    /// meaning that document may modify variables, classes, or objects set by
    /// the script in arbitrary or unpredictable ways.
    ///
    /// If an error occurred, the FrameError will be set to one of these values:
    /// - `BUFFER_NOT_UTF8`: `script` is not UTF-8 encoded.
    /// - `INVALID_ORIGIN`: The [`Frame`]'s current URL does not match any of the values in
    ///   `origins` or `origins` is an empty vector.
    ExecuteJavaScript {
        origins: Vec<String>,
        script: fidl_fuchsia_mem::Buffer,
        responder: FrameExecuteJavaScriptResponder,
    },
    /// Variant of [`Frame.ExecuteJavaScript`] which executes the supplied script without returning
    /// a result.
    ExecuteJavaScriptNoResult {
        origins: Vec<String>,
        script: fidl_fuchsia_mem::Buffer,
        responder: FrameExecuteJavaScriptNoResultResponder,
    },
    /// Executes a UTF-8 encoded `script` for every subsequent page load where the [`Frame`]'s URL
    /// has an origin reflected in `origins`. The script is executed early, prior to the execution
    /// of the document's scripts.
    ///
    /// Scripts are identified by a client-managed identifier `id`. Any script previously injected
    /// using the same `id` will be replaced.
    ///
    /// The order in which multiple bindings are executed is the same as the order in which the
    /// bindings were added. If a script is added which clobbers an existing script of the same
    /// `id`, the previous script's precedence in the injection order will be preserved.
    ///
    /// At least one `origins` entry must be specified. If a wildcard `"*"` is specified in
    /// `origins`, then the script will be evaluated unconditionally.
    ///
    /// If an error occurred, the [`FrameError`] will be set to one of these values:
    /// - `BUFFER_NOT_UTF8`: `script` is not UTF-8 encoded.
    /// - `INVALID_ORIGIN`: `origins` is an empty vector.
    AddBeforeLoadJavaScript {
        id: u64,
        origins: Vec<String>,
        script: fidl_fuchsia_mem::Buffer,
        responder: FrameAddBeforeLoadJavaScriptResponder,
    },
    /// Removes a previously added JavaScript snippet identified by `id`. This is a no-op if there
    /// is no JavaScript snippet identified by `id`.
    RemoveBeforeLoadJavaScript { id: u64, control_handle: FrameControlHandle },
    /// Posts a message to the frame's onMessage handler.
    ///
    /// `target_origin` restricts message delivery to the specified origin. If `target_origin` is
    /// `"*"`, then the message will be sent to the document regardless of its origin.
    /// See the
    /// [HTML spec](https://html.spec.whatwg.org/multipage/web-messaging.html#posting-messages)
    /// section 9.4.3 for more details on how the target origin policy is applied.
    ///
    /// If an error occurred, the [`FrameError`] will be set to one of these values:
    /// - `INTERNAL_ERROR`: The WebEngine failed to create a message pipe.
    /// - `BUFFER_NOT_UTF8`: The script in `message`'s `data` property is not UTF-8 encoded.
    /// - `INVALID_ORIGIN`: `origins` is an empty vector.
    /// - `NO_DATA_IN_MESSAGE`: The `data` property is missing in `message`.
    PostMessage { target_origin: String, message: WebMessage, responder: FramePostMessageResponder },
    /// Sets the listener for handling page navigation events.
    ///
    /// - `listener`: The observer to use. Unregisters any existing listener if null.
    SetNavigationEventListener {
        listener: Option<fidl::endpoints::ClientEnd<NavigationEventListenerMarker>>,
        control_handle: FrameControlHandle,
    },
    /// Sets the listener for handling page navigation events. The listener will receive the
    /// current navigation state immediately. After that, it's notified whenever the state changes.
    ///
    /// - `listener`: The observer to use. Unregisters any existing listener if null.
    /// - `flags`: Flags for optional features that should be enabled for the listener.
    SetNavigationEventListener2 {
        listener: Option<fidl::endpoints::ClientEnd<NavigationEventListenerMarker>>,
        flags: NavigationEventListenerFlags,
        control_handle: FrameControlHandle,
    },
    /// If set to a value other than [`ConsoleLogLevel.NONE`], allows web content to log messages
    /// to the [`fuchsia.logger/LogSink`] configured for this [`Frame`], via the
    /// `console` object (e.g. using `debug()`, `log()`, `info()`, `warn()` and
    /// `error()`).
    /// The default value is [`ConsoleLogLevel.NONE`].
    ///
    /// As the system log may be persisted, it is recommended that [`ConsoleLogLevel.NONE`] be used
    /// in Incognito and other private browsing modes.
    ///
    /// Log lines are written to the [`fuchsia.logger/LogsSink`] configured
    /// for this [`fuchsia.web/Frame`], with severities mapped as follows:
    /// - `debug()`, `log()` and `info()` are logged at [`fuchsia.logger/LogLevelFilter.INFO`]
    ///   severity.
    /// - `warn()` is logged at [`fuchsia.logger/LogLevelFilter.WARN`] severity.
    /// - `error()` is logged at [`fuchsia.logger/LogLevelFilter.ERROR`] severity.
    SetJavaScriptLogLevel { level: ConsoleLogLevel, control_handle: FrameControlHandle },
    /// Specifies where to emit `console` log output to. By default log output will be routed to a
    /// [`fuchsia.logger/LogSink`] obtained via the [`fuchsia.web/Context`]'s service directory.
    ///
    /// - `sink`: The [`fuchsia.logger/LogSink`] to use to emit logs. Passing a `null` handle
    ///   resets logging to use the default [`fuchsia.logger/LogSink`].
    SetConsoleLogSink {
        sink: Option<fidl::endpoints::ClientEnd<fidl_fuchsia_logger::LogSinkMarker>>,
        control_handle: FrameControlHandle,
    },
    /// Enables or disables the processing of the specified `types` of user inputs.
    /// `allow` specifies whether to enable or disable the specified `types`.
    /// All input types are enabled by default.
    ConfigureInputTypes {
        types: InputTypes,
        allow: AllowInputState,
        control_handle: FrameControlHandle,
    },
    /// Sets the listener for handling popup frame opened by web content. If no listener is
    /// present, then any new popup frame will be blocked.
    ///
    /// - `listener`: The listener to use. Unregisters any existing listener if null.
    SetPopupFrameCreationListener {
        listener: Option<fidl::endpoints::ClientEnd<PopupFrameCreationListenerMarker>>,
        control_handle: FrameControlHandle,
    },
    /// Supplies a set of [`UrlRequestRewriteRule`] to apply on every subsequent URL request.
    /// - `rules` are cumulative and applied in order.
    /// - `rules` are only applied on the first URL request in a redirect chain.
    /// - `rules` will be validated before being applied. If `rules` are invalid, the [`Frame`]
    ///   will be closed with `ERR_INVALID_ARGS`.
    /// - [`Frame.SetUrlRequestRewriteRules`] must not be called again until its acknowledgement
    ///   callback has been processed. If this happens, the [`Frame`] will be closed with
    ///   `ERR_BAD_STATE`.
    SetUrlRequestRewriteRules {
        rules: Vec<UrlRequestRewriteRule>,
        responder: FrameSetUrlRequestRewriteRulesResponder,
    },
    /// Sets [`fuchsia.media/FrameMediaSettings`] for the frame. The specified parameters are
    /// applied to audio streams that started after this message is processed. Should be called
    /// before the Frame is navigated to content in order to ensure that the settings applied to
    /// all media streams. Due to request pipelining, this means doing so before calling
    /// [`Frame.GetNavigationController()`] and [`NavigationController.LoadUrl()`].
    SetMediaSettings { settings: FrameMediaSettings, control_handle: FrameControlHandle },
    /// Overrides the dimensions reported to web content. The devicePixelRatio reported to
    /// web content will be adjusted in response to changes in the pixel size of the View,
    /// rather than changing the size reported to the content. Call with null `web_dips` to
    /// remove any prior forced content dimensions.
    ForceContentDimensions {
        web_dips: Option<Box<fidl_fuchsia_ui_gfx::Vec2>>,
        control_handle: FrameControlHandle,
    },
    /// Sets the permission state for the specified `permission` and `web_origin`. By default, all
    /// permissions are denied.
    SetPermissionState {
        permission: PermissionDescriptor,
        web_origin: String,
        state: PermissionState,
        control_handle: FrameControlHandle,
    },
    /// Sets whether to block all HTMLMediaElements in the frame from fetching and loading media
    /// resources.
    ///
    /// May be used, for example, to prevent loading media in frames that are not visible.
    ///
    /// While media loading is blocked, elements with `autoplay` set to `true` will not start
    /// playback. The promises returned by calls to `play()` will remain unresolved until loading is
    /// unblocked by a call to this method.
    ///
    /// When media loading is unblocked, elements will begin fetching, resource, loading, and
    /// playing as appropriate.
    ///
    /// Any elements that have begun fetching or loading media resources for the current source
    /// before media loading was blocked will continue to fetch, load, and start playback as
    /// appropriate. This includes calls to `play()` even after media loading is blocked.
    SetBlockMediaLoading { blocked: bool, control_handle: FrameControlHandle },
    /// Returns the amount of private (non-shared) physical memory used by the Frame's main
    /// document. The returned size might not reflect the memory usage of embedded iframes.
    GetPrivateMemorySize { responder: FrameGetPrivateMemorySizeResponder },
    /// Sets the navigation policy provider for the [`Frame`]. When set, the [`Frame`] sends
    /// [`NavigationPolicyProvider.EvaluateRequestedNavigation`] when processing navigation
    /// requests. `params` defines when the message is sent. After sending the
    /// `EvaluateRequestedNavigation` message, the [`Frame`] blocks the corresponding navigation
    /// until it receives a response.
    ///
    /// Should be called before `GetNavigationController` to ensure that it is applied to all
    /// navigations including the first [`NavigationController.LoadURL`] request.
    SetNavigationPolicyProvider {
        params: NavigationPolicyProviderParams,
        provider: fidl::endpoints::ClientEnd<NavigationPolicyProviderMarker>,
        control_handle: FrameControlHandle,
    },
    /// Sets various settings for how web content should be run in the Frame. May be called at any
    /// time, including after the URL has loaded. Each call changes only the specified fields,
    /// overwriting any prior value.
    ///
    /// This method will fail with `ZX_ERR_NOT_SUPPORTED` if any value in [`ContentAreaSettings`]
    /// is not supported by the Frame.
    SetContentAreaSettings { settings: ContentAreaSettings, control_handle: FrameControlHandle },
    /// Reset the Frame's [`ContentAreaSettings`] to default values.
    ResetContentAreaSettings { control_handle: FrameControlHandle },
    /// Request graceful or immediate teardown of the Frame content and notification of completion
    /// via Frame epitaph.
    ///
    /// Graceful teardown allows unload and cleanup tasks in the implementation and web content
    /// (e.g., `unload` event handlers) to run for up to the specified period of time. Immediate
    /// teardown only runs the minimum cleanup tasks in the implementation and does not allow web
    /// content to run event handlers.
    ///
    /// * If `timeout` is zero, an immediate teardown is initiated. The channel will close with
    ///   `ZX_OK`. This is equivalent to the caller closing the Frame channel.
    ///
    /// * If `timeout` is non-zero, a graceful teardown is initiated. The channel will close with
    ///   `ZX_OK` if the Frame closes within the specified `timeout` and with `ZX_ERR_TIMED_OUT`
    ///   otherwise.
    ///
    /// * If `timeout` is not specified, a reasonable implementation-specific timeout is applied.
    ///
    /// Subsequent calls to `Close()` will override any previously specified `Close()` timeout.
    Close { payload: FrameCloseRequest, control_handle: FrameControlHandle },
}

impl FrameRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_create_view(
        self,
    ) -> Option<(fidl_fuchsia_ui_views::ViewToken, FrameControlHandle)> {
        if let FrameRequest::CreateView { view_token, control_handle } = self {
            Some((view_token, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_view_with_view_ref(
        self,
    ) -> Option<(
        fidl_fuchsia_ui_views::ViewToken,
        fidl_fuchsia_ui_views::ViewRefControl,
        fidl_fuchsia_ui_views::ViewRef,
        FrameControlHandle,
    )> {
        if let FrameRequest::CreateViewWithViewRef {
            view_token,
            view_ref_control,
            view_ref,
            control_handle,
        } = self
        {
            Some((view_token, view_ref_control, view_ref, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_create_view2(self) -> Option<(CreateView2Args, FrameControlHandle)> {
        if let FrameRequest::CreateView2 { args, control_handle } = self {
            Some((args, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_enable_headless_rendering(self) -> Option<(FrameControlHandle)> {
        if let FrameRequest::EnableHeadlessRendering { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_disable_headless_rendering(self) -> Option<(FrameControlHandle)> {
        if let FrameRequest::DisableHeadlessRendering { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_media_player(
        self,
    ) -> Option<(
        fidl::endpoints::ServerEnd<fidl_fuchsia_media_sessions2::PlayerMarker>,
        FrameControlHandle,
    )> {
        if let FrameRequest::GetMediaPlayer { player, control_handle } = self {
            Some((player, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_navigation_controller(
        self,
    ) -> Option<(fidl::endpoints::ServerEnd<NavigationControllerMarker>, FrameControlHandle)> {
        if let FrameRequest::GetNavigationController { controller, control_handle } = self {
            Some((controller, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_execute_java_script(
        self,
    ) -> Option<(Vec<String>, fidl_fuchsia_mem::Buffer, FrameExecuteJavaScriptResponder)> {
        if let FrameRequest::ExecuteJavaScript { origins, script, responder } = self {
            Some((origins, script, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_execute_java_script_no_result(
        self,
    ) -> Option<(Vec<String>, fidl_fuchsia_mem::Buffer, FrameExecuteJavaScriptNoResultResponder)>
    {
        if let FrameRequest::ExecuteJavaScriptNoResult { origins, script, responder } = self {
            Some((origins, script, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_add_before_load_java_script(
        self,
    ) -> Option<(u64, Vec<String>, fidl_fuchsia_mem::Buffer, FrameAddBeforeLoadJavaScriptResponder)>
    {
        if let FrameRequest::AddBeforeLoadJavaScript { id, origins, script, responder } = self {
            Some((id, origins, script, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_remove_before_load_java_script(self) -> Option<(u64, FrameControlHandle)> {
        if let FrameRequest::RemoveBeforeLoadJavaScript { id, control_handle } = self {
            Some((id, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_post_message(self) -> Option<(String, WebMessage, FramePostMessageResponder)> {
        if let FrameRequest::PostMessage { target_origin, message, responder } = self {
            Some((target_origin, message, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_navigation_event_listener(
        self,
    ) -> Option<(
        Option<fidl::endpoints::ClientEnd<NavigationEventListenerMarker>>,
        FrameControlHandle,
    )> {
        if let FrameRequest::SetNavigationEventListener { listener, control_handle } = self {
            Some((listener, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_navigation_event_listener2(
        self,
    ) -> Option<(
        Option<fidl::endpoints::ClientEnd<NavigationEventListenerMarker>>,
        NavigationEventListenerFlags,
        FrameControlHandle,
    )> {
        if let FrameRequest::SetNavigationEventListener2 { listener, flags, control_handle } = self
        {
            Some((listener, flags, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_java_script_log_level(self) -> Option<(ConsoleLogLevel, FrameControlHandle)> {
        if let FrameRequest::SetJavaScriptLogLevel { level, control_handle } = self {
            Some((level, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_console_log_sink(
        self,
    ) -> Option<(
        Option<fidl::endpoints::ClientEnd<fidl_fuchsia_logger::LogSinkMarker>>,
        FrameControlHandle,
    )> {
        if let FrameRequest::SetConsoleLogSink { sink, control_handle } = self {
            Some((sink, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_configure_input_types(
        self,
    ) -> Option<(InputTypes, AllowInputState, FrameControlHandle)> {
        if let FrameRequest::ConfigureInputTypes { types, allow, control_handle } = self {
            Some((types, allow, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_popup_frame_creation_listener(
        self,
    ) -> Option<(
        Option<fidl::endpoints::ClientEnd<PopupFrameCreationListenerMarker>>,
        FrameControlHandle,
    )> {
        if let FrameRequest::SetPopupFrameCreationListener { listener, control_handle } = self {
            Some((listener, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_url_request_rewrite_rules(
        self,
    ) -> Option<(Vec<UrlRequestRewriteRule>, FrameSetUrlRequestRewriteRulesResponder)> {
        if let FrameRequest::SetUrlRequestRewriteRules { rules, responder } = self {
            Some((rules, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_media_settings(self) -> Option<(FrameMediaSettings, FrameControlHandle)> {
        if let FrameRequest::SetMediaSettings { settings, control_handle } = self {
            Some((settings, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_force_content_dimensions(
        self,
    ) -> Option<(Option<Box<fidl_fuchsia_ui_gfx::Vec2>>, FrameControlHandle)> {
        if let FrameRequest::ForceContentDimensions { web_dips, control_handle } = self {
            Some((web_dips, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_permission_state(
        self,
    ) -> Option<(PermissionDescriptor, String, PermissionState, FrameControlHandle)> {
        if let FrameRequest::SetPermissionState { permission, web_origin, state, control_handle } =
            self
        {
            Some((permission, web_origin, state, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_block_media_loading(self) -> Option<(bool, FrameControlHandle)> {
        if let FrameRequest::SetBlockMediaLoading { blocked, control_handle } = self {
            Some((blocked, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_get_private_memory_size(self) -> Option<(FrameGetPrivateMemorySizeResponder)> {
        if let FrameRequest::GetPrivateMemorySize { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_navigation_policy_provider(
        self,
    ) -> Option<(
        NavigationPolicyProviderParams,
        fidl::endpoints::ClientEnd<NavigationPolicyProviderMarker>,
        FrameControlHandle,
    )> {
        if let FrameRequest::SetNavigationPolicyProvider { params, provider, control_handle } = self
        {
            Some((params, provider, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_set_content_area_settings(
        self,
    ) -> Option<(ContentAreaSettings, FrameControlHandle)> {
        if let FrameRequest::SetContentAreaSettings { settings, control_handle } = self {
            Some((settings, control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_reset_content_area_settings(self) -> Option<(FrameControlHandle)> {
        if let FrameRequest::ResetContentAreaSettings { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_close(self) -> Option<(FrameCloseRequest, FrameControlHandle)> {
        if let FrameRequest::Close { payload, control_handle } = self {
            Some((payload, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            FrameRequest::CreateView { .. } => "create_view",
            FrameRequest::CreateViewWithViewRef { .. } => "create_view_with_view_ref",
            FrameRequest::CreateView2 { .. } => "create_view2",
            FrameRequest::EnableHeadlessRendering { .. } => "enable_headless_rendering",
            FrameRequest::DisableHeadlessRendering { .. } => "disable_headless_rendering",
            FrameRequest::GetMediaPlayer { .. } => "get_media_player",
            FrameRequest::GetNavigationController { .. } => "get_navigation_controller",
            FrameRequest::ExecuteJavaScript { .. } => "execute_java_script",
            FrameRequest::ExecuteJavaScriptNoResult { .. } => "execute_java_script_no_result",
            FrameRequest::AddBeforeLoadJavaScript { .. } => "add_before_load_java_script",
            FrameRequest::RemoveBeforeLoadJavaScript { .. } => "remove_before_load_java_script",
            FrameRequest::PostMessage { .. } => "post_message",
            FrameRequest::SetNavigationEventListener { .. } => "set_navigation_event_listener",
            FrameRequest::SetNavigationEventListener2 { .. } => "set_navigation_event_listener2",
            FrameRequest::SetJavaScriptLogLevel { .. } => "set_java_script_log_level",
            FrameRequest::SetConsoleLogSink { .. } => "set_console_log_sink",
            FrameRequest::ConfigureInputTypes { .. } => "configure_input_types",
            FrameRequest::SetPopupFrameCreationListener { .. } => {
                "set_popup_frame_creation_listener"
            }
            FrameRequest::SetUrlRequestRewriteRules { .. } => "set_url_request_rewrite_rules",
            FrameRequest::SetMediaSettings { .. } => "set_media_settings",
            FrameRequest::ForceContentDimensions { .. } => "force_content_dimensions",
            FrameRequest::SetPermissionState { .. } => "set_permission_state",
            FrameRequest::SetBlockMediaLoading { .. } => "set_block_media_loading",
            FrameRequest::GetPrivateMemorySize { .. } => "get_private_memory_size",
            FrameRequest::SetNavigationPolicyProvider { .. } => "set_navigation_policy_provider",
            FrameRequest::SetContentAreaSettings { .. } => "set_content_area_settings",
            FrameRequest::ResetContentAreaSettings { .. } => "reset_content_area_settings",
            FrameRequest::Close { .. } => "close",
        }
    }
}

#[derive(Debug, Clone)]
pub struct FrameControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::ControlHandle for FrameControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl FrameControlHandle {}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct FrameExecuteJavaScriptResponder {
    control_handle: std::mem::ManuallyDrop<FrameControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`FrameControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for FrameExecuteJavaScriptResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for FrameExecuteJavaScriptResponder {
    type ControlHandle = FrameControlHandle;

    fn control_handle(&self) -> &FrameControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl FrameExecuteJavaScriptResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<fidl_fuchsia_mem::Buffer, FrameError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<fidl_fuchsia_mem::Buffer, FrameError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<fidl_fuchsia_mem::Buffer, FrameError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            FrameExecuteJavaScriptResponse,
            FrameError,
        >>(
            result.as_mut().map_err(|e| *e).map(|result| (result,)),
            self.tx_id,
            0x79abdd4907000542,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct FrameExecuteJavaScriptNoResultResponder {
    control_handle: std::mem::ManuallyDrop<FrameControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`FrameControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for FrameExecuteJavaScriptNoResultResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for FrameExecuteJavaScriptNoResultResponder {
    type ControlHandle = FrameControlHandle;

    fn control_handle(&self) -> &FrameControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl FrameExecuteJavaScriptNoResultResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), FrameError>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), FrameError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), FrameError>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, FrameError>>(
                result,
                self.tx_id,
                0x16b8491520cbcd63,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct FrameAddBeforeLoadJavaScriptResponder {
    control_handle: std::mem::ManuallyDrop<FrameControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`FrameControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for FrameAddBeforeLoadJavaScriptResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for FrameAddBeforeLoadJavaScriptResponder {
    type ControlHandle = FrameControlHandle;

    fn control_handle(&self) -> &FrameControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl FrameAddBeforeLoadJavaScriptResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), FrameError>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), FrameError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), FrameError>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, FrameError>>(
                result,
                self.tx_id,
                0x540ac0da59d823e,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct FramePostMessageResponder {
    control_handle: std::mem::ManuallyDrop<FrameControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`FrameControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for FramePostMessageResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for FramePostMessageResponder {
    type ControlHandle = FrameControlHandle;

    fn control_handle(&self) -> &FrameControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl FramePostMessageResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), FrameError>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), FrameError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), FrameError>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, FrameError>>(
                result,
                self.tx_id,
                0x751d686eb7caa341,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct FrameSetUrlRequestRewriteRulesResponder {
    control_handle: std::mem::ManuallyDrop<FrameControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`FrameControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for FrameSetUrlRequestRewriteRulesResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for FrameSetUrlRequestRewriteRulesResponder {
    type ControlHandle = FrameControlHandle;

    fn control_handle(&self) -> &FrameControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl FrameSetUrlRequestRewriteRulesResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self) -> Result<(), fidl::Error> {
        let _result = self.send_raw();
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
        let _result = self.send_raw();
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            self.tx_id,
            0x2e3f797350ab3281,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct FrameGetPrivateMemorySizeResponder {
    control_handle: std::mem::ManuallyDrop<FrameControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`FrameControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for FrameGetPrivateMemorySizeResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for FrameGetPrivateMemorySizeResponder {
    type ControlHandle = FrameControlHandle;

    fn control_handle(&self) -> &FrameControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl FrameGetPrivateMemorySizeResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut size_bytes: u64) -> Result<(), fidl::Error> {
        let _result = self.send_raw(size_bytes);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut size_bytes: u64) -> Result<(), fidl::Error> {
        let _result = self.send_raw(size_bytes);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut size_bytes: u64) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<FrameGetPrivateMemorySizeResponse>(
            (size_bytes,),
            self.tx_id,
            0x6ad4d43da6c129b0,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct FrameHostMarker;

impl fidl::endpoints::ProtocolMarker for FrameHostMarker {
    type Proxy = FrameHostProxy;
    type RequestStream = FrameHostRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = FrameHostSynchronousProxy;

    const DEBUG_NAME: &'static str = "fuchsia.web.FrameHost";
}
impl fidl::endpoints::DiscoverableProtocolMarker for FrameHostMarker {}

pub trait FrameHostProxyInterface: Send + Sync {
    fn r#create_frame_with_params(
        &self,
        params: CreateFrameParams,
        frame: fidl::endpoints::ServerEnd<FrameMarker>,
    ) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct FrameHostSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for FrameHostSynchronousProxy {
    type Proxy = FrameHostProxy;
    type Protocol = FrameHostMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl FrameHostSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <FrameHostMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<FrameHostEvent, fidl::Error> {
        FrameHostEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Behaves identically to [`Context.CreateFrameWithParams`].
    pub fn r#create_frame_with_params(
        &self,
        mut params: CreateFrameParams,
        mut frame: fidl::endpoints::ServerEnd<FrameMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FrameHostCreateFrameWithParamsRequest>(
            (&mut params, frame),
            0x670186c3a1b3f28,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Clone)]
pub struct FrameHostProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for FrameHostProxy {
    type Protocol = FrameHostMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl FrameHostProxy {
    /// Create a new Proxy for fuchsia.web/FrameHost.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <FrameHostMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> FrameHostEventStream {
        FrameHostEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Behaves identically to [`Context.CreateFrameWithParams`].
    pub fn r#create_frame_with_params(
        &self,
        mut params: CreateFrameParams,
        mut frame: fidl::endpoints::ServerEnd<FrameMarker>,
    ) -> Result<(), fidl::Error> {
        FrameHostProxyInterface::r#create_frame_with_params(self, params, frame)
    }
}

impl FrameHostProxyInterface for FrameHostProxy {
    fn r#create_frame_with_params(
        &self,
        mut params: CreateFrameParams,
        mut frame: fidl::endpoints::ServerEnd<FrameMarker>,
    ) -> Result<(), fidl::Error> {
        self.client.send::<FrameHostCreateFrameWithParamsRequest>(
            (&mut params, frame),
            0x670186c3a1b3f28,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

pub struct FrameHostEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for FrameHostEventStream {}

impl futures::stream::FusedStream for FrameHostEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for FrameHostEventStream {
    type Item = Result<FrameHostEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(FrameHostEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum FrameHostEvent {}

impl FrameHostEvent {
    /// Decodes a message buffer as a [`FrameHostEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<FrameHostEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <FrameHostMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.web/FrameHost.
pub struct FrameHostRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for FrameHostRequestStream {}

impl futures::stream::FusedStream for FrameHostRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for FrameHostRequestStream {
    type Protocol = FrameHostMarker;
    type ControlHandle = FrameHostControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        FrameHostControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for FrameHostRequestStream {
    type Item = Result<FrameHostRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled FrameHostRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))))
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x670186c3a1b3f28 => {
                        header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                        let mut req = fidl::new_empty!(
                            FrameHostCreateFrameWithParamsRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<FrameHostCreateFrameWithParamsRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = FrameHostControlHandle { inner: this.inner.clone() };
                        Ok(FrameHostRequest::CreateFrameWithParams {
                            params: req.params,
                            frame: req.frame,

                            control_handle,
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <FrameHostMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Used by [`Context`] clients to delegate [`Frame`] hosting capabilities to selected peers.
#[derive(Debug)]
pub enum FrameHostRequest {
    /// Behaves identically to [`Context.CreateFrameWithParams`].
    CreateFrameWithParams {
        params: CreateFrameParams,
        frame: fidl::endpoints::ServerEnd<FrameMarker>,
        control_handle: FrameHostControlHandle,
    },
}

impl FrameHostRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_create_frame_with_params(
        self,
    ) -> Option<(CreateFrameParams, fidl::endpoints::ServerEnd<FrameMarker>, FrameHostControlHandle)>
    {
        if let FrameHostRequest::CreateFrameWithParams { params, frame, control_handle } = self {
            Some((params, frame, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            FrameHostRequest::CreateFrameWithParams { .. } => "create_frame_with_params",
        }
    }
}

#[derive(Debug, Clone)]
pub struct FrameHostControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::ControlHandle for FrameHostControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl FrameHostControlHandle {}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct MessagePortMarker;

impl fidl::endpoints::ProtocolMarker for MessagePortMarker {
    type Proxy = MessagePortProxy;
    type RequestStream = MessagePortRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = MessagePortSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) MessagePort";
}
pub type MessagePortPostMessageResult = Result<(), FrameError>;

pub trait MessagePortProxyInterface: Send + Sync {
    type PostMessageResponseFut: std::future::Future<Output = Result<MessagePortPostMessageResult, fidl::Error>>
        + Send;
    fn r#post_message(&self, message: WebMessage) -> Self::PostMessageResponseFut;
    type ReceiveMessageResponseFut: std::future::Future<Output = Result<WebMessage, fidl::Error>>
        + Send;
    fn r#receive_message(&self) -> Self::ReceiveMessageResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct MessagePortSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for MessagePortSynchronousProxy {
    type Proxy = MessagePortProxy;
    type Protocol = MessagePortMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl MessagePortSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name = <MessagePortMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<MessagePortEvent, fidl::Error> {
        MessagePortEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Sends a [`WebMessage`] to the peer. These are processed in order, one at a
    /// time. It is not necessary for the caller to wait for the completion callback before calling
    /// [`MessagePort.PostMessage`] again.
    ///
    /// If an error occurred, the [`FrameError`] will be set to one of these value:
    /// - `BUFFER_NOT_UTF8`: The script in `message`'s `data` property is not UTF-8 encoded.
    /// - `NO_DATA_IN_MESSAGE`: The `data` property is missing in `message`.
    pub fn r#post_message(
        &self,
        mut message: WebMessage,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<MessagePortPostMessageResult, fidl::Error> {
        let _response = self.client.send_query::<
            MessagePortPostMessageRequest,
            fidl::encoding::ResultType<fidl::encoding::EmptyStruct, FrameError>,
        >(
            (&mut message,),
            0x2bcf0a6ed30ffd1f,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.map(|x| x))
    }

    /// Asynchronously reads the next message from the channel. The client should invoke the
    /// callback when it is ready to process another message. Unreceived messages are buffered
    /// on the sender's side and bounded by its available resources.
    pub fn r#receive_message(
        &self,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<WebMessage, fidl::Error> {
        let _response = self
            .client
            .send_query::<fidl::encoding::EmptyPayload, MessagePortReceiveMessageResponse>(
                (),
                0x6c8a6051690be58d,
                fidl::encoding::DynamicFlags::empty(),
                ___deadline,
            )?;
        Ok(_response.message)
    }
}

#[derive(Debug, Clone)]
pub struct MessagePortProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for MessagePortProxy {
    type Protocol = MessagePortMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl MessagePortProxy {
    /// Create a new Proxy for fuchsia.web/MessagePort.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name = <MessagePortMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> MessagePortEventStream {
        MessagePortEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Sends a [`WebMessage`] to the peer. These are processed in order, one at a
    /// time. It is not necessary for the caller to wait for the completion callback before calling
    /// [`MessagePort.PostMessage`] again.
    ///
    /// If an error occurred, the [`FrameError`] will be set to one of these value:
    /// - `BUFFER_NOT_UTF8`: The script in `message`'s `data` property is not UTF-8 encoded.
    /// - `NO_DATA_IN_MESSAGE`: The `data` property is missing in `message`.
    pub fn r#post_message(
        &self,
        mut message: WebMessage,
    ) -> fidl::client::QueryResponseFut<
        MessagePortPostMessageResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        MessagePortProxyInterface::r#post_message(self, message)
    }

    /// Asynchronously reads the next message from the channel. The client should invoke the
    /// callback when it is ready to process another message. Unreceived messages are buffered
    /// on the sender's side and bounded by its available resources.
    pub fn r#receive_message(
        &self,
    ) -> fidl::client::QueryResponseFut<WebMessage, fidl::encoding::DefaultFuchsiaResourceDialect>
    {
        MessagePortProxyInterface::r#receive_message(self)
    }
}

impl MessagePortProxyInterface for MessagePortProxy {
    type PostMessageResponseFut = fidl::client::QueryResponseFut<
        MessagePortPostMessageResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#post_message(&self, mut message: WebMessage) -> Self::PostMessageResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<MessagePortPostMessageResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, FrameError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x2bcf0a6ed30ffd1f,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client
            .send_query_and_decode::<MessagePortPostMessageRequest, MessagePortPostMessageResult>(
                (&mut message,),
                0x2bcf0a6ed30ffd1f,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }

    type ReceiveMessageResponseFut =
        fidl::client::QueryResponseFut<WebMessage, fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#receive_message(&self) -> Self::ReceiveMessageResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<WebMessage, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                MessagePortReceiveMessageResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x6c8a6051690be58d,
            >(_buf?)?;
            Ok(_response.message)
        }
        self.client.send_query_and_decode::<fidl::encoding::EmptyPayload, WebMessage>(
            (),
            0x6c8a6051690be58d,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct MessagePortEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for MessagePortEventStream {}

impl futures::stream::FusedStream for MessagePortEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for MessagePortEventStream {
    type Item = Result<MessagePortEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(MessagePortEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum MessagePortEvent {}

impl MessagePortEvent {
    /// Decodes a message buffer as a [`MessagePortEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<MessagePortEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <MessagePortMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.web/MessagePort.
pub struct MessagePortRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for MessagePortRequestStream {}

impl futures::stream::FusedStream for MessagePortRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for MessagePortRequestStream {
    type Protocol = MessagePortMarker;
    type ControlHandle = MessagePortControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        MessagePortControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for MessagePortRequestStream {
    type Item = Result<MessagePortRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled MessagePortRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))))
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                    0x2bcf0a6ed30ffd1f => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            MessagePortPostMessageRequest,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<MessagePortPostMessageRequest>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MessagePortControlHandle { inner: this.inner.clone() };
                        Ok(MessagePortRequest::PostMessage {
                            message: req.message,

                            responder: MessagePortPostMessageResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    0x6c8a6051690be58d => {
                        header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                        let mut req = fidl::new_empty!(
                            fidl::encoding::EmptyPayload,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        );
                        fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                        let control_handle = MessagePortControlHandle { inner: this.inner.clone() };
                        Ok(MessagePortRequest::ReceiveMessage {
                            responder: MessagePortReceiveMessageResponder {
                                control_handle: std::mem::ManuallyDrop::new(control_handle),
                                tx_id: header.tx_id,
                            },
                        })
                    }
                    _ => Err(fidl::Error::UnknownOrdinal {
                        ordinal: header.ordinal,
                        protocol_name:
                            <MessagePortMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                    }),
                }))
            },
        )
    }
}

/// Represents one end of an HTML5 MessageChannel. Can be used to send and exchange Messages with
/// the peered MessagePort in the Frame's script context. The port is destroyed when either end of
/// the MessagePort channel is torn down.
#[derive(Debug)]
pub enum MessagePortRequest {
    /// Sends a [`WebMessage`] to the peer. These are processed in order, one at a
    /// time. It is not necessary for the caller to wait for the completion callback before calling
    /// [`MessagePort.PostMessage`] again.
    ///
    /// If an error occurred, the [`FrameError`] will be set to one of these value:
    /// - `BUFFER_NOT_UTF8`: The script in `message`'s `data` property is not UTF-8 encoded.
    /// - `NO_DATA_IN_MESSAGE`: The `data` property is missing in `message`.
    PostMessage { message: WebMessage, responder: MessagePortPostMessageResponder },
    /// Asynchronously reads the next message from the channel. The client should invoke the
    /// callback when it is ready to process another message. Unreceived messages are buffered
    /// on the sender's side and bounded by its available resources.
    ReceiveMessage { responder: MessagePortReceiveMessageResponder },
}

impl MessagePortRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_post_message(self) -> Option<(WebMessage, MessagePortPostMessageResponder)> {
        if let MessagePortRequest::PostMessage { message, responder } = self {
            Some((message, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_receive_message(self) -> Option<(MessagePortReceiveMessageResponder)> {
        if let MessagePortRequest::ReceiveMessage { responder } = self {
            Some((responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            MessagePortRequest::PostMessage { .. } => "post_message",
            MessagePortRequest::ReceiveMessage { .. } => "receive_message",
        }
    }
}

#[derive(Debug, Clone)]
pub struct MessagePortControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::ControlHandle for MessagePortControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl MessagePortControlHandle {}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct MessagePortPostMessageResponder {
    control_handle: std::mem::ManuallyDrop<MessagePortControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`MessagePortControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for MessagePortPostMessageResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for MessagePortPostMessageResponder {
    type ControlHandle = MessagePortControlHandle;

    fn control_handle(&self) -> &MessagePortControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl MessagePortPostMessageResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut result: Result<(), FrameError>) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), FrameError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut result: Result<(), FrameError>) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<fidl::encoding::ResultType<fidl::encoding::EmptyStruct, FrameError>>(
                result,
                self.tx_id,
                0x2bcf0a6ed30ffd1f,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct MessagePortReceiveMessageResponder {
    control_handle: std::mem::ManuallyDrop<MessagePortControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`MessagePortControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for MessagePortReceiveMessageResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for MessagePortReceiveMessageResponder {
    type ControlHandle = MessagePortControlHandle;

    fn control_handle(&self) -> &MessagePortControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl MessagePortReceiveMessageResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut message: WebMessage) -> Result<(), fidl::Error> {
        let _result = self.send_raw(message);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self, mut message: WebMessage) -> Result<(), fidl::Error> {
        let _result = self.send_raw(message);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut message: WebMessage) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<MessagePortReceiveMessageResponse>(
            (&mut message,),
            self.tx_id,
            0x6c8a6051690be58d,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct NavigationControllerMarker;

impl fidl::endpoints::ProtocolMarker for NavigationControllerMarker {
    type Proxy = NavigationControllerProxy;
    type RequestStream = NavigationControllerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = NavigationControllerSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) NavigationController";
}
pub type NavigationControllerLoadUrlResult = Result<(), NavigationControllerError>;

pub trait NavigationControllerProxyInterface: Send + Sync {
    type LoadUrlResponseFut: std::future::Future<Output = Result<NavigationControllerLoadUrlResult, fidl::Error>>
        + Send;
    fn r#load_url(&self, url: &str, params: LoadUrlParams) -> Self::LoadUrlResponseFut;
    fn r#go_back(&self) -> Result<(), fidl::Error>;
    fn r#go_forward(&self) -> Result<(), fidl::Error>;
    fn r#stop(&self) -> Result<(), fidl::Error>;
    fn r#reload(&self, type_: ReloadType) -> Result<(), fidl::Error>;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct NavigationControllerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for NavigationControllerSynchronousProxy {
    type Proxy = NavigationControllerProxy;
    type Protocol = NavigationControllerMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl NavigationControllerSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <NavigationControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<NavigationControllerEvent, fidl::Error> {
        NavigationControllerEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Tells the [`Frame`] to navigate to a `url`.
    ///
    /// - `url`: The address to navigate to.
    /// - `params`: Additional parameters that affect how the resource will be  loaded (e.g.
    ///   cookies, HTTP headers, etc.)
    ///
    /// If an error occurred, the [`NavigationControllerError`] will be set to one of these values:
    /// - `INVALID_URL`: The `url` parameter is invalid.
    /// - `INVALID_HEADER`: At least one of the headers in [`LoadUrlParams.headers`] is invalid.
    pub fn r#load_url(
        &self,
        mut url: &str,
        mut params: LoadUrlParams,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NavigationControllerLoadUrlResult, fidl::Error> {
        let _response =
            self.client
                .send_query::<NavigationControllerLoadUrlRequest, fidl::encoding::ResultType<
                    fidl::encoding::EmptyStruct,
                    NavigationControllerError,
                >>(
                    (url, &mut params),
                    0x78f2ab0a480d0182,
                    fidl::encoding::DynamicFlags::empty(),
                    ___deadline,
                )?;
        Ok(_response.map(|x| x))
    }

    /// Tells the [`Frame`] to navigate to the previous page in its history, if any.
    pub fn r#go_back(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x2accdd8d87d89c38,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Tells the [`Frame`] to navigate to the next page in its history, if any.
    pub fn r#go_forward(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x39e4ac955ade2781,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Tells the [`Frame`] to stop the current navigation if a navigation is ongoing.
    pub fn r#stop(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x2383078ffbe6fea,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    /// Tells the [`Frame`] to reload the current page.
    pub fn r#reload(&self, mut type_: ReloadType) -> Result<(), fidl::Error> {
        self.client.send::<NavigationControllerReloadRequest>(
            (type_,),
            0x33faedfe67d6f00,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Clone)]
pub struct NavigationControllerProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for NavigationControllerProxy {
    type Protocol = NavigationControllerMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl NavigationControllerProxy {
    /// Create a new Proxy for fuchsia.web/NavigationController.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <NavigationControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> NavigationControllerEventStream {
        NavigationControllerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Tells the [`Frame`] to navigate to a `url`.
    ///
    /// - `url`: The address to navigate to.
    /// - `params`: Additional parameters that affect how the resource will be  loaded (e.g.
    ///   cookies, HTTP headers, etc.)
    ///
    /// If an error occurred, the [`NavigationControllerError`] will be set to one of these values:
    /// - `INVALID_URL`: The `url` parameter is invalid.
    /// - `INVALID_HEADER`: At least one of the headers in [`LoadUrlParams.headers`] is invalid.
    pub fn r#load_url(
        &self,
        mut url: &str,
        mut params: LoadUrlParams,
    ) -> fidl::client::QueryResponseFut<
        NavigationControllerLoadUrlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        NavigationControllerProxyInterface::r#load_url(self, url, params)
    }

    /// Tells the [`Frame`] to navigate to the previous page in its history, if any.
    pub fn r#go_back(&self) -> Result<(), fidl::Error> {
        NavigationControllerProxyInterface::r#go_back(self)
    }

    /// Tells the [`Frame`] to navigate to the next page in its history, if any.
    pub fn r#go_forward(&self) -> Result<(), fidl::Error> {
        NavigationControllerProxyInterface::r#go_forward(self)
    }

    /// Tells the [`Frame`] to stop the current navigation if a navigation is ongoing.
    pub fn r#stop(&self) -> Result<(), fidl::Error> {
        NavigationControllerProxyInterface::r#stop(self)
    }

    /// Tells the [`Frame`] to reload the current page.
    pub fn r#reload(&self, mut type_: ReloadType) -> Result<(), fidl::Error> {
        NavigationControllerProxyInterface::r#reload(self, type_)
    }
}

impl NavigationControllerProxyInterface for NavigationControllerProxy {
    type LoadUrlResponseFut = fidl::client::QueryResponseFut<
        NavigationControllerLoadUrlResult,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#load_url(&self, mut url: &str, mut params: LoadUrlParams) -> Self::LoadUrlResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NavigationControllerLoadUrlResult, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::ResultType<fidl::encoding::EmptyStruct, NavigationControllerError>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x78f2ab0a480d0182,
            >(_buf?)?;
            Ok(_response.map(|x| x))
        }
        self.client.send_query_and_decode::<
            NavigationControllerLoadUrlRequest,
            NavigationControllerLoadUrlResult,
        >(
            (url, &mut params,),
            0x78f2ab0a480d0182,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }

    fn r#go_back(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x2accdd8d87d89c38,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#go_forward(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x39e4ac955ade2781,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#stop(&self) -> Result<(), fidl::Error> {
        self.client.send::<fidl::encoding::EmptyPayload>(
            (),
            0x2383078ffbe6fea,
            fidl::encoding::DynamicFlags::empty(),
        )
    }

    fn r#reload(&self, mut type_: ReloadType) -> Result<(), fidl::Error> {
        self.client.send::<NavigationControllerReloadRequest>(
            (type_,),
            0x33faedfe67d6f00,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

pub struct NavigationControllerEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for NavigationControllerEventStream {}

impl futures::stream::FusedStream for NavigationControllerEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for NavigationControllerEventStream {
    type Item = Result<NavigationControllerEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(NavigationControllerEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum NavigationControllerEvent {}

impl NavigationControllerEvent {
    /// Decodes a message buffer as a [`NavigationControllerEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<NavigationControllerEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <NavigationControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.web/NavigationController.
pub struct NavigationControllerRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for NavigationControllerRequestStream {}

impl futures::stream::FusedStream for NavigationControllerRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for NavigationControllerRequestStream {
    type Protocol = NavigationControllerMarker;
    type ControlHandle = NavigationControllerControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        NavigationControllerControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for NavigationControllerRequestStream {
    type Item = Result<NavigationControllerRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled NavigationControllerRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))))
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                0x78f2ab0a480d0182 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(NavigationControllerLoadUrlRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NavigationControllerLoadUrlRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = NavigationControllerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(NavigationControllerRequest::LoadUrl {url: req.url,
params: req.params,

                        responder: NavigationControllerLoadUrlResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                0x2accdd8d87d89c38 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = NavigationControllerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(NavigationControllerRequest::GoBack {
                        control_handle,
                    })
                }
                0x39e4ac955ade2781 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = NavigationControllerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(NavigationControllerRequest::GoForward {
                        control_handle,
                    })
                }
                0x2383078ffbe6fea => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(fidl::encoding::EmptyPayload, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<fidl::encoding::EmptyPayload>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = NavigationControllerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(NavigationControllerRequest::Stop {
                        control_handle,
                    })
                }
                0x33faedfe67d6f00 => {
                    header.validate_request_tx_id(fidl::MethodType::OneWay)?;
                    let mut req = fidl::new_empty!(NavigationControllerReloadRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NavigationControllerReloadRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = NavigationControllerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(NavigationControllerRequest::Reload {type_: req.type_,

                        control_handle,
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <NavigationControllerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// Provides methods for controlling and querying the navigation state of a [`Frame`].
#[derive(Debug)]
pub enum NavigationControllerRequest {
    /// Tells the [`Frame`] to navigate to a `url`.
    ///
    /// - `url`: The address to navigate to.
    /// - `params`: Additional parameters that affect how the resource will be  loaded (e.g.
    ///   cookies, HTTP headers, etc.)
    ///
    /// If an error occurred, the [`NavigationControllerError`] will be set to one of these values:
    /// - `INVALID_URL`: The `url` parameter is invalid.
    /// - `INVALID_HEADER`: At least one of the headers in [`LoadUrlParams.headers`] is invalid.
    LoadUrl { url: String, params: LoadUrlParams, responder: NavigationControllerLoadUrlResponder },
    /// Tells the [`Frame`] to navigate to the previous page in its history, if any.
    GoBack { control_handle: NavigationControllerControlHandle },
    /// Tells the [`Frame`] to navigate to the next page in its history, if any.
    GoForward { control_handle: NavigationControllerControlHandle },
    /// Tells the [`Frame`] to stop the current navigation if a navigation is ongoing.
    Stop { control_handle: NavigationControllerControlHandle },
    /// Tells the [`Frame`] to reload the current page.
    Reload { type_: ReloadType, control_handle: NavigationControllerControlHandle },
}

impl NavigationControllerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_load_url(
        self,
    ) -> Option<(String, LoadUrlParams, NavigationControllerLoadUrlResponder)> {
        if let NavigationControllerRequest::LoadUrl { url, params, responder } = self {
            Some((url, params, responder))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_go_back(self) -> Option<(NavigationControllerControlHandle)> {
        if let NavigationControllerRequest::GoBack { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_go_forward(self) -> Option<(NavigationControllerControlHandle)> {
        if let NavigationControllerRequest::GoForward { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_stop(self) -> Option<(NavigationControllerControlHandle)> {
        if let NavigationControllerRequest::Stop { control_handle } = self {
            Some((control_handle))
        } else {
            None
        }
    }

    #[allow(irrefutable_let_patterns)]
    pub fn into_reload(self) -> Option<(ReloadType, NavigationControllerControlHandle)> {
        if let NavigationControllerRequest::Reload { type_, control_handle } = self {
            Some((type_, control_handle))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            NavigationControllerRequest::LoadUrl { .. } => "load_url",
            NavigationControllerRequest::GoBack { .. } => "go_back",
            NavigationControllerRequest::GoForward { .. } => "go_forward",
            NavigationControllerRequest::Stop { .. } => "stop",
            NavigationControllerRequest::Reload { .. } => "reload",
        }
    }
}

#[derive(Debug, Clone)]
pub struct NavigationControllerControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::ControlHandle for NavigationControllerControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl NavigationControllerControlHandle {}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct NavigationControllerLoadUrlResponder {
    control_handle: std::mem::ManuallyDrop<NavigationControllerControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`NavigationControllerControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for NavigationControllerLoadUrlResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for NavigationControllerLoadUrlResponder {
    type ControlHandle = NavigationControllerControlHandle;

    fn control_handle(&self) -> &NavigationControllerControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl NavigationControllerLoadUrlResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(
        self,
        mut result: Result<(), NavigationControllerError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut result: Result<(), NavigationControllerError>,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(result);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(
        &self,
        mut result: Result<(), NavigationControllerError>,
    ) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::ResultType<
            fidl::encoding::EmptyStruct,
            NavigationControllerError,
        >>(
            result,
            self.tx_id,
            0x78f2ab0a480d0182,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct NavigationEventListenerMarker;

impl fidl::endpoints::ProtocolMarker for NavigationEventListenerMarker {
    type Proxy = NavigationEventListenerProxy;
    type RequestStream = NavigationEventListenerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = NavigationEventListenerSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) NavigationEventListener";
}

pub trait NavigationEventListenerProxyInterface: Send + Sync {
    type OnNavigationStateChangedResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
        + Send;
    fn r#on_navigation_state_changed(
        &self,
        change: NavigationState,
    ) -> Self::OnNavigationStateChangedResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct NavigationEventListenerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for NavigationEventListenerSynchronousProxy {
    type Proxy = NavigationEventListenerProxy;
    type Protocol = NavigationEventListenerMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl NavigationEventListenerSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <NavigationEventListenerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<NavigationEventListenerEvent, fidl::Error> {
        NavigationEventListenerEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Called immediately after [`Frame.SetNavigationEventListener`] and every time user-visible
    /// navigation state has changed. In the first call, `change` contains the current navigation
    /// state (empty before the first navigation request). In every following call, `change` will
    /// have values set for all fields that have changed at any time since the previous
    /// notification. This means that some fields may have the same value as was previously
    /// reported, for example, if they changed to some other value and back again. If a field is
    /// unset, then its value has not changed at any time since the previous notification.
    ///
    /// Implementer must call the acknowledgement callback to receive new navigation events.
    pub fn r#on_navigation_state_changed(
        &self,
        mut change: NavigationState,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            NavigationEventListenerOnNavigationStateChangedRequest,
            fidl::encoding::EmptyPayload,
        >(
            (&mut change,),
            0x453ac6bcbc82fbb6,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }
}

#[derive(Debug, Clone)]
pub struct NavigationEventListenerProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for NavigationEventListenerProxy {
    type Protocol = NavigationEventListenerMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl NavigationEventListenerProxy {
    /// Create a new Proxy for fuchsia.web/NavigationEventListener.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <NavigationEventListenerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> NavigationEventListenerEventStream {
        NavigationEventListenerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Called immediately after [`Frame.SetNavigationEventListener`] and every time user-visible
    /// navigation state has changed. In the first call, `change` contains the current navigation
    /// state (empty before the first navigation request). In every following call, `change` will
    /// have values set for all fields that have changed at any time since the previous
    /// notification. This means that some fields may have the same value as was previously
    /// reported, for example, if they changed to some other value and back again. If a field is
    /// unset, then its value has not changed at any time since the previous notification.
    ///
    /// Implementer must call the acknowledgement callback to receive new navigation events.
    pub fn r#on_navigation_state_changed(
        &self,
        mut change: NavigationState,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        NavigationEventListenerProxyInterface::r#on_navigation_state_changed(self, change)
    }
}

impl NavigationEventListenerProxyInterface for NavigationEventListenerProxy {
    type OnNavigationStateChangedResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#on_navigation_state_changed(
        &self,
        mut change: NavigationState,
    ) -> Self::OnNavigationStateChangedResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x453ac6bcbc82fbb6,
            >(_buf?)?;
            Ok(_response)
        }
        self.client
            .send_query_and_decode::<NavigationEventListenerOnNavigationStateChangedRequest, ()>(
                (&mut change,),
                0x453ac6bcbc82fbb6,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }
}

pub struct NavigationEventListenerEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for NavigationEventListenerEventStream {}

impl futures::stream::FusedStream for NavigationEventListenerEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for NavigationEventListenerEventStream {
    type Item = Result<NavigationEventListenerEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(NavigationEventListenerEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum NavigationEventListenerEvent {}

impl NavigationEventListenerEvent {
    /// Decodes a message buffer as a [`NavigationEventListenerEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<NavigationEventListenerEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <NavigationEventListenerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.web/NavigationEventListener.
pub struct NavigationEventListenerRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for NavigationEventListenerRequestStream {}

impl futures::stream::FusedStream for NavigationEventListenerRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for NavigationEventListenerRequestStream {
    type Protocol = NavigationEventListenerMarker;
    type ControlHandle = NavigationEventListenerControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        NavigationEventListenerControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for NavigationEventListenerRequestStream {
    type Item = Result<NavigationEventListenerRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled NavigationEventListenerRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))))
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                0x453ac6bcbc82fbb6 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(NavigationEventListenerOnNavigationStateChangedRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NavigationEventListenerOnNavigationStateChangedRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = NavigationEventListenerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(NavigationEventListenerRequest::OnNavigationStateChanged {change: req.change,

                        responder: NavigationEventListenerOnNavigationStateChangedResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <NavigationEventListenerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

/// Interface supplied by the embedder for receiving notifications about navigation events in a
/// [`Frame`].
#[derive(Debug)]
pub enum NavigationEventListenerRequest {
    /// Called immediately after [`Frame.SetNavigationEventListener`] and every time user-visible
    /// navigation state has changed. In the first call, `change` contains the current navigation
    /// state (empty before the first navigation request). In every following call, `change` will
    /// have values set for all fields that have changed at any time since the previous
    /// notification. This means that some fields may have the same value as was previously
    /// reported, for example, if they changed to some other value and back again. If a field is
    /// unset, then its value has not changed at any time since the previous notification.
    ///
    /// Implementer must call the acknowledgement callback to receive new navigation events.
    OnNavigationStateChanged {
        change: NavigationState,
        responder: NavigationEventListenerOnNavigationStateChangedResponder,
    },
}

impl NavigationEventListenerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_navigation_state_changed(
        self,
    ) -> Option<(NavigationState, NavigationEventListenerOnNavigationStateChangedResponder)> {
        if let NavigationEventListenerRequest::OnNavigationStateChanged { change, responder } = self
        {
            Some((change, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            NavigationEventListenerRequest::OnNavigationStateChanged { .. } => {
                "on_navigation_state_changed"
            }
        }
    }
}

#[derive(Debug, Clone)]
pub struct NavigationEventListenerControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::ControlHandle for NavigationEventListenerControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl NavigationEventListenerControlHandle {}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct NavigationEventListenerOnNavigationStateChangedResponder {
    control_handle: std::mem::ManuallyDrop<NavigationEventListenerControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`NavigationEventListenerControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for NavigationEventListenerOnNavigationStateChangedResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for NavigationEventListenerOnNavigationStateChangedResponder {
    type ControlHandle = NavigationEventListenerControlHandle;

    fn control_handle(&self) -> &NavigationEventListenerControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl NavigationEventListenerOnNavigationStateChangedResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self) -> Result<(), fidl::Error> {
        let _result = self.send_raw();
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
        let _result = self.send_raw();
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            self.tx_id,
            0x453ac6bcbc82fbb6,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct NavigationPolicyProviderMarker;

impl fidl::endpoints::ProtocolMarker for NavigationPolicyProviderMarker {
    type Proxy = NavigationPolicyProviderProxy;
    type RequestStream = NavigationPolicyProviderRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = NavigationPolicyProviderSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) NavigationPolicyProvider";
}

pub trait NavigationPolicyProviderProxyInterface: Send + Sync {
    type EvaluateRequestedNavigationResponseFut: std::future::Future<Output = Result<NavigationDecision, fidl::Error>>
        + Send;
    fn r#evaluate_requested_navigation(
        &self,
        requested_navigation: &RequestedNavigation,
    ) -> Self::EvaluateRequestedNavigationResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct NavigationPolicyProviderSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for NavigationPolicyProviderSynchronousProxy {
    type Proxy = NavigationPolicyProviderProxy;
    type Protocol = NavigationPolicyProviderMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl NavigationPolicyProviderSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <NavigationPolicyProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<NavigationPolicyProviderEvent, fidl::Error> {
        NavigationPolicyProviderEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Called when the [`Frame`] is processing a navigation request in one of the phase(s)
    /// specified in [`NavigationPolicyProviderParams`]. Navigation is paused until the result is
    /// received. The returned [`NavigationDecision`] defines how the navigation should proceed.
    pub fn r#evaluate_requested_navigation(
        &self,
        mut requested_navigation: &RequestedNavigation,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<NavigationDecision, fidl::Error> {
        let _response = self.client.send_query::<
            NavigationPolicyProviderEvaluateRequestedNavigationRequest,
            NavigationPolicyProviderEvaluateRequestedNavigationResponse,
        >(
            (requested_navigation,),
            0x54446b50cf3512b6,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response.decision)
    }
}

#[derive(Debug, Clone)]
pub struct NavigationPolicyProviderProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for NavigationPolicyProviderProxy {
    type Protocol = NavigationPolicyProviderMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl NavigationPolicyProviderProxy {
    /// Create a new Proxy for fuchsia.web/NavigationPolicyProvider.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <NavigationPolicyProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> NavigationPolicyProviderEventStream {
        NavigationPolicyProviderEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Called when the [`Frame`] is processing a navigation request in one of the phase(s)
    /// specified in [`NavigationPolicyProviderParams`]. Navigation is paused until the result is
    /// received. The returned [`NavigationDecision`] defines how the navigation should proceed.
    pub fn r#evaluate_requested_navigation(
        &self,
        mut requested_navigation: &RequestedNavigation,
    ) -> fidl::client::QueryResponseFut<
        NavigationDecision,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    > {
        NavigationPolicyProviderProxyInterface::r#evaluate_requested_navigation(
            self,
            requested_navigation,
        )
    }
}

impl NavigationPolicyProviderProxyInterface for NavigationPolicyProviderProxy {
    type EvaluateRequestedNavigationResponseFut = fidl::client::QueryResponseFut<
        NavigationDecision,
        fidl::encoding::DefaultFuchsiaResourceDialect,
    >;
    fn r#evaluate_requested_navigation(
        &self,
        mut requested_navigation: &RequestedNavigation,
    ) -> Self::EvaluateRequestedNavigationResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<NavigationDecision, fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                NavigationPolicyProviderEvaluateRequestedNavigationResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x54446b50cf3512b6,
            >(_buf?)?;
            Ok(_response.decision)
        }
        self.client.send_query_and_decode::<
            NavigationPolicyProviderEvaluateRequestedNavigationRequest,
            NavigationDecision,
        >(
            (requested_navigation,),
            0x54446b50cf3512b6,
            fidl::encoding::DynamicFlags::empty(),
            _decode,
        )
    }
}

pub struct NavigationPolicyProviderEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for NavigationPolicyProviderEventStream {}

impl futures::stream::FusedStream for NavigationPolicyProviderEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for NavigationPolicyProviderEventStream {
    type Item = Result<NavigationPolicyProviderEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(NavigationPolicyProviderEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum NavigationPolicyProviderEvent {}

impl NavigationPolicyProviderEvent {
    /// Decodes a message buffer as a [`NavigationPolicyProviderEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<NavigationPolicyProviderEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name:
                    <NavigationPolicyProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            }),
        }
    }
}

/// A Stream of incoming requests for fuchsia.web/NavigationPolicyProvider.
pub struct NavigationPolicyProviderRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for NavigationPolicyProviderRequestStream {}

impl futures::stream::FusedStream for NavigationPolicyProviderRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for NavigationPolicyProviderRequestStream {
    type Protocol = NavigationPolicyProviderMarker;
    type ControlHandle = NavigationPolicyProviderControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        NavigationPolicyProviderControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for NavigationPolicyProviderRequestStream {
    type Item = Result<NavigationPolicyProviderRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled NavigationPolicyProviderRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))))
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                0x54446b50cf3512b6 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(NavigationPolicyProviderEvaluateRequestedNavigationRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<NavigationPolicyProviderEvaluateRequestedNavigationRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = NavigationPolicyProviderControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(NavigationPolicyProviderRequest::EvaluateRequestedNavigation {requested_navigation: req.requested_navigation,

                        responder: NavigationPolicyProviderEvaluateRequestedNavigationResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <NavigationPolicyProviderMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

#[derive(Debug)]
pub enum NavigationPolicyProviderRequest {
    /// Called when the [`Frame`] is processing a navigation request in one of the phase(s)
    /// specified in [`NavigationPolicyProviderParams`]. Navigation is paused until the result is
    /// received. The returned [`NavigationDecision`] defines how the navigation should proceed.
    EvaluateRequestedNavigation {
        requested_navigation: RequestedNavigation,
        responder: NavigationPolicyProviderEvaluateRequestedNavigationResponder,
    },
}

impl NavigationPolicyProviderRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_evaluate_requested_navigation(
        self,
    ) -> Option<(RequestedNavigation, NavigationPolicyProviderEvaluateRequestedNavigationResponder)>
    {
        if let NavigationPolicyProviderRequest::EvaluateRequestedNavigation {
            requested_navigation,
            responder,
        } = self
        {
            Some((requested_navigation, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            NavigationPolicyProviderRequest::EvaluateRequestedNavigation { .. } => {
                "evaluate_requested_navigation"
            }
        }
    }
}

#[derive(Debug, Clone)]
pub struct NavigationPolicyProviderControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::ControlHandle for NavigationPolicyProviderControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl NavigationPolicyProviderControlHandle {}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct NavigationPolicyProviderEvaluateRequestedNavigationResponder {
    control_handle: std::mem::ManuallyDrop<NavigationPolicyProviderControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`NavigationPolicyProviderControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for NavigationPolicyProviderEvaluateRequestedNavigationResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for NavigationPolicyProviderEvaluateRequestedNavigationResponder {
    type ControlHandle = NavigationPolicyProviderControlHandle;

    fn control_handle(&self) -> &NavigationPolicyProviderControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl NavigationPolicyProviderEvaluateRequestedNavigationResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self, mut decision: NavigationDecision) -> Result<(), fidl::Error> {
        let _result = self.send_raw(decision);
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(
        self,
        mut decision: NavigationDecision,
    ) -> Result<(), fidl::Error> {
        let _result = self.send_raw(decision);
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self, mut decision: NavigationDecision) -> Result<(), fidl::Error> {
        self.control_handle
            .inner
            .send::<NavigationPolicyProviderEvaluateRequestedNavigationResponse>(
                (&mut decision,),
                self.tx_id,
                0x54446b50cf3512b6,
                fidl::encoding::DynamicFlags::empty(),
            )
    }
}

#[derive(Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct PopupFrameCreationListenerMarker;

impl fidl::endpoints::ProtocolMarker for PopupFrameCreationListenerMarker {
    type Proxy = PopupFrameCreationListenerProxy;
    type RequestStream = PopupFrameCreationListenerRequestStream;
    #[cfg(target_os = "fuchsia")]
    type SynchronousProxy = PopupFrameCreationListenerSynchronousProxy;

    const DEBUG_NAME: &'static str = "(anonymous) PopupFrameCreationListener";
}

pub trait PopupFrameCreationListenerProxyInterface: Send + Sync {
    type OnPopupFrameCreatedResponseFut: std::future::Future<Output = Result<(), fidl::Error>>
        + Send;
    fn r#on_popup_frame_created(
        &self,
        frame: fidl::endpoints::ClientEnd<FrameMarker>,
        info: PopupFrameCreationInfo,
    ) -> Self::OnPopupFrameCreatedResponseFut;
}
#[derive(Debug)]
#[cfg(target_os = "fuchsia")]
pub struct PopupFrameCreationListenerSynchronousProxy {
    client: fidl::client::sync::Client,
}

#[cfg(target_os = "fuchsia")]
impl fidl::endpoints::SynchronousProxy for PopupFrameCreationListenerSynchronousProxy {
    type Proxy = PopupFrameCreationListenerProxy;
    type Protocol = PopupFrameCreationListenerMarker;

    fn from_channel(inner: fidl::Channel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    fn as_channel(&self) -> &fidl::Channel {
        self.client.as_channel()
    }
}

#[cfg(target_os = "fuchsia")]
impl PopupFrameCreationListenerSynchronousProxy {
    pub fn new(channel: fidl::Channel) -> Self {
        let protocol_name =
            <PopupFrameCreationListenerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::sync::Client::new(channel, protocol_name) }
    }

    pub fn into_channel(self) -> fidl::Channel {
        self.client.into_channel()
    }

    /// Waits until an event arrives and returns it. It is safe for other
    /// threads to make concurrent requests while waiting for an event.
    pub fn wait_for_event(
        &self,
        deadline: zx::MonotonicInstant,
    ) -> Result<PopupFrameCreationListenerEvent, fidl::Error> {
        PopupFrameCreationListenerEvent::decode(self.client.wait_for_event(deadline)?)
    }

    /// Called when a [`Frame`] has created a new popup `frame`. Information about the popup frame,
    /// and how it was created, is provided via `info`. Additional popup frames are delivered after
    /// the acknowledgement callback is invoked.
    pub fn r#on_popup_frame_created(
        &self,
        mut frame: fidl::endpoints::ClientEnd<FrameMarker>,
        mut info: PopupFrameCreationInfo,
        ___deadline: zx::MonotonicInstant,
    ) -> Result<(), fidl::Error> {
        let _response = self.client.send_query::<
            PopupFrameCreationListenerOnPopupFrameCreatedRequest,
            fidl::encoding::EmptyPayload,
        >(
            (frame, &mut info,),
            0x19b212672dc41d51,
            fidl::encoding::DynamicFlags::empty(),
            ___deadline,
        )?;
        Ok(_response)
    }
}

#[derive(Debug, Clone)]
pub struct PopupFrameCreationListenerProxy {
    client: fidl::client::Client<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl fidl::endpoints::Proxy for PopupFrameCreationListenerProxy {
    type Protocol = PopupFrameCreationListenerMarker;

    fn from_channel(inner: ::fidl::AsyncChannel) -> Self {
        Self::new(inner)
    }

    fn into_channel(self) -> Result<::fidl::AsyncChannel, Self> {
        self.client.into_channel().map_err(|client| Self { client })
    }

    fn as_channel(&self) -> &::fidl::AsyncChannel {
        self.client.as_channel()
    }
}

impl PopupFrameCreationListenerProxy {
    /// Create a new Proxy for fuchsia.web/PopupFrameCreationListener.
    pub fn new(channel: ::fidl::AsyncChannel) -> Self {
        let protocol_name =
            <PopupFrameCreationListenerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME;
        Self { client: fidl::client::Client::new(channel, protocol_name) }
    }

    /// Get a Stream of events from the remote end of the protocol.
    ///
    /// # Panics
    ///
    /// Panics if the event stream was already taken.
    pub fn take_event_stream(&self) -> PopupFrameCreationListenerEventStream {
        PopupFrameCreationListenerEventStream { event_receiver: self.client.take_event_receiver() }
    }

    /// Called when a [`Frame`] has created a new popup `frame`. Information about the popup frame,
    /// and how it was created, is provided via `info`. Additional popup frames are delivered after
    /// the acknowledgement callback is invoked.
    pub fn r#on_popup_frame_created(
        &self,
        mut frame: fidl::endpoints::ClientEnd<FrameMarker>,
        mut info: PopupFrameCreationInfo,
    ) -> fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect> {
        PopupFrameCreationListenerProxyInterface::r#on_popup_frame_created(self, frame, info)
    }
}

impl PopupFrameCreationListenerProxyInterface for PopupFrameCreationListenerProxy {
    type OnPopupFrameCreatedResponseFut =
        fidl::client::QueryResponseFut<(), fidl::encoding::DefaultFuchsiaResourceDialect>;
    fn r#on_popup_frame_created(
        &self,
        mut frame: fidl::endpoints::ClientEnd<FrameMarker>,
        mut info: PopupFrameCreationInfo,
    ) -> Self::OnPopupFrameCreatedResponseFut {
        fn _decode(
            mut _buf: Result<<fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc, fidl::Error>,
        ) -> Result<(), fidl::Error> {
            let _response = fidl::client::decode_transaction_body::<
                fidl::encoding::EmptyPayload,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                0x19b212672dc41d51,
            >(_buf?)?;
            Ok(_response)
        }
        self.client
            .send_query_and_decode::<PopupFrameCreationListenerOnPopupFrameCreatedRequest, ()>(
                (frame, &mut info),
                0x19b212672dc41d51,
                fidl::encoding::DynamicFlags::empty(),
                _decode,
            )
    }
}

pub struct PopupFrameCreationListenerEventStream {
    event_receiver: fidl::client::EventReceiver<fidl::encoding::DefaultFuchsiaResourceDialect>,
}

impl std::marker::Unpin for PopupFrameCreationListenerEventStream {}

impl futures::stream::FusedStream for PopupFrameCreationListenerEventStream {
    fn is_terminated(&self) -> bool {
        self.event_receiver.is_terminated()
    }
}

impl futures::Stream for PopupFrameCreationListenerEventStream {
    type Item = Result<PopupFrameCreationListenerEvent, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        match futures::ready!(futures::stream::StreamExt::poll_next_unpin(
            &mut self.event_receiver,
            cx
        )?) {
            Some(buf) => std::task::Poll::Ready(Some(PopupFrameCreationListenerEvent::decode(buf))),
            None => std::task::Poll::Ready(None),
        }
    }
}

#[derive(Debug)]
pub enum PopupFrameCreationListenerEvent {}

impl PopupFrameCreationListenerEvent {
    /// Decodes a message buffer as a [`PopupFrameCreationListenerEvent`].
    fn decode(
        mut buf: <fidl::encoding::DefaultFuchsiaResourceDialect as fidl::encoding::ResourceDialect>::MessageBufEtc,
    ) -> Result<PopupFrameCreationListenerEvent, fidl::Error> {
        let (bytes, _handles) = buf.split_mut();
        let (tx_header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;
        debug_assert_eq!(tx_header.tx_id, 0);
        match tx_header.ordinal {
            _ => Err(fidl::Error::UnknownOrdinal {
                ordinal: tx_header.ordinal,
                protocol_name: <PopupFrameCreationListenerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
            })
        }
    }
}

/// A Stream of incoming requests for fuchsia.web/PopupFrameCreationListener.
pub struct PopupFrameCreationListenerRequestStream {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
    is_terminated: bool,
}

impl std::marker::Unpin for PopupFrameCreationListenerRequestStream {}

impl futures::stream::FusedStream for PopupFrameCreationListenerRequestStream {
    fn is_terminated(&self) -> bool {
        self.is_terminated
    }
}

impl fidl::endpoints::RequestStream for PopupFrameCreationListenerRequestStream {
    type Protocol = PopupFrameCreationListenerMarker;
    type ControlHandle = PopupFrameCreationListenerControlHandle;

    fn from_channel(channel: ::fidl::AsyncChannel) -> Self {
        Self { inner: std::sync::Arc::new(fidl::ServeInner::new(channel)), is_terminated: false }
    }

    fn control_handle(&self) -> Self::ControlHandle {
        PopupFrameCreationListenerControlHandle { inner: self.inner.clone() }
    }

    fn into_inner(
        self,
    ) -> (::std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>, bool)
    {
        (self.inner, self.is_terminated)
    }

    fn from_inner(
        inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
        is_terminated: bool,
    ) -> Self {
        Self { inner, is_terminated }
    }
}

impl futures::Stream for PopupFrameCreationListenerRequestStream {
    type Item = Result<PopupFrameCreationListenerRequest, fidl::Error>;

    fn poll_next(
        mut self: std::pin::Pin<&mut Self>,
        cx: &mut std::task::Context<'_>,
    ) -> std::task::Poll<Option<Self::Item>> {
        let this = &mut *self;
        if this.inner.check_shutdown(cx) {
            this.is_terminated = true;
            return std::task::Poll::Ready(None);
        }
        if this.is_terminated {
            panic!("polled PopupFrameCreationListenerRequestStream after completion");
        }
        fidl::encoding::with_tls_decode_buf::<_, fidl::encoding::DefaultFuchsiaResourceDialect>(
            |bytes, handles| {
                match this.inner.channel().read_etc(cx, bytes, handles) {
                    std::task::Poll::Ready(Ok(())) => {}
                    std::task::Poll::Pending => return std::task::Poll::Pending,
                    std::task::Poll::Ready(Err(zx_status::Status::PEER_CLOSED)) => {
                        this.is_terminated = true;
                        return std::task::Poll::Ready(None);
                    }
                    std::task::Poll::Ready(Err(e)) => {
                        return std::task::Poll::Ready(Some(Err(fidl::Error::ServerRequestRead(
                            e.into(),
                        ))))
                    }
                }

                // A message has been received from the channel
                let (header, _body_bytes) = fidl::encoding::decode_transaction_header(bytes)?;

                std::task::Poll::Ready(Some(match header.ordinal {
                0x19b212672dc41d51 => {
                    header.validate_request_tx_id(fidl::MethodType::TwoWay)?;
                    let mut req = fidl::new_empty!(PopupFrameCreationListenerOnPopupFrameCreatedRequest, fidl::encoding::DefaultFuchsiaResourceDialect);
                    fidl::encoding::Decoder::<fidl::encoding::DefaultFuchsiaResourceDialect>::decode_into::<PopupFrameCreationListenerOnPopupFrameCreatedRequest>(&header, _body_bytes, handles, &mut req)?;
                    let control_handle = PopupFrameCreationListenerControlHandle {
                        inner: this.inner.clone(),
                    };
                    Ok(PopupFrameCreationListenerRequest::OnPopupFrameCreated {frame: req.frame,
info: req.info,

                        responder: PopupFrameCreationListenerOnPopupFrameCreatedResponder {
                            control_handle: std::mem::ManuallyDrop::new(control_handle),
                            tx_id: header.tx_id,
                        },
                    })
                }
                _ => Err(fidl::Error::UnknownOrdinal {
                    ordinal: header.ordinal,
                    protocol_name: <PopupFrameCreationListenerMarker as fidl::endpoints::ProtocolMarker>::DEBUG_NAME,
                }),
            }))
            },
        )
    }
}

#[derive(Debug)]
pub enum PopupFrameCreationListenerRequest {
    /// Called when a [`Frame`] has created a new popup `frame`. Information about the popup frame,
    /// and how it was created, is provided via `info`. Additional popup frames are delivered after
    /// the acknowledgement callback is invoked.
    OnPopupFrameCreated {
        frame: fidl::endpoints::ClientEnd<FrameMarker>,
        info: PopupFrameCreationInfo,
        responder: PopupFrameCreationListenerOnPopupFrameCreatedResponder,
    },
}

impl PopupFrameCreationListenerRequest {
    #[allow(irrefutable_let_patterns)]
    pub fn into_on_popup_frame_created(
        self,
    ) -> Option<(
        fidl::endpoints::ClientEnd<FrameMarker>,
        PopupFrameCreationInfo,
        PopupFrameCreationListenerOnPopupFrameCreatedResponder,
    )> {
        if let PopupFrameCreationListenerRequest::OnPopupFrameCreated { frame, info, responder } =
            self
        {
            Some((frame, info, responder))
        } else {
            None
        }
    }

    /// Name of the method defined in FIDL
    pub fn method_name(&self) -> &'static str {
        match *self {
            PopupFrameCreationListenerRequest::OnPopupFrameCreated { .. } => {
                "on_popup_frame_created"
            }
        }
    }
}

#[derive(Debug, Clone)]
pub struct PopupFrameCreationListenerControlHandle {
    inner: std::sync::Arc<fidl::ServeInner<fidl::encoding::DefaultFuchsiaResourceDialect>>,
}

impl fidl::endpoints::ControlHandle for PopupFrameCreationListenerControlHandle {
    fn shutdown(&self) {
        self.inner.shutdown()
    }
    fn shutdown_with_epitaph(&self, status: zx_status::Status) {
        self.inner.shutdown_with_epitaph(status)
    }

    fn is_closed(&self) -> bool {
        self.inner.channel().is_closed()
    }
    fn on_closed(&self) -> fidl::OnSignalsRef<'_> {
        self.inner.channel().on_closed()
    }

    #[cfg(target_os = "fuchsia")]
    fn signal_peer(
        &self,
        clear_mask: zx::Signals,
        set_mask: zx::Signals,
    ) -> Result<(), zx_status::Status> {
        use fidl::Peered;
        self.inner.channel().signal_peer(clear_mask, set_mask)
    }
}

impl PopupFrameCreationListenerControlHandle {}

#[must_use = "FIDL methods require a response to be sent"]
#[derive(Debug)]
pub struct PopupFrameCreationListenerOnPopupFrameCreatedResponder {
    control_handle: std::mem::ManuallyDrop<PopupFrameCreationListenerControlHandle>,
    tx_id: u32,
}

/// Set the the channel to be shutdown (see [`PopupFrameCreationListenerControlHandle::shutdown`])
/// if the responder is dropped without sending a response, so that the client
/// doesn't hang. To prevent this behavior, call `drop_without_shutdown`.
impl std::ops::Drop for PopupFrameCreationListenerOnPopupFrameCreatedResponder {
    fn drop(&mut self) {
        self.control_handle.shutdown();
        // Safety: drops once, never accessed again
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
    }
}

impl fidl::endpoints::Responder for PopupFrameCreationListenerOnPopupFrameCreatedResponder {
    type ControlHandle = PopupFrameCreationListenerControlHandle;

    fn control_handle(&self) -> &PopupFrameCreationListenerControlHandle {
        &self.control_handle
    }

    fn drop_without_shutdown(mut self) {
        // Safety: drops once, never accessed again due to mem::forget
        unsafe { std::mem::ManuallyDrop::drop(&mut self.control_handle) };
        // Prevent Drop from running (which would shut down the channel)
        std::mem::forget(self);
    }
}

impl PopupFrameCreationListenerOnPopupFrameCreatedResponder {
    /// Sends a response to the FIDL transaction.
    ///
    /// Sets the channel to shutdown if an error occurs.
    pub fn send(self) -> Result<(), fidl::Error> {
        let _result = self.send_raw();
        if _result.is_err() {
            self.control_handle.shutdown();
        }
        self.drop_without_shutdown();
        _result
    }

    /// Similar to "send" but does not shutdown the channel if an error occurs.
    pub fn send_no_shutdown_on_err(self) -> Result<(), fidl::Error> {
        let _result = self.send_raw();
        self.drop_without_shutdown();
        _result
    }

    fn send_raw(&self) -> Result<(), fidl::Error> {
        self.control_handle.inner.send::<fidl::encoding::EmptyPayload>(
            (),
            self.tx_id,
            0x19b212672dc41d51,
            fidl::encoding::DynamicFlags::empty(),
        )
    }
}

mod internal {
    use super::*;
    unsafe impl fidl::encoding::TypeMarker for ContextFeatureFlags {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            8
        }
    }

    impl fidl::encoding::ValueTypeMarker for ContextFeatureFlags {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for ContextFeatureFlags
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            if self.bits() & Self::all().bits() != self.bits() {
                return Err(fidl::Error::InvalidBitsValue);
            }
            encoder.write_num(self.bits(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ContextFeatureFlags {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::empty()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u64>(offset);
            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for InputTypes {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            8
        }
    }

    impl fidl::encoding::ValueTypeMarker for InputTypes {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for InputTypes {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            if self.bits() & Self::all().bits() != self.bits() {
                return Err(fidl::Error::InvalidBitsValue);
            }
            encoder.write_num(self.bits(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for InputTypes {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::empty()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u64>(offset);
            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for NavigationEventListenerFlags {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            8
        }
    }

    impl fidl::encoding::ValueTypeMarker for NavigationEventListenerFlags {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for NavigationEventListenerFlags
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            if self.bits() & Self::all().bits() != self.bits() {
                return Err(fidl::Error::InvalidBitsValue);
            }
            encoder.write_num(self.bits(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for NavigationEventListenerFlags
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::empty()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u64>(offset);
            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for NavigationPhase {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
    }

    impl fidl::encoding::ValueTypeMarker for NavigationPhase {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for NavigationPhase
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            if self.bits() & Self::all().bits() != self.bits() {
                return Err(fidl::Error::InvalidBitsValue);
            }
            encoder.write_num(self.bits(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NavigationPhase {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::empty()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);
            *self = Self::from_bits(prim).ok_or(fidl::Error::InvalidBitsValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for AllowInputState {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<i32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<i32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for AllowInputState {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for AllowInputState
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AllowInputState {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Allow
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<i32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for AutoplayPolicy {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<i32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<i32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for AutoplayPolicy {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for AutoplayPolicy {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for AutoplayPolicy {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Allow
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<i32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for ConsoleLogLevel {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<i32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<i32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for ConsoleLogLevel {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for ConsoleLogLevel
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ConsoleLogLevel {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Debug
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<i32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for ContextError {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<i32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<i32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for ContextError {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ContextError {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ContextError {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::RemoteDebuggingPortNotOpened
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<i32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for ErrorDetail {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            false
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for ErrorDetail {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ErrorDetail {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ErrorDetail {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::unknown()
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive_allow_unknown(prim);
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for FrameError {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<i32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<i32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for FrameError {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for FrameError {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FrameError {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::InternalError
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<i32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for LoadUrlReason {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for LoadUrlReason {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for LoadUrlReason {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for LoadUrlReason {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Link
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for NavigationControllerError {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<i32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<i32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for NavigationControllerError {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for NavigationControllerError
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for NavigationControllerError
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::InvalidUrl
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<i32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for PageType {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for PageType {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for PageType {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PageType {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Normal
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for PermissionState {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u8>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u8>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for PermissionState {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for PermissionState
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PermissionState {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Denied
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u8>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for PermissionType {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u16>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u16>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for PermissionType {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for PermissionType {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PermissionType {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Microphone
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u16>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for ReloadType {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<u32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<u32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for ReloadType {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D> for ReloadType {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ReloadType {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::PartialCache
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<u32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for UrlRequestAction {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<i32>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<i32>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for UrlRequestAction {
        type Borrowed<'a> = Self;
        #[inline(always)]
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            *value
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Self, D>
        for UrlRequestAction
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Self>(offset);
            encoder.write_num(self.into_primitive(), offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UrlRequestAction {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Allow
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let prim = decoder.read_num::<i32>(offset);

            *self = Self::from_primitive(prim).ok_or(fidl::Error::InvalidEnumValue)?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ContextCreateFrameRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ContextCreateFrameRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            ContextCreateFrameRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ContextCreateFrameRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ContextCreateFrameRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ContextCreateFrameRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<FrameMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.frame),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<FrameMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            ContextCreateFrameRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ContextCreateFrameRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ContextCreateFrameRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                frame: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<FrameMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<FrameMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.frame,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ContextCreateFrameWithParamsRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ContextCreateFrameWithParamsRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            24
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            ContextCreateFrameWithParamsRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ContextCreateFrameWithParamsRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ContextCreateFrameWithParamsRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ContextCreateFrameWithParamsRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <CreateFrameParams as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.params),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<FrameMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.frame),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                CreateFrameParams,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<FrameMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            ContextCreateFrameWithParamsRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ContextCreateFrameWithParamsRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ContextCreateFrameWithParamsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                params: fidl::new_empty!(
                    CreateFrameParams,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                frame: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<FrameMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                CreateFrameParams,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.params,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<FrameMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.frame,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ContextGetCookieManagerRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ContextGetCookieManagerRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            ContextGetCookieManagerRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ContextGetCookieManagerRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ContextGetCookieManagerRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ContextGetCookieManagerRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<CookieManagerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.manager),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<CookieManagerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            ContextGetCookieManagerRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ContextGetCookieManagerRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ContextGetCookieManagerRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                manager: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<CookieManagerMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<CookieManagerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.manager,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ContextProviderCreateRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ContextProviderCreateRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            24
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            ContextProviderCreateRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ContextProviderCreateRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ContextProviderCreateRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<ContextProviderCreateRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <CreateContextParams as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.params),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ContextMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.context),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                CreateContextParams,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ContextMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            ContextProviderCreateRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ContextProviderCreateRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ContextProviderCreateRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                params: fidl::new_empty!(
                    CreateContextParams,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                context: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ContextMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                CreateContextParams,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.params,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<ContextMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.context,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for ContextGetRemoteDebuggingPortResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ContextGetRemoteDebuggingPortResponse {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            2
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            2
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<ContextGetRemoteDebuggingPortResponse, D>
        for &ContextGetRemoteDebuggingPortResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ContextGetRemoteDebuggingPortResponse>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut ContextGetRemoteDebuggingPortResponse)
                    .write_unaligned((self as *const ContextGetRemoteDebuggingPortResponse).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
        fidl::encoding::Encode<ContextGetRemoteDebuggingPortResponse, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ContextGetRemoteDebuggingPortResponse>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for ContextGetRemoteDebuggingPortResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { port: fidl::new_empty!(u16, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for CookieManagerGetCookieListRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for CookieManagerGetCookieListRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            40
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            CookieManagerGetCookieListRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut CookieManagerGetCookieListRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CookieManagerGetCookieListRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<CookieManagerGetCookieListRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Optional<fidl::encoding::BoundedString<65536>> as fidl::encoding::ValueTypeMarker>::borrow(&self.url),
                    <fidl::encoding::Optional<fidl::encoding::UnboundedString> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<CookiesIteratorMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.cookies),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Optional<fidl::encoding::BoundedString<65536>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::Optional<fidl::encoding::UnboundedString>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<CookiesIteratorMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            CookieManagerGetCookieListRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CookieManagerGetCookieListRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 32, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for CookieManagerGetCookieListRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                url: fidl::new_empty!(
                    fidl::encoding::Optional<fidl::encoding::BoundedString<65536>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                name: fidl::new_empty!(
                    fidl::encoding::Optional<fidl::encoding::UnboundedString>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                cookies: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<CookiesIteratorMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::Optional<fidl::encoding::BoundedString<65536>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.url,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<fidl::encoding::UnboundedString>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.name,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<CookiesIteratorMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.cookies,
                decoder,
                offset + 32,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for CookieManagerObserveCookieChangesRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for CookieManagerObserveCookieChangesRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            40
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            CookieManagerObserveCookieChangesRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut CookieManagerObserveCookieChangesRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CookieManagerObserveCookieChangesRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<CookieManagerObserveCookieChangesRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Optional<fidl::encoding::BoundedString<65536>> as fidl::encoding::ValueTypeMarker>::borrow(&self.url),
                    <fidl::encoding::Optional<fidl::encoding::UnboundedString> as fidl::encoding::ValueTypeMarker>::borrow(&self.name),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<CookiesIteratorMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.changes),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Optional<fidl::encoding::BoundedString<65536>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::Optional<fidl::encoding::UnboundedString>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T2: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<CookiesIteratorMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            CookieManagerObserveCookieChangesRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CookieManagerObserveCookieChangesRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 32, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for CookieManagerObserveCookieChangesRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                url: fidl::new_empty!(
                    fidl::encoding::Optional<fidl::encoding::BoundedString<65536>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                name: fidl::new_empty!(
                    fidl::encoding::Optional<fidl::encoding::UnboundedString>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                changes: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<CookiesIteratorMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::Optional<fidl::encoding::BoundedString<65536>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.url,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Optional<fidl::encoding::UnboundedString>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.name,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<CookiesIteratorMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.changes,
                decoder,
                offset + 32,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for CookiesIteratorGetNextResponse {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for CookiesIteratorGetNextResponse {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            CookiesIteratorGetNextResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut CookiesIteratorGetNextResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CookiesIteratorGetNextResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<CookiesIteratorGetNextResponse, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::UnboundedVector<Cookie> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.changed_cookies),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::UnboundedVector<Cookie>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            CookiesIteratorGetNextResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CookiesIteratorGetNextResponse>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for CookiesIteratorGetNextResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                changed_cookies: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<Cookie>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::UnboundedVector<Cookie>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.changed_cookies,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for DebugEnableDevToolsRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for DebugEnableDevToolsRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            DebugEnableDevToolsRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut DebugEnableDevToolsRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DebugEnableDevToolsRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<DebugEnableDevToolsRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DevToolsListenerMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.listener),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DevToolsListenerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            DebugEnableDevToolsRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DebugEnableDevToolsRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DebugEnableDevToolsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                listener: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DevToolsListenerMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<DevToolsListenerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.listener,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for DevToolsListenerOnContextDevToolsAvailableRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for DevToolsListenerOnContextDevToolsAvailableRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            DevToolsListenerOnContextDevToolsAvailableRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut DevToolsListenerOnContextDevToolsAvailableRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DevToolsListenerOnContextDevToolsAvailableRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                DevToolsListenerOnContextDevToolsAvailableRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<DevToolsPerContextListenerMarker>,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.listener
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<DevToolsPerContextListenerMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            DevToolsListenerOnContextDevToolsAvailableRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DevToolsListenerOnContextDevToolsAvailableRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for DevToolsListenerOnContextDevToolsAvailableRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                listener: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<DevToolsPerContextListenerMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<DevToolsPerContextListenerMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.listener,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for DevToolsPerContextListenerOnHttpPortOpenRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for DevToolsPerContextListenerOnHttpPortOpenRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            2
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            2
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<DevToolsPerContextListenerOnHttpPortOpenRequest, D>
        for &DevToolsPerContextListenerOnHttpPortOpenRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DevToolsPerContextListenerOnHttpPortOpenRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut DevToolsPerContextListenerOnHttpPortOpenRequest).write_unaligned(
                    (self as *const DevToolsPerContextListenerOnHttpPortOpenRequest).read(),
                );
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u16, D>>
        fidl::encoding::Encode<DevToolsPerContextListenerOnHttpPortOpenRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<DevToolsPerContextListenerOnHttpPortOpenRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for DevToolsPerContextListenerOnHttpPortOpenRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { port: fidl::new_empty!(u16, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 2);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for FrameAddBeforeLoadJavaScriptRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FrameAddBeforeLoadJavaScriptRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            40
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            FrameAddBeforeLoadJavaScriptRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut FrameAddBeforeLoadJavaScriptRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameAddBeforeLoadJavaScriptRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FrameAddBeforeLoadJavaScriptRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.id),
                    <fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<65536>> as fidl::encoding::ValueTypeMarker>::borrow(&self.origins),
                    <fidl_fuchsia_mem::Buffer as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.script),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<u64, fidl::encoding::DefaultFuchsiaResourceDialect>,
            T1: fidl::encoding::Encode<
                fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<65536>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T2: fidl::encoding::Encode<
                fidl_fuchsia_mem::Buffer,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            FrameAddBeforeLoadJavaScriptRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameAddBeforeLoadJavaScriptRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            self.2.encode(encoder, offset + 24, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for FrameAddBeforeLoadJavaScriptRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                id: fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect),
                origins: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<65536>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                script: fidl::new_empty!(
                    fidl_fuchsia_mem::Buffer,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                u64,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.id,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<65536>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.origins,
                decoder,
                offset + 8,
                _depth
            )?;
            fidl::decode!(
                fidl_fuchsia_mem::Buffer,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.script,
                decoder,
                offset + 24,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for FrameConfigureInputTypesRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FrameConfigureInputTypesRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FrameConfigureInputTypesRequest, D>
        for &FrameConfigureInputTypesRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameConfigureInputTypesRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FrameConfigureInputTypesRequest, D>::encode(
                (
                    <InputTypes as fidl::encoding::ValueTypeMarker>::borrow(&self.types),
                    <AllowInputState as fidl::encoding::ValueTypeMarker>::borrow(&self.allow),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<InputTypes, D>,
            T1: fidl::encoding::Encode<AllowInputState, D>,
        > fidl::encoding::Encode<FrameConfigureInputTypesRequest, D> for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameConfigureInputTypesRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(8);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FrameConfigureInputTypesRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                types: fidl::new_empty!(InputTypes, D),
                allow: fidl::new_empty!(AllowInputState, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(8) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 8 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(InputTypes, D, &mut self.types, decoder, offset + 0, _depth)?;
            fidl::decode!(AllowInputState, D, &mut self.allow, decoder, offset + 8, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for FrameCreateView2Request {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FrameCreateView2Request {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            FrameCreateView2Request,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut FrameCreateView2Request
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameCreateView2Request>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                FrameCreateView2Request,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<CreateView2Args as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.args,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<CreateView2Args, fidl::encoding::DefaultFuchsiaResourceDialect>,
        >
        fidl::encoding::Encode<
            FrameCreateView2Request,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameCreateView2Request>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for FrameCreateView2Request
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                args: fidl::new_empty!(
                    CreateView2Args,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                CreateView2Args,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.args,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for FrameCreateViewRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FrameCreateViewRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            FrameCreateViewRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut FrameCreateViewRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameCreateViewRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FrameCreateViewRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl_fuchsia_ui_views::ViewToken as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.view_token),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl_fuchsia_ui_views::ViewToken,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            FrameCreateViewRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameCreateViewRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for FrameCreateViewRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                view_token: fidl::new_empty!(
                    fidl_fuchsia_ui_views::ViewToken,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl_fuchsia_ui_views::ViewToken,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.view_token,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for FrameCreateViewWithViewRefRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FrameCreateViewWithViewRefRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            12
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            FrameCreateViewWithViewRefRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut FrameCreateViewWithViewRefRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameCreateViewWithViewRefRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FrameCreateViewWithViewRefRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl_fuchsia_ui_views::ViewToken as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.view_token),
                    <fidl_fuchsia_ui_views::ViewRefControl as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.view_ref_control),
                    <fidl_fuchsia_ui_views::ViewRef as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.view_ref),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl_fuchsia_ui_views::ViewToken,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl_fuchsia_ui_views::ViewRefControl,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T2: fidl::encoding::Encode<
                fidl_fuchsia_ui_views::ViewRef,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            FrameCreateViewWithViewRefRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameCreateViewWithViewRefRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 4, depth)?;
            self.2.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for FrameCreateViewWithViewRefRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                view_token: fidl::new_empty!(
                    fidl_fuchsia_ui_views::ViewToken,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                view_ref_control: fidl::new_empty!(
                    fidl_fuchsia_ui_views::ViewRefControl,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                view_ref: fidl::new_empty!(
                    fidl_fuchsia_ui_views::ViewRef,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl_fuchsia_ui_views::ViewToken,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.view_token,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl_fuchsia_ui_views::ViewRefControl,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.view_ref_control,
                decoder,
                offset + 4,
                _depth
            )?;
            fidl::decode!(
                fidl_fuchsia_ui_views::ViewRef,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.view_ref,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for FrameExecuteJavaScriptNoResultRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FrameExecuteJavaScriptNoResultRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            32
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            FrameExecuteJavaScriptNoResultRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut FrameExecuteJavaScriptNoResultRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameExecuteJavaScriptNoResultRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FrameExecuteJavaScriptNoResultRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<65536>> as fidl::encoding::ValueTypeMarker>::borrow(&self.origins),
                    <fidl_fuchsia_mem::Buffer as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.script),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<65536>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl_fuchsia_mem::Buffer,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            FrameExecuteJavaScriptNoResultRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameExecuteJavaScriptNoResultRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for FrameExecuteJavaScriptNoResultRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                origins: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<65536>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                script: fidl::new_empty!(
                    fidl_fuchsia_mem::Buffer,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<65536>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.origins,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl_fuchsia_mem::Buffer,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.script,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for FrameExecuteJavaScriptRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FrameExecuteJavaScriptRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            32
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            FrameExecuteJavaScriptRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut FrameExecuteJavaScriptRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameExecuteJavaScriptRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FrameExecuteJavaScriptRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<65536>> as fidl::encoding::ValueTypeMarker>::borrow(&self.origins),
                    <fidl_fuchsia_mem::Buffer as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.script),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<65536>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl_fuchsia_mem::Buffer,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            FrameExecuteJavaScriptRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameExecuteJavaScriptRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for FrameExecuteJavaScriptRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                origins: fidl::new_empty!(
                    fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<65536>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                script: fidl::new_empty!(
                    fidl_fuchsia_mem::Buffer,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::UnboundedVector<fidl::encoding::BoundedString<65536>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.origins,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl_fuchsia_mem::Buffer,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.script,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for FrameForceContentDimensionsRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FrameForceContentDimensionsRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            8
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FrameForceContentDimensionsRequest, D>
        for &FrameForceContentDimensionsRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameForceContentDimensionsRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FrameForceContentDimensionsRequest, D>::encode(
                (
                    <fidl::encoding::Boxed<fidl_fuchsia_ui_gfx::Vec2> as fidl::encoding::ValueTypeMarker>::borrow(&self.web_dips),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl::encoding::Boxed<fidl_fuchsia_ui_gfx::Vec2>, D>,
        > fidl::encoding::Encode<FrameForceContentDimensionsRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameForceContentDimensionsRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FrameForceContentDimensionsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { web_dips: fidl::new_empty!(fidl::encoding::Boxed<fidl_fuchsia_ui_gfx::Vec2>, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Boxed<fidl_fuchsia_ui_gfx::Vec2>,
                D,
                &mut self.web_dips,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for FrameGetMediaPlayerRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FrameGetMediaPlayerRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            FrameGetMediaPlayerRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut FrameGetMediaPlayerRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameGetMediaPlayerRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                FrameGetMediaPlayerRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_media_sessions2::PlayerMarker>,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.player
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_media_sessions2::PlayerMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            FrameGetMediaPlayerRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameGetMediaPlayerRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for FrameGetMediaPlayerRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                player: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<fidl_fuchsia_media_sessions2::PlayerMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fidl::endpoints::ServerEnd<fidl_fuchsia_media_sessions2::PlayerMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.player,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for FrameGetNavigationControllerRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FrameGetNavigationControllerRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            FrameGetNavigationControllerRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut FrameGetNavigationControllerRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameGetNavigationControllerRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                FrameGetNavigationControllerRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<NavigationControllerMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.controller
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<NavigationControllerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            FrameGetNavigationControllerRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameGetNavigationControllerRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for FrameGetNavigationControllerRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                controller: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ServerEnd<NavigationControllerMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<NavigationControllerMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.controller,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for FrameGetPrivateMemorySizeResponse {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FrameGetPrivateMemorySizeResponse {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            8
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FrameGetPrivateMemorySizeResponse, D>
        for &FrameGetPrivateMemorySizeResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameGetPrivateMemorySizeResponse>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut FrameGetPrivateMemorySizeResponse)
                    .write_unaligned((self as *const FrameGetPrivateMemorySizeResponse).read());
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
        fidl::encoding::Encode<FrameGetPrivateMemorySizeResponse, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameGetPrivateMemorySizeResponse>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FrameGetPrivateMemorySizeResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { size_bytes: fidl::new_empty!(u64, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for FrameHostCreateFrameWithParamsRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FrameHostCreateFrameWithParamsRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            24
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            FrameHostCreateFrameWithParamsRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut FrameHostCreateFrameWithParamsRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameHostCreateFrameWithParamsRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FrameHostCreateFrameWithParamsRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <CreateFrameParams as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.params),
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<FrameMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.frame),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                CreateFrameParams,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<FrameMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            FrameHostCreateFrameWithParamsRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameHostCreateFrameWithParamsRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for FrameHostCreateFrameWithParamsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                params: fidl::new_empty!(
                    CreateFrameParams,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                frame: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<FrameMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                CreateFrameParams,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.params,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<FrameMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.frame,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for FramePostMessageRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FramePostMessageRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            32
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            FramePostMessageRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut FramePostMessageRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FramePostMessageRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FramePostMessageRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<65536> as fidl::encoding::ValueTypeMarker>::borrow(&self.target_origin),
                    <WebMessage as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.message),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<65536>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<WebMessage, fidl::encoding::DefaultFuchsiaResourceDialect>,
        >
        fidl::encoding::Encode<
            FramePostMessageRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FramePostMessageRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for FramePostMessageRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                target_origin: fidl::new_empty!(
                    fidl::encoding::BoundedString<65536>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                message: fidl::new_empty!(
                    WebMessage,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::BoundedString<65536>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.target_origin,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                WebMessage,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.message,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for FrameRemoveBeforeLoadJavaScriptRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FrameRemoveBeforeLoadJavaScriptRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            8
        }
        #[inline(always)]
        fn encode_is_copy() -> bool {
            true
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            true
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FrameRemoveBeforeLoadJavaScriptRequest, D>
        for &FrameRemoveBeforeLoadJavaScriptRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameRemoveBeforeLoadJavaScriptRequest>(offset);
            unsafe {
                // Copy the object into the buffer.
                let buf_ptr = encoder.buf.as_mut_ptr().add(offset);
                (buf_ptr as *mut FrameRemoveBeforeLoadJavaScriptRequest).write_unaligned(
                    (self as *const FrameRemoveBeforeLoadJavaScriptRequest).read(),
                );
                // Zero out padding regions. Unlike `fidl_struct_impl_noncopy!`, this must be
                // done second because the memcpy will write garbage to these bytes.
            }
            Ok(())
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<u64, D>>
        fidl::encoding::Encode<FrameRemoveBeforeLoadJavaScriptRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameRemoveBeforeLoadJavaScriptRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FrameRemoveBeforeLoadJavaScriptRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { id: fidl::new_empty!(u64, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let buf_ptr = unsafe { decoder.buf.as_ptr().add(offset) };
            // Verify that padding bytes are zero.
            // Copy from the buffer into the object.
            unsafe {
                std::ptr::copy_nonoverlapping(buf_ptr, self as *mut Self as *mut u8, 8);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for FrameSetBlockMediaLoadingRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FrameSetBlockMediaLoadingRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            1
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            1
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FrameSetBlockMediaLoadingRequest, D>
        for &FrameSetBlockMediaLoadingRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameSetBlockMediaLoadingRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FrameSetBlockMediaLoadingRequest, D>::encode(
                (<bool as fidl::encoding::ValueTypeMarker>::borrow(&self.blocked),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<bool, D>>
        fidl::encoding::Encode<FrameSetBlockMediaLoadingRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameSetBlockMediaLoadingRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FrameSetBlockMediaLoadingRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { blocked: fidl::new_empty!(bool, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(bool, D, &mut self.blocked, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for FrameSetConsoleLogSinkRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FrameSetConsoleLogSinkRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            FrameSetConsoleLogSinkRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut FrameSetConsoleLogSinkRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameSetConsoleLogSinkRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                FrameSetConsoleLogSinkRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::Optional<
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_logger::LogSinkMarker>,
                    >,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.sink
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_logger::LogSinkMarker>,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            FrameSetConsoleLogSinkRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameSetConsoleLogSinkRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for FrameSetConsoleLogSinkRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                sink: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::Endpoint<
                            fidl::endpoints::ClientEnd<fidl_fuchsia_logger::LogSinkMarker>,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_logger::LogSinkMarker>,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.sink,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for FrameSetContentAreaSettingsRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FrameSetContentAreaSettingsRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FrameSetContentAreaSettingsRequest, D>
        for &FrameSetContentAreaSettingsRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameSetContentAreaSettingsRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FrameSetContentAreaSettingsRequest, D>::encode(
                (<ContentAreaSettings as fidl::encoding::ValueTypeMarker>::borrow(&self.settings),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<ContentAreaSettings, D>,
        > fidl::encoding::Encode<FrameSetContentAreaSettingsRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameSetContentAreaSettingsRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FrameSetContentAreaSettingsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { settings: fidl::new_empty!(ContentAreaSettings, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(ContentAreaSettings, D, &mut self.settings, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for FrameSetJavaScriptLogLevelRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FrameSetJavaScriptLogLevelRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FrameSetJavaScriptLogLevelRequest, D>
        for &FrameSetJavaScriptLogLevelRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameSetJavaScriptLogLevelRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FrameSetJavaScriptLogLevelRequest, D>::encode(
                (<ConsoleLogLevel as fidl::encoding::ValueTypeMarker>::borrow(&self.level),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ConsoleLogLevel, D>>
        fidl::encoding::Encode<FrameSetJavaScriptLogLevelRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameSetJavaScriptLogLevelRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FrameSetJavaScriptLogLevelRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { level: fidl::new_empty!(ConsoleLogLevel, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(ConsoleLogLevel, D, &mut self.level, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for FrameSetMediaSettingsRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FrameSetMediaSettingsRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FrameSetMediaSettingsRequest, D> for &FrameSetMediaSettingsRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameSetMediaSettingsRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FrameSetMediaSettingsRequest, D>::encode(
                (<FrameMediaSettings as fidl::encoding::ValueTypeMarker>::borrow(&self.settings),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<FrameMediaSettings, D>>
        fidl::encoding::Encode<FrameSetMediaSettingsRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameSetMediaSettingsRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FrameSetMediaSettingsRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { settings: fidl::new_empty!(FrameMediaSettings, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(FrameMediaSettings, D, &mut self.settings, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for FrameSetNavigationEventListener2Request {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FrameSetNavigationEventListener2Request {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            FrameSetNavigationEventListener2Request,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut FrameSetNavigationEventListener2Request
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameSetNavigationEventListener2Request>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                FrameSetNavigationEventListener2Request,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <fidl::encoding::Optional<
                        fidl::encoding::Endpoint<
                            fidl::endpoints::ClientEnd<NavigationEventListenerMarker>,
                        >,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.listener
                    ),
                    <NavigationEventListenerFlags as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.flags,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<NavigationEventListenerMarker>,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                NavigationEventListenerFlags,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            FrameSetNavigationEventListener2Request,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameSetNavigationEventListener2Request>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for FrameSetNavigationEventListener2Request
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                listener: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::Endpoint<
                            fidl::endpoints::ClientEnd<NavigationEventListenerMarker>,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                flags: fidl::new_empty!(
                    NavigationEventListenerFlags,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<NavigationEventListenerMarker>,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.listener,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                NavigationEventListenerFlags,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.flags,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for FrameSetNavigationEventListenerRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FrameSetNavigationEventListenerRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            FrameSetNavigationEventListenerRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut FrameSetNavigationEventListenerRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameSetNavigationEventListenerRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                FrameSetNavigationEventListenerRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::Optional<
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<NavigationEventListenerMarker>,
                    >,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.listener
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<NavigationEventListenerMarker>,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            FrameSetNavigationEventListenerRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameSetNavigationEventListenerRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for FrameSetNavigationEventListenerRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                listener: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::Endpoint<
                            fidl::endpoints::ClientEnd<NavigationEventListenerMarker>,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<NavigationEventListenerMarker>,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.listener,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for FrameSetNavigationPolicyProviderRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FrameSetNavigationPolicyProviderRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            24
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            FrameSetNavigationPolicyProviderRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut FrameSetNavigationPolicyProviderRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameSetNavigationPolicyProviderRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                FrameSetNavigationPolicyProviderRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (
                    <NavigationPolicyProviderParams as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.params,
                    ),
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<NavigationPolicyProviderMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                        &mut self.provider
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                NavigationPolicyProviderParams,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<NavigationPolicyProviderMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            FrameSetNavigationPolicyProviderRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameSetNavigationPolicyProviderRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(16);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for FrameSetNavigationPolicyProviderRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                params: fidl::new_empty!(
                    NavigationPolicyProviderParams,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                provider: fidl::new_empty!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<NavigationPolicyProviderMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(16) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 16 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                NavigationPolicyProviderParams,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.params,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<NavigationPolicyProviderMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.provider,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for FrameSetPermissionStateRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FrameSetPermissionStateRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            40
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FrameSetPermissionStateRequest, D>
        for &FrameSetPermissionStateRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameSetPermissionStateRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FrameSetPermissionStateRequest, D>::encode(
                (
                    <PermissionDescriptor as fidl::encoding::ValueTypeMarker>::borrow(&self.permission),
                    <fidl::encoding::BoundedString<65536> as fidl::encoding::ValueTypeMarker>::borrow(&self.web_origin),
                    <PermissionState as fidl::encoding::ValueTypeMarker>::borrow(&self.state),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<PermissionDescriptor, D>,
            T1: fidl::encoding::Encode<fidl::encoding::BoundedString<65536>, D>,
            T2: fidl::encoding::Encode<PermissionState, D>,
        > fidl::encoding::Encode<FrameSetPermissionStateRequest, D> for (T0, T1, T2)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameSetPermissionStateRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(32);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            self.2.encode(encoder, offset + 32, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FrameSetPermissionStateRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                permission: fidl::new_empty!(PermissionDescriptor, D),
                web_origin: fidl::new_empty!(fidl::encoding::BoundedString<65536>, D),
                state: fidl::new_empty!(PermissionState, D),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(32) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffffffffff00u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 32 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                PermissionDescriptor,
                D,
                &mut self.permission,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl::encoding::BoundedString<65536>,
                D,
                &mut self.web_origin,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(PermissionState, D, &mut self.state, decoder, offset + 32, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for FrameSetPopupFrameCreationListenerRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FrameSetPopupFrameCreationListenerRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            FrameSetPopupFrameCreationListenerRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut FrameSetPopupFrameCreationListenerRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameSetPopupFrameCreationListenerRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                FrameSetPopupFrameCreationListenerRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl::encoding::Optional<
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<PopupFrameCreationListenerMarker>,
                    >,
                > as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.listener
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<PopupFrameCreationListenerMarker>,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            FrameSetPopupFrameCreationListenerRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameSetPopupFrameCreationListenerRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for FrameSetPopupFrameCreationListenerRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                listener: fidl::new_empty!(
                    fidl::encoding::Optional<
                        fidl::encoding::Endpoint<
                            fidl::endpoints::ClientEnd<PopupFrameCreationListenerMarker>,
                        >,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::Optional<
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<PopupFrameCreationListenerMarker>,
                    >,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.listener,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for FrameSetUrlRequestRewriteRulesRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FrameSetUrlRequestRewriteRulesRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<FrameSetUrlRequestRewriteRulesRequest, D>
        for &FrameSetUrlRequestRewriteRulesRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameSetUrlRequestRewriteRulesRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<FrameSetUrlRequestRewriteRulesRequest, D>::encode(
                (
                    <fidl::encoding::Vector<UrlRequestRewriteRule, 4096> as fidl::encoding::ValueTypeMarker>::borrow(&self.rules),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<fidl::encoding::Vector<UrlRequestRewriteRule, 4096>, D>,
        > fidl::encoding::Encode<FrameSetUrlRequestRewriteRulesRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameSetUrlRequestRewriteRulesRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for FrameSetUrlRequestRewriteRulesRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { rules: fidl::new_empty!(fidl::encoding::Vector<UrlRequestRewriteRule, 4096>, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(fidl::encoding::Vector<UrlRequestRewriteRule, 4096>, D, &mut self.rules, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for FrameExecuteJavaScriptResponse {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FrameExecuteJavaScriptResponse {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            FrameExecuteJavaScriptResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut FrameExecuteJavaScriptResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameExecuteJavaScriptResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                FrameExecuteJavaScriptResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<fidl_fuchsia_mem::Buffer as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.result,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl_fuchsia_mem::Buffer,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            FrameExecuteJavaScriptResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameExecuteJavaScriptResponse>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for FrameExecuteJavaScriptResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                result: fidl::new_empty!(
                    fidl_fuchsia_mem::Buffer,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl_fuchsia_mem::Buffer,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.result,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for MessagePortPostMessageRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for MessagePortPostMessageRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            MessagePortPostMessageRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut MessagePortPostMessageRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MessagePortPostMessageRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                MessagePortPostMessageRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<WebMessage as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.message,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<T0: fidl::encoding::Encode<WebMessage, fidl::encoding::DefaultFuchsiaResourceDialect>>
        fidl::encoding::Encode<
            MessagePortPostMessageRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MessagePortPostMessageRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for MessagePortPostMessageRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                message: fidl::new_empty!(
                    WebMessage,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                WebMessage,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.message,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for MessagePortReceiveMessageResponse {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for MessagePortReceiveMessageResponse {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            MessagePortReceiveMessageResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut MessagePortReceiveMessageResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MessagePortReceiveMessageResponse>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                MessagePortReceiveMessageResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<WebMessage as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.message,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<T0: fidl::encoding::Encode<WebMessage, fidl::encoding::DefaultFuchsiaResourceDialect>>
        fidl::encoding::Encode<
            MessagePortReceiveMessageResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<MessagePortReceiveMessageResponse>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for MessagePortReceiveMessageResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                message: fidl::new_empty!(
                    WebMessage,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                WebMessage,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.message,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for NavigationControllerLoadUrlRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for NavigationControllerLoadUrlRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            32
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            NavigationControllerLoadUrlRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut NavigationControllerLoadUrlRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NavigationControllerLoadUrlRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<NavigationControllerLoadUrlRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::BoundedString<65536> as fidl::encoding::ValueTypeMarker>::borrow(&self.url),
                    <LoadUrlParams as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.params),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::BoundedString<65536>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<LoadUrlParams, fidl::encoding::DefaultFuchsiaResourceDialect>,
        >
        fidl::encoding::Encode<
            NavigationControllerLoadUrlRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NavigationControllerLoadUrlRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 16, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for NavigationControllerLoadUrlRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                url: fidl::new_empty!(
                    fidl::encoding::BoundedString<65536>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                params: fidl::new_empty!(
                    LoadUrlParams,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                fidl::encoding::BoundedString<65536>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.url,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                LoadUrlParams,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.params,
                decoder,
                offset + 16,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for NavigationControllerReloadRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for NavigationControllerReloadRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            4
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<NavigationControllerReloadRequest, D>
        for &NavigationControllerReloadRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NavigationControllerReloadRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<NavigationControllerReloadRequest, D>::encode(
                (<ReloadType as fidl::encoding::ValueTypeMarker>::borrow(&self.type_),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<D: fidl::encoding::ResourceDialect, T0: fidl::encoding::Encode<ReloadType, D>>
        fidl::encoding::Encode<NavigationControllerReloadRequest, D> for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NavigationControllerReloadRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for NavigationControllerReloadRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { type_: fidl::new_empty!(ReloadType, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(ReloadType, D, &mut self.type_, decoder, offset + 0, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for NavigationEventListenerOnNavigationStateChangedRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for NavigationEventListenerOnNavigationStateChangedRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            NavigationEventListenerOnNavigationStateChangedRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut NavigationEventListenerOnNavigationStateChangedRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NavigationEventListenerOnNavigationStateChangedRequest>(
                offset,
            );
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                NavigationEventListenerOnNavigationStateChangedRequest,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<NavigationState as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.change,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<NavigationState, fidl::encoding::DefaultFuchsiaResourceDialect>,
        >
        fidl::encoding::Encode<
            NavigationEventListenerOnNavigationStateChangedRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NavigationEventListenerOnNavigationStateChangedRequest>(
                offset,
            );
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for NavigationEventListenerOnNavigationStateChangedRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                change: fidl::new_empty!(
                    NavigationState,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                NavigationState,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.change,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker
        for NavigationPolicyProviderEvaluateRequestedNavigationRequest
    {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker
        for NavigationPolicyProviderEvaluateRequestedNavigationRequest
    {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<NavigationPolicyProviderEvaluateRequestedNavigationRequest, D>
        for &NavigationPolicyProviderEvaluateRequestedNavigationRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<NavigationPolicyProviderEvaluateRequestedNavigationRequest>(
                    offset,
                );
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<NavigationPolicyProviderEvaluateRequestedNavigationRequest, D>::encode(
                (
                    <RequestedNavigation as fidl::encoding::ValueTypeMarker>::borrow(&self.requested_navigation),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            D: fidl::encoding::ResourceDialect,
            T0: fidl::encoding::Encode<RequestedNavigation, D>,
        > fidl::encoding::Encode<NavigationPolicyProviderEvaluateRequestedNavigationRequest, D>
        for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<NavigationPolicyProviderEvaluateRequestedNavigationRequest>(
                    offset,
                );
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for NavigationPolicyProviderEvaluateRequestedNavigationRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self { requested_navigation: fidl::new_empty!(RequestedNavigation, D) }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                RequestedNavigation,
                D,
                &mut self.requested_navigation,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker
        for NavigationPolicyProviderEvaluateRequestedNavigationResponse
    {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker
        for NavigationPolicyProviderEvaluateRequestedNavigationResponse
    {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            NavigationPolicyProviderEvaluateRequestedNavigationResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut NavigationPolicyProviderEvaluateRequestedNavigationResponse
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<NavigationPolicyProviderEvaluateRequestedNavigationResponse>(
                    offset,
                );
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<
                NavigationPolicyProviderEvaluateRequestedNavigationResponse,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >::encode(
                (<NavigationDecision as fidl::encoding::ResourceTypeMarker>::take_or_borrow(
                    &mut self.decision,
                ),),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                NavigationDecision,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            NavigationPolicyProviderEvaluateRequestedNavigationResponse,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0,)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<NavigationPolicyProviderEvaluateRequestedNavigationResponse>(
                    offset,
                );
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for NavigationPolicyProviderEvaluateRequestedNavigationResponse
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                decision: fidl::new_empty!(
                    NavigationDecision,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            fidl::decode!(
                NavigationDecision,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.decision,
                decoder,
                offset + 0,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for NoArgumentsAction {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for NoArgumentsAction {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            1
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            1
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<NoArgumentsAction, D>
        for &NoArgumentsAction
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NoArgumentsAction>(offset);
            encoder.write_num(0u8, offset);
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for NoArgumentsAction {
        #[inline(always)]
        fn new_empty() -> Self {
            Self
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            match decoder.read_num::<u8>(offset) {
                0 => Ok(()),
                _ => Err(fidl::Error::Invalid),
            }
        }
    }

    impl fidl::encoding::ResourceTypeMarker for PopupFrameCreationListenerOnPopupFrameCreatedRequest {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for PopupFrameCreationListenerOnPopupFrameCreatedRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            24
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            PopupFrameCreationListenerOnPopupFrameCreatedRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut PopupFrameCreationListenerOnPopupFrameCreatedRequest
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<PopupFrameCreationListenerOnPopupFrameCreatedRequest>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<PopupFrameCreationListenerOnPopupFrameCreatedRequest, fidl::encoding::DefaultFuchsiaResourceDialect>::encode(
                (
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<FrameMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.frame),
                    <PopupFrameCreationInfo as fidl::encoding::ResourceTypeMarker>::take_or_borrow(&mut self.info),
                ),
                encoder, offset, _depth
            )
        }
    }
    unsafe impl<
            T0: fidl::encoding::Encode<
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<FrameMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            T1: fidl::encoding::Encode<
                PopupFrameCreationInfo,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
        >
        fidl::encoding::Encode<
            PopupFrameCreationListenerOnPopupFrameCreatedRequest,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for (T0, T1)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder
                .debug_check_bounds::<PopupFrameCreationListenerOnPopupFrameCreatedRequest>(offset);
            // Zero out padding regions. There's no need to apply masks
            // because the unmasked parts will be overwritten by fields.
            unsafe {
                let ptr = encoder.buf.as_mut_ptr().add(offset).offset(0);
                (ptr as *mut u64).write_unaligned(0);
            }
            // Write the fields.
            self.0.encode(encoder, offset + 0, depth)?;
            self.1.encode(encoder, offset + 8, depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for PopupFrameCreationListenerOnPopupFrameCreatedRequest
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                frame: fidl::new_empty!(
                    fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<FrameMarker>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
                info: fidl::new_empty!(
                    PopupFrameCreationInfo,
                    fidl::encoding::DefaultFuchsiaResourceDialect
                ),
            }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            // Verify that padding bytes are zero.
            let ptr = unsafe { decoder.buf.as_ptr().add(offset).offset(0) };
            let padval = unsafe { (ptr as *const u64).read_unaligned() };
            let mask = 0xffffffff00000000u64;
            let maskedval = padval & mask;
            if maskedval != 0 {
                return Err(fidl::Error::NonZeroPadding {
                    padding_start: offset + 0 + ((mask as u64).trailing_zeros() / 8) as usize,
                });
            }
            fidl::decode!(
                fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<FrameMarker>>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.frame,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                PopupFrameCreationInfo,
                fidl::encoding::DefaultFuchsiaResourceDialect,
                &mut self.info,
                decoder,
                offset + 8,
                _depth
            )?;
            Ok(())
        }
    }

    impl ContentAreaSettings {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.page_scale {
                return 4;
            }
            if let Some(_) = self.theme {
                return 3;
            }
            if let Some(_) = self.autoplay_policy {
                return 2;
            }
            if let Some(_) = self.hide_scrollbars {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for ContentAreaSettings {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ContentAreaSettings {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<ContentAreaSettings, D>
        for &ContentAreaSettings
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ContentAreaSettings>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<bool, D>(
                self.hide_scrollbars
                    .as_ref()
                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<AutoplayPolicy, D>(
                self.autoplay_policy
                    .as_ref()
                    .map(<AutoplayPolicy as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 3 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (3 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_settings::ThemeType, D>(
                self.theme.as_ref().map(
                    <fidl_fuchsia_settings::ThemeType as fidl::encoding::ValueTypeMarker>::borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 4 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (4 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<f32, D>(
                self.page_scale.as_ref().map(<f32 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for ContentAreaSettings {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.hide_scrollbars.get_or_insert_with(|| fidl::new_empty!(bool, D));
                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <AutoplayPolicy as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                    self.autoplay_policy.get_or_insert_with(|| fidl::new_empty!(AutoplayPolicy, D));
                fidl::decode!(AutoplayPolicy, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 3 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <fidl_fuchsia_settings::ThemeType as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self
                    .theme
                    .get_or_insert_with(|| fidl::new_empty!(fidl_fuchsia_settings::ThemeType, D));
                fidl::decode!(
                    fidl_fuchsia_settings::ThemeType,
                    D,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 4 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.page_scale.get_or_insert_with(|| fidl::new_empty!(f32, D));
                fidl::decode!(f32, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl ContentDirectoryProvider {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.directory {
                return 2;
            }
            if let Some(_) = self.name {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for ContentDirectoryProvider {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for ContentDirectoryProvider {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            ContentDirectoryProvider,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut ContentDirectoryProvider
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<ContentDirectoryProvider>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::BoundedString<255>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.name.as_ref().map(
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.directory.as_mut().map(
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for ContentDirectoryProvider
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.name.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::BoundedString<255>,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::BoundedString<255>,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.directory.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Endpoint<
                            fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                        >,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl Cookie {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.value {
                return 2;
            }
            if let Some(_) = self.id {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for Cookie {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Cookie {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl fidl::encoding::Encode<Cookie, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut Cookie
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Cookie>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                CookieId,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.id.as_ref().map(<CookieId as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::UnboundedString,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.value.as_ref().map(
                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Cookie {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <CookieId as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.id.get_or_insert_with(|| {
                    fidl::new_empty!(CookieId, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    CookieId,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.value.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::UnboundedString,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::UnboundedString,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl CookieId {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.path {
                return 3;
            }
            if let Some(_) = self.domain {
                return 2;
            }
            if let Some(_) = self.name {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for CookieId {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for CookieId {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<CookieId, D> for &CookieId {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CookieId>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedString, D>(
                self.name.as_ref().map(
                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<255>, D>(
                self.domain.as_ref().map(
                    <fidl::encoding::BoundedString<255> as fidl::encoding::ValueTypeMarker>::borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 3 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (3 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65536>, D>(
            self.path.as_ref().map(<fidl::encoding::BoundedString<65536> as fidl::encoding::ValueTypeMarker>::borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for CookieId {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self
                    .name
                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::UnboundedString, D));
                fidl::decode!(
                    fidl::encoding::UnboundedString,
                    D,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <fidl::encoding::BoundedString<255> as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self
                    .domain
                    .get_or_insert_with(|| fidl::new_empty!(fidl::encoding::BoundedString<255>, D));
                fidl::decode!(
                    fidl::encoding::BoundedString<255>,
                    D,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 3 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::BoundedString<65536> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.path.get_or_insert_with(|| {
                    fidl::new_empty!(fidl::encoding::BoundedString<65536>, D)
                });
                fidl::decode!(
                    fidl::encoding::BoundedString<65536>,
                    D,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl CreateContextParams {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.data_quota_bytes {
                return 13;
            }
            if let Some(_) = self.cdm_data_quota_bytes {
                return 12;
            }
            if let Some(_) = self.cdm_data_directory {
                return 11;
            }
            if let Some(_) = self.cors_exempt_headers {
                return 10;
            }
            if let Some(_) = self.unsafely_treat_insecure_origins_as_secure {
                return 9;
            }
            if let Some(_) = self.playready_key_system {
                return 8;
            }
            if let Some(_) = self.features {
                return 7;
            }
            if let Some(_) = self.content_directories {
                return 6;
            }
            if let Some(_) = self.remote_debugging_port {
                return 5;
            }
            if let Some(_) = self.user_agent_version {
                return 4;
            }
            if let Some(_) = self.user_agent_product {
                return 3;
            }
            if let Some(_) = self.data_directory {
                return 2;
            }
            if let Some(_) = self.service_directory {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for CreateContextParams {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for CreateContextParams {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<CreateContextParams, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut CreateContextParams
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CreateContextParams>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.service_directory.as_mut().map(
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.data_directory.as_mut().map(
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 3 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (3 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::BoundedString<128>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.user_agent_product.as_ref().map(
                    <fidl::encoding::BoundedString<128> as fidl::encoding::ValueTypeMarker>::borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 4 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (4 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::BoundedString<128>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.user_agent_version.as_ref().map(
                    <fidl::encoding::BoundedString<128> as fidl::encoding::ValueTypeMarker>::borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 5 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (5 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                u16,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.remote_debugging_port
                    .as_ref()
                    .map(<u16 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 6 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (6 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<ContentDirectoryProvider, 100>, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.content_directories.as_mut().map(<fidl::encoding::Vector<ContentDirectoryProvider, 100> as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 7 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (7 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                ContextFeatureFlags,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.features
                    .as_ref()
                    .map(<ContextFeatureFlags as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 8 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (8 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::BoundedString<128>,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.playready_key_system.as_ref().map(
                    <fidl::encoding::BoundedString<128> as fidl::encoding::ValueTypeMarker>::borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 9 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (9 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<513>, 100>, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.unsafely_treat_insecure_origins_as_secure.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<513>, 100> as fidl::encoding::ValueTypeMarker>::borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 10 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (10 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl::encoding::UnboundedVector<u8>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.cors_exempt_headers.as_ref().map(<fidl::encoding::UnboundedVector<fidl::encoding::UnboundedVector<u8>> as fidl::encoding::ValueTypeMarker>::borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 11 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (11 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                >,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.cdm_data_directory.as_mut().map(
                    <fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                    > as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 12 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (12 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                u64,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.cdm_data_quota_bytes
                    .as_ref()
                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 13 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (13 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                u64,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.data_quota_bytes
                    .as_ref()
                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for CreateContextParams
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.service_directory.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Endpoint<
                            fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                        >,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.data_directory.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Endpoint<
                            fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                        >,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 3 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <fidl::encoding::BoundedString<128> as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.user_agent_product.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::BoundedString<128>,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::BoundedString<128>,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 4 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <fidl::encoding::BoundedString<128> as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.user_agent_version.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::BoundedString<128>,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::BoundedString<128>,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 5 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <u16 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.remote_debugging_port.get_or_insert_with(|| {
                    fidl::new_empty!(u16, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    u16,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 6 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Vector<ContentDirectoryProvider, 100> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                self.content_directories.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<ContentDirectoryProvider, 100>, fidl::encoding::DefaultFuchsiaResourceDialect));
                fidl::decode!(fidl::encoding::Vector<ContentDirectoryProvider, 100>, fidl::encoding::DefaultFuchsiaResourceDialect, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 7 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <ContextFeatureFlags as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.features.get_or_insert_with(|| {
                    fidl::new_empty!(
                        ContextFeatureFlags,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    ContextFeatureFlags,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 8 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <fidl::encoding::BoundedString<128> as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.playready_key_system.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::BoundedString<128>,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::BoundedString<128>,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 9 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Vector<
                    fidl::encoding::BoundedString<513>,
                    100,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                    self.unsafely_treat_insecure_origins_as_secure.get_or_insert_with(|| {
                        fidl::new_empty!(
                            fidl::encoding::Vector<fidl::encoding::BoundedString<513>, 100>,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        )
                    });
                fidl::decode!(
                    fidl::encoding::Vector<fidl::encoding::BoundedString<513>, 100>,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 10 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::UnboundedVector<
                    fidl::encoding::UnboundedVector<u8>,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.cors_exempt_headers.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::UnboundedVector<fidl::encoding::UnboundedVector<u8>>,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::UnboundedVector<fidl::encoding::UnboundedVector<u8>>,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 11 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Endpoint<
                    fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.cdm_data_directory.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Endpoint<
                            fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                        >,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::Endpoint<
                        fidl::endpoints::ClientEnd<fidl_fuchsia_io::DirectoryMarker>,
                    >,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 12 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.cdm_data_quota_bytes.get_or_insert_with(|| {
                    fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    u64,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 13 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.data_quota_bytes.get_or_insert_with(|| {
                    fidl::new_empty!(u64, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    u64,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl CreateFrameParams {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.explicit_sites_filter_error_page {
                return 4;
            }
            if let Some(_) = self.debug_name {
                return 2;
            }
            if let Some(_) = self.enable_remote_debugging {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for CreateFrameParams {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for CreateFrameParams {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<CreateFrameParams, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut CreateFrameParams
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CreateFrameParams>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                bool,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.enable_remote_debugging
                    .as_ref()
                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::UnboundedString,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.debug_name.as_ref().map(
                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 4 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (4 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl_fuchsia_mem::Data,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.explicit_sites_filter_error_page.as_mut().map(
                    <fidl_fuchsia_mem::Data as fidl::encoding::ResourceTypeMarker>::take_or_borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for CreateFrameParams
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.enable_remote_debugging.get_or_insert_with(|| {
                    fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    bool,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.debug_name.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::UnboundedString,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::UnboundedString,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 4 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <fidl_fuchsia_mem::Data as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.explicit_sites_filter_error_page.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl_fuchsia_mem::Data,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl_fuchsia_mem::Data,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl CreateView2Args {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.view_creation_token {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for CreateView2Args {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for CreateView2Args {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<CreateView2Args, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut CreateView2Args
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<CreateView2Args>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_ui_views::ViewCreationToken, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.view_creation_token.as_mut().map(<fidl_fuchsia_ui_views::ViewCreationToken as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for CreateView2Args
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl_fuchsia_ui_views::ViewCreationToken as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.view_creation_token.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl_fuchsia_ui_views::ViewCreationToken,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl_fuchsia_ui_views::ViewCreationToken,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl Favicon {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.height {
                return 3;
            }
            if let Some(_) = self.width {
                return 2;
            }
            if let Some(_) = self.data {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for Favicon {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Favicon {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl fidl::encoding::Encode<Favicon, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut Favicon
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Favicon>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_mem::Buffer, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.data.as_mut().map(<fidl_fuchsia_mem::Buffer as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                u32,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.width.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 3 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (3 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                u32,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.height.as_ref().map(<u32 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for Favicon {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <fidl_fuchsia_mem::Buffer as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.data.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl_fuchsia_mem::Buffer,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl_fuchsia_mem::Buffer,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.width.get_or_insert_with(|| {
                    fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    u32,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 3 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <u32 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.height.get_or_insert_with(|| {
                    fidl::new_empty!(u32, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    u32,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl FrameCloseRequest {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.timeout {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for FrameCloseRequest {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FrameCloseRequest {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FrameCloseRequest, D>
        for &FrameCloseRequest
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameCloseRequest>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<i64, D>(
                self.timeout.as_ref().map(<i64 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FrameCloseRequest {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <i64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.timeout.get_or_insert_with(|| fidl::new_empty!(i64, D));
                fidl::decode!(i64, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl FrameMediaSettings {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.audio_consumer_session_id {
                return 2;
            }
            if let Some(_) = self.renderer_usage {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for FrameMediaSettings {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for FrameMediaSettings {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<FrameMediaSettings, D>
        for &FrameMediaSettings
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<FrameMediaSettings>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_media::AudioRenderUsage, D>(
            self.renderer_usage.as_ref().map(<fidl_fuchsia_media::AudioRenderUsage as fidl::encoding::ValueTypeMarker>::borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<u64, D>(
                self.audio_consumer_session_id
                    .as_ref()
                    .map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for FrameMediaSettings {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl_fuchsia_media::AudioRenderUsage as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.renderer_usage.get_or_insert_with(|| {
                    fidl::new_empty!(fidl_fuchsia_media::AudioRenderUsage, D)
                });
                fidl::decode!(
                    fidl_fuchsia_media::AudioRenderUsage,
                    D,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                    self.audio_consumer_session_id.get_or_insert_with(|| fidl::new_empty!(u64, D));
                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl LoadUrlParams {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.headers {
                return 4;
            }
            if let Some(_) = self.was_user_activated {
                return 3;
            }
            if let Some(_) = self.referrer_url {
                return 2;
            }
            if let Some(_) = self.type_ {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for LoadUrlParams {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for LoadUrlParams {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl fidl::encoding::Encode<LoadUrlParams, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut LoadUrlParams
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<LoadUrlParams>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                LoadUrlReason,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.type_.as_ref().map(<LoadUrlReason as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65536>, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.referrer_url.as_ref().map(<fidl::encoding::BoundedString<65536> as fidl::encoding::ValueTypeMarker>::borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 3 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (3 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                bool,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.was_user_activated
                    .as_ref()
                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 4 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (4 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<fidl_fuchsia_net_http::Header>, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.headers.as_ref().map(<fidl::encoding::UnboundedVector<fidl_fuchsia_net_http::Header> as fidl::encoding::ValueTypeMarker>::borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for LoadUrlParams {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <LoadUrlReason as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.type_.get_or_insert_with(|| {
                    fidl::new_empty!(LoadUrlReason, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    LoadUrlReason,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::BoundedString<65536> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.referrer_url.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::BoundedString<65536>,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::BoundedString<65536>,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 3 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.was_user_activated.get_or_insert_with(|| {
                    fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    bool,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 4 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::UnboundedVector<
                    fidl_fuchsia_net_http::Header,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.headers.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::UnboundedVector<fidl_fuchsia_net_http::Header>,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::UnboundedVector<fidl_fuchsia_net_http::Header>,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl NavigationPolicyProviderParams {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.subframe_phases {
                return 2;
            }
            if let Some(_) = self.main_frame_phases {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for NavigationPolicyProviderParams {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for NavigationPolicyProviderParams {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<NavigationPolicyProviderParams, D>
        for &NavigationPolicyProviderParams
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NavigationPolicyProviderParams>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<NavigationPhase, D>(
                self.main_frame_phases
                    .as_ref()
                    .map(<NavigationPhase as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<NavigationPhase, D>(
                self.subframe_phases
                    .as_ref()
                    .map(<NavigationPhase as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for NavigationPolicyProviderParams
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <NavigationPhase as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self
                    .main_frame_phases
                    .get_or_insert_with(|| fidl::new_empty!(NavigationPhase, D));
                fidl::decode!(NavigationPhase, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <NavigationPhase as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self
                    .subframe_phases
                    .get_or_insert_with(|| fidl::new_empty!(NavigationPhase, D));
                fidl::decode!(NavigationPhase, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl NavigationState {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.error_detail {
                return 8;
            }
            if let Some(_) = self.favicon {
                return 7;
            }
            if let Some(_) = self.is_main_document_loaded {
                return 6;
            }
            if let Some(_) = self.can_go_back {
                return 5;
            }
            if let Some(_) = self.can_go_forward {
                return 4;
            }
            if let Some(_) = self.page_type {
                return 3;
            }
            if let Some(_) = self.title {
                return 2;
            }
            if let Some(_) = self.url {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for NavigationState {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for NavigationState {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<NavigationState, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut NavigationState
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NavigationState>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65536>, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.url.as_ref().map(<fidl::encoding::BoundedString<65536> as fidl::encoding::ValueTypeMarker>::borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                fidl::encoding::UnboundedString,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.title.as_ref().map(
                    <fidl::encoding::UnboundedString as fidl::encoding::ValueTypeMarker>::borrow,
                ),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 3 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (3 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                PageType,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.page_type.as_ref().map(<PageType as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 4 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (4 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                bool,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.can_go_forward.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 5 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (5 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                bool,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.can_go_back.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 6 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (6 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                bool,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.is_main_document_loaded
                    .as_ref()
                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 7 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (7 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                Favicon,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.favicon
                    .as_mut()
                    .map(<Favicon as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 8 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (8 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                ErrorDetail,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.error_detail
                    .as_ref()
                    .map(<ErrorDetail as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for NavigationState
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::BoundedString<65536> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.url.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::BoundedString<65536>,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::BoundedString<65536>,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <fidl::encoding::UnboundedString as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.title.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::UnboundedString,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::UnboundedString,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 3 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <PageType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.page_type.get_or_insert_with(|| {
                    fidl::new_empty!(PageType, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    PageType,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 4 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.can_go_forward.get_or_insert_with(|| {
                    fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    bool,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 5 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.can_go_back.get_or_insert_with(|| {
                    fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    bool,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 6 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.is_main_document_loaded.get_or_insert_with(|| {
                    fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    bool,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 7 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <Favicon as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.favicon.get_or_insert_with(|| {
                    fidl::new_empty!(Favicon, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    Favicon,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 8 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <ErrorDetail as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.error_detail.get_or_insert_with(|| {
                    fidl::new_empty!(ErrorDetail, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    ErrorDetail,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl PermissionDescriptor {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.type_ {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for PermissionDescriptor {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for PermissionDescriptor {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<PermissionDescriptor, D>
        for &PermissionDescriptor
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PermissionDescriptor>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<PermissionType, D>(
                self.type_
                    .as_ref()
                    .map(<PermissionType as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for PermissionDescriptor {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <PermissionType as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.type_.get_or_insert_with(|| fidl::new_empty!(PermissionType, D));
                fidl::decode!(PermissionType, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl PopupFrameCreationInfo {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.initiated_by_user {
                return 2;
            }
            if let Some(_) = self.initial_url {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for PopupFrameCreationInfo {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for PopupFrameCreationInfo {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<
            PopupFrameCreationInfo,
            fidl::encoding::DefaultFuchsiaResourceDialect,
        > for &mut PopupFrameCreationInfo
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<PopupFrameCreationInfo>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65536>, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.initial_url.as_ref().map(<fidl::encoding::BoundedString<65536> as fidl::encoding::ValueTypeMarker>::borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<
                bool,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >(
                self.initiated_by_user
                    .as_ref()
                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for PopupFrameCreationInfo
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::BoundedString<65536> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.initial_url.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::BoundedString<65536>,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::BoundedString<65536>,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.initiated_by_user.get_or_insert_with(|| {
                    fidl::new_empty!(bool, fidl::encoding::DefaultFuchsiaResourceDialect)
                });
                fidl::decode!(
                    bool,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl RequestedNavigation {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.was_server_redirect {
                return 8;
            }
            if let Some(_) = self.has_gesture {
                return 7;
            }
            if let Some(_) = self.url {
                return 6;
            }
            if let Some(_) = self.is_http_post {
                return 5;
            }
            if let Some(_) = self.is_same_document {
                return 4;
            }
            if let Some(_) = self.is_main_frame {
                return 3;
            }
            if let Some(_) = self.phase {
                return 2;
            }
            if let Some(_) = self.id {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for RequestedNavigation {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for RequestedNavigation {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<RequestedNavigation, D>
        for &RequestedNavigation
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<RequestedNavigation>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<u64, D>(
                self.id.as_ref().map(<u64 as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<NavigationPhase, D>(
                self.phase
                    .as_ref()
                    .map(<NavigationPhase as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 3 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (3 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<bool, D>(
                self.is_main_frame.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 4 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (4 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<bool, D>(
                self.is_same_document
                    .as_ref()
                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 5 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (5 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<bool, D>(
                self.is_http_post.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 6 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (6 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65536>, D>(
            self.url.as_ref().map(<fidl::encoding::BoundedString<65536> as fidl::encoding::ValueTypeMarker>::borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 7 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (7 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<bool, D>(
                self.has_gesture.as_ref().map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 8 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (8 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<bool, D>(
                self.was_server_redirect
                    .as_ref()
                    .map(<bool as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for RequestedNavigation {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.id.get_or_insert_with(|| fidl::new_empty!(u64, D));
                fidl::decode!(u64, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <NavigationPhase as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                    self.phase.get_or_insert_with(|| fidl::new_empty!(NavigationPhase, D));
                fidl::decode!(NavigationPhase, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 3 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.is_main_frame.get_or_insert_with(|| fidl::new_empty!(bool, D));
                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 4 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                    self.is_same_document.get_or_insert_with(|| fidl::new_empty!(bool, D));
                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 5 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.is_http_post.get_or_insert_with(|| fidl::new_empty!(bool, D));
                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 6 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::BoundedString<65536> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.url.get_or_insert_with(|| {
                    fidl::new_empty!(fidl::encoding::BoundedString<65536>, D)
                });
                fidl::decode!(
                    fidl::encoding::BoundedString<65536>,
                    D,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 7 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.has_gesture.get_or_insert_with(|| fidl::new_empty!(bool, D));
                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 8 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <bool as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                    self.was_server_redirect.get_or_insert_with(|| fidl::new_empty!(bool, D));
                fidl::decode!(bool, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl UrlRequestRewriteAddHeaders {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.headers {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for UrlRequestRewriteAddHeaders {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for UrlRequestRewriteAddHeaders {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<UrlRequestRewriteAddHeaders, D> for &UrlRequestRewriteAddHeaders
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<UrlRequestRewriteAddHeaders>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl_fuchsia_net_http::Header, 4096>, D>(
            self.headers.as_ref().map(<fidl::encoding::Vector<fidl_fuchsia_net_http::Header, 4096> as fidl::encoding::ValueTypeMarker>::borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for UrlRequestRewriteAddHeaders
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Vector<
                    fidl_fuchsia_net_http::Header,
                    4096,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                self.headers.get_or_insert_with(|| fidl::new_empty!(fidl::encoding::Vector<fidl_fuchsia_net_http::Header, 4096>, D));
                fidl::decode!(fidl::encoding::Vector<fidl_fuchsia_net_http::Header, 4096>, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl UrlRequestRewriteAppendToQuery {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.query {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for UrlRequestRewriteAppendToQuery {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for UrlRequestRewriteAppendToQuery {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<UrlRequestRewriteAppendToQuery, D>
        for &UrlRequestRewriteAppendToQuery
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<UrlRequestRewriteAppendToQuery>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65536>, D>(
            self.query.as_ref().map(<fidl::encoding::BoundedString<65536> as fidl::encoding::ValueTypeMarker>::borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for UrlRequestRewriteAppendToQuery
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::BoundedString<65536> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.query.get_or_insert_with(|| {
                    fidl::new_empty!(fidl::encoding::BoundedString<65536>, D)
                });
                fidl::decode!(
                    fidl::encoding::BoundedString<65536>,
                    D,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl UrlRequestRewriteRemoveHeader {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.header_name {
                return 2;
            }
            if let Some(_) = self.query_pattern {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for UrlRequestRewriteRemoveHeader {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for UrlRequestRewriteRemoveHeader {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<UrlRequestRewriteRemoveHeader, D>
        for &UrlRequestRewriteRemoveHeader
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<UrlRequestRewriteRemoveHeader>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65536>, D>(
            self.query_pattern.as_ref().map(<fidl::encoding::BoundedString<65536> as fidl::encoding::ValueTypeMarker>::borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<u8>, D>(
            self.header_name.as_ref().map(<fidl::encoding::UnboundedVector<u8> as fidl::encoding::ValueTypeMarker>::borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for UrlRequestRewriteRemoveHeader
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::BoundedString<65536> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.query_pattern.get_or_insert_with(|| {
                    fidl::new_empty!(fidl::encoding::BoundedString<65536>, D)
                });
                fidl::decode!(
                    fidl::encoding::BoundedString<65536>,
                    D,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::UnboundedVector<u8> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.header_name.get_or_insert_with(|| {
                    fidl::new_empty!(fidl::encoding::UnboundedVector<u8>, D)
                });
                fidl::decode!(
                    fidl::encoding::UnboundedVector<u8>,
                    D,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl UrlRequestRewriteReplaceUrl {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.new_url {
                return 2;
            }
            if let Some(_) = self.url_ends_with {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for UrlRequestRewriteReplaceUrl {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for UrlRequestRewriteReplaceUrl {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<UrlRequestRewriteReplaceUrl, D> for &UrlRequestRewriteReplaceUrl
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<UrlRequestRewriteReplaceUrl>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65536>, D>(
            self.url_ends_with.as_ref().map(<fidl::encoding::BoundedString<65536> as fidl::encoding::ValueTypeMarker>::borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65536>, D>(
            self.new_url.as_ref().map(<fidl::encoding::BoundedString<65536> as fidl::encoding::ValueTypeMarker>::borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for UrlRequestRewriteReplaceUrl
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::BoundedString<65536> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.url_ends_with.get_or_insert_with(|| {
                    fidl::new_empty!(fidl::encoding::BoundedString<65536>, D)
                });
                fidl::decode!(
                    fidl::encoding::BoundedString<65536>,
                    D,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::BoundedString<65536> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.new_url.get_or_insert_with(|| {
                    fidl::new_empty!(fidl::encoding::BoundedString<65536>, D)
                });
                fidl::decode!(
                    fidl::encoding::BoundedString<65536>,
                    D,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl UrlRequestRewriteRule {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.action {
                return 4;
            }
            if let Some(_) = self.rewrites {
                return 3;
            }
            if let Some(_) = self.schemes_filter {
                return 2;
            }
            if let Some(_) = self.hosts_filter {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for UrlRequestRewriteRule {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for UrlRequestRewriteRule {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UrlRequestRewriteRule, D>
        for &UrlRequestRewriteRule
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<UrlRequestRewriteRule>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 4096>, D>(
            self.hosts_filter.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 4096> as fidl::encoding::ValueTypeMarker>::borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 4096>, D>(
            self.schemes_filter.as_ref().map(<fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 4096> as fidl::encoding::ValueTypeMarker>::borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 3 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (3 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::Vector<UrlRequestRewrite, 4096>, D>(
            self.rewrites.as_ref().map(<fidl::encoding::Vector<UrlRequestRewrite, 4096> as fidl::encoding::ValueTypeMarker>::borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 4 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (4 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<UrlRequestAction, D>(
                self.action
                    .as_ref()
                    .map(<UrlRequestAction as fidl::encoding::ValueTypeMarker>::borrow),
                encoder,
                offset + cur_offset,
                depth,
            )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UrlRequestRewriteRule {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Vector<
                    fidl::encoding::BoundedString<255>,
                    4096,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.hosts_filter.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 4096>,
                        D
                    )
                });
                fidl::decode!(
                    fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 4096>,
                    D,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Vector<
                    fidl::encoding::BoundedString<255>,
                    4096,
                > as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context
                );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.schemes_filter.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 4096>,
                        D
                    )
                });
                fidl::decode!(
                    fidl::encoding::Vector<fidl::encoding::BoundedString<255>, 4096>,
                    D,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 3 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::Vector<UrlRequestRewrite, 4096> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.rewrites.get_or_insert_with(
                    || fidl::new_empty!(fidl::encoding::Vector<UrlRequestRewrite, 4096>, D),
                );
                fidl::decode!(fidl::encoding::Vector<UrlRequestRewrite, 4096>, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 4 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <UrlRequestAction as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref =
                    self.action.get_or_insert_with(|| fidl::new_empty!(UrlRequestAction, D));
                fidl::decode!(UrlRequestAction, D, val_ref, decoder, inner_offset, inner_depth)?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl UrlRequestRewriteSubstituteQueryPattern {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.substitution {
                return 2;
            }
            if let Some(_) = self.pattern {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for UrlRequestRewriteSubstituteQueryPattern {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for UrlRequestRewriteSubstituteQueryPattern {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<UrlRequestRewriteSubstituteQueryPattern, D>
        for &UrlRequestRewriteSubstituteQueryPattern
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<UrlRequestRewriteSubstituteQueryPattern>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65536>, D>(
            self.pattern.as_ref().map(<fidl::encoding::BoundedString<65536> as fidl::encoding::ValueTypeMarker>::borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::BoundedString<65536>, D>(
            self.substitution.as_ref().map(<fidl::encoding::BoundedString<65536> as fidl::encoding::ValueTypeMarker>::borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for UrlRequestRewriteSubstituteQueryPattern
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::BoundedString<65536> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.pattern.get_or_insert_with(|| {
                    fidl::new_empty!(fidl::encoding::BoundedString<65536>, D)
                });
                fidl::decode!(
                    fidl::encoding::BoundedString<65536>,
                    D,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::BoundedString<65536> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.substitution.get_or_insert_with(|| {
                    fidl::new_empty!(fidl::encoding::BoundedString<65536>, D)
                });
                fidl::decode!(
                    fidl::encoding::BoundedString<65536>,
                    D,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl WebMessage {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.outgoing_transfer {
                return 3;
            }
            if let Some(_) = self.incoming_transfer {
                return 2;
            }
            if let Some(_) = self.data {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ResourceTypeMarker for WebMessage {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for WebMessage {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl fidl::encoding::Encode<WebMessage, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut WebMessage
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<WebMessage>(offset);
            // Vector header
            let max_ordinal: u64 = self.max_ordinal_present();
            encoder.write_num(max_ordinal, offset);
            encoder.write_num(fidl::encoding::ALLOC_PRESENT_U64, offset + 8);
            // Calling encoder.out_of_line_offset(0) is not allowed.
            if max_ordinal == 0 {
                return Ok(());
            }
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = max_ordinal as usize * envelope_size;
            #[allow(unused_variables)]
            let offset = encoder.out_of_line_offset(bytes_len);
            let mut _prev_end_offset: usize = 0;
            if 1 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (1 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl_fuchsia_mem::Buffer, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.data.as_mut().map(<fidl_fuchsia_mem::Buffer as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 2 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (2 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<IncomingTransferable>, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.incoming_transfer.as_mut().map(<fidl::encoding::UnboundedVector<IncomingTransferable> as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;
            if 3 > max_ordinal {
                return Ok(());
            }

            // Write at offset+(ordinal-1)*envelope_size, since ordinals are one-based and envelopes
            // are envelope_size bytes.
            let cur_offset: usize = (3 - 1) * envelope_size;

            // Zero reserved fields.
            encoder.padding(offset + _prev_end_offset, cur_offset - _prev_end_offset);

            // Safety:
            // - bytes_len is calculated to fit envelope_size*max(member.ordinal).
            // - Since cur_offset is envelope_size*(member.ordinal - 1) and the envelope takes
            //   envelope_size bytes, there is always sufficient room.
            fidl::encoding::encode_in_envelope_optional::<fidl::encoding::UnboundedVector<OutgoingTransferable>, fidl::encoding::DefaultFuchsiaResourceDialect>(
            self.outgoing_transfer.as_mut().map(<fidl::encoding::UnboundedVector<OutgoingTransferable> as fidl::encoding::ResourceTypeMarker>::take_or_borrow),
            encoder, offset + cur_offset, depth
        )?;

            _prev_end_offset = cur_offset + envelope_size;

            Ok(())
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect> for WebMessage {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::default()
        }

        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            let len = match fidl::encoding::decode_vector_header(decoder, offset)? {
                None => return Err(fidl::Error::NotNullable),
                Some(len) => len,
            };
            // Calling decoder.out_of_line_offset(0) is not allowed.
            if len == 0 {
                return Ok(());
            };
            depth.increment()?;
            let envelope_size = 8;
            let bytes_len = len * envelope_size;
            let offset = decoder.out_of_line_offset(bytes_len)?;
            // Decode the envelope for each type.
            let mut _next_ordinal_to_read = 0;
            let mut next_offset = offset;
            let end_offset = offset + bytes_len;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 1 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size =
                    <fidl_fuchsia_mem::Buffer as fidl::encoding::TypeMarker>::inline_size(
                        decoder.context,
                    );
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.data.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl_fuchsia_mem::Buffer,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl_fuchsia_mem::Buffer,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 2 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::UnboundedVector<IncomingTransferable> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.incoming_transfer.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::UnboundedVector<IncomingTransferable>,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::UnboundedVector<IncomingTransferable>,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;
            _next_ordinal_to_read += 1;
            if next_offset >= end_offset {
                return Ok(());
            }

            // Decode unknown envelopes for gaps in ordinals.
            while _next_ordinal_to_read < 3 {
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                _next_ordinal_to_read += 1;
                next_offset += envelope_size;
            }

            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            if let Some((inlined, num_bytes, num_handles)) =
                fidl::encoding::decode_envelope_header(decoder, next_offset)?
            {
                let member_inline_size = <fidl::encoding::UnboundedVector<OutgoingTransferable> as fidl::encoding::TypeMarker>::inline_size(decoder.context);
                if inlined != (member_inline_size <= 4) {
                    return Err(fidl::Error::InvalidInlineBitInEnvelope);
                }
                let inner_offset;
                let mut inner_depth = depth.clone();
                if inlined {
                    decoder.check_inline_envelope_padding(next_offset, member_inline_size)?;
                    inner_offset = next_offset;
                } else {
                    inner_offset = decoder.out_of_line_offset(member_inline_size)?;
                    inner_depth.increment()?;
                }
                let val_ref = self.outgoing_transfer.get_or_insert_with(|| {
                    fidl::new_empty!(
                        fidl::encoding::UnboundedVector<OutgoingTransferable>,
                        fidl::encoding::DefaultFuchsiaResourceDialect
                    )
                });
                fidl::decode!(
                    fidl::encoding::UnboundedVector<OutgoingTransferable>,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                    val_ref,
                    decoder,
                    inner_offset,
                    inner_depth
                )?;
                if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize)
                {
                    return Err(fidl::Error::InvalidNumBytesInEnvelope);
                }
                if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                    return Err(fidl::Error::InvalidNumHandlesInEnvelope);
                }
            }

            next_offset += envelope_size;

            // Decode the remaining unknown envelopes.
            while next_offset < end_offset {
                _next_ordinal_to_read += 1;
                fidl::encoding::decode_unknown_envelope(decoder, next_offset, depth)?;
                next_offset += envelope_size;
            }

            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for IncomingTransferable {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for IncomingTransferable {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<IncomingTransferable, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut IncomingTransferable
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<IncomingTransferable>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
            IncomingTransferable::MessagePort(ref mut val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<MessagePortMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<MessagePortMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            IncomingTransferable::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
        }
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for IncomingTransferable
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::__SourceBreaking { unknown_ordinal: 0 }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            #[allow(unused_variables)]
            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            let (ordinal, inlined, num_bytes, num_handles) =
                fidl::encoding::decode_union_inline_portion(decoder, offset)?;

            let member_inline_size = match ordinal {
            1 => <fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<MessagePortMarker>> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            0 => return Err(fidl::Error::UnknownUnionTag),
            _ => num_bytes as usize,
        };

            if inlined != (member_inline_size <= 4) {
                return Err(fidl::Error::InvalidInlineBitInEnvelope);
            }
            let _inner_offset;
            if inlined {
                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
                _inner_offset = offset + 8;
            } else {
                depth.increment()?;
                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
            }
            match ordinal {
                1 => {
                    #[allow(irrefutable_let_patterns)]
                    if let IncomingTransferable::MessagePort(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = IncomingTransferable::MessagePort(fidl::new_empty!(
                            fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<MessagePortMarker>>,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let IncomingTransferable::MessagePort(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::Endpoint<fidl::endpoints::ClientEnd<MessagePortMarker>>,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                #[allow(deprecated)]
                ordinal => {
                    for _ in 0..num_handles {
                        decoder.drop_next_handle()?;
                    }
                    *self = IncomingTransferable::__SourceBreaking { unknown_ordinal: ordinal };
                }
            }
            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
                return Err(fidl::Error::InvalidNumBytesInEnvelope);
            }
            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for NavigationDecision {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for NavigationDecision {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<NavigationDecision, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut NavigationDecision
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<NavigationDecision>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                NavigationDecision::Proceed(ref val) => fidl::encoding::encode_in_envelope::<
                    NoArgumentsAction,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <NoArgumentsAction as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                NavigationDecision::Abort(ref val) => fidl::encoding::encode_in_envelope::<
                    NoArgumentsAction,
                    fidl::encoding::DefaultFuchsiaResourceDialect,
                >(
                    <NoArgumentsAction as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
            }
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for NavigationDecision
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::Proceed(fidl::new_empty!(
                NoArgumentsAction,
                fidl::encoding::DefaultFuchsiaResourceDialect
            ))
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            #[allow(unused_variables)]
            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            let (ordinal, inlined, num_bytes, num_handles) =
                fidl::encoding::decode_union_inline_portion(decoder, offset)?;

            let member_inline_size = match ordinal {
                1 => {
                    <NoArgumentsAction as fidl::encoding::TypeMarker>::inline_size(decoder.context)
                }
                2 => {
                    <NoArgumentsAction as fidl::encoding::TypeMarker>::inline_size(decoder.context)
                }
                _ => return Err(fidl::Error::UnknownUnionTag),
            };

            if inlined != (member_inline_size <= 4) {
                return Err(fidl::Error::InvalidInlineBitInEnvelope);
            }
            let _inner_offset;
            if inlined {
                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
                _inner_offset = offset + 8;
            } else {
                depth.increment()?;
                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
            }
            match ordinal {
                1 => {
                    #[allow(irrefutable_let_patterns)]
                    if let NavigationDecision::Proceed(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = NavigationDecision::Proceed(fidl::new_empty!(
                            NoArgumentsAction,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let NavigationDecision::Proceed(ref mut val) = self {
                        fidl::decode!(
                            NoArgumentsAction,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let NavigationDecision::Abort(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = NavigationDecision::Abort(fidl::new_empty!(
                            NoArgumentsAction,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let NavigationDecision::Abort(ref mut val) = self {
                        fidl::decode!(
                            NoArgumentsAction,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                ordinal => panic!("unexpected ordinal {:?}", ordinal),
            }
            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
                return Err(fidl::Error::InvalidNumBytesInEnvelope);
            }
            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ResourceTypeMarker for OutgoingTransferable {
        type Borrowed<'a> = &'a mut Self;
        fn take_or_borrow<'a>(
            value: &'a mut <Self as fidl::encoding::TypeMarker>::Owned,
        ) -> Self::Borrowed<'a> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for OutgoingTransferable {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl
        fidl::encoding::Encode<OutgoingTransferable, fidl::encoding::DefaultFuchsiaResourceDialect>
        for &mut OutgoingTransferable
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<OutgoingTransferable>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
            OutgoingTransferable::MessagePort(ref mut val) => {
                fidl::encoding::encode_in_envelope::<fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<MessagePortMarker>>, fidl::encoding::DefaultFuchsiaResourceDialect>(
                    <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<MessagePortMarker>> as fidl::encoding::ResourceTypeMarker>::take_or_borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            OutgoingTransferable::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
        }
        }
    }

    impl fidl::encoding::Decode<Self, fidl::encoding::DefaultFuchsiaResourceDialect>
        for OutgoingTransferable
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::__SourceBreaking { unknown_ordinal: 0 }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<
                '_,
                fidl::encoding::DefaultFuchsiaResourceDialect,
            >,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            #[allow(unused_variables)]
            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            let (ordinal, inlined, num_bytes, num_handles) =
                fidl::encoding::decode_union_inline_portion(decoder, offset)?;

            let member_inline_size = match ordinal {
            1 => <fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<MessagePortMarker>> as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            0 => return Err(fidl::Error::UnknownUnionTag),
            _ => num_bytes as usize,
        };

            if inlined != (member_inline_size <= 4) {
                return Err(fidl::Error::InvalidInlineBitInEnvelope);
            }
            let _inner_offset;
            if inlined {
                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
                _inner_offset = offset + 8;
            } else {
                depth.increment()?;
                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
            }
            match ordinal {
                1 => {
                    #[allow(irrefutable_let_patterns)]
                    if let OutgoingTransferable::MessagePort(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = OutgoingTransferable::MessagePort(fidl::new_empty!(
                            fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<MessagePortMarker>>,
                            fidl::encoding::DefaultFuchsiaResourceDialect
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let OutgoingTransferable::MessagePort(ref mut val) = self {
                        fidl::decode!(
                            fidl::encoding::Endpoint<fidl::endpoints::ServerEnd<MessagePortMarker>>,
                            fidl::encoding::DefaultFuchsiaResourceDialect,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                #[allow(deprecated)]
                ordinal => {
                    for _ in 0..num_handles {
                        decoder.drop_next_handle()?;
                    }
                    *self = OutgoingTransferable::__SourceBreaking { unknown_ordinal: ordinal };
                }
            }
            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
                return Err(fidl::Error::InvalidNumBytesInEnvelope);
            }
            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
            }
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for UrlRequestRewrite {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for UrlRequestRewrite {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            8
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            16
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<UrlRequestRewrite, D>
        for &UrlRequestRewrite
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<UrlRequestRewrite>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
            UrlRequestRewrite::AddHeaders(ref val) => {
                fidl::encoding::encode_in_envelope::<UrlRequestRewriteAddHeaders, D>(
                    <UrlRequestRewriteAddHeaders as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            UrlRequestRewrite::RemoveHeader(ref val) => {
                fidl::encoding::encode_in_envelope::<UrlRequestRewriteRemoveHeader, D>(
                    <UrlRequestRewriteRemoveHeader as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            UrlRequestRewrite::SubstituteQueryPattern(ref val) => {
                fidl::encoding::encode_in_envelope::<UrlRequestRewriteSubstituteQueryPattern, D>(
                    <UrlRequestRewriteSubstituteQueryPattern as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            UrlRequestRewrite::ReplaceUrl(ref val) => {
                fidl::encoding::encode_in_envelope::<UrlRequestRewriteReplaceUrl, D>(
                    <UrlRequestRewriteReplaceUrl as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            UrlRequestRewrite::AppendToQuery(ref val) => {
                fidl::encoding::encode_in_envelope::<UrlRequestRewriteAppendToQuery, D>(
                    <UrlRequestRewriteAppendToQuery as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder, offset + 8, _depth
                )
            }
            UrlRequestRewrite::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
        }
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for UrlRequestRewrite {
        #[inline(always)]
        fn new_empty() -> Self {
            Self::__SourceBreaking { unknown_ordinal: 0 }
        }

        #[inline]
        unsafe fn decode(
            &mut self,
            decoder: &mut fidl::encoding::Decoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            decoder.debug_check_bounds::<Self>(offset);
            #[allow(unused_variables)]
            let next_out_of_line = decoder.next_out_of_line();
            let handles_before = decoder.remaining_handles();
            let (ordinal, inlined, num_bytes, num_handles) =
                fidl::encoding::decode_union_inline_portion(decoder, offset)?;

            let member_inline_size = match ordinal {
            1 => <UrlRequestRewriteAddHeaders as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            2 => <UrlRequestRewriteRemoveHeader as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            3 => <UrlRequestRewriteSubstituteQueryPattern as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            4 => <UrlRequestRewriteReplaceUrl as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            5 => <UrlRequestRewriteAppendToQuery as fidl::encoding::TypeMarker>::inline_size(decoder.context),
            0 => return Err(fidl::Error::UnknownUnionTag),
            _ => num_bytes as usize,
        };

            if inlined != (member_inline_size <= 4) {
                return Err(fidl::Error::InvalidInlineBitInEnvelope);
            }
            let _inner_offset;
            if inlined {
                decoder.check_inline_envelope_padding(offset + 8, member_inline_size)?;
                _inner_offset = offset + 8;
            } else {
                depth.increment()?;
                _inner_offset = decoder.out_of_line_offset(member_inline_size)?;
            }
            match ordinal {
                1 => {
                    #[allow(irrefutable_let_patterns)]
                    if let UrlRequestRewrite::AddHeaders(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = UrlRequestRewrite::AddHeaders(fidl::new_empty!(
                            UrlRequestRewriteAddHeaders,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let UrlRequestRewrite::AddHeaders(ref mut val) = self {
                        fidl::decode!(
                            UrlRequestRewriteAddHeaders,
                            D,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let UrlRequestRewrite::RemoveHeader(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = UrlRequestRewrite::RemoveHeader(fidl::new_empty!(
                            UrlRequestRewriteRemoveHeader,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let UrlRequestRewrite::RemoveHeader(ref mut val) = self {
                        fidl::decode!(
                            UrlRequestRewriteRemoveHeader,
                            D,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                3 => {
                    #[allow(irrefutable_let_patterns)]
                    if let UrlRequestRewrite::SubstituteQueryPattern(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = UrlRequestRewrite::SubstituteQueryPattern(fidl::new_empty!(
                            UrlRequestRewriteSubstituteQueryPattern,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let UrlRequestRewrite::SubstituteQueryPattern(ref mut val) = self {
                        fidl::decode!(
                            UrlRequestRewriteSubstituteQueryPattern,
                            D,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                4 => {
                    #[allow(irrefutable_let_patterns)]
                    if let UrlRequestRewrite::ReplaceUrl(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = UrlRequestRewrite::ReplaceUrl(fidl::new_empty!(
                            UrlRequestRewriteReplaceUrl,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let UrlRequestRewrite::ReplaceUrl(ref mut val) = self {
                        fidl::decode!(
                            UrlRequestRewriteReplaceUrl,
                            D,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                5 => {
                    #[allow(irrefutable_let_patterns)]
                    if let UrlRequestRewrite::AppendToQuery(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = UrlRequestRewrite::AppendToQuery(fidl::new_empty!(
                            UrlRequestRewriteAppendToQuery,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let UrlRequestRewrite::AppendToQuery(ref mut val) = self {
                        fidl::decode!(
                            UrlRequestRewriteAppendToQuery,
                            D,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                #[allow(deprecated)]
                ordinal => {
                    for _ in 0..num_handles {
                        decoder.drop_next_handle()?;
                    }
                    *self = UrlRequestRewrite::__SourceBreaking { unknown_ordinal: ordinal };
                }
            }
            if !inlined && decoder.next_out_of_line() != next_out_of_line + (num_bytes as usize) {
                return Err(fidl::Error::InvalidNumBytesInEnvelope);
            }
            if handles_before != decoder.remaining_handles() + (num_handles as usize) {
                return Err(fidl::Error::InvalidNumHandlesInEnvelope);
            }
            Ok(())
        }
    }
}