fidl_fuchsia_sensors_types__common/

fidl_fuchsia_sensors_types__common.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::encoding::{MessageBufFor, ProxyChannelBox, ResourceDialect};
use futures::future::{self, MaybeDone, TryFutureExt};
use zx_status;

/// Uniquely identifies a sensor in the sensor APIs.
///
/// Defined to be compatible with:
/// https://android.googlesource.com/platform/hardware/interfaces/+/main/sensors/1.0/types.hal#817
pub type SensorId = i32;

/// A revision number for the part/driver combination. The value must be updated
/// when the driver is updated in a way that changes the output of the sensor.
/// This is important for fused sensors when the fusion algorithm is updated.
///
/// Defined to be compatible with:
/// https://android.googlesource.com/platform/hardware/interfaces/+/main/sensors/1.0/types.hal#834
pub type SensorVersion = i32;

/// Exponential scaling value for SI units.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum Scale {
    Nano,
    Micro,
    Milli,
    Centi,
    Deci,
    None,
    Deca,
    Hecto,
    Kilo,
    Mega,
    Giga,
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: i16,
    },
}

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

impl Scale {
    #[inline]
    pub fn from_primitive(prim: i16) -> Option<Self> {
        match prim {
            -9 => Some(Self::Nano),
            -6 => Some(Self::Micro),
            -3 => Some(Self::Milli),
            -2 => Some(Self::Centi),
            -1 => Some(Self::Deci),
            0 => Some(Self::None),
            1 => Some(Self::Deca),
            2 => Some(Self::Hecto),
            3 => Some(Self::Kilo),
            6 => Some(Self::Mega),
            9 => Some(Self::Giga),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: i16) -> Self {
        match prim {
            -9 => Self::Nano,
            -6 => Self::Micro,
            -3 => Self::Milli,
            -2 => Self::Centi,
            -1 => Self::Deci,
            0 => Self::None,
            1 => Self::Deca,
            2 => Self::Hecto,
            3 => Self::Kilo,
            6 => Self::Mega,
            9 => Self::Giga,
            unknown_ordinal => Self::__SourceBreaking { unknown_ordinal },
        }
    }

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

    #[inline]
    pub const fn into_primitive(self) -> i16 {
        match self {
            Self::Nano => -9,
            Self::Micro => -6,
            Self::Milli => -3,
            Self::Centi => -2,
            Self::Deci => -1,
            Self::None => 0,
            Self::Deca => 1,
            Self::Hecto => 2,
            Self::Kilo => 3,
            Self::Mega => 6,
            Self::Giga => 9,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

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

/// Describes a sensor's reporting mode.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum SensorReportingMode {
    /// Continous reporting will continuously deliver samples, subject to the
    /// requested sampling rate and maximum reporting latency.
    Continuous,
    /// On-change reporting will deliver a sample any time the sensor value
    /// changes, subject to the requested sampling rate and max reporting
    /// latency.
    OnChange,
    OneShot,
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u32,
    },
}

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

impl SensorReportingMode {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::Continuous),
            1 => Some(Self::OnChange),
            2 => Some(Self::OneShot),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
        match prim {
            0 => Self::Continuous,
            1 => Self::OnChange,
            2 => Self::OneShot,
            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::Continuous => 0,
            Self::OnChange => 1,
            Self::OneShot => 2,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

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

/// Labels for different types of sensors.
///
/// These values are derived from:
/// https://android.googlesource.com/platform/hardware/interfaces/+/main/sensors/1.0/types.hal#118
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum SensorType {
    /// Raw inertial measurement.
    AccelerometerUncalibrated,
    GyroscopeUncalibrated,
    MagneticFieldUncalibrated,
    /// Calibrated inertial measurement.
    Accelerometer,
    Gyroscope,
    MagneticField,
    /// Derived/fused from inertial measurement.
    Orientation,
    Gravity,
    LinearAcceleration,
    RotationVector,
    GameRotationVector,
    SignificantMotion,
    StepDetector,
    StepCounter,
    GeomagneticRotationVector,
    TiltDetector,
    WakeGesture,
    GlanceGesture,
    PickUpGesture,
    WristTiltGesture,
    DeviceOrientation,
    Pose6Dof,
    StationaryDetect,
    MotionDetect,
    LowLatencyOffbodyDetect,
    /// Environmental.
    Light,
    Pressure,
    Proximity,
    RelativeHumidity,
    AmbientTemperature,
    /// Biometric.
    HeartRate,
    HeartBeat,
    /// Power and electrical.
    Power,
    /// Base for device manufacturers' private sensor types.
    DevicePrivateBase,
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u32,
    },
}

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

impl SensorType {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            35 => Some(Self::AccelerometerUncalibrated),
            16 => Some(Self::GyroscopeUncalibrated),
            14 => Some(Self::MagneticFieldUncalibrated),
            1 => Some(Self::Accelerometer),
            4 => Some(Self::Gyroscope),
            2 => Some(Self::MagneticField),
            3 => Some(Self::Orientation),
            9 => Some(Self::Gravity),
            10 => Some(Self::LinearAcceleration),
            11 => Some(Self::RotationVector),
            15 => Some(Self::GameRotationVector),
            17 => Some(Self::SignificantMotion),
            18 => Some(Self::StepDetector),
            19 => Some(Self::StepCounter),
            20 => Some(Self::GeomagneticRotationVector),
            22 => Some(Self::TiltDetector),
            23 => Some(Self::WakeGesture),
            24 => Some(Self::GlanceGesture),
            25 => Some(Self::PickUpGesture),
            26 => Some(Self::WristTiltGesture),
            27 => Some(Self::DeviceOrientation),
            28 => Some(Self::Pose6Dof),
            29 => Some(Self::StationaryDetect),
            30 => Some(Self::MotionDetect),
            34 => Some(Self::LowLatencyOffbodyDetect),
            5 => Some(Self::Light),
            6 => Some(Self::Pressure),
            8 => Some(Self::Proximity),
            12 => Some(Self::RelativeHumidity),
            13 => Some(Self::AmbientTemperature),
            21 => Some(Self::HeartRate),
            31 => Some(Self::HeartBeat),
            1001 => Some(Self::Power),
            65536 => Some(Self::DevicePrivateBase),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
        match prim {
            35 => Self::AccelerometerUncalibrated,
            16 => Self::GyroscopeUncalibrated,
            14 => Self::MagneticFieldUncalibrated,
            1 => Self::Accelerometer,
            4 => Self::Gyroscope,
            2 => Self::MagneticField,
            3 => Self::Orientation,
            9 => Self::Gravity,
            10 => Self::LinearAcceleration,
            11 => Self::RotationVector,
            15 => Self::GameRotationVector,
            17 => Self::SignificantMotion,
            18 => Self::StepDetector,
            19 => Self::StepCounter,
            20 => Self::GeomagneticRotationVector,
            22 => Self::TiltDetector,
            23 => Self::WakeGesture,
            24 => Self::GlanceGesture,
            25 => Self::PickUpGesture,
            26 => Self::WristTiltGesture,
            27 => Self::DeviceOrientation,
            28 => Self::Pose6Dof,
            29 => Self::StationaryDetect,
            30 => Self::MotionDetect,
            34 => Self::LowLatencyOffbodyDetect,
            5 => Self::Light,
            6 => Self::Pressure,
            8 => Self::Proximity,
            12 => Self::RelativeHumidity,
            13 => Self::AmbientTemperature,
            21 => Self::HeartRate,
            31 => Self::HeartBeat,
            1001 => Self::Power,
            65536 => Self::DevicePrivateBase,
            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::AccelerometerUncalibrated => 35,
            Self::GyroscopeUncalibrated => 16,
            Self::MagneticFieldUncalibrated => 14,
            Self::Accelerometer => 1,
            Self::Gyroscope => 4,
            Self::MagneticField => 2,
            Self::Orientation => 3,
            Self::Gravity => 9,
            Self::LinearAcceleration => 10,
            Self::RotationVector => 11,
            Self::GameRotationVector => 15,
            Self::SignificantMotion => 17,
            Self::StepDetector => 18,
            Self::StepCounter => 19,
            Self::GeomagneticRotationVector => 20,
            Self::TiltDetector => 22,
            Self::WakeGesture => 23,
            Self::GlanceGesture => 24,
            Self::PickUpGesture => 25,
            Self::WristTiltGesture => 26,
            Self::DeviceOrientation => 27,
            Self::Pose6Dof => 28,
            Self::StationaryDetect => 29,
            Self::MotionDetect => 30,
            Self::LowLatencyOffbodyDetect => 34,
            Self::Light => 5,
            Self::Pressure => 6,
            Self::Proximity => 8,
            Self::RelativeHumidity => 12,
            Self::AmbientTemperature => 13,
            Self::HeartRate => 21,
            Self::HeartBeat => 31,
            Self::Power => 1001,
            Self::DevicePrivateBase => 65536,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

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

/// Describes a sensor's wake-up behavior. A wake-up sensor will wake up the
/// application processor when there is new data available. A non wake-up sensor
/// will not.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum SensorWakeUpType {
    NonWakeUp,
    WakeUp,
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u32,
    },
}

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

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

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
        match prim {
            0 => Self::NonWakeUp,
            1 => Self::WakeUp,
            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::NonWakeUp => 0,
            Self::WakeUp => 1,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

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

/// Unit type for measurements and configuration settings.
#[derive(Copy, Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub enum Unit {
    /// Unitless
    None,
    /// Movement/position
    MPerSecSqrd,
    Degrees,
    RadPerSecond,
    QuaternionAndMeters,
    /// Environment
    Tesla,
    Pascal,
    Meter,
    RelativeHumidity,
    Celsius,
    Lux,
    /// Biometric
    Steps,
    BeatsPerMin,
    /// Power sensors
    Watts,
    Volts,
    Amps,
    Joules,
    Coulombs,
    #[doc(hidden)]
    __SourceBreaking {
        unknown_ordinal: u32,
    },
}

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

impl Unit {
    #[inline]
    pub fn from_primitive(prim: u32) -> Option<Self> {
        match prim {
            0 => Some(Self::None),
            1 => Some(Self::MPerSecSqrd),
            2 => Some(Self::Degrees),
            3 => Some(Self::RadPerSecond),
            4 => Some(Self::QuaternionAndMeters),
            5 => Some(Self::Tesla),
            6 => Some(Self::Pascal),
            7 => Some(Self::Meter),
            8 => Some(Self::RelativeHumidity),
            9 => Some(Self::Celsius),
            10 => Some(Self::Lux),
            11 => Some(Self::Steps),
            12 => Some(Self::BeatsPerMin),
            21 => Some(Self::Watts),
            22 => Some(Self::Volts),
            23 => Some(Self::Amps),
            24 => Some(Self::Joules),
            25 => Some(Self::Coulombs),
            _ => None,
        }
    }

    #[inline]
    pub fn from_primitive_allow_unknown(prim: u32) -> Self {
        match prim {
            0 => Self::None,
            1 => Self::MPerSecSqrd,
            2 => Self::Degrees,
            3 => Self::RadPerSecond,
            4 => Self::QuaternionAndMeters,
            5 => Self::Tesla,
            6 => Self::Pascal,
            7 => Self::Meter,
            8 => Self::RelativeHumidity,
            9 => Self::Celsius,
            10 => Self::Lux,
            11 => Self::Steps,
            12 => Self::BeatsPerMin,
            21 => Self::Watts,
            22 => Self::Volts,
            23 => Self::Amps,
            24 => Self::Joules,
            25 => Self::Coulombs,
            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::None => 0,
            Self::MPerSecSqrd => 1,
            Self::Degrees => 2,
            Self::RadPerSecond => 3,
            Self::QuaternionAndMeters => 4,
            Self::Tesla => 5,
            Self::Pascal => 6,
            Self::Meter => 7,
            Self::RelativeHumidity => 8,
            Self::Celsius => 9,
            Self::Lux => 10,
            Self::Steps => 11,
            Self::BeatsPerMin => 12,
            Self::Watts => 21,
            Self::Volts => 22,
            Self::Amps => 23,
            Self::Joules => 24,
            Self::Coulombs => 25,
            Self::__SourceBreaking { unknown_ordinal } => unknown_ordinal,
        }
    }

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

/// A 6 degree of freedom (“6DOF”) pose describes a position and orientation in
/// a 3D space.
#[derive(Clone, Debug, PartialEq)]
pub struct Pose {
    /// A quaternion representing the orientation.
    pub rotation: fidl_fuchsia_math__common::Vec4F,
    /// A vector represeting the position.
    pub translation: fidl_fuchsia_math__common::Vec3F,
    /// A quaternion describing the rotation from the last known orientation.
    pub rotation_delta: fidl_fuchsia_math__common::Vec4F,
    /// A vector describing the translation from the last known position.
    pub translation_delta: fidl_fuchsia_math__common::Vec3F,
}

impl fidl::Persistable for Pose {}

/// A sample from a single sensor.
#[derive(Clone, Debug, PartialEq)]
pub struct SensorEvent {
    /// The sample timestamp relative to device boot.
    pub timestamp: i64,
    /// The SensorId of the originating sensor.
    pub sensor_id: i32,
    /// The type of the originating sensor.
    pub sensor_type: SensorType,
    /// A sequence number that will be incremented for every sensor event
    /// emitted.
    pub sequence_number: u64,
    /// The sample data (see documentation for EventPayload).
    pub payload: EventPayload,
}

impl fidl::Persistable for SensorEvent {}

/// Uncalibrated samples from 3 axis sensors (eg. accelerometer, gyroscope,
/// magnetometer) come with bias data for each axis.
#[derive(Clone, Debug, PartialEq)]
pub struct UncalibratedVec3FSample {
    pub sample: fidl_fuchsia_math__common::Vec3F,
    pub biases: fidl_fuchsia_math__common::Vec3F,
}

impl fidl::Persistable for UncalibratedVec3FSample {}

/// All the information to describe a specific sensor and its output.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct SensorInfo {
    /// Identifies this sensor.
    ///
    /// Required.
    pub sensor_id: Option<i32>,
    /// Name of this sensor.
    /// All sensors of the same "type" must have a different "name".
    ///
    /// Required.
    pub name: Option<String>,
    /// Vendor of the hardware part.
    ///
    /// Required.
    pub vendor: Option<String>,
    /// Version number. See documentation for SensorVersion.
    ///
    /// Required.
    pub version: Option<i32>,
    /// This sensor's type.
    ///
    /// Required.
    pub sensor_type: Option<SensorType>,
    /// The wake-up behavior of this sensor.
    ///
    /// Required.
    pub wake_up: Option<SensorWakeUpType>,
    /// The reporting mode of this sensor.
    ///
    /// Required.
    pub reporting_mode: Option<SensorReportingMode>,
    /// The unit type of returned measurements.
    pub measurement_unit: Option<Unit>,
    /// The magnitude of returned measurements as an exponent.
    /// Measurement = |value| * 10^|measurement_scale| units.
    pub measurement_scale: Option<Scale>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for SensorInfo {}

/// Rate configuration given to Driver::ConfigureSensorRate and
/// Manager::ConfigureSensorRate.
#[derive(Clone, Debug, Default, PartialEq)]
pub struct SensorRateConfig {
    /// The desired time period between samples arriving from the hardware.
    ///
    /// Required.
    pub sampling_period_ns: Option<i64>,
    /// How long a sensor value may be buffered before it is emitted. A value of
    /// zero will result in no buffering.
    ///
    /// Required.
    pub max_reporting_latency_ns: Option<i64>,
    #[doc(hidden)]
    pub __source_breaking: fidl::marker::SourceBreaking,
}

impl fidl::Persistable for SensorRateConfig {}

/// All of the potential data types a SensorEvent may carry depending on the
/// sensor type.
#[derive(Clone, Debug)]
pub enum EventPayload {
    /// The following sensors emit basic 3D float vectors:
    /// ACCELEROMETER, MAGNETIC_FIELD, ORIENTATION, GYROSCOPE, GRAVITY,
    /// LINEAR_ACCELERATION.
    Vec3(fidl_fuchsia_math__common::Vec3F),
    /// The following sensors emit floating point quaternions:
    /// ROTATION_VECTOR, GEOMAGNETIC_ROTATION_VECTOR, GAME_ROTATION_VECTOR.
    Quaternion(fidl_fuchsia_math__common::Vec4F),
    /// The following sensors emit pairs of float vectors (see documentation for
    /// UncalibratedImuSample):
    /// MAGNETIC_FIELD_UNCALIBRATED, GYROSCOPE_UNCALIBRATED,
    /// ACCELEROMETER_UNCALIBRATED.
    UncalibratedVec3(UncalibratedVec3FSample),
    /// The following sensors emit a single float:
    /// DEVICE_ORIENTATION, LIGHT, PRESSURE, TEMPERATURE, PROXIMITY,
    /// RELATIVE_HUMIDITY, AMBIENT_TEMPERATURE, SIGNIFICANT_MOTION,
    /// STEP_DETECTOR, TILT_DETECTOR, WAKE_GESTURE, GLANCE_GESTURE,
    /// PICK_UP_GESTURE, WRIST_TILT_GESTURE, STATIONARY_DETECT, MOTION_DETECT,
    /// HEART_BEAT, LOW_LATENCY_OFFBODY_DETECT, HEART_RATE.
    Float(f32),
    /// The following senors emit an unsigned 64-bit integer:
    /// STEP_COUNTER
    Integer(u64),
    /// The following sensor types emit a pose (see documentation for Pose):
    /// POSE_6DOF.
    Pose(Pose),
    #[doc(hidden)]
    __SourceBreaking { unknown_ordinal: u64 },
}

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

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

impl EventPayload {
    #[inline]
    pub fn ordinal(&self) -> u64 {
        match *self {
            Self::Vec3(_) => 1,
            Self::Quaternion(_) => 2,
            Self::UncalibratedVec3(_) => 3,
            Self::Float(_) => 4,
            Self::Integer(_) => 5,
            Self::Pose(_) => 6,
            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 EventPayload {}

mod internal {
    use super::*;
    unsafe impl fidl::encoding::TypeMarker for Scale {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            std::mem::align_of::<i16>()
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            std::mem::size_of::<i16>()
        }

        #[inline(always)]
        fn encode_is_copy() -> bool {
            false
        }

        #[inline(always)]
        fn decode_is_copy() -> bool {
            false
        }
    }

    impl fidl::encoding::ValueTypeMarker for Scale {
        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 Scale {
        #[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 Scale {
        #[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::<i16>(offset);

            *self = Self::from_primitive_allow_unknown(prim);
            Ok(())
        }
    }
    unsafe impl fidl::encoding::TypeMarker for SensorReportingMode {
        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 SensorReportingMode {
        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 SensorReportingMode
    {
        #[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 SensorReportingMode {
        #[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 SensorType {
        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 SensorType {
        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 SensorType {
        #[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 SensorType {
        #[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 SensorWakeUpType {
        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 SensorWakeUpType {
        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 SensorWakeUpType
    {
        #[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 SensorWakeUpType {
        #[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 Unit {
        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 Unit {
        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 Unit {
        #[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 Unit {
        #[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(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for Pose {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for Pose {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            56
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Encode<Pose, D> for &Pose {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Pose>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<Pose, D>::encode(
                (
                    <fidl_fuchsia_math__common::Vec4F as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.rotation,
                    ),
                    <fidl_fuchsia_math__common::Vec3F as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.translation,
                    ),
                    <fidl_fuchsia_math__common::Vec4F as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.rotation_delta,
                    ),
                    <fidl_fuchsia_math__common::Vec3F as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.translation_delta,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl_fuchsia_math__common::Vec4F, D>,
        T1: fidl::encoding::Encode<fidl_fuchsia_math__common::Vec3F, D>,
        T2: fidl::encoding::Encode<fidl_fuchsia_math__common::Vec4F, D>,
        T3: fidl::encoding::Encode<fidl_fuchsia_math__common::Vec3F, D>,
    > fidl::encoding::Encode<Pose, D> for (T0, T1, T2, T3)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<Pose>(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)?;
            self.2.encode(encoder, offset + 28, depth)?;
            self.3.encode(encoder, offset + 44, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for Pose {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                rotation: fidl::new_empty!(fidl_fuchsia_math__common::Vec4F, D),
                translation: fidl::new_empty!(fidl_fuchsia_math__common::Vec3F, D),
                rotation_delta: fidl::new_empty!(fidl_fuchsia_math__common::Vec4F, D),
                translation_delta: fidl::new_empty!(fidl_fuchsia_math__common::Vec3F, 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_fuchsia_math__common::Vec4F,
                D,
                &mut self.rotation,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl_fuchsia_math__common::Vec3F,
                D,
                &mut self.translation,
                decoder,
                offset + 16,
                _depth
            )?;
            fidl::decode!(
                fidl_fuchsia_math__common::Vec4F,
                D,
                &mut self.rotation_delta,
                decoder,
                offset + 28,
                _depth
            )?;
            fidl::decode!(
                fidl_fuchsia_math__common::Vec3F,
                D,
                &mut self.translation_delta,
                decoder,
                offset + 44,
                _depth
            )?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for SensorEvent {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for SensorEvent {
        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<SensorEvent, D>
        for &SensorEvent
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SensorEvent>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<SensorEvent, D>::encode(
                (
                    <i64 as fidl::encoding::ValueTypeMarker>::borrow(&self.timestamp),
                    <i32 as fidl::encoding::ValueTypeMarker>::borrow(&self.sensor_id),
                    <SensorType as fidl::encoding::ValueTypeMarker>::borrow(&self.sensor_type),
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(&self.sequence_number),
                    <EventPayload as fidl::encoding::ValueTypeMarker>::borrow(&self.payload),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<i64, D>,
        T1: fidl::encoding::Encode<i32, D>,
        T2: fidl::encoding::Encode<SensorType, D>,
        T3: fidl::encoding::Encode<u64, D>,
        T4: fidl::encoding::Encode<EventPayload, D>,
    > fidl::encoding::Encode<SensorEvent, D> for (T0, T1, T2, T3, T4)
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SensorEvent>(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 + 12, depth)?;
            self.3.encode(encoder, offset + 16, depth)?;
            self.4.encode(encoder, offset + 24, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for SensorEvent {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                timestamp: fidl::new_empty!(i64, D),
                sensor_id: fidl::new_empty!(i32, D),
                sensor_type: fidl::new_empty!(SensorType, D),
                sequence_number: fidl::new_empty!(u64, D),
                payload: fidl::new_empty!(EventPayload, 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!(i64, D, &mut self.timestamp, decoder, offset + 0, _depth)?;
            fidl::decode!(i32, D, &mut self.sensor_id, decoder, offset + 8, _depth)?;
            fidl::decode!(SensorType, D, &mut self.sensor_type, decoder, offset + 12, _depth)?;
            fidl::decode!(u64, D, &mut self.sequence_number, decoder, offset + 16, _depth)?;
            fidl::decode!(EventPayload, D, &mut self.payload, decoder, offset + 24, _depth)?;
            Ok(())
        }
    }

    impl fidl::encoding::ValueTypeMarker for UncalibratedVec3FSample {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for UncalibratedVec3FSample {
        type Owned = Self;

        #[inline(always)]
        fn inline_align(_context: fidl::encoding::Context) -> usize {
            4
        }

        #[inline(always)]
        fn inline_size(_context: fidl::encoding::Context) -> usize {
            24
        }
    }

    unsafe impl<D: fidl::encoding::ResourceDialect>
        fidl::encoding::Encode<UncalibratedVec3FSample, D> for &UncalibratedVec3FSample
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<UncalibratedVec3FSample>(offset);
            // Delegate to tuple encoding.
            fidl::encoding::Encode::<UncalibratedVec3FSample, D>::encode(
                (
                    <fidl_fuchsia_math__common::Vec3F as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.sample,
                    ),
                    <fidl_fuchsia_math__common::Vec3F as fidl::encoding::ValueTypeMarker>::borrow(
                        &self.biases,
                    ),
                ),
                encoder,
                offset,
                _depth,
            )
        }
    }
    unsafe impl<
        D: fidl::encoding::ResourceDialect,
        T0: fidl::encoding::Encode<fidl_fuchsia_math__common::Vec3F, D>,
        T1: fidl::encoding::Encode<fidl_fuchsia_math__common::Vec3F, D>,
    > fidl::encoding::Encode<UncalibratedVec3FSample, 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::<UncalibratedVec3FSample>(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 + 12, depth)?;
            Ok(())
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D>
        for UncalibratedVec3FSample
    {
        #[inline(always)]
        fn new_empty() -> Self {
            Self {
                sample: fidl::new_empty!(fidl_fuchsia_math__common::Vec3F, D),
                biases: fidl::new_empty!(fidl_fuchsia_math__common::Vec3F, 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_fuchsia_math__common::Vec3F,
                D,
                &mut self.sample,
                decoder,
                offset + 0,
                _depth
            )?;
            fidl::decode!(
                fidl_fuchsia_math__common::Vec3F,
                D,
                &mut self.biases,
                decoder,
                offset + 12,
                _depth
            )?;
            Ok(())
        }
    }

    impl SensorInfo {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.measurement_scale {
                return 9;
            }
            if let Some(_) = self.measurement_unit {
                return 8;
            }
            if let Some(_) = self.reporting_mode {
                return 7;
            }
            if let Some(_) = self.wake_up {
                return 6;
            }
            if let Some(_) = self.sensor_type {
                return 5;
            }
            if let Some(_) = self.version {
                return 4;
            }
            if let Some(_) = self.vendor {
                return 3;
            }
            if let Some(_) = self.name {
                return 2;
            }
            if let Some(_) = self.sensor_id {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for SensorInfo {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for SensorInfo {
        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<SensorInfo, D>
        for &SensorInfo
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SensorInfo>(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::<i32, D>(
                self.sensor_id.as_ref().map(<i32 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, 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 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::UnboundedString, D>(
                self.vendor.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::<i32, D>(
                self.version.as_ref().map(<i32 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::<SensorType, D>(
                self.sensor_type
                    .as_ref()
                    .map(<SensorType 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::<SensorWakeUpType, D>(
                self.wake_up
                    .as_ref()
                    .map(<SensorWakeUpType 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::<SensorReportingMode, D>(
                self.reporting_mode
                    .as_ref()
                    .map(<SensorReportingMode 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::<Unit, D>(
                self.measurement_unit
                    .as_ref()
                    .map(<Unit 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::<Scale, D>(
                self.measurement_scale
                    .as_ref()
                    .map(<Scale 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 SensorInfo {
        #[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 =
                    <i32 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.sensor_id.get_or_insert_with(|| fidl::new_empty!(i32, D));
                fidl::decode!(i32, 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::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 < 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::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
                    .vendor
                    .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 < 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 =
                    <i32 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.version.get_or_insert_with(|| fidl::new_empty!(i32, D));
                fidl::decode!(i32, 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 =
                    <SensorType 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.sensor_type.get_or_insert_with(|| fidl::new_empty!(SensorType, D));
                fidl::decode!(SensorType, 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 =
                    <SensorWakeUpType 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.wake_up.get_or_insert_with(|| fidl::new_empty!(SensorWakeUpType, D));
                fidl::decode!(SensorWakeUpType, 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 =
                    <SensorReportingMode 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
                    .reporting_mode
                    .get_or_insert_with(|| fidl::new_empty!(SensorReportingMode, D));
                fidl::decode!(SensorReportingMode, 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 =
                    <Unit 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.measurement_unit.get_or_insert_with(|| fidl::new_empty!(Unit, D));
                fidl::decode!(Unit, 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 < 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 =
                    <Scale 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.measurement_scale.get_or_insert_with(|| fidl::new_empty!(Scale, D));
                fidl::decode!(Scale, 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 SensorRateConfig {
        #[inline(always)]
        fn max_ordinal_present(&self) -> u64 {
            if let Some(_) = self.max_reporting_latency_ns {
                return 2;
            }
            if let Some(_) = self.sampling_period_ns {
                return 1;
            }
            0
        }
    }

    impl fidl::encoding::ValueTypeMarker for SensorRateConfig {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for SensorRateConfig {
        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<SensorRateConfig, D>
        for &SensorRateConfig
    {
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            mut depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<SensorRateConfig>(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.sampling_period_ns
                    .as_ref()
                    .map(<i64 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::<i64, D>(
                self.max_reporting_latency_ns
                    .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 SensorRateConfig {
        #[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.sampling_period_ns.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;
            _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 =
                    <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.max_reporting_latency_ns.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 fidl::encoding::ValueTypeMarker for EventPayload {
        type Borrowed<'a> = &'a Self;
        fn borrow(value: &<Self as fidl::encoding::TypeMarker>::Owned) -> Self::Borrowed<'_> {
            value
        }
    }

    unsafe impl fidl::encoding::TypeMarker for EventPayload {
        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<EventPayload, D>
        for &EventPayload
    {
        #[inline]
        unsafe fn encode(
            self,
            encoder: &mut fidl::encoding::Encoder<'_, D>,
            offset: usize,
            _depth: fidl::encoding::Depth,
        ) -> fidl::Result<()> {
            encoder.debug_check_bounds::<EventPayload>(offset);
            encoder.write_num::<u64>(self.ordinal(), offset);
            match self {
                EventPayload::Vec3(ref val) => fidl::encoding::encode_in_envelope::<
                    fidl_fuchsia_math__common::Vec3F,
                    D,
                >(
                    <fidl_fuchsia_math__common::Vec3F as fidl::encoding::ValueTypeMarker>::borrow(
                        val,
                    ),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                EventPayload::Quaternion(ref val) => fidl::encoding::encode_in_envelope::<
                    fidl_fuchsia_math__common::Vec4F,
                    D,
                >(
                    <fidl_fuchsia_math__common::Vec4F as fidl::encoding::ValueTypeMarker>::borrow(
                        val,
                    ),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                EventPayload::UncalibratedVec3(ref val) => {
                    fidl::encoding::encode_in_envelope::<UncalibratedVec3FSample, D>(
                        <UncalibratedVec3FSample as fidl::encoding::ValueTypeMarker>::borrow(val),
                        encoder,
                        offset + 8,
                        _depth,
                    )
                }
                EventPayload::Float(ref val) => fidl::encoding::encode_in_envelope::<f32, D>(
                    <f32 as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                EventPayload::Integer(ref val) => fidl::encoding::encode_in_envelope::<u64, D>(
                    <u64 as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                EventPayload::Pose(ref val) => fidl::encoding::encode_in_envelope::<Pose, D>(
                    <Pose as fidl::encoding::ValueTypeMarker>::borrow(val),
                    encoder,
                    offset + 8,
                    _depth,
                ),
                EventPayload::__SourceBreaking { .. } => Err(fidl::Error::UnknownUnionTag),
            }
        }
    }

    impl<D: fidl::encoding::ResourceDialect> fidl::encoding::Decode<Self, D> for EventPayload {
        #[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 => <fidl_fuchsia_math__common::Vec3F as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                2 => <fidl_fuchsia_math__common::Vec4F as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                3 => <UncalibratedVec3FSample as fidl::encoding::TypeMarker>::inline_size(
                    decoder.context,
                ),
                4 => <f32 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                5 => <u64 as fidl::encoding::TypeMarker>::inline_size(decoder.context),
                6 => <Pose 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 EventPayload::Vec3(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = EventPayload::Vec3(fidl::new_empty!(
                            fidl_fuchsia_math__common::Vec3F,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::Vec3(ref mut val) = self {
                        fidl::decode!(
                            fidl_fuchsia_math__common::Vec3F,
                            D,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                2 => {
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::Quaternion(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = EventPayload::Quaternion(fidl::new_empty!(
                            fidl_fuchsia_math__common::Vec4F,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::Quaternion(ref mut val) = self {
                        fidl::decode!(
                            fidl_fuchsia_math__common::Vec4F,
                            D,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                3 => {
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::UncalibratedVec3(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = EventPayload::UncalibratedVec3(fidl::new_empty!(
                            UncalibratedVec3FSample,
                            D
                        ));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::UncalibratedVec3(ref mut val) = self {
                        fidl::decode!(
                            UncalibratedVec3FSample,
                            D,
                            val,
                            decoder,
                            _inner_offset,
                            depth
                        )?;
                    } else {
                        unreachable!()
                    }
                }
                4 => {
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::Float(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = EventPayload::Float(fidl::new_empty!(f32, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::Float(ref mut val) = self {
                        fidl::decode!(f32, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                5 => {
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::Integer(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = EventPayload::Integer(fidl::new_empty!(u64, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::Integer(ref mut val) = self {
                        fidl::decode!(u64, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                6 => {
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::Pose(_) = self {
                        // Do nothing, read the value into the object
                    } else {
                        // Initialize `self` to the right variant
                        *self = EventPayload::Pose(fidl::new_empty!(Pose, D));
                    }
                    #[allow(irrefutable_let_patterns)]
                    if let EventPayload::Pose(ref mut val) = self {
                        fidl::decode!(Pose, D, val, decoder, _inner_offset, depth)?;
                    } else {
                        unreachable!()
                    }
                }
                #[allow(deprecated)]
                ordinal => {
                    for _ in 0..num_handles {
                        decoder.drop_next_handle()?;
                    }
                    *self = EventPayload::__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(())
        }
    }
}