pw_bluetooth_l2cap_frames_emb/

l2cap_frames.rs

#![allow(dead_code, unused_imports, unused_variables, non_camel_case_types, unused_parens)]

use emboss_runtime::prelude::*;
pub use emboss_runtime::{BitFlag, Error, Flag, InfallibleRead, Int, MutStorage, Storage, TryRead, TryWrite, UInt, View, VirtualField};



pub struct BasicL2capHeader<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::Storage> BasicL2capHeader<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for BasicL2capHeader<S, ST> {
    fn clone(&self) -> Self {
        Self {
            storage: self.storage.clone(),
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> BasicL2capHeader<S, ST> {
    /**
     * Constructs a view in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    pub fn pdu_length(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
    }
    pub fn channel_id(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (2) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
    }

}

pub struct BasicL2capHeaderMut<S: emboss_runtime::MutStorage> {
    storage: S,
}

impl<S: emboss_runtime::MutStorage> BasicL2capHeaderMut<S> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
        }
    }
    pub fn into_writer(self) -> BasicL2capHeaderWriter<S, emboss_runtime::UncheckedState> {
        BasicL2capHeaderWriter::new(self.storage)
    }
    /** Borrows the mutable view as an immutable view in UncheckedState. */
    pub fn as_view(&self) -> BasicL2capHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        unsafe { BasicL2capHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn pdu_length(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }
    pub fn channel_id(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (2) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }

}

impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for BasicL2capHeaderMut<S> {
    type Writer = BasicL2capHeaderWriter<S, emboss_runtime::UncheckedState>;
    fn into_writer(self) -> Self::Writer {
        BasicL2capHeaderWriter::new(self.storage)
    }
}

pub struct BasicL2capHeaderWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::MutStorage> BasicL2capHeaderWriter<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> BasicL2capHeaderWriter<S, ST> {
    /**
     * Constructs a writer in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    /** Converts the writer into an immutable view in the same typestate. */
    pub fn into_view(self) -> BasicL2capHeader<S, ST> {
        unsafe { BasicL2capHeader::new_in_state(self.storage) }
    }
    /** Borrows the writer as an immutable view in the same typestate. */
    pub fn as_view(&self) -> BasicL2capHeader<S::Sliced<'_>, ST> {
        unsafe { BasicL2capHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn write_pdu_length(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> BasicL2capHeaderWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { BasicL2capHeaderWriter::new_in_state(storage) }
    }
    pub fn write_channel_id(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> BasicL2capHeaderWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (2) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { BasicL2capHeaderWriter::new_in_state(storage) }
    }

}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for BasicL2capHeader<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self;
        core::result::Result::Ok((4) as usize)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::View for BasicL2capHeaderMut<S> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <BasicL2capHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for BasicL2capHeaderWriter<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <BasicL2capHeader<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for BasicL2capHeader<S, emboss_runtime::UncheckedState> {
    type Completed = BasicL2capHeader<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { BasicL2capHeader::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for BasicL2capHeaderWriter<S, emboss_runtime::UncheckedState> {
    type Completed = BasicL2capHeaderWriter<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { BasicL2capHeaderWriter::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for BasicL2capHeader<S, emboss_runtime::UncheckedState> {
    type Ok = BasicL2capHeader<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { BasicL2capHeader::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for BasicL2capHeader<S, emboss_runtime::CompleteState> {
    type Ok = BasicL2capHeader<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { BasicL2capHeader::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for BasicL2capHeader<S, emboss_runtime::OkState> {
    type Ok = BasicL2capHeader<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for BasicL2capHeaderWriter<S, emboss_runtime::UncheckedState> {
    type Ok = BasicL2capHeaderWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { BasicL2capHeaderWriter::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for BasicL2capHeaderWriter<S, emboss_runtime::CompleteState> {
    type Ok = BasicL2capHeaderWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { BasicL2capHeaderWriter::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for BasicL2capHeaderWriter<S, emboss_runtime::OkState> {
    type Ok = BasicL2capHeaderWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

pub mod basic_l2cap_header {
    pub type View<S, ST = emboss_runtime::UncheckedState> = super::BasicL2capHeader<S, ST>;
    pub type ViewMut<S> = super::BasicL2capHeaderMut<S>;
    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::BasicL2capHeaderWriter<S, ST>;

    pub const MIN_SIZE_IN_BYTES: usize = 4;
    pub const MAX_SIZE_IN_BYTES: usize = 4;
    pub const SIZE_IN_BYTES: usize = 4;
}pub struct BFrame_Payload_ArrayView<S: emboss_runtime::Storage> {
    storage: S,
    element_count: usize,
}

impl<S: emboss_runtime::Storage + core::clone::Clone> core::clone::Clone for BFrame_Payload_ArrayView<S> {
    fn clone(&self) -> Self {
        Self {
            storage: self.storage.clone(),
            element_count: self.element_count,
        }
    }
}

impl<S: emboss_runtime::Storage> BFrame_Payload_ArrayView<S> {
    pub const ELEMENT_SIZE_BYTES: usize = 1;
    pub fn new(storage: S, element_count: usize) -> Self {
        Self { storage, element_count }
    }
    pub fn element_count(&self) -> usize {
        self.element_count
    }
    pub fn get(&self, index: usize) -> core::result::Result<emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>>
, emboss_runtime::Error> {
        if index >= self.element_count {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        let offset = index * Self::ELEMENT_SIZE_BYTES;
        let storage = self.storage.slice(offset, Self::ELEMENT_SIZE_BYTES);
        core::result::Result::Ok(emboss_runtime::UInt::new(storage)
)
    }
}

pub struct BFrame_Payload_ArrayViewMut<S: emboss_runtime::MutStorage> {
    storage: S,
    element_count: usize,
}

impl<S: emboss_runtime::MutStorage> BFrame_Payload_ArrayViewMut<S> {
    pub const ELEMENT_SIZE_BYTES: usize = 1;
    pub fn new(storage: S, element_count: usize) -> Self {
        Self { storage, element_count }
    }
    pub fn element_count(&self) -> usize {
        self.element_count
    }
    pub fn get_mut(&mut self, index: usize) -> core::result::Result<emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>>
, emboss_runtime::Error> {
        if index >= self.element_count {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        let offset = index * Self::ELEMENT_SIZE_BYTES;
        let storage = self.storage.slice_mut(offset, Self::ELEMENT_SIZE_BYTES);
        core::result::Result::Ok(emboss_runtime::UInt::new(storage)
)
    }
}
pub struct BFrame<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::Storage> BFrame<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for BFrame<S, ST> {
    fn clone(&self) -> Self {
        Self {
            storage: self.storage.clone(),
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> BFrame<S, ST> {
    /**
     * Constructs a view in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    pub fn header(&self) -> BasicL2capHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (4) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        unsafe { BasicL2capHeader::<S::Sliced<'_>, emboss_runtime::UncheckedState>::new_in_state(storage) }
    }
    pub fn pdu_length(&self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (({ let val = self.header().pdu_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn channel_id(&self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (({ let val = self.header().channel_id().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn payload(&self) -> core::result::Result<BFrame_Payload_ArrayView<S::Sliced<'_>>, emboss_runtime::Error> {
        let offset_res = (|| -> core::result::Result<(usize, usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (({ let val = self.pdu_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as usize;
            let element_count = (len / (1)) as usize;
            core::result::Result::Ok((offset, len, element_count))
        })();
        match offset_res {
            core::result::Result::Ok((offset, len, element_count)) => {
                if len > 0 {
                    let end = offset.checked_add(len).ok_or(emboss_runtime::Error::OutOfBounds)?;
                    self.storage.try_read_byte(end - 1)?;
                }
                let storage = self.storage.slice(offset, len);
                core::result::Result::Ok(BFrame_Payload_ArrayView::new(storage, element_count))
            },
            core::result::Result::Err(e) => core::result::Result::Err(e),
        }
    }

}

pub struct BFrameMut<S: emboss_runtime::MutStorage> {
    storage: S,
}

impl<S: emboss_runtime::MutStorage> BFrameMut<S> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
        }
    }
    pub fn into_writer(self) -> BFrameWriter<S, emboss_runtime::UncheckedState> {
        BFrameWriter::new(self.storage)
    }
    /** Borrows the mutable view as an immutable view in UncheckedState. */
    pub fn as_view(&self) -> BFrame<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        unsafe { BFrame::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn header(&mut self) -> BasicL2capHeaderMut<S::SlicedMut<'_>> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (4) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        BasicL2capHeaderMut::<S::SlicedMut<'_>>::new(storage)
    }
    pub fn pdu_length(&mut self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (({ let val = self.header().pdu_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn channel_id(&mut self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (({ let val = self.header().channel_id().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn payload_mut(&mut self) -> core::result::Result<BFrame_Payload_ArrayViewMut<S::SlicedMut<'_>>, emboss_runtime::Error> {
        let offset_res = (|| -> core::result::Result<(usize, usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (({ let val = self.pdu_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as usize;
            let element_count = (len / (1)) as usize;
            core::result::Result::Ok((offset, len, element_count))
        })();
        match offset_res {
            core::result::Result::Ok((offset, len, element_count)) => {
                if len > 0 {
                    let end = offset.checked_add(len).ok_or(emboss_runtime::Error::OutOfBounds)?;
                    self.storage.try_read_byte(end - 1)?;
                }
                let storage = self.storage.slice_mut(offset, len);
                core::result::Result::Ok(BFrame_Payload_ArrayViewMut::new(storage, element_count))
            },
            core::result::Result::Err(e) => core::result::Result::Err(e),
        }
    }

}

impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for BFrameMut<S> {
    type Writer = BFrameWriter<S, emboss_runtime::UncheckedState>;
    fn into_writer(self) -> Self::Writer {
        BFrameWriter::new(self.storage)
    }
}

pub struct BFrameWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::MutStorage> BFrameWriter<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> BFrameWriter<S, ST> {
    /**
     * Constructs a writer in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    /** Converts the writer into an immutable view in the same typestate. */
    pub fn into_view(self) -> BFrame<S, ST> {
        unsafe { BFrame::new_in_state(self.storage) }
    }
    /** Borrows the writer as an immutable view in the same typestate. */
    pub fn as_view(&self) -> BFrame<S::Sliced<'_>, ST> {
        unsafe { BFrame::new_in_state(self.storage.slice(0, self.storage.len())) }
    }

}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for BFrame<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self;
        core::result::Result::Ok((core::cmp::max((core::cmp::max((0) as i64, (4) as i64)
) as i64, ((if true { ( (4) as i64 + (({ let val = view.pdu_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as i64 )
 } else { 0 })

) as i64)
) as usize)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::View for BFrameMut<S> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <BFrame<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for BFrameWriter<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <BFrame<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for BFrame<S, emboss_runtime::UncheckedState> {
    type Completed = BFrame<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { BFrame::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for BFrameWriter<S, emboss_runtime::UncheckedState> {
    type Completed = BFrameWriter<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { BFrameWriter::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for BFrame<S, emboss_runtime::UncheckedState> {
    type Ok = BFrame<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { BFrame::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for BFrame<S, emboss_runtime::CompleteState> {
    type Ok = BFrame<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { BFrame::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for BFrame<S, emboss_runtime::OkState> {
    type Ok = BFrame<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for BFrameWriter<S, emboss_runtime::UncheckedState> {
    type Ok = BFrameWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { BFrameWriter::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for BFrameWriter<S, emboss_runtime::CompleteState> {
    type Ok = BFrameWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { BFrameWriter::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for BFrameWriter<S, emboss_runtime::OkState> {
    type Ok = BFrameWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

pub mod b_frame {
    pub type View<S, ST = emboss_runtime::UncheckedState> = super::BFrame<S, ST>;
    pub type ViewMut<S> = super::BFrameMut<S>;
    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::BFrameWriter<S, ST>;

    pub const MIN_SIZE_IN_BYTES: usize = 4;
    pub const MAX_SIZE_IN_BYTES: usize = 65539;
}pub struct BFrameHeader<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::Storage> BFrameHeader<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for BFrameHeader<S, ST> {
    fn clone(&self) -> Self {
        Self {
            storage: self.storage.clone(),
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> BFrameHeader<S, ST> {
    /**
     * Constructs a view in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    pub fn pdu_length(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
    }
    pub fn channel_id(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (2) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
    }

}

pub struct BFrameHeaderMut<S: emboss_runtime::MutStorage> {
    storage: S,
}

impl<S: emboss_runtime::MutStorage> BFrameHeaderMut<S> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
        }
    }
    pub fn into_writer(self) -> BFrameHeaderWriter<S, emboss_runtime::UncheckedState> {
        BFrameHeaderWriter::new(self.storage)
    }
    /** Borrows the mutable view as an immutable view in UncheckedState. */
    pub fn as_view(&self) -> BFrameHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        unsafe { BFrameHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn pdu_length(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }
    pub fn channel_id(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (2) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }

}

impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for BFrameHeaderMut<S> {
    type Writer = BFrameHeaderWriter<S, emboss_runtime::UncheckedState>;
    fn into_writer(self) -> Self::Writer {
        BFrameHeaderWriter::new(self.storage)
    }
}

pub struct BFrameHeaderWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::MutStorage> BFrameHeaderWriter<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> BFrameHeaderWriter<S, ST> {
    /**
     * Constructs a writer in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    /** Converts the writer into an immutable view in the same typestate. */
    pub fn into_view(self) -> BFrameHeader<S, ST> {
        unsafe { BFrameHeader::new_in_state(self.storage) }
    }
    /** Borrows the writer as an immutable view in the same typestate. */
    pub fn as_view(&self) -> BFrameHeader<S::Sliced<'_>, ST> {
        unsafe { BFrameHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn write_pdu_length(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> BFrameHeaderWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { BFrameHeaderWriter::new_in_state(storage) }
    }
    pub fn write_channel_id(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> BFrameHeaderWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (2) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { BFrameHeaderWriter::new_in_state(storage) }
    }

}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for BFrameHeader<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self;
        core::result::Result::Ok((4) as usize)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::View for BFrameHeaderMut<S> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <BFrameHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for BFrameHeaderWriter<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <BFrameHeader<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for BFrameHeader<S, emboss_runtime::UncheckedState> {
    type Completed = BFrameHeader<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { BFrameHeader::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for BFrameHeaderWriter<S, emboss_runtime::UncheckedState> {
    type Completed = BFrameHeaderWriter<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { BFrameHeaderWriter::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for BFrameHeader<S, emboss_runtime::UncheckedState> {
    type Ok = BFrameHeader<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { BFrameHeader::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for BFrameHeader<S, emboss_runtime::CompleteState> {
    type Ok = BFrameHeader<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { BFrameHeader::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for BFrameHeader<S, emboss_runtime::OkState> {
    type Ok = BFrameHeader<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for BFrameHeaderWriter<S, emboss_runtime::UncheckedState> {
    type Ok = BFrameHeaderWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { BFrameHeaderWriter::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for BFrameHeaderWriter<S, emboss_runtime::CompleteState> {
    type Ok = BFrameHeaderWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { BFrameHeaderWriter::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for BFrameHeaderWriter<S, emboss_runtime::OkState> {
    type Ok = BFrameHeaderWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

pub mod b_frame_header {
    pub type View<S, ST = emboss_runtime::UncheckedState> = super::BFrameHeader<S, ST>;
    pub type ViewMut<S> = super::BFrameHeaderMut<S>;
    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::BFrameHeaderWriter<S, ST>;

    pub const MIN_SIZE_IN_BYTES: usize = 4;
    pub const MAX_SIZE_IN_BYTES: usize = 4;
    pub const SIZE_IN_BYTES: usize = 4;
}pub struct FirstKFrame_Payload_ArrayView<S: emboss_runtime::Storage> {
    storage: S,
    element_count: usize,
}

impl<S: emboss_runtime::Storage + core::clone::Clone> core::clone::Clone for FirstKFrame_Payload_ArrayView<S> {
    fn clone(&self) -> Self {
        Self {
            storage: self.storage.clone(),
            element_count: self.element_count,
        }
    }
}

impl<S: emboss_runtime::Storage> FirstKFrame_Payload_ArrayView<S> {
    pub const ELEMENT_SIZE_BYTES: usize = 1;
    pub fn new(storage: S, element_count: usize) -> Self {
        Self { storage, element_count }
    }
    pub fn element_count(&self) -> usize {
        self.element_count
    }
    pub fn get(&self, index: usize) -> core::result::Result<emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>>
, emboss_runtime::Error> {
        if index >= self.element_count {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        let offset = index * Self::ELEMENT_SIZE_BYTES;
        let storage = self.storage.slice(offset, Self::ELEMENT_SIZE_BYTES);
        core::result::Result::Ok(emboss_runtime::UInt::new(storage)
)
    }
}

pub struct FirstKFrame_Payload_ArrayViewMut<S: emboss_runtime::MutStorage> {
    storage: S,
    element_count: usize,
}

impl<S: emboss_runtime::MutStorage> FirstKFrame_Payload_ArrayViewMut<S> {
    pub const ELEMENT_SIZE_BYTES: usize = 1;
    pub fn new(storage: S, element_count: usize) -> Self {
        Self { storage, element_count }
    }
    pub fn element_count(&self) -> usize {
        self.element_count
    }
    pub fn get_mut(&mut self, index: usize) -> core::result::Result<emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>>
, emboss_runtime::Error> {
        if index >= self.element_count {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        let offset = index * Self::ELEMENT_SIZE_BYTES;
        let storage = self.storage.slice_mut(offset, Self::ELEMENT_SIZE_BYTES);
        core::result::Result::Ok(emboss_runtime::UInt::new(storage)
)
    }
}
pub struct FirstKFrame<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::Storage> FirstKFrame<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for FirstKFrame<S, ST> {
    fn clone(&self) -> Self {
        Self {
            storage: self.storage.clone(),
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> FirstKFrame<S, ST> {
    /**
     * Constructs a view in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    pub fn header(&self) -> BasicL2capHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (4) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        unsafe { BasicL2capHeader::<S::Sliced<'_>, emboss_runtime::UncheckedState>::new_in_state(storage) }
    }
    pub fn pdu_length(&self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (({ let val = self.header().pdu_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn channel_id(&self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (({ let val = self.header().channel_id().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn payload_size(&self) -> emboss_runtime::VirtualField<i64> {
        let value = (|| -> core::result::Result<i64, emboss_runtime::Error> {
        core::result::Result::Ok( (( (({ let val = self.pdu_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as i64 - (2) as i64 )
) as i64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn sdu_length(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
    }
    pub fn payload(&self) -> core::result::Result<FirstKFrame_Payload_ArrayView<S::Sliced<'_>>, emboss_runtime::Error> {
        let offset_res = (|| -> core::result::Result<(usize, usize, usize), emboss_runtime::Error> {
            let offset = (6) as usize;
            let len = (({ let val = self.payload_size().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as usize;
            let element_count = (len / (1)) as usize;
            core::result::Result::Ok((offset, len, element_count))
        })();
        match offset_res {
            core::result::Result::Ok((offset, len, element_count)) => {
                if len > 0 {
                    let end = offset.checked_add(len).ok_or(emboss_runtime::Error::OutOfBounds)?;
                    self.storage.try_read_byte(end - 1)?;
                }
                let storage = self.storage.slice(offset, len);
                core::result::Result::Ok(FirstKFrame_Payload_ArrayView::new(storage, element_count))
            },
            core::result::Result::Err(e) => core::result::Result::Err(e),
        }
    }

}

pub struct FirstKFrameMut<S: emboss_runtime::MutStorage> {
    storage: S,
}

impl<S: emboss_runtime::MutStorage> FirstKFrameMut<S> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
        }
    }
    pub fn into_writer(self) -> FirstKFrameWriter<S, emboss_runtime::UncheckedState> {
        FirstKFrameWriter::new(self.storage)
    }
    /** Borrows the mutable view as an immutable view in UncheckedState. */
    pub fn as_view(&self) -> FirstKFrame<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        unsafe { FirstKFrame::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn header(&mut self) -> BasicL2capHeaderMut<S::SlicedMut<'_>> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (4) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        BasicL2capHeaderMut::<S::SlicedMut<'_>>::new(storage)
    }
    pub fn pdu_length(&mut self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (({ let val = self.header().pdu_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn channel_id(&mut self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (({ let val = self.header().channel_id().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn payload_size(&mut self) -> emboss_runtime::VirtualField<i64> {
        let value = (|| -> core::result::Result<i64, emboss_runtime::Error> {
        core::result::Result::Ok( (( (({ let val = self.pdu_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as i64 - (2) as i64 )
) as i64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn sdu_length(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }
    pub fn payload_mut(&mut self) -> core::result::Result<FirstKFrame_Payload_ArrayViewMut<S::SlicedMut<'_>>, emboss_runtime::Error> {
        let offset_res = (|| -> core::result::Result<(usize, usize, usize), emboss_runtime::Error> {
            let offset = (6) as usize;
            let len = (({ let val = self.payload_size().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as usize;
            let element_count = (len / (1)) as usize;
            core::result::Result::Ok((offset, len, element_count))
        })();
        match offset_res {
            core::result::Result::Ok((offset, len, element_count)) => {
                if len > 0 {
                    let end = offset.checked_add(len).ok_or(emboss_runtime::Error::OutOfBounds)?;
                    self.storage.try_read_byte(end - 1)?;
                }
                let storage = self.storage.slice_mut(offset, len);
                core::result::Result::Ok(FirstKFrame_Payload_ArrayViewMut::new(storage, element_count))
            },
            core::result::Result::Err(e) => core::result::Result::Err(e),
        }
    }

}

impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for FirstKFrameMut<S> {
    type Writer = FirstKFrameWriter<S, emboss_runtime::UncheckedState>;
    fn into_writer(self) -> Self::Writer {
        FirstKFrameWriter::new(self.storage)
    }
}

pub struct FirstKFrameWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::MutStorage> FirstKFrameWriter<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> FirstKFrameWriter<S, ST> {
    /**
     * Constructs a writer in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    /** Converts the writer into an immutable view in the same typestate. */
    pub fn into_view(self) -> FirstKFrame<S, ST> {
        unsafe { FirstKFrame::new_in_state(self.storage) }
    }
    /** Borrows the writer as an immutable view in the same typestate. */
    pub fn as_view(&self) -> FirstKFrame<S::Sliced<'_>, ST> {
        unsafe { FirstKFrame::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn write_sdu_length(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> FirstKFrameWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { FirstKFrameWriter::new_in_state(storage) }
    }

}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for FirstKFrame<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self;
        core::result::Result::Ok((core::cmp::max((core::cmp::max((core::cmp::max((0) as i64, (4) as i64)
) as i64, (6) as i64)
) as i64, ((if true { ( (6) as i64 + (({ let val = view.payload_size().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as i64 )
 } else { 0 })

) as i64)
) as usize)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::View for FirstKFrameMut<S> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <FirstKFrame<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for FirstKFrameWriter<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <FirstKFrame<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for FirstKFrame<S, emboss_runtime::UncheckedState> {
    type Completed = FirstKFrame<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { FirstKFrame::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for FirstKFrameWriter<S, emboss_runtime::UncheckedState> {
    type Completed = FirstKFrameWriter<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { FirstKFrameWriter::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for FirstKFrame<S, emboss_runtime::UncheckedState> {
    type Ok = FirstKFrame<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { FirstKFrame::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for FirstKFrame<S, emboss_runtime::CompleteState> {
    type Ok = FirstKFrame<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { FirstKFrame::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for FirstKFrame<S, emboss_runtime::OkState> {
    type Ok = FirstKFrame<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for FirstKFrameWriter<S, emboss_runtime::UncheckedState> {
    type Ok = FirstKFrameWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { FirstKFrameWriter::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for FirstKFrameWriter<S, emboss_runtime::CompleteState> {
    type Ok = FirstKFrameWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { FirstKFrameWriter::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for FirstKFrameWriter<S, emboss_runtime::OkState> {
    type Ok = FirstKFrameWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

pub mod first_k_frame {
    pub type View<S, ST = emboss_runtime::UncheckedState> = super::FirstKFrame<S, ST>;
    pub type ViewMut<S> = super::FirstKFrameMut<S>;
    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::FirstKFrameWriter<S, ST>;

    pub const MIN_SIZE_IN_BYTES: usize = 6;
    pub const MAX_SIZE_IN_BYTES: usize = 65539;
}pub struct SubsequentKFrame_Payload_ArrayView<S: emboss_runtime::Storage> {
    storage: S,
    element_count: usize,
}

impl<S: emboss_runtime::Storage + core::clone::Clone> core::clone::Clone for SubsequentKFrame_Payload_ArrayView<S> {
    fn clone(&self) -> Self {
        Self {
            storage: self.storage.clone(),
            element_count: self.element_count,
        }
    }
}

impl<S: emboss_runtime::Storage> SubsequentKFrame_Payload_ArrayView<S> {
    pub const ELEMENT_SIZE_BYTES: usize = 1;
    pub fn new(storage: S, element_count: usize) -> Self {
        Self { storage, element_count }
    }
    pub fn element_count(&self) -> usize {
        self.element_count
    }
    pub fn get(&self, index: usize) -> core::result::Result<emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>>
, emboss_runtime::Error> {
        if index >= self.element_count {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        let offset = index * Self::ELEMENT_SIZE_BYTES;
        let storage = self.storage.slice(offset, Self::ELEMENT_SIZE_BYTES);
        core::result::Result::Ok(emboss_runtime::UInt::new(storage)
)
    }
}

pub struct SubsequentKFrame_Payload_ArrayViewMut<S: emboss_runtime::MutStorage> {
    storage: S,
    element_count: usize,
}

impl<S: emboss_runtime::MutStorage> SubsequentKFrame_Payload_ArrayViewMut<S> {
    pub const ELEMENT_SIZE_BYTES: usize = 1;
    pub fn new(storage: S, element_count: usize) -> Self {
        Self { storage, element_count }
    }
    pub fn element_count(&self) -> usize {
        self.element_count
    }
    pub fn get_mut(&mut self, index: usize) -> core::result::Result<emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>>
, emboss_runtime::Error> {
        if index >= self.element_count {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        let offset = index * Self::ELEMENT_SIZE_BYTES;
        let storage = self.storage.slice_mut(offset, Self::ELEMENT_SIZE_BYTES);
        core::result::Result::Ok(emboss_runtime::UInt::new(storage)
)
    }
}
pub struct SubsequentKFrame<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::Storage> SubsequentKFrame<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for SubsequentKFrame<S, ST> {
    fn clone(&self) -> Self {
        Self {
            storage: self.storage.clone(),
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> SubsequentKFrame<S, ST> {
    /**
     * Constructs a view in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    pub fn header(&self) -> BasicL2capHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (4) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        unsafe { BasicL2capHeader::<S::Sliced<'_>, emboss_runtime::UncheckedState>::new_in_state(storage) }
    }
    pub fn pdu_length(&self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (({ let val = self.header().pdu_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn channel_id(&self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (({ let val = self.header().channel_id().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn payload_size(&self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (({ let val = self.pdu_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn payload(&self) -> core::result::Result<SubsequentKFrame_Payload_ArrayView<S::Sliced<'_>>, emboss_runtime::Error> {
        let offset_res = (|| -> core::result::Result<(usize, usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (({ let val = self.payload_size().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as usize;
            let element_count = (len / (1)) as usize;
            core::result::Result::Ok((offset, len, element_count))
        })();
        match offset_res {
            core::result::Result::Ok((offset, len, element_count)) => {
                if len > 0 {
                    let end = offset.checked_add(len).ok_or(emboss_runtime::Error::OutOfBounds)?;
                    self.storage.try_read_byte(end - 1)?;
                }
                let storage = self.storage.slice(offset, len);
                core::result::Result::Ok(SubsequentKFrame_Payload_ArrayView::new(storage, element_count))
            },
            core::result::Result::Err(e) => core::result::Result::Err(e),
        }
    }

}

pub struct SubsequentKFrameMut<S: emboss_runtime::MutStorage> {
    storage: S,
}

impl<S: emboss_runtime::MutStorage> SubsequentKFrameMut<S> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
        }
    }
    pub fn into_writer(self) -> SubsequentKFrameWriter<S, emboss_runtime::UncheckedState> {
        SubsequentKFrameWriter::new(self.storage)
    }
    /** Borrows the mutable view as an immutable view in UncheckedState. */
    pub fn as_view(&self) -> SubsequentKFrame<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        unsafe { SubsequentKFrame::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn header(&mut self) -> BasicL2capHeaderMut<S::SlicedMut<'_>> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (4) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        BasicL2capHeaderMut::<S::SlicedMut<'_>>::new(storage)
    }
    pub fn pdu_length(&mut self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (({ let val = self.header().pdu_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn channel_id(&mut self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (({ let val = self.header().channel_id().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn payload_size(&mut self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (({ let val = self.pdu_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn payload_mut(&mut self) -> core::result::Result<SubsequentKFrame_Payload_ArrayViewMut<S::SlicedMut<'_>>, emboss_runtime::Error> {
        let offset_res = (|| -> core::result::Result<(usize, usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (({ let val = self.payload_size().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as usize;
            let element_count = (len / (1)) as usize;
            core::result::Result::Ok((offset, len, element_count))
        })();
        match offset_res {
            core::result::Result::Ok((offset, len, element_count)) => {
                if len > 0 {
                    let end = offset.checked_add(len).ok_or(emboss_runtime::Error::OutOfBounds)?;
                    self.storage.try_read_byte(end - 1)?;
                }
                let storage = self.storage.slice_mut(offset, len);
                core::result::Result::Ok(SubsequentKFrame_Payload_ArrayViewMut::new(storage, element_count))
            },
            core::result::Result::Err(e) => core::result::Result::Err(e),
        }
    }

}

impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for SubsequentKFrameMut<S> {
    type Writer = SubsequentKFrameWriter<S, emboss_runtime::UncheckedState>;
    fn into_writer(self) -> Self::Writer {
        SubsequentKFrameWriter::new(self.storage)
    }
}

pub struct SubsequentKFrameWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::MutStorage> SubsequentKFrameWriter<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> SubsequentKFrameWriter<S, ST> {
    /**
     * Constructs a writer in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    /** Converts the writer into an immutable view in the same typestate. */
    pub fn into_view(self) -> SubsequentKFrame<S, ST> {
        unsafe { SubsequentKFrame::new_in_state(self.storage) }
    }
    /** Borrows the writer as an immutable view in the same typestate. */
    pub fn as_view(&self) -> SubsequentKFrame<S::Sliced<'_>, ST> {
        unsafe { SubsequentKFrame::new_in_state(self.storage.slice(0, self.storage.len())) }
    }

}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for SubsequentKFrame<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self;
        core::result::Result::Ok((core::cmp::max((core::cmp::max((0) as i64, (4) as i64)
) as i64, ((if true { ( (4) as i64 + (({ let val = view.payload_size().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as i64 )
 } else { 0 })

) as i64)
) as usize)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::View for SubsequentKFrameMut<S> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <SubsequentKFrame<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for SubsequentKFrameWriter<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <SubsequentKFrame<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for SubsequentKFrame<S, emboss_runtime::UncheckedState> {
    type Completed = SubsequentKFrame<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { SubsequentKFrame::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for SubsequentKFrameWriter<S, emboss_runtime::UncheckedState> {
    type Completed = SubsequentKFrameWriter<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { SubsequentKFrameWriter::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for SubsequentKFrame<S, emboss_runtime::UncheckedState> {
    type Ok = SubsequentKFrame<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { SubsequentKFrame::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for SubsequentKFrame<S, emboss_runtime::CompleteState> {
    type Ok = SubsequentKFrame<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { SubsequentKFrame::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for SubsequentKFrame<S, emboss_runtime::OkState> {
    type Ok = SubsequentKFrame<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for SubsequentKFrameWriter<S, emboss_runtime::UncheckedState> {
    type Ok = SubsequentKFrameWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { SubsequentKFrameWriter::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for SubsequentKFrameWriter<S, emboss_runtime::CompleteState> {
    type Ok = SubsequentKFrameWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { SubsequentKFrameWriter::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for SubsequentKFrameWriter<S, emboss_runtime::OkState> {
    type Ok = SubsequentKFrameWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

pub mod subsequent_k_frame {
    pub type View<S, ST = emboss_runtime::UncheckedState> = super::SubsequentKFrame<S, ST>;
    pub type ViewMut<S> = super::SubsequentKFrameMut<S>;
    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::SubsequentKFrameWriter<S, ST>;

    pub const MIN_SIZE_IN_BYTES: usize = 4;
    pub const MAX_SIZE_IN_BYTES: usize = 65539;
}pub struct KFrameSduHeader<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::Storage> KFrameSduHeader<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for KFrameSduHeader<S, ST> {
    fn clone(&self) -> Self {
        Self {
            storage: self.storage.clone(),
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> KFrameSduHeader<S, ST> {
    /**
     * Constructs a view in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    pub fn sdu_length(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
    }

}

pub struct KFrameSduHeaderMut<S: emboss_runtime::MutStorage> {
    storage: S,
}

impl<S: emboss_runtime::MutStorage> KFrameSduHeaderMut<S> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
        }
    }
    pub fn into_writer(self) -> KFrameSduHeaderWriter<S, emboss_runtime::UncheckedState> {
        KFrameSduHeaderWriter::new(self.storage)
    }
    /** Borrows the mutable view as an immutable view in UncheckedState. */
    pub fn as_view(&self) -> KFrameSduHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        unsafe { KFrameSduHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn sdu_length(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }

}

impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for KFrameSduHeaderMut<S> {
    type Writer = KFrameSduHeaderWriter<S, emboss_runtime::UncheckedState>;
    fn into_writer(self) -> Self::Writer {
        KFrameSduHeaderWriter::new(self.storage)
    }
}

pub struct KFrameSduHeaderWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::MutStorage> KFrameSduHeaderWriter<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> KFrameSduHeaderWriter<S, ST> {
    /**
     * Constructs a writer in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    /** Converts the writer into an immutable view in the same typestate. */
    pub fn into_view(self) -> KFrameSduHeader<S, ST> {
        unsafe { KFrameSduHeader::new_in_state(self.storage) }
    }
    /** Borrows the writer as an immutable view in the same typestate. */
    pub fn as_view(&self) -> KFrameSduHeader<S::Sliced<'_>, ST> {
        unsafe { KFrameSduHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn write_sdu_length(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> KFrameSduHeaderWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { KFrameSduHeaderWriter::new_in_state(storage) }
    }

}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for KFrameSduHeader<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self;
        core::result::Result::Ok((2) as usize)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::View for KFrameSduHeaderMut<S> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <KFrameSduHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for KFrameSduHeaderWriter<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <KFrameSduHeader<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for KFrameSduHeader<S, emboss_runtime::UncheckedState> {
    type Completed = KFrameSduHeader<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { KFrameSduHeader::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for KFrameSduHeaderWriter<S, emboss_runtime::UncheckedState> {
    type Completed = KFrameSduHeaderWriter<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { KFrameSduHeaderWriter::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for KFrameSduHeader<S, emboss_runtime::UncheckedState> {
    type Ok = KFrameSduHeader<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { KFrameSduHeader::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for KFrameSduHeader<S, emboss_runtime::CompleteState> {
    type Ok = KFrameSduHeader<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { KFrameSduHeader::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for KFrameSduHeader<S, emboss_runtime::OkState> {
    type Ok = KFrameSduHeader<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for KFrameSduHeaderWriter<S, emboss_runtime::UncheckedState> {
    type Ok = KFrameSduHeaderWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { KFrameSduHeaderWriter::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for KFrameSduHeaderWriter<S, emboss_runtime::CompleteState> {
    type Ok = KFrameSduHeaderWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { KFrameSduHeaderWriter::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for KFrameSduHeaderWriter<S, emboss_runtime::OkState> {
    type Ok = KFrameSduHeaderWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

pub mod k_frame_sdu_header {
    pub type View<S, ST = emboss_runtime::UncheckedState> = super::KFrameSduHeader<S, ST>;
    pub type ViewMut<S> = super::KFrameSduHeaderMut<S>;
    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::KFrameSduHeaderWriter<S, ST>;

    pub const MIN_SIZE_IN_BYTES: usize = 2;
    pub const MAX_SIZE_IN_BYTES: usize = 2;
    pub const SIZE_IN_BYTES: usize = 2;
}pub struct KFramePduHeader<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::Storage> KFramePduHeader<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for KFramePduHeader<S, ST> {
    fn clone(&self) -> Self {
        Self {
            storage: self.storage.clone(),
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> KFramePduHeader<S, ST> {
    /**
     * Constructs a view in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    pub fn pdu_length(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
    }
    pub fn channel_id(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (2) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
    }

}

pub struct KFramePduHeaderMut<S: emboss_runtime::MutStorage> {
    storage: S,
}

impl<S: emboss_runtime::MutStorage> KFramePduHeaderMut<S> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
        }
    }
    pub fn into_writer(self) -> KFramePduHeaderWriter<S, emboss_runtime::UncheckedState> {
        KFramePduHeaderWriter::new(self.storage)
    }
    /** Borrows the mutable view as an immutable view in UncheckedState. */
    pub fn as_view(&self) -> KFramePduHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        unsafe { KFramePduHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn pdu_length(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }
    pub fn channel_id(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (2) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }

}

impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for KFramePduHeaderMut<S> {
    type Writer = KFramePduHeaderWriter<S, emboss_runtime::UncheckedState>;
    fn into_writer(self) -> Self::Writer {
        KFramePduHeaderWriter::new(self.storage)
    }
}

pub struct KFramePduHeaderWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::MutStorage> KFramePduHeaderWriter<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> KFramePduHeaderWriter<S, ST> {
    /**
     * Constructs a writer in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    /** Converts the writer into an immutable view in the same typestate. */
    pub fn into_view(self) -> KFramePduHeader<S, ST> {
        unsafe { KFramePduHeader::new_in_state(self.storage) }
    }
    /** Borrows the writer as an immutable view in the same typestate. */
    pub fn as_view(&self) -> KFramePduHeader<S::Sliced<'_>, ST> {
        unsafe { KFramePduHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn write_pdu_length(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> KFramePduHeaderWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { KFramePduHeaderWriter::new_in_state(storage) }
    }
    pub fn write_channel_id(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> KFramePduHeaderWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (2) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { KFramePduHeaderWriter::new_in_state(storage) }
    }

}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for KFramePduHeader<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self;
        core::result::Result::Ok((4) as usize)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::View for KFramePduHeaderMut<S> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <KFramePduHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for KFramePduHeaderWriter<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <KFramePduHeader<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for KFramePduHeader<S, emboss_runtime::UncheckedState> {
    type Completed = KFramePduHeader<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { KFramePduHeader::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for KFramePduHeaderWriter<S, emboss_runtime::UncheckedState> {
    type Completed = KFramePduHeaderWriter<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { KFramePduHeaderWriter::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for KFramePduHeader<S, emboss_runtime::UncheckedState> {
    type Ok = KFramePduHeader<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { KFramePduHeader::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for KFramePduHeader<S, emboss_runtime::CompleteState> {
    type Ok = KFramePduHeader<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { KFramePduHeader::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for KFramePduHeader<S, emboss_runtime::OkState> {
    type Ok = KFramePduHeader<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for KFramePduHeaderWriter<S, emboss_runtime::UncheckedState> {
    type Ok = KFramePduHeaderWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { KFramePduHeaderWriter::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for KFramePduHeaderWriter<S, emboss_runtime::CompleteState> {
    type Ok = KFramePduHeaderWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { KFramePduHeaderWriter::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for KFramePduHeaderWriter<S, emboss_runtime::OkState> {
    type Ok = KFramePduHeaderWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

pub mod k_frame_pdu_header {
    pub type View<S, ST = emboss_runtime::UncheckedState> = super::KFramePduHeader<S, ST>;
    pub type ViewMut<S> = super::KFramePduHeaderMut<S>;
    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::KFramePduHeaderWriter<S, ST>;

    pub const MIN_SIZE_IN_BYTES: usize = 4;
    pub const MAX_SIZE_IN_BYTES: usize = 4;
    pub const SIZE_IN_BYTES: usize = 4;
}#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u64)]
pub enum L2capSignalingPacketCode {
    COMMAND_REJECT_RSP = 1,
    CONNECTION_REQ = 2,
    CONNECTION_RSP = 3,
    CONFIGURATION_REQ = 4,
    CONFIGURATION_RSP = 5,
    DISCONNECTION_REQ = 6,
    DISCONNECTION_RSP = 7,
    ECHO_REQ = 8,
    ECHO_RSP = 9,
    INFORMATION_REQ = 10,
    INFORMATION_RSP = 11,
    CONNECTION_PARAMETER_UPDATE_REQ = 18,
    CONNECTION_PARAMETER_UPDATE_RSP = 19,
    LE_CREDIT_BASED_CONNECTION_REQ = 20,
    LE_CREDIT_BASED_CONNECTION_RSP = 21,
    FLOW_CONTROL_CREDIT_IND = 22,
    CREDIT_BASED_CONNECTION_REQ = 23,
    CREDIT_BASED_CONNECTION_RSP = 24,
    CREDIT_BASED_RECONFIGURE_REQ = 25,
    CREDIT_BASED_RECONFIGURE_RSP = 26,

}

impl core::convert::From<L2capSignalingPacketCode> for u8 { fn from(val: L2capSignalingPacketCode) -> Self { val as u8 } }
impl core::convert::From<L2capSignalingPacketCode> for u16 { fn from(val: L2capSignalingPacketCode) -> Self { val as u16 } }
impl core::convert::From<L2capSignalingPacketCode> for u32 { fn from(val: L2capSignalingPacketCode) -> Self { val as u32 } }
impl core::convert::From<L2capSignalingPacketCode> for u64 { fn from(val: L2capSignalingPacketCode) -> Self { val as u64 } }
impl core::convert::From<L2capSignalingPacketCode> for i8 { fn from(val: L2capSignalingPacketCode) -> Self { val as i8 } }
impl core::convert::From<L2capSignalingPacketCode> for i16 { fn from(val: L2capSignalingPacketCode) -> Self { val as i16 } }
impl core::convert::From<L2capSignalingPacketCode> for i32 { fn from(val: L2capSignalingPacketCode) -> Self { val as i32 } }
impl core::convert::From<L2capSignalingPacketCode> for i64 { fn from(val: L2capSignalingPacketCode) -> Self { val as i64 } }

impl emboss_runtime::SafeCmp<L2capSignalingPacketCode> for L2capSignalingPacketCode {
    fn safe_eq(&self, other: Self) -> bool { *self == other }
    fn safe_less(&self, other: Self) -> bool { (*self as u64) < (other as u64) }
}

impl emboss_runtime::SafeCmp<u64> for L2capSignalingPacketCode {
    fn safe_eq(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
    fn safe_less(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
}

impl emboss_runtime::SafeCmp<i64> for L2capSignalingPacketCode {
    fn safe_eq(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
    fn safe_less(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
}

impl emboss_runtime::SafeCmp<i32> for L2capSignalingPacketCode {
    fn safe_eq(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as i64) }
    fn safe_less(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as i64) }
}

impl emboss_runtime::SafeCmp<u32> for L2capSignalingPacketCode {
    fn safe_eq(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as u64) }
    fn safe_less(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as u64) }
}

impl emboss_runtime::SafeCmp<L2capSignalingPacketCode> for u64 {
    fn safe_eq(&self, other: L2capSignalingPacketCode) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
    fn safe_less(&self, other: L2capSignalingPacketCode) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
}

impl emboss_runtime::SafeCmp<L2capSignalingPacketCode> for i64 {
    fn safe_eq(&self, other: L2capSignalingPacketCode) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
    fn safe_less(&self, other: L2capSignalingPacketCode) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
}

impl<V: core::convert::Into<u64> + core::marker::Copy> emboss_runtime::TryFromRaw<V> for L2capSignalingPacketCode {
    fn try_from_raw(val: V) -> core::result::Result<Self, emboss_runtime::Error<V>> {
        let v_raw: u64 = val.into();
        match v_raw {
            1 => Ok(L2capSignalingPacketCode::COMMAND_REJECT_RSP),
            2 => Ok(L2capSignalingPacketCode::CONNECTION_REQ),
            3 => Ok(L2capSignalingPacketCode::CONNECTION_RSP),
            4 => Ok(L2capSignalingPacketCode::CONFIGURATION_REQ),
            5 => Ok(L2capSignalingPacketCode::CONFIGURATION_RSP),
            6 => Ok(L2capSignalingPacketCode::DISCONNECTION_REQ),
            7 => Ok(L2capSignalingPacketCode::DISCONNECTION_RSP),
            8 => Ok(L2capSignalingPacketCode::ECHO_REQ),
            9 => Ok(L2capSignalingPacketCode::ECHO_RSP),
            10 => Ok(L2capSignalingPacketCode::INFORMATION_REQ),
            11 => Ok(L2capSignalingPacketCode::INFORMATION_RSP),
            18 => Ok(L2capSignalingPacketCode::CONNECTION_PARAMETER_UPDATE_REQ),
            19 => Ok(L2capSignalingPacketCode::CONNECTION_PARAMETER_UPDATE_RSP),
            20 => Ok(L2capSignalingPacketCode::LE_CREDIT_BASED_CONNECTION_REQ),
            21 => Ok(L2capSignalingPacketCode::LE_CREDIT_BASED_CONNECTION_RSP),
            22 => Ok(L2capSignalingPacketCode::FLOW_CONTROL_CREDIT_IND),
            23 => Ok(L2capSignalingPacketCode::CREDIT_BASED_CONNECTION_REQ),
            24 => Ok(L2capSignalingPacketCode::CREDIT_BASED_CONNECTION_RSP),
            25 => Ok(L2capSignalingPacketCode::CREDIT_BASED_RECONFIGURE_REQ),
            26 => Ok(L2capSignalingPacketCode::CREDIT_BASED_RECONFIGURE_RSP),

            _ => Err(emboss_runtime::Error::UnknownEnum(val)),
        }
    }
}

impl L2capSignalingPacketCode {

}
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u64)]
pub enum L2capFixedCid {
    ACL_U_SIGNALING = 1,
    CONNECTIONLESS = 2,
    ACL_U_SECURITY_MANAGER = 7,
    LE_U_ATTRIBUTE_PROTOCOL = 4,
    LE_U_SIGNALING = 5,
    LE_U_SECURITY_MANAGER = 6,

}

impl core::convert::From<L2capFixedCid> for u8 { fn from(val: L2capFixedCid) -> Self { val as u8 } }
impl core::convert::From<L2capFixedCid> for u16 { fn from(val: L2capFixedCid) -> Self { val as u16 } }
impl core::convert::From<L2capFixedCid> for u32 { fn from(val: L2capFixedCid) -> Self { val as u32 } }
impl core::convert::From<L2capFixedCid> for u64 { fn from(val: L2capFixedCid) -> Self { val as u64 } }
impl core::convert::From<L2capFixedCid> for i8 { fn from(val: L2capFixedCid) -> Self { val as i8 } }
impl core::convert::From<L2capFixedCid> for i16 { fn from(val: L2capFixedCid) -> Self { val as i16 } }
impl core::convert::From<L2capFixedCid> for i32 { fn from(val: L2capFixedCid) -> Self { val as i32 } }
impl core::convert::From<L2capFixedCid> for i64 { fn from(val: L2capFixedCid) -> Self { val as i64 } }

impl emboss_runtime::SafeCmp<L2capFixedCid> for L2capFixedCid {
    fn safe_eq(&self, other: Self) -> bool { *self == other }
    fn safe_less(&self, other: Self) -> bool { (*self as u64) < (other as u64) }
}

impl emboss_runtime::SafeCmp<u64> for L2capFixedCid {
    fn safe_eq(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
    fn safe_less(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
}

impl emboss_runtime::SafeCmp<i64> for L2capFixedCid {
    fn safe_eq(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
    fn safe_less(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
}

impl emboss_runtime::SafeCmp<i32> for L2capFixedCid {
    fn safe_eq(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as i64) }
    fn safe_less(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as i64) }
}

impl emboss_runtime::SafeCmp<u32> for L2capFixedCid {
    fn safe_eq(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as u64) }
    fn safe_less(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as u64) }
}

impl emboss_runtime::SafeCmp<L2capFixedCid> for u64 {
    fn safe_eq(&self, other: L2capFixedCid) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
    fn safe_less(&self, other: L2capFixedCid) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
}

impl emboss_runtime::SafeCmp<L2capFixedCid> for i64 {
    fn safe_eq(&self, other: L2capFixedCid) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
    fn safe_less(&self, other: L2capFixedCid) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
}

impl<V: core::convert::Into<u64> + core::marker::Copy> emboss_runtime::TryFromRaw<V> for L2capFixedCid {
    fn try_from_raw(val: V) -> core::result::Result<Self, emboss_runtime::Error<V>> {
        let v_raw: u64 = val.into();
        match v_raw {
            1 => Ok(L2capFixedCid::ACL_U_SIGNALING),
            2 => Ok(L2capFixedCid::CONNECTIONLESS),
            7 => Ok(L2capFixedCid::ACL_U_SECURITY_MANAGER),
            4 => Ok(L2capFixedCid::LE_U_ATTRIBUTE_PROTOCOL),
            5 => Ok(L2capFixedCid::LE_U_SIGNALING),
            6 => Ok(L2capFixedCid::LE_U_SECURITY_MANAGER),

            _ => Err(emboss_runtime::Error::UnknownEnum(val)),
        }
    }
}

impl L2capFixedCid {

}
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u64)]
pub enum L2capFixedPsmCode {
    SDP = 1,
    RFCOMM = 3,
    AVDTP = 25,
    ATT = 31,
    EATT = 39,

}

impl core::convert::From<L2capFixedPsmCode> for u8 { fn from(val: L2capFixedPsmCode) -> Self { val as u8 } }
impl core::convert::From<L2capFixedPsmCode> for u16 { fn from(val: L2capFixedPsmCode) -> Self { val as u16 } }
impl core::convert::From<L2capFixedPsmCode> for u32 { fn from(val: L2capFixedPsmCode) -> Self { val as u32 } }
impl core::convert::From<L2capFixedPsmCode> for u64 { fn from(val: L2capFixedPsmCode) -> Self { val as u64 } }
impl core::convert::From<L2capFixedPsmCode> for i8 { fn from(val: L2capFixedPsmCode) -> Self { val as i8 } }
impl core::convert::From<L2capFixedPsmCode> for i16 { fn from(val: L2capFixedPsmCode) -> Self { val as i16 } }
impl core::convert::From<L2capFixedPsmCode> for i32 { fn from(val: L2capFixedPsmCode) -> Self { val as i32 } }
impl core::convert::From<L2capFixedPsmCode> for i64 { fn from(val: L2capFixedPsmCode) -> Self { val as i64 } }

impl emboss_runtime::SafeCmp<L2capFixedPsmCode> for L2capFixedPsmCode {
    fn safe_eq(&self, other: Self) -> bool { *self == other }
    fn safe_less(&self, other: Self) -> bool { (*self as u64) < (other as u64) }
}

impl emboss_runtime::SafeCmp<u64> for L2capFixedPsmCode {
    fn safe_eq(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
    fn safe_less(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
}

impl emboss_runtime::SafeCmp<i64> for L2capFixedPsmCode {
    fn safe_eq(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
    fn safe_less(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
}

impl emboss_runtime::SafeCmp<i32> for L2capFixedPsmCode {
    fn safe_eq(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as i64) }
    fn safe_less(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as i64) }
}

impl emboss_runtime::SafeCmp<u32> for L2capFixedPsmCode {
    fn safe_eq(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as u64) }
    fn safe_less(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as u64) }
}

impl emboss_runtime::SafeCmp<L2capFixedPsmCode> for u64 {
    fn safe_eq(&self, other: L2capFixedPsmCode) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
    fn safe_less(&self, other: L2capFixedPsmCode) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
}

impl emboss_runtime::SafeCmp<L2capFixedPsmCode> for i64 {
    fn safe_eq(&self, other: L2capFixedPsmCode) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
    fn safe_less(&self, other: L2capFixedPsmCode) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
}

impl<V: core::convert::Into<u64> + core::marker::Copy> emboss_runtime::TryFromRaw<V> for L2capFixedPsmCode {
    fn try_from_raw(val: V) -> core::result::Result<Self, emboss_runtime::Error<V>> {
        let v_raw: u64 = val.into();
        match v_raw {
            1 => Ok(L2capFixedPsmCode::SDP),
            3 => Ok(L2capFixedPsmCode::RFCOMM),
            25 => Ok(L2capFixedPsmCode::AVDTP),
            31 => Ok(L2capFixedPsmCode::ATT),
            39 => Ok(L2capFixedPsmCode::EATT),

            _ => Err(emboss_runtime::Error::UnknownEnum(val)),
        }
    }
}

impl L2capFixedPsmCode {

}
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u64)]
pub enum L2capCommandRejectReasonCode {
    NOT_UNDERSTOOD = 0,
    SIG_MTU_EXCEEDED = 1,
    INVALID_CID = 2,

}

impl core::convert::From<L2capCommandRejectReasonCode> for u8 { fn from(val: L2capCommandRejectReasonCode) -> Self { val as u8 } }
impl core::convert::From<L2capCommandRejectReasonCode> for u16 { fn from(val: L2capCommandRejectReasonCode) -> Self { val as u16 } }
impl core::convert::From<L2capCommandRejectReasonCode> for u32 { fn from(val: L2capCommandRejectReasonCode) -> Self { val as u32 } }
impl core::convert::From<L2capCommandRejectReasonCode> for u64 { fn from(val: L2capCommandRejectReasonCode) -> Self { val as u64 } }
impl core::convert::From<L2capCommandRejectReasonCode> for i8 { fn from(val: L2capCommandRejectReasonCode) -> Self { val as i8 } }
impl core::convert::From<L2capCommandRejectReasonCode> for i16 { fn from(val: L2capCommandRejectReasonCode) -> Self { val as i16 } }
impl core::convert::From<L2capCommandRejectReasonCode> for i32 { fn from(val: L2capCommandRejectReasonCode) -> Self { val as i32 } }
impl core::convert::From<L2capCommandRejectReasonCode> for i64 { fn from(val: L2capCommandRejectReasonCode) -> Self { val as i64 } }

impl emboss_runtime::SafeCmp<L2capCommandRejectReasonCode> for L2capCommandRejectReasonCode {
    fn safe_eq(&self, other: Self) -> bool { *self == other }
    fn safe_less(&self, other: Self) -> bool { (*self as u64) < (other as u64) }
}

impl emboss_runtime::SafeCmp<u64> for L2capCommandRejectReasonCode {
    fn safe_eq(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
    fn safe_less(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
}

impl emboss_runtime::SafeCmp<i64> for L2capCommandRejectReasonCode {
    fn safe_eq(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
    fn safe_less(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
}

impl emboss_runtime::SafeCmp<i32> for L2capCommandRejectReasonCode {
    fn safe_eq(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as i64) }
    fn safe_less(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as i64) }
}

impl emboss_runtime::SafeCmp<u32> for L2capCommandRejectReasonCode {
    fn safe_eq(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as u64) }
    fn safe_less(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as u64) }
}

impl emboss_runtime::SafeCmp<L2capCommandRejectReasonCode> for u64 {
    fn safe_eq(&self, other: L2capCommandRejectReasonCode) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
    fn safe_less(&self, other: L2capCommandRejectReasonCode) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
}

impl emboss_runtime::SafeCmp<L2capCommandRejectReasonCode> for i64 {
    fn safe_eq(&self, other: L2capCommandRejectReasonCode) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
    fn safe_less(&self, other: L2capCommandRejectReasonCode) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
}

impl<V: core::convert::Into<u64> + core::marker::Copy> emboss_runtime::TryFromRaw<V> for L2capCommandRejectReasonCode {
    fn try_from_raw(val: V) -> core::result::Result<Self, emboss_runtime::Error<V>> {
        let v_raw: u64 = val.into();
        match v_raw {
            0 => Ok(L2capCommandRejectReasonCode::NOT_UNDERSTOOD),
            1 => Ok(L2capCommandRejectReasonCode::SIG_MTU_EXCEEDED),
            2 => Ok(L2capCommandRejectReasonCode::INVALID_CID),

            _ => Err(emboss_runtime::Error::UnknownEnum(val)),
        }
    }
}

impl L2capCommandRejectReasonCode {

}
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u64)]
pub enum L2capConfigurationOptionType {
    MTU = 1,

}

impl core::convert::From<L2capConfigurationOptionType> for u8 { fn from(val: L2capConfigurationOptionType) -> Self { val as u8 } }
impl core::convert::From<L2capConfigurationOptionType> for u16 { fn from(val: L2capConfigurationOptionType) -> Self { val as u16 } }
impl core::convert::From<L2capConfigurationOptionType> for u32 { fn from(val: L2capConfigurationOptionType) -> Self { val as u32 } }
impl core::convert::From<L2capConfigurationOptionType> for u64 { fn from(val: L2capConfigurationOptionType) -> Self { val as u64 } }
impl core::convert::From<L2capConfigurationOptionType> for i8 { fn from(val: L2capConfigurationOptionType) -> Self { val as i8 } }
impl core::convert::From<L2capConfigurationOptionType> for i16 { fn from(val: L2capConfigurationOptionType) -> Self { val as i16 } }
impl core::convert::From<L2capConfigurationOptionType> for i32 { fn from(val: L2capConfigurationOptionType) -> Self { val as i32 } }
impl core::convert::From<L2capConfigurationOptionType> for i64 { fn from(val: L2capConfigurationOptionType) -> Self { val as i64 } }

impl emboss_runtime::SafeCmp<L2capConfigurationOptionType> for L2capConfigurationOptionType {
    fn safe_eq(&self, other: Self) -> bool { *self == other }
    fn safe_less(&self, other: Self) -> bool { (*self as u64) < (other as u64) }
}

impl emboss_runtime::SafeCmp<u64> for L2capConfigurationOptionType {
    fn safe_eq(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
    fn safe_less(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
}

impl emboss_runtime::SafeCmp<i64> for L2capConfigurationOptionType {
    fn safe_eq(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
    fn safe_less(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
}

impl emboss_runtime::SafeCmp<i32> for L2capConfigurationOptionType {
    fn safe_eq(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as i64) }
    fn safe_less(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as i64) }
}

impl emboss_runtime::SafeCmp<u32> for L2capConfigurationOptionType {
    fn safe_eq(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as u64) }
    fn safe_less(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as u64) }
}

impl emboss_runtime::SafeCmp<L2capConfigurationOptionType> for u64 {
    fn safe_eq(&self, other: L2capConfigurationOptionType) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
    fn safe_less(&self, other: L2capConfigurationOptionType) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
}

impl emboss_runtime::SafeCmp<L2capConfigurationOptionType> for i64 {
    fn safe_eq(&self, other: L2capConfigurationOptionType) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
    fn safe_less(&self, other: L2capConfigurationOptionType) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
}

impl<V: core::convert::Into<u64> + core::marker::Copy> emboss_runtime::TryFromRaw<V> for L2capConfigurationOptionType {
    fn try_from_raw(val: V) -> core::result::Result<Self, emboss_runtime::Error<V>> {
        let v_raw: u64 = val.into();
        match v_raw {
            1 => Ok(L2capConfigurationOptionType::MTU),

            _ => Err(emboss_runtime::Error::UnknownEnum(val)),
        }
    }
}

impl L2capConfigurationOptionType {

}
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u64)]
pub enum L2capConfigurationResult {
    SUCCESS = 0,
    FAILURE_UNACCEPTABLE_PARAMETERS = 1,
    FAILURE_REJECTED = 2,
    FAILURE_UNKNOWN_OPTIONS = 3,
    PENDING = 4,
    FAILURE_FLOW_SPEC_REJECT = 5,

}

impl core::convert::From<L2capConfigurationResult> for u8 { fn from(val: L2capConfigurationResult) -> Self { val as u8 } }
impl core::convert::From<L2capConfigurationResult> for u16 { fn from(val: L2capConfigurationResult) -> Self { val as u16 } }
impl core::convert::From<L2capConfigurationResult> for u32 { fn from(val: L2capConfigurationResult) -> Self { val as u32 } }
impl core::convert::From<L2capConfigurationResult> for u64 { fn from(val: L2capConfigurationResult) -> Self { val as u64 } }
impl core::convert::From<L2capConfigurationResult> for i8 { fn from(val: L2capConfigurationResult) -> Self { val as i8 } }
impl core::convert::From<L2capConfigurationResult> for i16 { fn from(val: L2capConfigurationResult) -> Self { val as i16 } }
impl core::convert::From<L2capConfigurationResult> for i32 { fn from(val: L2capConfigurationResult) -> Self { val as i32 } }
impl core::convert::From<L2capConfigurationResult> for i64 { fn from(val: L2capConfigurationResult) -> Self { val as i64 } }

impl emboss_runtime::SafeCmp<L2capConfigurationResult> for L2capConfigurationResult {
    fn safe_eq(&self, other: Self) -> bool { *self == other }
    fn safe_less(&self, other: Self) -> bool { (*self as u64) < (other as u64) }
}

impl emboss_runtime::SafeCmp<u64> for L2capConfigurationResult {
    fn safe_eq(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
    fn safe_less(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
}

impl emboss_runtime::SafeCmp<i64> for L2capConfigurationResult {
    fn safe_eq(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
    fn safe_less(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
}

impl emboss_runtime::SafeCmp<i32> for L2capConfigurationResult {
    fn safe_eq(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as i64) }
    fn safe_less(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as i64) }
}

impl emboss_runtime::SafeCmp<u32> for L2capConfigurationResult {
    fn safe_eq(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as u64) }
    fn safe_less(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as u64) }
}

impl emboss_runtime::SafeCmp<L2capConfigurationResult> for u64 {
    fn safe_eq(&self, other: L2capConfigurationResult) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
    fn safe_less(&self, other: L2capConfigurationResult) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
}

impl emboss_runtime::SafeCmp<L2capConfigurationResult> for i64 {
    fn safe_eq(&self, other: L2capConfigurationResult) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
    fn safe_less(&self, other: L2capConfigurationResult) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
}

impl<V: core::convert::Into<u64> + core::marker::Copy> emboss_runtime::TryFromRaw<V> for L2capConfigurationResult {
    fn try_from_raw(val: V) -> core::result::Result<Self, emboss_runtime::Error<V>> {
        let v_raw: u64 = val.into();
        match v_raw {
            0 => Ok(L2capConfigurationResult::SUCCESS),
            1 => Ok(L2capConfigurationResult::FAILURE_UNACCEPTABLE_PARAMETERS),
            2 => Ok(L2capConfigurationResult::FAILURE_REJECTED),
            3 => Ok(L2capConfigurationResult::FAILURE_UNKNOWN_OPTIONS),
            4 => Ok(L2capConfigurationResult::PENDING),
            5 => Ok(L2capConfigurationResult::FAILURE_FLOW_SPEC_REJECT),

            _ => Err(emboss_runtime::Error::UnknownEnum(val)),
        }
    }
}

impl L2capConfigurationResult {

}
pub struct L2capConfigurationOptionHeader<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::Storage> L2capConfigurationOptionHeader<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for L2capConfigurationOptionHeader<S, ST> {
    fn clone(&self) -> Self {
        Self {
            storage: self.storage.clone(),
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> L2capConfigurationOptionHeader<S, ST> {
    /**
     * Constructs a view in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    pub fn option_type(&self) -> emboss_runtime::EnumView<L2capConfigurationOptionType, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (1) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        emboss_runtime::EnumView::new(emboss_runtime::UInt::new(storage))
    }
    pub fn option_length(&self) -> UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (1) as usize;
            let len = (1) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        UInt::<8, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
    }

}

pub struct L2capConfigurationOptionHeaderMut<S: emboss_runtime::MutStorage> {
    storage: S,
}

impl<S: emboss_runtime::MutStorage> L2capConfigurationOptionHeaderMut<S> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
        }
    }
    pub fn into_writer(self) -> L2capConfigurationOptionHeaderWriter<S, emboss_runtime::UncheckedState> {
        L2capConfigurationOptionHeaderWriter::new(self.storage)
    }
    /** Borrows the mutable view as an immutable view in UncheckedState. */
    pub fn as_view(&self) -> L2capConfigurationOptionHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        unsafe { L2capConfigurationOptionHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn option_type(&mut self) -> emboss_runtime::EnumViewMut<L2capConfigurationOptionType, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (1) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        emboss_runtime::EnumViewMut::new(emboss_runtime::UInt::new(storage))
    }
    pub fn option_length(&mut self) -> UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (1) as usize;
            let len = (1) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        UInt::<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }

}

impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for L2capConfigurationOptionHeaderMut<S> {
    type Writer = L2capConfigurationOptionHeaderWriter<S, emboss_runtime::UncheckedState>;
    fn into_writer(self) -> Self::Writer {
        L2capConfigurationOptionHeaderWriter::new(self.storage)
    }
}

pub struct L2capConfigurationOptionHeaderWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::MutStorage> L2capConfigurationOptionHeaderWriter<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> L2capConfigurationOptionHeaderWriter<S, ST> {
    /**
     * Constructs a writer in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    /** Converts the writer into an immutable view in the same typestate. */
    pub fn into_view(self) -> L2capConfigurationOptionHeader<S, ST> {
        unsafe { L2capConfigurationOptionHeader::new_in_state(self.storage) }
    }
    /** Borrows the writer as an immutable view in the same typestate. */
    pub fn as_view(&self) -> L2capConfigurationOptionHeader<S::Sliced<'_>, ST> {
        unsafe { L2capConfigurationOptionHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn write_option_type(self, val: L2capConfigurationOptionType) -> L2capConfigurationOptionHeaderWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (1) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::EnumViewMut::<L2capConfigurationOptionType, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, _>>::new(emboss_runtime::UInt::new(slice));
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { L2capConfigurationOptionHeaderWriter::new_in_state(storage) }
    }
    pub fn write_option_length(self, val: <emboss_runtime::SizeSelector<8> as emboss_runtime::SmallestUInt>::T) -> L2capConfigurationOptionHeaderWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (1) as usize;
            let len = (1) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::UInt::<8, emboss_runtime::LittleEndian, _>::new(slice);
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { L2capConfigurationOptionHeaderWriter::new_in_state(storage) }
    }

}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for L2capConfigurationOptionHeader<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self;
        core::result::Result::Ok((2) as usize)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::View for L2capConfigurationOptionHeaderMut<S> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <L2capConfigurationOptionHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for L2capConfigurationOptionHeaderWriter<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <L2capConfigurationOptionHeader<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for L2capConfigurationOptionHeader<S, emboss_runtime::UncheckedState> {
    type Completed = L2capConfigurationOptionHeader<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { L2capConfigurationOptionHeader::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for L2capConfigurationOptionHeaderWriter<S, emboss_runtime::UncheckedState> {
    type Completed = L2capConfigurationOptionHeaderWriter<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { L2capConfigurationOptionHeaderWriter::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capConfigurationOptionHeader<S, emboss_runtime::UncheckedState> {
    type Ok = L2capConfigurationOptionHeader<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { L2capConfigurationOptionHeader::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capConfigurationOptionHeader<S, emboss_runtime::CompleteState> {
    type Ok = L2capConfigurationOptionHeader<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { L2capConfigurationOptionHeader::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capConfigurationOptionHeader<S, emboss_runtime::OkState> {
    type Ok = L2capConfigurationOptionHeader<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capConfigurationOptionHeaderWriter<S, emboss_runtime::UncheckedState> {
    type Ok = L2capConfigurationOptionHeaderWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { L2capConfigurationOptionHeaderWriter::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capConfigurationOptionHeaderWriter<S, emboss_runtime::CompleteState> {
    type Ok = L2capConfigurationOptionHeaderWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { L2capConfigurationOptionHeaderWriter::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capConfigurationOptionHeaderWriter<S, emboss_runtime::OkState> {
    type Ok = L2capConfigurationOptionHeaderWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

pub mod l2cap_configuration_option_header {
    pub type View<S, ST = emboss_runtime::UncheckedState> = super::L2capConfigurationOptionHeader<S, ST>;
    pub type ViewMut<S> = super::L2capConfigurationOptionHeaderMut<S>;
    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::L2capConfigurationOptionHeaderWriter<S, ST>;

    pub const MIN_SIZE_IN_BYTES: usize = 2;
    pub const MAX_SIZE_IN_BYTES: usize = 2;
    pub const SIZE_IN_BYTES: usize = 2;
}pub struct L2capMtuConfigurationOption<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::Storage> L2capMtuConfigurationOption<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for L2capMtuConfigurationOption<S, ST> {
    fn clone(&self) -> Self {
        Self {
            storage: self.storage.clone(),
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> L2capMtuConfigurationOption<S, ST> {
    /**
     * Constructs a view in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    pub fn header(&self) -> L2capConfigurationOptionHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        unsafe { L2capConfigurationOptionHeader::<S::Sliced<'_>, emboss_runtime::UncheckedState>::new_in_state(storage) }
    }
    pub fn mtu(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (2) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
    }

}

pub struct L2capMtuConfigurationOptionMut<S: emboss_runtime::MutStorage> {
    storage: S,
}

impl<S: emboss_runtime::MutStorage> L2capMtuConfigurationOptionMut<S> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
        }
    }
    pub fn into_writer(self) -> L2capMtuConfigurationOptionWriter<S, emboss_runtime::UncheckedState> {
        L2capMtuConfigurationOptionWriter::new(self.storage)
    }
    /** Borrows the mutable view as an immutable view in UncheckedState. */
    pub fn as_view(&self) -> L2capMtuConfigurationOption<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        unsafe { L2capMtuConfigurationOption::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn header(&mut self) -> L2capConfigurationOptionHeaderMut<S::SlicedMut<'_>> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        L2capConfigurationOptionHeaderMut::<S::SlicedMut<'_>>::new(storage)
    }
    pub fn mtu(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (2) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }

}

impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for L2capMtuConfigurationOptionMut<S> {
    type Writer = L2capMtuConfigurationOptionWriter<S, emboss_runtime::UncheckedState>;
    fn into_writer(self) -> Self::Writer {
        L2capMtuConfigurationOptionWriter::new(self.storage)
    }
}

pub struct L2capMtuConfigurationOptionWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::MutStorage> L2capMtuConfigurationOptionWriter<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> L2capMtuConfigurationOptionWriter<S, ST> {
    /**
     * Constructs a writer in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    /** Converts the writer into an immutable view in the same typestate. */
    pub fn into_view(self) -> L2capMtuConfigurationOption<S, ST> {
        unsafe { L2capMtuConfigurationOption::new_in_state(self.storage) }
    }
    /** Borrows the writer as an immutable view in the same typestate. */
    pub fn as_view(&self) -> L2capMtuConfigurationOption<S::Sliced<'_>, ST> {
        unsafe { L2capMtuConfigurationOption::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn write_mtu(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> L2capMtuConfigurationOptionWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (2) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { L2capMtuConfigurationOptionWriter::new_in_state(storage) }
    }

}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for L2capMtuConfigurationOption<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self;
        core::result::Result::Ok((4) as usize)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::View for L2capMtuConfigurationOptionMut<S> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <L2capMtuConfigurationOption<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for L2capMtuConfigurationOptionWriter<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <L2capMtuConfigurationOption<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for L2capMtuConfigurationOption<S, emboss_runtime::UncheckedState> {
    type Completed = L2capMtuConfigurationOption<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { L2capMtuConfigurationOption::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for L2capMtuConfigurationOptionWriter<S, emboss_runtime::UncheckedState> {
    type Completed = L2capMtuConfigurationOptionWriter<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { L2capMtuConfigurationOptionWriter::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capMtuConfigurationOption<S, emboss_runtime::UncheckedState> {
    type Ok = L2capMtuConfigurationOption<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { L2capMtuConfigurationOption::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capMtuConfigurationOption<S, emboss_runtime::CompleteState> {
    type Ok = L2capMtuConfigurationOption<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { L2capMtuConfigurationOption::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capMtuConfigurationOption<S, emboss_runtime::OkState> {
    type Ok = L2capMtuConfigurationOption<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capMtuConfigurationOptionWriter<S, emboss_runtime::UncheckedState> {
    type Ok = L2capMtuConfigurationOptionWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { L2capMtuConfigurationOptionWriter::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capMtuConfigurationOptionWriter<S, emboss_runtime::CompleteState> {
    type Ok = L2capMtuConfigurationOptionWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { L2capMtuConfigurationOptionWriter::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capMtuConfigurationOptionWriter<S, emboss_runtime::OkState> {
    type Ok = L2capMtuConfigurationOptionWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

pub mod l2cap_mtu_configuration_option {
    pub type View<S, ST = emboss_runtime::UncheckedState> = super::L2capMtuConfigurationOption<S, ST>;
    pub type ViewMut<S> = super::L2capMtuConfigurationOptionMut<S>;
    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::L2capMtuConfigurationOptionWriter<S, ST>;

    pub const MIN_SIZE_IN_BYTES: usize = 4;
    pub const MAX_SIZE_IN_BYTES: usize = 4;
    pub const SIZE_IN_BYTES: usize = 4;
}pub struct CFrame_Payload_ArrayView<S: emboss_runtime::Storage> {
    storage: S,
    element_count: usize,
}

impl<S: emboss_runtime::Storage + core::clone::Clone> core::clone::Clone for CFrame_Payload_ArrayView<S> {
    fn clone(&self) -> Self {
        Self {
            storage: self.storage.clone(),
            element_count: self.element_count,
        }
    }
}

impl<S: emboss_runtime::Storage> CFrame_Payload_ArrayView<S> {
    pub const ELEMENT_SIZE_BYTES: usize = 1;
    pub fn new(storage: S, element_count: usize) -> Self {
        Self { storage, element_count }
    }
    pub fn element_count(&self) -> usize {
        self.element_count
    }
    pub fn get(&self, index: usize) -> core::result::Result<emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>>
, emboss_runtime::Error> {
        if index >= self.element_count {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        let offset = index * Self::ELEMENT_SIZE_BYTES;
        let storage = self.storage.slice(offset, Self::ELEMENT_SIZE_BYTES);
        core::result::Result::Ok(emboss_runtime::UInt::new(storage)
)
    }
}

pub struct CFrame_Payload_ArrayViewMut<S: emboss_runtime::MutStorage> {
    storage: S,
    element_count: usize,
}

impl<S: emboss_runtime::MutStorage> CFrame_Payload_ArrayViewMut<S> {
    pub const ELEMENT_SIZE_BYTES: usize = 1;
    pub fn new(storage: S, element_count: usize) -> Self {
        Self { storage, element_count }
    }
    pub fn element_count(&self) -> usize {
        self.element_count
    }
    pub fn get_mut(&mut self, index: usize) -> core::result::Result<emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>>
, emboss_runtime::Error> {
        if index >= self.element_count {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        let offset = index * Self::ELEMENT_SIZE_BYTES;
        let storage = self.storage.slice_mut(offset, Self::ELEMENT_SIZE_BYTES);
        core::result::Result::Ok(emboss_runtime::UInt::new(storage)
)
    }
}
pub struct CFrame<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::Storage> CFrame<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for CFrame<S, ST> {
    fn clone(&self) -> Self {
        Self {
            storage: self.storage.clone(),
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> CFrame<S, ST> {
    /**
     * Constructs a view in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    pub fn header(&self) -> BasicL2capHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (4) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        unsafe { BasicL2capHeader::<S::Sliced<'_>, emboss_runtime::UncheckedState>::new_in_state(storage) }
    }
    pub fn pdu_length(&self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (({ let val = self.header().pdu_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn channel_id(&self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (({ let val = self.header().channel_id().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn payload(&self) -> core::result::Result<CFrame_Payload_ArrayView<S::Sliced<'_>>, emboss_runtime::Error> {
        let offset_res = (|| -> core::result::Result<(usize, usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (({ let val = self.pdu_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as usize;
            let element_count = (len / (1)) as usize;
            core::result::Result::Ok((offset, len, element_count))
        })();
        match offset_res {
            core::result::Result::Ok((offset, len, element_count)) => {
                if len > 0 {
                    let end = offset.checked_add(len).ok_or(emboss_runtime::Error::OutOfBounds)?;
                    self.storage.try_read_byte(end - 1)?;
                }
                let storage = self.storage.slice(offset, len);
                core::result::Result::Ok(CFrame_Payload_ArrayView::new(storage, element_count))
            },
            core::result::Result::Err(e) => core::result::Result::Err(e),
        }
    }

}

pub struct CFrameMut<S: emboss_runtime::MutStorage> {
    storage: S,
}

impl<S: emboss_runtime::MutStorage> CFrameMut<S> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
        }
    }
    pub fn into_writer(self) -> CFrameWriter<S, emboss_runtime::UncheckedState> {
        CFrameWriter::new(self.storage)
    }
    /** Borrows the mutable view as an immutable view in UncheckedState. */
    pub fn as_view(&self) -> CFrame<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        unsafe { CFrame::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn header(&mut self) -> BasicL2capHeaderMut<S::SlicedMut<'_>> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (4) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        BasicL2capHeaderMut::<S::SlicedMut<'_>>::new(storage)
    }
    pub fn pdu_length(&mut self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (({ let val = self.header().pdu_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn channel_id(&mut self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (({ let val = self.header().channel_id().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn payload_mut(&mut self) -> core::result::Result<CFrame_Payload_ArrayViewMut<S::SlicedMut<'_>>, emboss_runtime::Error> {
        let offset_res = (|| -> core::result::Result<(usize, usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (({ let val = self.pdu_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as usize;
            let element_count = (len / (1)) as usize;
            core::result::Result::Ok((offset, len, element_count))
        })();
        match offset_res {
            core::result::Result::Ok((offset, len, element_count)) => {
                if len > 0 {
                    let end = offset.checked_add(len).ok_or(emboss_runtime::Error::OutOfBounds)?;
                    self.storage.try_read_byte(end - 1)?;
                }
                let storage = self.storage.slice_mut(offset, len);
                core::result::Result::Ok(CFrame_Payload_ArrayViewMut::new(storage, element_count))
            },
            core::result::Result::Err(e) => core::result::Result::Err(e),
        }
    }

}

impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for CFrameMut<S> {
    type Writer = CFrameWriter<S, emboss_runtime::UncheckedState>;
    fn into_writer(self) -> Self::Writer {
        CFrameWriter::new(self.storage)
    }
}

pub struct CFrameWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::MutStorage> CFrameWriter<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> CFrameWriter<S, ST> {
    /**
     * Constructs a writer in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    /** Converts the writer into an immutable view in the same typestate. */
    pub fn into_view(self) -> CFrame<S, ST> {
        unsafe { CFrame::new_in_state(self.storage) }
    }
    /** Borrows the writer as an immutable view in the same typestate. */
    pub fn as_view(&self) -> CFrame<S::Sliced<'_>, ST> {
        unsafe { CFrame::new_in_state(self.storage.slice(0, self.storage.len())) }
    }

}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for CFrame<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self;
        core::result::Result::Ok((core::cmp::max((core::cmp::max((0) as i64, (4) as i64)
) as i64, ((if true { ( (4) as i64 + (({ let val = view.pdu_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as i64 )
 } else { 0 })

) as i64)
) as usize)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::View for CFrameMut<S> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <CFrame<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for CFrameWriter<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <CFrame<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for CFrame<S, emboss_runtime::UncheckedState> {
    type Completed = CFrame<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { CFrame::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for CFrameWriter<S, emboss_runtime::UncheckedState> {
    type Completed = CFrameWriter<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { CFrameWriter::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for CFrame<S, emboss_runtime::UncheckedState> {
    type Ok = CFrame<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { CFrame::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for CFrame<S, emboss_runtime::CompleteState> {
    type Ok = CFrame<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { CFrame::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for CFrame<S, emboss_runtime::OkState> {
    type Ok = CFrame<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for CFrameWriter<S, emboss_runtime::UncheckedState> {
    type Ok = CFrameWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { CFrameWriter::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for CFrameWriter<S, emboss_runtime::CompleteState> {
    type Ok = CFrameWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { CFrameWriter::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for CFrameWriter<S, emboss_runtime::OkState> {
    type Ok = CFrameWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

pub mod c_frame {
    pub type View<S, ST = emboss_runtime::UncheckedState> = super::CFrame<S, ST>;
    pub type ViewMut<S> = super::CFrameMut<S>;
    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::CFrameWriter<S, ST>;

    pub const MIN_SIZE_IN_BYTES: usize = 4;
    pub const MAX_SIZE_IN_BYTES: usize = 65539;
}pub struct L2capSignalingCommandHeader<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::Storage> L2capSignalingCommandHeader<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for L2capSignalingCommandHeader<S, ST> {
    fn clone(&self) -> Self {
        Self {
            storage: self.storage.clone(),
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> L2capSignalingCommandHeader<S, ST> {
    /**
     * Constructs a view in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    pub fn code(&self) -> emboss_runtime::EnumView<L2capSignalingPacketCode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (1) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        emboss_runtime::EnumView::new(emboss_runtime::UInt::new(storage))
    }
    pub fn identifier(&self) -> UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (1) as usize;
            let len = (1) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        UInt::<8, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
    }
    pub fn data_length(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (2) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
    }

}

pub struct L2capSignalingCommandHeaderMut<S: emboss_runtime::MutStorage> {
    storage: S,
}

impl<S: emboss_runtime::MutStorage> L2capSignalingCommandHeaderMut<S> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
        }
    }
    pub fn into_writer(self) -> L2capSignalingCommandHeaderWriter<S, emboss_runtime::UncheckedState> {
        L2capSignalingCommandHeaderWriter::new(self.storage)
    }
    /** Borrows the mutable view as an immutable view in UncheckedState. */
    pub fn as_view(&self) -> L2capSignalingCommandHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        unsafe { L2capSignalingCommandHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn code(&mut self) -> emboss_runtime::EnumViewMut<L2capSignalingPacketCode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (1) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        emboss_runtime::EnumViewMut::new(emboss_runtime::UInt::new(storage))
    }
    pub fn identifier(&mut self) -> UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (1) as usize;
            let len = (1) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        UInt::<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }
    pub fn data_length(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (2) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }

}

impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for L2capSignalingCommandHeaderMut<S> {
    type Writer = L2capSignalingCommandHeaderWriter<S, emboss_runtime::UncheckedState>;
    fn into_writer(self) -> Self::Writer {
        L2capSignalingCommandHeaderWriter::new(self.storage)
    }
}

pub struct L2capSignalingCommandHeaderWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::MutStorage> L2capSignalingCommandHeaderWriter<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> L2capSignalingCommandHeaderWriter<S, ST> {
    /**
     * Constructs a writer in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    /** Converts the writer into an immutable view in the same typestate. */
    pub fn into_view(self) -> L2capSignalingCommandHeader<S, ST> {
        unsafe { L2capSignalingCommandHeader::new_in_state(self.storage) }
    }
    /** Borrows the writer as an immutable view in the same typestate. */
    pub fn as_view(&self) -> L2capSignalingCommandHeader<S::Sliced<'_>, ST> {
        unsafe { L2capSignalingCommandHeader::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn write_code(self, val: L2capSignalingPacketCode) -> L2capSignalingCommandHeaderWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (1) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::EnumViewMut::<L2capSignalingPacketCode, emboss_runtime::UInt<8, emboss_runtime::LittleEndian, _>>::new(emboss_runtime::UInt::new(slice));
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { L2capSignalingCommandHeaderWriter::new_in_state(storage) }
    }
    pub fn write_identifier(self, val: <emboss_runtime::SizeSelector<8> as emboss_runtime::SmallestUInt>::T) -> L2capSignalingCommandHeaderWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (1) as usize;
            let len = (1) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::UInt::<8, emboss_runtime::LittleEndian, _>::new(slice);
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { L2capSignalingCommandHeaderWriter::new_in_state(storage) }
    }
    pub fn write_data_length(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> L2capSignalingCommandHeaderWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (2) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { L2capSignalingCommandHeaderWriter::new_in_state(storage) }
    }

}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for L2capSignalingCommandHeader<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self;
        core::result::Result::Ok((4) as usize)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::View for L2capSignalingCommandHeaderMut<S> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <L2capSignalingCommandHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for L2capSignalingCommandHeaderWriter<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <L2capSignalingCommandHeader<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for L2capSignalingCommandHeader<S, emboss_runtime::UncheckedState> {
    type Completed = L2capSignalingCommandHeader<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { L2capSignalingCommandHeader::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for L2capSignalingCommandHeaderWriter<S, emboss_runtime::UncheckedState> {
    type Completed = L2capSignalingCommandHeaderWriter<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { L2capSignalingCommandHeaderWriter::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capSignalingCommandHeader<S, emboss_runtime::UncheckedState> {
    type Ok = L2capSignalingCommandHeader<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { L2capSignalingCommandHeader::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capSignalingCommandHeader<S, emboss_runtime::CompleteState> {
    type Ok = L2capSignalingCommandHeader<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { L2capSignalingCommandHeader::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capSignalingCommandHeader<S, emboss_runtime::OkState> {
    type Ok = L2capSignalingCommandHeader<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capSignalingCommandHeaderWriter<S, emboss_runtime::UncheckedState> {
    type Ok = L2capSignalingCommandHeaderWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { L2capSignalingCommandHeaderWriter::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capSignalingCommandHeaderWriter<S, emboss_runtime::CompleteState> {
    type Ok = L2capSignalingCommandHeaderWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { L2capSignalingCommandHeaderWriter::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capSignalingCommandHeaderWriter<S, emboss_runtime::OkState> {
    type Ok = L2capSignalingCommandHeaderWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

pub mod l2cap_signaling_command_header {
    pub type View<S, ST = emboss_runtime::UncheckedState> = super::L2capSignalingCommandHeader<S, ST>;
    pub type ViewMut<S> = super::L2capSignalingCommandHeaderMut<S>;
    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::L2capSignalingCommandHeaderWriter<S, ST>;

    pub const MIN_SIZE_IN_BYTES: usize = 4;
    pub const MAX_SIZE_IN_BYTES: usize = 4;
    pub const SIZE_IN_BYTES: usize = 4;
}pub struct L2capSignalingCommand_Payload_ArrayView<S: emboss_runtime::Storage> {
    storage: S,
    element_count: usize,
}

impl<S: emboss_runtime::Storage + core::clone::Clone> core::clone::Clone for L2capSignalingCommand_Payload_ArrayView<S> {
    fn clone(&self) -> Self {
        Self {
            storage: self.storage.clone(),
            element_count: self.element_count,
        }
    }
}

impl<S: emboss_runtime::Storage> L2capSignalingCommand_Payload_ArrayView<S> {
    pub const ELEMENT_SIZE_BYTES: usize = 1;
    pub fn new(storage: S, element_count: usize) -> Self {
        Self { storage, element_count }
    }
    pub fn element_count(&self) -> usize {
        self.element_count
    }
    pub fn get(&self, index: usize) -> core::result::Result<emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::Sliced<'_>>
, emboss_runtime::Error> {
        if index >= self.element_count {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        let offset = index * Self::ELEMENT_SIZE_BYTES;
        let storage = self.storage.slice(offset, Self::ELEMENT_SIZE_BYTES);
        core::result::Result::Ok(emboss_runtime::UInt::new(storage)
)
    }
}

pub struct L2capSignalingCommand_Payload_ArrayViewMut<S: emboss_runtime::MutStorage> {
    storage: S,
    element_count: usize,
}

impl<S: emboss_runtime::MutStorage> L2capSignalingCommand_Payload_ArrayViewMut<S> {
    pub const ELEMENT_SIZE_BYTES: usize = 1;
    pub fn new(storage: S, element_count: usize) -> Self {
        Self { storage, element_count }
    }
    pub fn element_count(&self) -> usize {
        self.element_count
    }
    pub fn get_mut(&mut self, index: usize) -> core::result::Result<emboss_runtime::UInt<8, emboss_runtime::LittleEndian, S::SlicedMut<'_>>
, emboss_runtime::Error> {
        if index >= self.element_count {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        let offset = index * Self::ELEMENT_SIZE_BYTES;
        let storage = self.storage.slice_mut(offset, Self::ELEMENT_SIZE_BYTES);
        core::result::Result::Ok(emboss_runtime::UInt::new(storage)
)
    }
}
pub struct L2capSignalingCommand<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::Storage> L2capSignalingCommand<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for L2capSignalingCommand<S, ST> {
    fn clone(&self) -> Self {
        Self {
            storage: self.storage.clone(),
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> L2capSignalingCommand<S, ST> {
    /**
     * Constructs a view in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    pub fn command_header(&self) -> L2capSignalingCommandHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (4) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        unsafe { L2capSignalingCommandHeader::<S::Sliced<'_>, emboss_runtime::UncheckedState>::new_in_state(storage) }
    }
    pub fn data_length(&self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (({ let val = self.command_header().data_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn payload(&self) -> core::result::Result<L2capSignalingCommand_Payload_ArrayView<S::Sliced<'_>>, emboss_runtime::Error> {
        let offset_res = (|| -> core::result::Result<(usize, usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (({ let val = self.data_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as usize;
            let element_count = (len / (1)) as usize;
            core::result::Result::Ok((offset, len, element_count))
        })();
        match offset_res {
            core::result::Result::Ok((offset, len, element_count)) => {
                if len > 0 {
                    let end = offset.checked_add(len).ok_or(emboss_runtime::Error::OutOfBounds)?;
                    self.storage.try_read_byte(end - 1)?;
                }
                let storage = self.storage.slice(offset, len);
                core::result::Result::Ok(L2capSignalingCommand_Payload_ArrayView::new(storage, element_count))
            },
            core::result::Result::Err(e) => core::result::Result::Err(e),
        }
    }

}

pub struct L2capSignalingCommandMut<S: emboss_runtime::MutStorage> {
    storage: S,
}

impl<S: emboss_runtime::MutStorage> L2capSignalingCommandMut<S> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
        }
    }
    pub fn into_writer(self) -> L2capSignalingCommandWriter<S, emboss_runtime::UncheckedState> {
        L2capSignalingCommandWriter::new(self.storage)
    }
    /** Borrows the mutable view as an immutable view in UncheckedState. */
    pub fn as_view(&self) -> L2capSignalingCommand<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        unsafe { L2capSignalingCommand::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn command_header(&mut self) -> L2capSignalingCommandHeaderMut<S::SlicedMut<'_>> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (4) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        L2capSignalingCommandHeaderMut::<S::SlicedMut<'_>>::new(storage)
    }
    pub fn data_length(&mut self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (({ let val = self.command_header().data_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn payload_mut(&mut self) -> core::result::Result<L2capSignalingCommand_Payload_ArrayViewMut<S::SlicedMut<'_>>, emboss_runtime::Error> {
        let offset_res = (|| -> core::result::Result<(usize, usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (({ let val = self.data_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as usize;
            let element_count = (len / (1)) as usize;
            core::result::Result::Ok((offset, len, element_count))
        })();
        match offset_res {
            core::result::Result::Ok((offset, len, element_count)) => {
                if len > 0 {
                    let end = offset.checked_add(len).ok_or(emboss_runtime::Error::OutOfBounds)?;
                    self.storage.try_read_byte(end - 1)?;
                }
                let storage = self.storage.slice_mut(offset, len);
                core::result::Result::Ok(L2capSignalingCommand_Payload_ArrayViewMut::new(storage, element_count))
            },
            core::result::Result::Err(e) => core::result::Result::Err(e),
        }
    }

}

impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for L2capSignalingCommandMut<S> {
    type Writer = L2capSignalingCommandWriter<S, emboss_runtime::UncheckedState>;
    fn into_writer(self) -> Self::Writer {
        L2capSignalingCommandWriter::new(self.storage)
    }
}

pub struct L2capSignalingCommandWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::MutStorage> L2capSignalingCommandWriter<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> L2capSignalingCommandWriter<S, ST> {
    /**
     * Constructs a writer in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    /** Converts the writer into an immutable view in the same typestate. */
    pub fn into_view(self) -> L2capSignalingCommand<S, ST> {
        unsafe { L2capSignalingCommand::new_in_state(self.storage) }
    }
    /** Borrows the writer as an immutable view in the same typestate. */
    pub fn as_view(&self) -> L2capSignalingCommand<S::Sliced<'_>, ST> {
        unsafe { L2capSignalingCommand::new_in_state(self.storage.slice(0, self.storage.len())) }
    }

}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for L2capSignalingCommand<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self;
        core::result::Result::Ok((core::cmp::max((core::cmp::max((0) as i64, (4) as i64)
) as i64, ((if true { ( (4) as i64 + (({ let val = view.data_length().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as i64 )
 } else { 0 })

) as i64)
) as usize)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::View for L2capSignalingCommandMut<S> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <L2capSignalingCommand<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for L2capSignalingCommandWriter<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <L2capSignalingCommand<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for L2capSignalingCommand<S, emboss_runtime::UncheckedState> {
    type Completed = L2capSignalingCommand<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { L2capSignalingCommand::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for L2capSignalingCommandWriter<S, emboss_runtime::UncheckedState> {
    type Completed = L2capSignalingCommandWriter<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { L2capSignalingCommandWriter::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capSignalingCommand<S, emboss_runtime::UncheckedState> {
    type Ok = L2capSignalingCommand<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { L2capSignalingCommand::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capSignalingCommand<S, emboss_runtime::CompleteState> {
    type Ok = L2capSignalingCommand<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { L2capSignalingCommand::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capSignalingCommand<S, emboss_runtime::OkState> {
    type Ok = L2capSignalingCommand<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capSignalingCommandWriter<S, emboss_runtime::UncheckedState> {
    type Ok = L2capSignalingCommandWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { L2capSignalingCommandWriter::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capSignalingCommandWriter<S, emboss_runtime::CompleteState> {
    type Ok = L2capSignalingCommandWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { L2capSignalingCommandWriter::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capSignalingCommandWriter<S, emboss_runtime::OkState> {
    type Ok = L2capSignalingCommandWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

pub mod l2cap_signaling_command {
    pub type View<S, ST = emboss_runtime::UncheckedState> = super::L2capSignalingCommand<S, ST>;
    pub type ViewMut<S> = super::L2capSignalingCommandMut<S>;
    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::L2capSignalingCommandWriter<S, ST>;

    pub const MIN_SIZE_IN_BYTES: usize = 4;
    pub const MAX_SIZE_IN_BYTES: usize = 65539;
}pub struct L2capCommandRejectRsp<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::Storage> L2capCommandRejectRsp<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for L2capCommandRejectRsp<S, ST> {
    fn clone(&self) -> Self {
        Self {
            storage: self.storage.clone(),
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> L2capCommandRejectRsp<S, ST> {
    /**
     * Constructs a view in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    pub fn command_header(&self) -> L2capSignalingCommandHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (4) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        unsafe { L2capSignalingCommandHeader::<S::Sliced<'_>, emboss_runtime::UncheckedState>::new_in_state(storage) }
    }
    pub fn reason(&self) -> emboss_runtime::EnumView<L2capCommandRejectReasonCode, emboss_runtime::UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        emboss_runtime::EnumView::new(emboss_runtime::UInt::new(storage))
    }

}

pub struct L2capCommandRejectRspMut<S: emboss_runtime::MutStorage> {
    storage: S,
}

impl<S: emboss_runtime::MutStorage> L2capCommandRejectRspMut<S> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
        }
    }
    pub fn into_writer(self) -> L2capCommandRejectRspWriter<S, emboss_runtime::UncheckedState> {
        L2capCommandRejectRspWriter::new(self.storage)
    }
    /** Borrows the mutable view as an immutable view in UncheckedState. */
    pub fn as_view(&self) -> L2capCommandRejectRsp<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        unsafe { L2capCommandRejectRsp::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn command_header(&mut self) -> L2capSignalingCommandHeaderMut<S::SlicedMut<'_>> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (4) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        L2capSignalingCommandHeaderMut::<S::SlicedMut<'_>>::new(storage)
    }
    pub fn reason(&mut self) -> emboss_runtime::EnumViewMut<L2capCommandRejectReasonCode, emboss_runtime::UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        emboss_runtime::EnumViewMut::new(emboss_runtime::UInt::new(storage))
    }

}

impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for L2capCommandRejectRspMut<S> {
    type Writer = L2capCommandRejectRspWriter<S, emboss_runtime::UncheckedState>;
    fn into_writer(self) -> Self::Writer {
        L2capCommandRejectRspWriter::new(self.storage)
    }
}

pub struct L2capCommandRejectRspWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::MutStorage> L2capCommandRejectRspWriter<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> L2capCommandRejectRspWriter<S, ST> {
    /**
     * Constructs a writer in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    /** Converts the writer into an immutable view in the same typestate. */
    pub fn into_view(self) -> L2capCommandRejectRsp<S, ST> {
        unsafe { L2capCommandRejectRsp::new_in_state(self.storage) }
    }
    /** Borrows the writer as an immutable view in the same typestate. */
    pub fn as_view(&self) -> L2capCommandRejectRsp<S::Sliced<'_>, ST> {
        unsafe { L2capCommandRejectRsp::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn write_reason(self, val: L2capCommandRejectReasonCode) -> L2capCommandRejectRspWriter<S, ST::OnLayoutMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::EnumViewMut::<L2capCommandRejectReasonCode, emboss_runtime::UInt<16, emboss_runtime::LittleEndian, _>>::new(emboss_runtime::UInt::new(slice));
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { L2capCommandRejectRspWriter::new_in_state(storage) }
    }

}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for L2capCommandRejectRsp<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self;
        core::result::Result::Ok((core::cmp::max((core::cmp::max((core::cmp::max((core::cmp::max((core::cmp::max((0) as i64, (4) as i64)
) as i64, (6) as i64)
) as i64, ((if emboss_runtime::SafeCmp::safe_eq(&(({ let val = view.reason().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
), (1) as u64)
 { 8 } else { 0 })

) as i64)
) as i64, ((if emboss_runtime::SafeCmp::safe_eq(&(({ let val = view.reason().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
), (2) as u64)
 { 8 } else { 0 })

) as i64)
) as i64, ((if emboss_runtime::SafeCmp::safe_eq(&(({ let val = view.reason().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
), (2) as u64)
 { 10 } else { 0 })

) as i64)
) as usize)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::View for L2capCommandRejectRspMut<S> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <L2capCommandRejectRsp<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for L2capCommandRejectRspWriter<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <L2capCommandRejectRsp<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for L2capCommandRejectRsp<S, emboss_runtime::UncheckedState> {
    type Completed = L2capCommandRejectRsp<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { L2capCommandRejectRsp::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for L2capCommandRejectRspWriter<S, emboss_runtime::UncheckedState> {
    type Completed = L2capCommandRejectRspWriter<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { L2capCommandRejectRspWriter::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capCommandRejectRsp<S, emboss_runtime::UncheckedState> {
    type Ok = L2capCommandRejectRsp<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { L2capCommandRejectRsp::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capCommandRejectRsp<S, emboss_runtime::CompleteState> {
    type Ok = L2capCommandRejectRsp<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { L2capCommandRejectRsp::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capCommandRejectRsp<S, emboss_runtime::OkState> {
    type Ok = L2capCommandRejectRsp<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capCommandRejectRspWriter<S, emboss_runtime::UncheckedState> {
    type Ok = L2capCommandRejectRspWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { L2capCommandRejectRspWriter::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capCommandRejectRspWriter<S, emboss_runtime::CompleteState> {
    type Ok = L2capCommandRejectRspWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { L2capCommandRejectRspWriter::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capCommandRejectRspWriter<S, emboss_runtime::OkState> {
    type Ok = L2capCommandRejectRspWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

pub mod l2cap_command_reject_rsp {
    pub type View<S, ST = emboss_runtime::UncheckedState> = super::L2capCommandRejectRsp<S, ST>;
    pub type ViewMut<S> = super::L2capCommandRejectRspMut<S>;
    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::L2capCommandRejectRspWriter<S, ST>;

    pub const MIN_SIZE_IN_BYTES: usize = 6;
    pub const MAX_SIZE_IN_BYTES: usize = 10;
}pub struct L2capConnectionReq<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::Storage> L2capConnectionReq<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for L2capConnectionReq<S, ST> {
    fn clone(&self) -> Self {
        Self {
            storage: self.storage.clone(),
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> L2capConnectionReq<S, ST> {
    /**
     * Constructs a view in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    pub fn command_header(&self) -> L2capSignalingCommandHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (4) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        unsafe { L2capSignalingCommandHeader::<S::Sliced<'_>, emboss_runtime::UncheckedState>::new_in_state(storage) }
    }
    pub fn psm(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
    }
    pub fn source_cid(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (6) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
    }

}

pub struct L2capConnectionReqMut<S: emboss_runtime::MutStorage> {
    storage: S,
}

impl<S: emboss_runtime::MutStorage> L2capConnectionReqMut<S> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
        }
    }
    pub fn into_writer(self) -> L2capConnectionReqWriter<S, emboss_runtime::UncheckedState> {
        L2capConnectionReqWriter::new(self.storage)
    }
    /** Borrows the mutable view as an immutable view in UncheckedState. */
    pub fn as_view(&self) -> L2capConnectionReq<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        unsafe { L2capConnectionReq::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn command_header(&mut self) -> L2capSignalingCommandHeaderMut<S::SlicedMut<'_>> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (4) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        L2capSignalingCommandHeaderMut::<S::SlicedMut<'_>>::new(storage)
    }
    pub fn psm(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }
    pub fn source_cid(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (6) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }

}

impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for L2capConnectionReqMut<S> {
    type Writer = L2capConnectionReqWriter<S, emboss_runtime::UncheckedState>;
    fn into_writer(self) -> Self::Writer {
        L2capConnectionReqWriter::new(self.storage)
    }
}

pub struct L2capConnectionReqWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::MutStorage> L2capConnectionReqWriter<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> L2capConnectionReqWriter<S, ST> {
    /**
     * Constructs a writer in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    /** Converts the writer into an immutable view in the same typestate. */
    pub fn into_view(self) -> L2capConnectionReq<S, ST> {
        unsafe { L2capConnectionReq::new_in_state(self.storage) }
    }
    /** Borrows the writer as an immutable view in the same typestate. */
    pub fn as_view(&self) -> L2capConnectionReq<S::Sliced<'_>, ST> {
        unsafe { L2capConnectionReq::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn write_psm(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> L2capConnectionReqWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { L2capConnectionReqWriter::new_in_state(storage) }
    }
    pub fn write_source_cid(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> L2capConnectionReqWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (6) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { L2capConnectionReqWriter::new_in_state(storage) }
    }

}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for L2capConnectionReq<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self;
        core::result::Result::Ok((8) as usize)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::View for L2capConnectionReqMut<S> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <L2capConnectionReq<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for L2capConnectionReqWriter<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <L2capConnectionReq<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for L2capConnectionReq<S, emboss_runtime::UncheckedState> {
    type Completed = L2capConnectionReq<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { L2capConnectionReq::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for L2capConnectionReqWriter<S, emboss_runtime::UncheckedState> {
    type Completed = L2capConnectionReqWriter<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { L2capConnectionReqWriter::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capConnectionReq<S, emboss_runtime::UncheckedState> {
    type Ok = L2capConnectionReq<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { L2capConnectionReq::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capConnectionReq<S, emboss_runtime::CompleteState> {
    type Ok = L2capConnectionReq<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { L2capConnectionReq::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capConnectionReq<S, emboss_runtime::OkState> {
    type Ok = L2capConnectionReq<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capConnectionReqWriter<S, emboss_runtime::UncheckedState> {
    type Ok = L2capConnectionReqWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { L2capConnectionReqWriter::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capConnectionReqWriter<S, emboss_runtime::CompleteState> {
    type Ok = L2capConnectionReqWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { L2capConnectionReqWriter::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capConnectionReqWriter<S, emboss_runtime::OkState> {
    type Ok = L2capConnectionReqWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

pub mod l2cap_connection_req {
    pub type View<S, ST = emboss_runtime::UncheckedState> = super::L2capConnectionReq<S, ST>;
    pub type ViewMut<S> = super::L2capConnectionReqMut<S>;
    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::L2capConnectionReqWriter<S, ST>;

    pub const MIN_SIZE_IN_BYTES: usize = 8;
    pub const MAX_SIZE_IN_BYTES: usize = 8;
    pub const SIZE_IN_BYTES: usize = 8;
}#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u64)]
pub enum L2capConnectionRspResultCode {
    SUCCESSFUL = 0,
    PENDING = 1,
    PSM_NOT_SUPPORTED = 2,
    SECURITY_BLOCK = 3,
    NO_RESOURCES_AVAILABLE = 4,
    INVALID_SOURCE_CID = 5,
    SOURCE_CID_ALREADY_ALLOCATED = 6,

}

impl core::convert::From<L2capConnectionRspResultCode> for u8 { fn from(val: L2capConnectionRspResultCode) -> Self { val as u8 } }
impl core::convert::From<L2capConnectionRspResultCode> for u16 { fn from(val: L2capConnectionRspResultCode) -> Self { val as u16 } }
impl core::convert::From<L2capConnectionRspResultCode> for u32 { fn from(val: L2capConnectionRspResultCode) -> Self { val as u32 } }
impl core::convert::From<L2capConnectionRspResultCode> for u64 { fn from(val: L2capConnectionRspResultCode) -> Self { val as u64 } }
impl core::convert::From<L2capConnectionRspResultCode> for i8 { fn from(val: L2capConnectionRspResultCode) -> Self { val as i8 } }
impl core::convert::From<L2capConnectionRspResultCode> for i16 { fn from(val: L2capConnectionRspResultCode) -> Self { val as i16 } }
impl core::convert::From<L2capConnectionRspResultCode> for i32 { fn from(val: L2capConnectionRspResultCode) -> Self { val as i32 } }
impl core::convert::From<L2capConnectionRspResultCode> for i64 { fn from(val: L2capConnectionRspResultCode) -> Self { val as i64 } }

impl emboss_runtime::SafeCmp<L2capConnectionRspResultCode> for L2capConnectionRspResultCode {
    fn safe_eq(&self, other: Self) -> bool { *self == other }
    fn safe_less(&self, other: Self) -> bool { (*self as u64) < (other as u64) }
}

impl emboss_runtime::SafeCmp<u64> for L2capConnectionRspResultCode {
    fn safe_eq(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
    fn safe_less(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
}

impl emboss_runtime::SafeCmp<i64> for L2capConnectionRspResultCode {
    fn safe_eq(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
    fn safe_less(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
}

impl emboss_runtime::SafeCmp<i32> for L2capConnectionRspResultCode {
    fn safe_eq(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as i64) }
    fn safe_less(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as i64) }
}

impl emboss_runtime::SafeCmp<u32> for L2capConnectionRspResultCode {
    fn safe_eq(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as u64) }
    fn safe_less(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as u64) }
}

impl emboss_runtime::SafeCmp<L2capConnectionRspResultCode> for u64 {
    fn safe_eq(&self, other: L2capConnectionRspResultCode) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
    fn safe_less(&self, other: L2capConnectionRspResultCode) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
}

impl emboss_runtime::SafeCmp<L2capConnectionRspResultCode> for i64 {
    fn safe_eq(&self, other: L2capConnectionRspResultCode) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
    fn safe_less(&self, other: L2capConnectionRspResultCode) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
}

impl<V: core::convert::Into<u64> + core::marker::Copy> emboss_runtime::TryFromRaw<V> for L2capConnectionRspResultCode {
    fn try_from_raw(val: V) -> core::result::Result<Self, emboss_runtime::Error<V>> {
        let v_raw: u64 = val.into();
        match v_raw {
            0 => Ok(L2capConnectionRspResultCode::SUCCESSFUL),
            1 => Ok(L2capConnectionRspResultCode::PENDING),
            2 => Ok(L2capConnectionRspResultCode::PSM_NOT_SUPPORTED),
            3 => Ok(L2capConnectionRspResultCode::SECURITY_BLOCK),
            4 => Ok(L2capConnectionRspResultCode::NO_RESOURCES_AVAILABLE),
            5 => Ok(L2capConnectionRspResultCode::INVALID_SOURCE_CID),
            6 => Ok(L2capConnectionRspResultCode::SOURCE_CID_ALREADY_ALLOCATED),

            _ => Err(emboss_runtime::Error::UnknownEnum(val)),
        }
    }
}

impl L2capConnectionRspResultCode {

}
#[derive(Copy, Clone, Debug, Eq, PartialEq)]
#[repr(u64)]
pub enum L2capConnectionRspStatusCode {
    NO_INFORMATION = 0,
    AUTHENTICATION_PENDING = 1,
    AUTHORIZATION_PENDING = 2,

}

impl core::convert::From<L2capConnectionRspStatusCode> for u8 { fn from(val: L2capConnectionRspStatusCode) -> Self { val as u8 } }
impl core::convert::From<L2capConnectionRspStatusCode> for u16 { fn from(val: L2capConnectionRspStatusCode) -> Self { val as u16 } }
impl core::convert::From<L2capConnectionRspStatusCode> for u32 { fn from(val: L2capConnectionRspStatusCode) -> Self { val as u32 } }
impl core::convert::From<L2capConnectionRspStatusCode> for u64 { fn from(val: L2capConnectionRspStatusCode) -> Self { val as u64 } }
impl core::convert::From<L2capConnectionRspStatusCode> for i8 { fn from(val: L2capConnectionRspStatusCode) -> Self { val as i8 } }
impl core::convert::From<L2capConnectionRspStatusCode> for i16 { fn from(val: L2capConnectionRspStatusCode) -> Self { val as i16 } }
impl core::convert::From<L2capConnectionRspStatusCode> for i32 { fn from(val: L2capConnectionRspStatusCode) -> Self { val as i32 } }
impl core::convert::From<L2capConnectionRspStatusCode> for i64 { fn from(val: L2capConnectionRspStatusCode) -> Self { val as i64 } }

impl emboss_runtime::SafeCmp<L2capConnectionRspStatusCode> for L2capConnectionRspStatusCode {
    fn safe_eq(&self, other: Self) -> bool { *self == other }
    fn safe_less(&self, other: Self) -> bool { (*self as u64) < (other as u64) }
}

impl emboss_runtime::SafeCmp<u64> for L2capConnectionRspStatusCode {
    fn safe_eq(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
    fn safe_less(&self, other: u64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
}

impl emboss_runtime::SafeCmp<i64> for L2capConnectionRspStatusCode {
    fn safe_eq(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other) }
    fn safe_less(&self, other: i64) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other) }
}

impl emboss_runtime::SafeCmp<i32> for L2capConnectionRspStatusCode {
    fn safe_eq(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as i64) }
    fn safe_less(&self, other: i32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as i64) }
}

impl emboss_runtime::SafeCmp<u32> for L2capConnectionRspStatusCode {
    fn safe_eq(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_eq(&(*self as u64), other as u64) }
    fn safe_less(&self, other: u32) -> bool { emboss_runtime::SafeCmp::safe_less(&(*self as u64), other as u64) }
}

impl emboss_runtime::SafeCmp<L2capConnectionRspStatusCode> for u64 {
    fn safe_eq(&self, other: L2capConnectionRspStatusCode) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
    fn safe_less(&self, other: L2capConnectionRspStatusCode) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
}

impl emboss_runtime::SafeCmp<L2capConnectionRspStatusCode> for i64 {
    fn safe_eq(&self, other: L2capConnectionRspStatusCode) -> bool { emboss_runtime::SafeCmp::safe_eq(self, other as u64) }
    fn safe_less(&self, other: L2capConnectionRspStatusCode) -> bool { emboss_runtime::SafeCmp::safe_less(self, other as u64) }
}

impl<V: core::convert::Into<u64> + core::marker::Copy> emboss_runtime::TryFromRaw<V> for L2capConnectionRspStatusCode {
    fn try_from_raw(val: V) -> core::result::Result<Self, emboss_runtime::Error<V>> {
        let v_raw: u64 = val.into();
        match v_raw {
            0 => Ok(L2capConnectionRspStatusCode::NO_INFORMATION),
            1 => Ok(L2capConnectionRspStatusCode::AUTHENTICATION_PENDING),
            2 => Ok(L2capConnectionRspStatusCode::AUTHORIZATION_PENDING),

            _ => Err(emboss_runtime::Error::UnknownEnum(val)),
        }
    }
}

impl L2capConnectionRspStatusCode {

}
pub struct L2capConnectionRsp<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::Storage> L2capConnectionRsp<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for L2capConnectionRsp<S, ST> {
    fn clone(&self) -> Self {
        Self {
            storage: self.storage.clone(),
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> L2capConnectionRsp<S, ST> {
    /**
     * Constructs a view in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    pub fn command_header(&self) -> L2capSignalingCommandHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (4) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        unsafe { L2capSignalingCommandHeader::<S::Sliced<'_>, emboss_runtime::UncheckedState>::new_in_state(storage) }
    }
    pub fn destination_cid(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
    }
    pub fn source_cid(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (6) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
    }
    pub fn result(&self) -> emboss_runtime::EnumView<L2capConnectionRspResultCode, emboss_runtime::UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (8) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        emboss_runtime::EnumView::new(emboss_runtime::UInt::new(storage))
    }

}

pub struct L2capConnectionRspMut<S: emboss_runtime::MutStorage> {
    storage: S,
}

impl<S: emboss_runtime::MutStorage> L2capConnectionRspMut<S> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
        }
    }
    pub fn into_writer(self) -> L2capConnectionRspWriter<S, emboss_runtime::UncheckedState> {
        L2capConnectionRspWriter::new(self.storage)
    }
    /** Borrows the mutable view as an immutable view in UncheckedState. */
    pub fn as_view(&self) -> L2capConnectionRsp<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        unsafe { L2capConnectionRsp::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn command_header(&mut self) -> L2capSignalingCommandHeaderMut<S::SlicedMut<'_>> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (4) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        L2capSignalingCommandHeaderMut::<S::SlicedMut<'_>>::new(storage)
    }
    pub fn destination_cid(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }
    pub fn source_cid(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (6) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }
    pub fn result(&mut self) -> emboss_runtime::EnumViewMut<L2capConnectionRspResultCode, emboss_runtime::UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (8) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        emboss_runtime::EnumViewMut::new(emboss_runtime::UInt::new(storage))
    }

}

impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for L2capConnectionRspMut<S> {
    type Writer = L2capConnectionRspWriter<S, emboss_runtime::UncheckedState>;
    fn into_writer(self) -> Self::Writer {
        L2capConnectionRspWriter::new(self.storage)
    }
}

pub struct L2capConnectionRspWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::MutStorage> L2capConnectionRspWriter<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> L2capConnectionRspWriter<S, ST> {
    /**
     * Constructs a writer in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    /** Converts the writer into an immutable view in the same typestate. */
    pub fn into_view(self) -> L2capConnectionRsp<S, ST> {
        unsafe { L2capConnectionRsp::new_in_state(self.storage) }
    }
    /** Borrows the writer as an immutable view in the same typestate. */
    pub fn as_view(&self) -> L2capConnectionRsp<S::Sliced<'_>, ST> {
        unsafe { L2capConnectionRsp::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn write_destination_cid(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> L2capConnectionRspWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { L2capConnectionRspWriter::new_in_state(storage) }
    }
    pub fn write_source_cid(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> L2capConnectionRspWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (6) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { L2capConnectionRspWriter::new_in_state(storage) }
    }
    pub fn write_result(self, val: L2capConnectionRspResultCode) -> L2capConnectionRspWriter<S, ST::OnLayoutMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (8) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::EnumViewMut::<L2capConnectionRspResultCode, emboss_runtime::UInt<16, emboss_runtime::LittleEndian, _>>::new(emboss_runtime::UInt::new(slice));
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { L2capConnectionRspWriter::new_in_state(storage) }
    }

}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for L2capConnectionRsp<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self;
        core::result::Result::Ok((core::cmp::max((core::cmp::max((core::cmp::max((core::cmp::max((core::cmp::max((0) as i64, (4) as i64)
) as i64, (6) as i64)
) as i64, (8) as i64)
) as i64, (10) as i64)
) as i64, ((if emboss_runtime::SafeCmp::safe_eq(&(({ let val = view.result().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
), (1) as u64)
 { 12 } else { 0 })

) as i64)
) as usize)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::View for L2capConnectionRspMut<S> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <L2capConnectionRsp<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for L2capConnectionRspWriter<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <L2capConnectionRsp<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for L2capConnectionRsp<S, emboss_runtime::UncheckedState> {
    type Completed = L2capConnectionRsp<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { L2capConnectionRsp::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for L2capConnectionRspWriter<S, emboss_runtime::UncheckedState> {
    type Completed = L2capConnectionRspWriter<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { L2capConnectionRspWriter::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capConnectionRsp<S, emboss_runtime::UncheckedState> {
    type Ok = L2capConnectionRsp<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { L2capConnectionRsp::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capConnectionRsp<S, emboss_runtime::CompleteState> {
    type Ok = L2capConnectionRsp<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { L2capConnectionRsp::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capConnectionRsp<S, emboss_runtime::OkState> {
    type Ok = L2capConnectionRsp<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capConnectionRspWriter<S, emboss_runtime::UncheckedState> {
    type Ok = L2capConnectionRspWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { L2capConnectionRspWriter::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capConnectionRspWriter<S, emboss_runtime::CompleteState> {
    type Ok = L2capConnectionRspWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { L2capConnectionRspWriter::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capConnectionRspWriter<S, emboss_runtime::OkState> {
    type Ok = L2capConnectionRspWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

pub mod l2cap_connection_rsp {
    pub type View<S, ST = emboss_runtime::UncheckedState> = super::L2capConnectionRsp<S, ST>;
    pub type ViewMut<S> = super::L2capConnectionRspMut<S>;
    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::L2capConnectionRspWriter<S, ST>;

    pub const MIN_SIZE_IN_BYTES: usize = 10;
    pub const MAX_SIZE_IN_BYTES: usize = 12;
}pub struct L2capConfigureReq_EmbossReservedAnonymousField2<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::Storage> L2capConfigureReq_EmbossReservedAnonymousField2<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for L2capConfigureReq_EmbossReservedAnonymousField2<S, ST> {
    fn clone(&self) -> Self {
        Self {
            storage: self.storage.clone(),
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> L2capConfigureReq_EmbossReservedAnonymousField2<S, ST> {
    /**
     * Constructs a view in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    pub fn rfu(&self) -> emboss_runtime::BitUInt<15, 0, emboss_runtime::Null, S::Sliced<'_>, ST> {
        let len = (2) as usize; // Total struct size in bytes
        let storage = self.storage.slice(0, len);
        emboss_runtime::BitUInt::<15, 0, emboss_runtime::Null, S::Sliced<'_>, ST>::new(storage)
    }
    pub fn continuation_flag(&self) -> emboss_runtime::BitFlag<1, 15, emboss_runtime::Null, S::Sliced<'_>, ST> {
        let len = (2) as usize; // Total struct size in bytes
        let storage = self.storage.slice(0, len);
        emboss_runtime::BitFlag::<1, 15, emboss_runtime::Null, S::Sliced<'_>, ST>::new(storage)
    }

}

pub struct L2capConfigureReq_EmbossReservedAnonymousField2Mut<S: emboss_runtime::MutStorage> {
    storage: S,
}

impl<S: emboss_runtime::MutStorage> L2capConfigureReq_EmbossReservedAnonymousField2Mut<S> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
        }
    }
    pub fn into_writer(self) -> L2capConfigureReq_EmbossReservedAnonymousField2Writer<S, emboss_runtime::UncheckedState> {
        L2capConfigureReq_EmbossReservedAnonymousField2Writer::new(self.storage)
    }
    /** Borrows the mutable view as an immutable view in UncheckedState. */
    pub fn as_view(&self) -> L2capConfigureReq_EmbossReservedAnonymousField2<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        unsafe { L2capConfigureReq_EmbossReservedAnonymousField2::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn rfu(&mut self) -> emboss_runtime::BitUInt<15, 0, emboss_runtime::Null, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let len = (2) as usize;
        let storage = self.storage.slice_mut(0, len);
        emboss_runtime::BitUInt::<15, 0, emboss_runtime::Null, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }
    pub fn continuation_flag(&mut self) -> emboss_runtime::BitFlag<1, 15, emboss_runtime::Null, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let len = (2) as usize;
        let storage = self.storage.slice_mut(0, len);
        emboss_runtime::BitFlag::<1, 15, emboss_runtime::Null, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }

}

impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for L2capConfigureReq_EmbossReservedAnonymousField2Mut<S> {
    type Writer = L2capConfigureReq_EmbossReservedAnonymousField2Writer<S, emboss_runtime::UncheckedState>;
    fn into_writer(self) -> Self::Writer {
        L2capConfigureReq_EmbossReservedAnonymousField2Writer::new(self.storage)
    }
}

pub struct L2capConfigureReq_EmbossReservedAnonymousField2Writer<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::MutStorage> L2capConfigureReq_EmbossReservedAnonymousField2Writer<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> L2capConfigureReq_EmbossReservedAnonymousField2Writer<S, ST> {
    /**
     * Constructs a writer in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    /** Converts the writer into an immutable view in the same typestate. */
    pub fn into_view(self) -> L2capConfigureReq_EmbossReservedAnonymousField2<S, ST> {
        unsafe { L2capConfigureReq_EmbossReservedAnonymousField2::new_in_state(self.storage) }
    }
    /** Borrows the writer as an immutable view in the same typestate. */
    pub fn as_view(&self) -> L2capConfigureReq_EmbossReservedAnonymousField2<S::Sliced<'_>, ST> {
        unsafe { L2capConfigureReq_EmbossReservedAnonymousField2::new_in_state(self.storage.slice(0, self.storage.len())) }
    }

}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for L2capConfigureReq_EmbossReservedAnonymousField2<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self;
        core::result::Result::Ok((((16) + 7) / 8) as usize)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::View for L2capConfigureReq_EmbossReservedAnonymousField2Mut<S> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <L2capConfigureReq_EmbossReservedAnonymousField2<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for L2capConfigureReq_EmbossReservedAnonymousField2Writer<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <L2capConfigureReq_EmbossReservedAnonymousField2<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for L2capConfigureReq_EmbossReservedAnonymousField2<S, emboss_runtime::UncheckedState> {
    type Completed = L2capConfigureReq_EmbossReservedAnonymousField2<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { L2capConfigureReq_EmbossReservedAnonymousField2::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for L2capConfigureReq_EmbossReservedAnonymousField2Writer<S, emboss_runtime::UncheckedState> {
    type Completed = L2capConfigureReq_EmbossReservedAnonymousField2Writer<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { L2capConfigureReq_EmbossReservedAnonymousField2Writer::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capConfigureReq_EmbossReservedAnonymousField2<S, emboss_runtime::UncheckedState> {
    type Ok = L2capConfigureReq_EmbossReservedAnonymousField2<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { L2capConfigureReq_EmbossReservedAnonymousField2::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capConfigureReq_EmbossReservedAnonymousField2<S, emboss_runtime::CompleteState> {
    type Ok = L2capConfigureReq_EmbossReservedAnonymousField2<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { L2capConfigureReq_EmbossReservedAnonymousField2::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capConfigureReq_EmbossReservedAnonymousField2<S, emboss_runtime::OkState> {
    type Ok = L2capConfigureReq_EmbossReservedAnonymousField2<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capConfigureReq_EmbossReservedAnonymousField2Writer<S, emboss_runtime::UncheckedState> {
    type Ok = L2capConfigureReq_EmbossReservedAnonymousField2Writer<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { L2capConfigureReq_EmbossReservedAnonymousField2Writer::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capConfigureReq_EmbossReservedAnonymousField2Writer<S, emboss_runtime::CompleteState> {
    type Ok = L2capConfigureReq_EmbossReservedAnonymousField2Writer<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { L2capConfigureReq_EmbossReservedAnonymousField2Writer::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capConfigureReq_EmbossReservedAnonymousField2Writer<S, emboss_runtime::OkState> {
    type Ok = L2capConfigureReq_EmbossReservedAnonymousField2Writer<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

pub mod l2cap_configure_req_emboss_reserved_anonymous_field2 {
    pub type View<S, ST = emboss_runtime::UncheckedState> = super::L2capConfigureReq_EmbossReservedAnonymousField2<S, ST>;
    pub type ViewMut<S> = super::L2capConfigureReq_EmbossReservedAnonymousField2Mut<S>;
    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::L2capConfigureReq_EmbossReservedAnonymousField2Writer<S, ST>;

    pub const MIN_SIZE_IN_BYTES: usize = 2;
    pub const MAX_SIZE_IN_BYTES: usize = 2;
    pub const SIZE_IN_BYTES: usize = 2;
}pub struct L2capConfigureReq<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::Storage> L2capConfigureReq<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for L2capConfigureReq<S, ST> {
    fn clone(&self) -> Self {
        Self {
            storage: self.storage.clone(),
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> L2capConfigureReq<S, ST> {
    /**
     * Constructs a view in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    pub fn command_header(&self) -> L2capSignalingCommandHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (4) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        unsafe { L2capSignalingCommandHeader::<S::Sliced<'_>, emboss_runtime::UncheckedState>::new_in_state(storage) }
    }
    pub fn destination_cid(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
    }
    pub fn emboss_reserved_anonymous_field_2(&self) -> L2capConfigureReq_EmbossReservedAnonymousField2<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (6) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        unsafe { L2capConfigureReq_EmbossReservedAnonymousField2::<S::Sliced<'_>, emboss_runtime::UncheckedState>::new_in_state(storage) }
    }
    pub fn rfu(&self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (({ let val = self.emboss_reserved_anonymous_field_2().rfu().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn continuation_flag(&self) -> emboss_runtime::VirtualField<bool> {
        let value = (|| -> core::result::Result<bool, emboss_runtime::Error> {
        core::result::Result::Ok( (({ let val = self.emboss_reserved_anonymous_field_2().continuation_flag().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) )
    })();
        emboss_runtime::VirtualField::new(value)
    }

}

pub struct L2capConfigureReqMut<S: emboss_runtime::MutStorage> {
    storage: S,
}

impl<S: emboss_runtime::MutStorage> L2capConfigureReqMut<S> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
        }
    }
    pub fn into_writer(self) -> L2capConfigureReqWriter<S, emboss_runtime::UncheckedState> {
        L2capConfigureReqWriter::new(self.storage)
    }
    /** Borrows the mutable view as an immutable view in UncheckedState. */
    pub fn as_view(&self) -> L2capConfigureReq<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        unsafe { L2capConfigureReq::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn command_header(&mut self) -> L2capSignalingCommandHeaderMut<S::SlicedMut<'_>> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (4) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        L2capSignalingCommandHeaderMut::<S::SlicedMut<'_>>::new(storage)
    }
    pub fn destination_cid(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }
    pub fn emboss_reserved_anonymous_field_2(&mut self) -> L2capConfigureReq_EmbossReservedAnonymousField2Mut<S::SlicedMut<'_>> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (6) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        L2capConfigureReq_EmbossReservedAnonymousField2Mut::<S::SlicedMut<'_>>::new(storage)
    }
    pub fn rfu(&mut self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (({ let val = self.emboss_reserved_anonymous_field_2().rfu().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn continuation_flag(&mut self) -> emboss_runtime::VirtualField<bool> {
        let value = (|| -> core::result::Result<bool, emboss_runtime::Error> {
        core::result::Result::Ok( (({ let val = self.emboss_reserved_anonymous_field_2().continuation_flag().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) )
    })();
        emboss_runtime::VirtualField::new(value)
    }

}

impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for L2capConfigureReqMut<S> {
    type Writer = L2capConfigureReqWriter<S, emboss_runtime::UncheckedState>;
    fn into_writer(self) -> Self::Writer {
        L2capConfigureReqWriter::new(self.storage)
    }
}

pub struct L2capConfigureReqWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::MutStorage> L2capConfigureReqWriter<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> L2capConfigureReqWriter<S, ST> {
    /**
     * Constructs a writer in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    /** Converts the writer into an immutable view in the same typestate. */
    pub fn into_view(self) -> L2capConfigureReq<S, ST> {
        unsafe { L2capConfigureReq::new_in_state(self.storage) }
    }
    /** Borrows the writer as an immutable view in the same typestate. */
    pub fn as_view(&self) -> L2capConfigureReq<S::Sliced<'_>, ST> {
        unsafe { L2capConfigureReq::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn write_destination_cid(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> L2capConfigureReqWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { L2capConfigureReqWriter::new_in_state(storage) }
    }

}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for L2capConfigureReq<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self;
        core::result::Result::Ok((0) as usize)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::View for L2capConfigureReqMut<S> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <L2capConfigureReq<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for L2capConfigureReqWriter<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <L2capConfigureReq<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for L2capConfigureReq<S, emboss_runtime::UncheckedState> {
    type Completed = L2capConfigureReq<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { L2capConfigureReq::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for L2capConfigureReqWriter<S, emboss_runtime::UncheckedState> {
    type Completed = L2capConfigureReqWriter<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { L2capConfigureReqWriter::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capConfigureReq<S, emboss_runtime::UncheckedState> {
    type Ok = L2capConfigureReq<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { L2capConfigureReq::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capConfigureReq<S, emboss_runtime::CompleteState> {
    type Ok = L2capConfigureReq<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { L2capConfigureReq::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capConfigureReq<S, emboss_runtime::OkState> {
    type Ok = L2capConfigureReq<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capConfigureReqWriter<S, emboss_runtime::UncheckedState> {
    type Ok = L2capConfigureReqWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { L2capConfigureReqWriter::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capConfigureReqWriter<S, emboss_runtime::CompleteState> {
    type Ok = L2capConfigureReqWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { L2capConfigureReqWriter::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capConfigureReqWriter<S, emboss_runtime::OkState> {
    type Ok = L2capConfigureReqWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

pub mod l2cap_configure_req {
    pub type View<S, ST = emboss_runtime::UncheckedState> = super::L2capConfigureReq<S, ST>;
    pub type ViewMut<S> = super::L2capConfigureReqMut<S>;
    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::L2capConfigureReqWriter<S, ST>;

    pub const MIN_SIZE_IN_BYTES: usize = 8;
    pub const MAX_SIZE_IN_BYTES: usize = 4294967295;
}pub struct L2capConfigureRsp_EmbossReservedAnonymousField1<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::Storage> L2capConfigureRsp_EmbossReservedAnonymousField1<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for L2capConfigureRsp_EmbossReservedAnonymousField1<S, ST> {
    fn clone(&self) -> Self {
        Self {
            storage: self.storage.clone(),
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> L2capConfigureRsp_EmbossReservedAnonymousField1<S, ST> {
    /**
     * Constructs a view in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    pub fn rfu(&self) -> emboss_runtime::BitUInt<15, 0, emboss_runtime::Null, S::Sliced<'_>, ST> {
        let len = (2) as usize; // Total struct size in bytes
        let storage = self.storage.slice(0, len);
        emboss_runtime::BitUInt::<15, 0, emboss_runtime::Null, S::Sliced<'_>, ST>::new(storage)
    }
    pub fn continuation_flag(&self) -> emboss_runtime::BitFlag<1, 15, emboss_runtime::Null, S::Sliced<'_>, ST> {
        let len = (2) as usize; // Total struct size in bytes
        let storage = self.storage.slice(0, len);
        emboss_runtime::BitFlag::<1, 15, emboss_runtime::Null, S::Sliced<'_>, ST>::new(storage)
    }

}

pub struct L2capConfigureRsp_EmbossReservedAnonymousField1Mut<S: emboss_runtime::MutStorage> {
    storage: S,
}

impl<S: emboss_runtime::MutStorage> L2capConfigureRsp_EmbossReservedAnonymousField1Mut<S> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
        }
    }
    pub fn into_writer(self) -> L2capConfigureRsp_EmbossReservedAnonymousField1Writer<S, emboss_runtime::UncheckedState> {
        L2capConfigureRsp_EmbossReservedAnonymousField1Writer::new(self.storage)
    }
    /** Borrows the mutable view as an immutable view in UncheckedState. */
    pub fn as_view(&self) -> L2capConfigureRsp_EmbossReservedAnonymousField1<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        unsafe { L2capConfigureRsp_EmbossReservedAnonymousField1::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn rfu(&mut self) -> emboss_runtime::BitUInt<15, 0, emboss_runtime::Null, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let len = (2) as usize;
        let storage = self.storage.slice_mut(0, len);
        emboss_runtime::BitUInt::<15, 0, emboss_runtime::Null, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }
    pub fn continuation_flag(&mut self) -> emboss_runtime::BitFlag<1, 15, emboss_runtime::Null, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let len = (2) as usize;
        let storage = self.storage.slice_mut(0, len);
        emboss_runtime::BitFlag::<1, 15, emboss_runtime::Null, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }

}

impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for L2capConfigureRsp_EmbossReservedAnonymousField1Mut<S> {
    type Writer = L2capConfigureRsp_EmbossReservedAnonymousField1Writer<S, emboss_runtime::UncheckedState>;
    fn into_writer(self) -> Self::Writer {
        L2capConfigureRsp_EmbossReservedAnonymousField1Writer::new(self.storage)
    }
}

pub struct L2capConfigureRsp_EmbossReservedAnonymousField1Writer<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::MutStorage> L2capConfigureRsp_EmbossReservedAnonymousField1Writer<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> L2capConfigureRsp_EmbossReservedAnonymousField1Writer<S, ST> {
    /**
     * Constructs a writer in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    /** Converts the writer into an immutable view in the same typestate. */
    pub fn into_view(self) -> L2capConfigureRsp_EmbossReservedAnonymousField1<S, ST> {
        unsafe { L2capConfigureRsp_EmbossReservedAnonymousField1::new_in_state(self.storage) }
    }
    /** Borrows the writer as an immutable view in the same typestate. */
    pub fn as_view(&self) -> L2capConfigureRsp_EmbossReservedAnonymousField1<S::Sliced<'_>, ST> {
        unsafe { L2capConfigureRsp_EmbossReservedAnonymousField1::new_in_state(self.storage.slice(0, self.storage.len())) }
    }

}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for L2capConfigureRsp_EmbossReservedAnonymousField1<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self;
        core::result::Result::Ok((((16) + 7) / 8) as usize)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::View for L2capConfigureRsp_EmbossReservedAnonymousField1Mut<S> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <L2capConfigureRsp_EmbossReservedAnonymousField1<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for L2capConfigureRsp_EmbossReservedAnonymousField1Writer<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <L2capConfigureRsp_EmbossReservedAnonymousField1<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for L2capConfigureRsp_EmbossReservedAnonymousField1<S, emboss_runtime::UncheckedState> {
    type Completed = L2capConfigureRsp_EmbossReservedAnonymousField1<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { L2capConfigureRsp_EmbossReservedAnonymousField1::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for L2capConfigureRsp_EmbossReservedAnonymousField1Writer<S, emboss_runtime::UncheckedState> {
    type Completed = L2capConfigureRsp_EmbossReservedAnonymousField1Writer<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { L2capConfigureRsp_EmbossReservedAnonymousField1Writer::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capConfigureRsp_EmbossReservedAnonymousField1<S, emboss_runtime::UncheckedState> {
    type Ok = L2capConfigureRsp_EmbossReservedAnonymousField1<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { L2capConfigureRsp_EmbossReservedAnonymousField1::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capConfigureRsp_EmbossReservedAnonymousField1<S, emboss_runtime::CompleteState> {
    type Ok = L2capConfigureRsp_EmbossReservedAnonymousField1<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { L2capConfigureRsp_EmbossReservedAnonymousField1::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capConfigureRsp_EmbossReservedAnonymousField1<S, emboss_runtime::OkState> {
    type Ok = L2capConfigureRsp_EmbossReservedAnonymousField1<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capConfigureRsp_EmbossReservedAnonymousField1Writer<S, emboss_runtime::UncheckedState> {
    type Ok = L2capConfigureRsp_EmbossReservedAnonymousField1Writer<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { L2capConfigureRsp_EmbossReservedAnonymousField1Writer::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capConfigureRsp_EmbossReservedAnonymousField1Writer<S, emboss_runtime::CompleteState> {
    type Ok = L2capConfigureRsp_EmbossReservedAnonymousField1Writer<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { L2capConfigureRsp_EmbossReservedAnonymousField1Writer::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capConfigureRsp_EmbossReservedAnonymousField1Writer<S, emboss_runtime::OkState> {
    type Ok = L2capConfigureRsp_EmbossReservedAnonymousField1Writer<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

pub mod l2cap_configure_rsp_emboss_reserved_anonymous_field1 {
    pub type View<S, ST = emboss_runtime::UncheckedState> = super::L2capConfigureRsp_EmbossReservedAnonymousField1<S, ST>;
    pub type ViewMut<S> = super::L2capConfigureRsp_EmbossReservedAnonymousField1Mut<S>;
    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::L2capConfigureRsp_EmbossReservedAnonymousField1Writer<S, ST>;

    pub const MIN_SIZE_IN_BYTES: usize = 2;
    pub const MAX_SIZE_IN_BYTES: usize = 2;
    pub const SIZE_IN_BYTES: usize = 2;
}pub struct L2capConfigureRsp<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::Storage> L2capConfigureRsp<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for L2capConfigureRsp<S, ST> {
    fn clone(&self) -> Self {
        Self {
            storage: self.storage.clone(),
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> L2capConfigureRsp<S, ST> {
    /**
     * Constructs a view in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    pub fn command_header(&self) -> L2capSignalingCommandHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (4) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        unsafe { L2capSignalingCommandHeader::<S::Sliced<'_>, emboss_runtime::UncheckedState>::new_in_state(storage) }
    }
    pub fn source_cid(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
    }
    pub fn emboss_reserved_anonymous_field_1(&self) -> L2capConfigureRsp_EmbossReservedAnonymousField1<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (6) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        unsafe { L2capConfigureRsp_EmbossReservedAnonymousField1::<S::Sliced<'_>, emboss_runtime::UncheckedState>::new_in_state(storage) }
    }
    pub fn rfu(&self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (({ let val = self.emboss_reserved_anonymous_field_1().rfu().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn continuation_flag(&self) -> emboss_runtime::VirtualField<bool> {
        let value = (|| -> core::result::Result<bool, emboss_runtime::Error> {
        core::result::Result::Ok( (({ let val = self.emboss_reserved_anonymous_field_1().continuation_flag().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn result(&self) -> emboss_runtime::EnumView<L2capConfigurationResult, emboss_runtime::UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (8) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        emboss_runtime::EnumView::new(emboss_runtime::UInt::new(storage))
    }

}

pub struct L2capConfigureRspMut<S: emboss_runtime::MutStorage> {
    storage: S,
}

impl<S: emboss_runtime::MutStorage> L2capConfigureRspMut<S> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
        }
    }
    pub fn into_writer(self) -> L2capConfigureRspWriter<S, emboss_runtime::UncheckedState> {
        L2capConfigureRspWriter::new(self.storage)
    }
    /** Borrows the mutable view as an immutable view in UncheckedState. */
    pub fn as_view(&self) -> L2capConfigureRsp<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        unsafe { L2capConfigureRsp::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn command_header(&mut self) -> L2capSignalingCommandHeaderMut<S::SlicedMut<'_>> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (4) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        L2capSignalingCommandHeaderMut::<S::SlicedMut<'_>>::new(storage)
    }
    pub fn source_cid(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }
    pub fn emboss_reserved_anonymous_field_1(&mut self) -> L2capConfigureRsp_EmbossReservedAnonymousField1Mut<S::SlicedMut<'_>> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (6) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        L2capConfigureRsp_EmbossReservedAnonymousField1Mut::<S::SlicedMut<'_>>::new(storage)
    }
    pub fn rfu(&mut self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (({ let val = self.emboss_reserved_anonymous_field_1().rfu().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn continuation_flag(&mut self) -> emboss_runtime::VirtualField<bool> {
        let value = (|| -> core::result::Result<bool, emboss_runtime::Error> {
        core::result::Result::Ok( (({ let val = self.emboss_reserved_anonymous_field_1().continuation_flag().try_read().map_err(|e| match e { emboss_runtime::Error::OutOfBounds => emboss_runtime::Error::OutOfBounds, emboss_runtime::Error::UnknownEnum(_) => emboss_runtime::Error::UnknownEnum(()) })?; val })
) )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn result(&mut self) -> emboss_runtime::EnumViewMut<L2capConfigurationResult, emboss_runtime::UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (8) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        emboss_runtime::EnumViewMut::new(emboss_runtime::UInt::new(storage))
    }

}

impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for L2capConfigureRspMut<S> {
    type Writer = L2capConfigureRspWriter<S, emboss_runtime::UncheckedState>;
    fn into_writer(self) -> Self::Writer {
        L2capConfigureRspWriter::new(self.storage)
    }
}

pub struct L2capConfigureRspWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::MutStorage> L2capConfigureRspWriter<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> L2capConfigureRspWriter<S, ST> {
    /**
     * Constructs a writer in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    /** Converts the writer into an immutable view in the same typestate. */
    pub fn into_view(self) -> L2capConfigureRsp<S, ST> {
        unsafe { L2capConfigureRsp::new_in_state(self.storage) }
    }
    /** Borrows the writer as an immutable view in the same typestate. */
    pub fn as_view(&self) -> L2capConfigureRsp<S::Sliced<'_>, ST> {
        unsafe { L2capConfigureRsp::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn write_source_cid(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> L2capConfigureRspWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { L2capConfigureRspWriter::new_in_state(storage) }
    }
    pub fn write_result(self, val: L2capConfigurationResult) -> L2capConfigureRspWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (8) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::EnumViewMut::<L2capConfigurationResult, emboss_runtime::UInt<16, emboss_runtime::LittleEndian, _>>::new(emboss_runtime::UInt::new(slice));
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { L2capConfigureRspWriter::new_in_state(storage) }
    }

}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for L2capConfigureRsp<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self;
        core::result::Result::Ok((0) as usize)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::View for L2capConfigureRspMut<S> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <L2capConfigureRsp<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for L2capConfigureRspWriter<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <L2capConfigureRsp<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for L2capConfigureRsp<S, emboss_runtime::UncheckedState> {
    type Completed = L2capConfigureRsp<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { L2capConfigureRsp::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for L2capConfigureRspWriter<S, emboss_runtime::UncheckedState> {
    type Completed = L2capConfigureRspWriter<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { L2capConfigureRspWriter::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capConfigureRsp<S, emboss_runtime::UncheckedState> {
    type Ok = L2capConfigureRsp<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { L2capConfigureRsp::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capConfigureRsp<S, emboss_runtime::CompleteState> {
    type Ok = L2capConfigureRsp<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { L2capConfigureRsp::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capConfigureRsp<S, emboss_runtime::OkState> {
    type Ok = L2capConfigureRsp<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capConfigureRspWriter<S, emboss_runtime::UncheckedState> {
    type Ok = L2capConfigureRspWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { L2capConfigureRspWriter::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capConfigureRspWriter<S, emboss_runtime::CompleteState> {
    type Ok = L2capConfigureRspWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { L2capConfigureRspWriter::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capConfigureRspWriter<S, emboss_runtime::OkState> {
    type Ok = L2capConfigureRspWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

pub mod l2cap_configure_rsp {
    pub type View<S, ST = emboss_runtime::UncheckedState> = super::L2capConfigureRsp<S, ST>;
    pub type ViewMut<S> = super::L2capConfigureRspMut<S>;
    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::L2capConfigureRspWriter<S, ST>;

    pub const MIN_SIZE_IN_BYTES: usize = 10;
    pub const MAX_SIZE_IN_BYTES: usize = 4294967295;
}pub struct L2capDisconnectionReq<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::Storage> L2capDisconnectionReq<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for L2capDisconnectionReq<S, ST> {
    fn clone(&self) -> Self {
        Self {
            storage: self.storage.clone(),
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> L2capDisconnectionReq<S, ST> {
    /**
     * Constructs a view in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    pub fn command_header(&self) -> L2capSignalingCommandHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (4) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        unsafe { L2capSignalingCommandHeader::<S::Sliced<'_>, emboss_runtime::UncheckedState>::new_in_state(storage) }
    }
    pub fn destination_cid(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
    }
    pub fn source_cid(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (6) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
    }

}

pub struct L2capDisconnectionReqMut<S: emboss_runtime::MutStorage> {
    storage: S,
}

impl<S: emboss_runtime::MutStorage> L2capDisconnectionReqMut<S> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
        }
    }
    pub fn into_writer(self) -> L2capDisconnectionReqWriter<S, emboss_runtime::UncheckedState> {
        L2capDisconnectionReqWriter::new(self.storage)
    }
    /** Borrows the mutable view as an immutable view in UncheckedState. */
    pub fn as_view(&self) -> L2capDisconnectionReq<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        unsafe { L2capDisconnectionReq::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn command_header(&mut self) -> L2capSignalingCommandHeaderMut<S::SlicedMut<'_>> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (4) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        L2capSignalingCommandHeaderMut::<S::SlicedMut<'_>>::new(storage)
    }
    pub fn destination_cid(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }
    pub fn source_cid(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (6) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }

}

impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for L2capDisconnectionReqMut<S> {
    type Writer = L2capDisconnectionReqWriter<S, emboss_runtime::UncheckedState>;
    fn into_writer(self) -> Self::Writer {
        L2capDisconnectionReqWriter::new(self.storage)
    }
}

pub struct L2capDisconnectionReqWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::MutStorage> L2capDisconnectionReqWriter<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> L2capDisconnectionReqWriter<S, ST> {
    /**
     * Constructs a writer in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    /** Converts the writer into an immutable view in the same typestate. */
    pub fn into_view(self) -> L2capDisconnectionReq<S, ST> {
        unsafe { L2capDisconnectionReq::new_in_state(self.storage) }
    }
    /** Borrows the writer as an immutable view in the same typestate. */
    pub fn as_view(&self) -> L2capDisconnectionReq<S::Sliced<'_>, ST> {
        unsafe { L2capDisconnectionReq::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn write_destination_cid(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> L2capDisconnectionReqWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { L2capDisconnectionReqWriter::new_in_state(storage) }
    }
    pub fn write_source_cid(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> L2capDisconnectionReqWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (6) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { L2capDisconnectionReqWriter::new_in_state(storage) }
    }

}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for L2capDisconnectionReq<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self;
        core::result::Result::Ok((8) as usize)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::View for L2capDisconnectionReqMut<S> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <L2capDisconnectionReq<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for L2capDisconnectionReqWriter<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <L2capDisconnectionReq<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for L2capDisconnectionReq<S, emboss_runtime::UncheckedState> {
    type Completed = L2capDisconnectionReq<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { L2capDisconnectionReq::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for L2capDisconnectionReqWriter<S, emboss_runtime::UncheckedState> {
    type Completed = L2capDisconnectionReqWriter<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { L2capDisconnectionReqWriter::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capDisconnectionReq<S, emboss_runtime::UncheckedState> {
    type Ok = L2capDisconnectionReq<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { L2capDisconnectionReq::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capDisconnectionReq<S, emboss_runtime::CompleteState> {
    type Ok = L2capDisconnectionReq<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { L2capDisconnectionReq::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capDisconnectionReq<S, emboss_runtime::OkState> {
    type Ok = L2capDisconnectionReq<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capDisconnectionReqWriter<S, emboss_runtime::UncheckedState> {
    type Ok = L2capDisconnectionReqWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { L2capDisconnectionReqWriter::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capDisconnectionReqWriter<S, emboss_runtime::CompleteState> {
    type Ok = L2capDisconnectionReqWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { L2capDisconnectionReqWriter::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capDisconnectionReqWriter<S, emboss_runtime::OkState> {
    type Ok = L2capDisconnectionReqWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

pub mod l2cap_disconnection_req {
    pub type View<S, ST = emboss_runtime::UncheckedState> = super::L2capDisconnectionReq<S, ST>;
    pub type ViewMut<S> = super::L2capDisconnectionReqMut<S>;
    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::L2capDisconnectionReqWriter<S, ST>;

    pub const MIN_SIZE_IN_BYTES: usize = 8;
    pub const MAX_SIZE_IN_BYTES: usize = 8;
    pub const SIZE_IN_BYTES: usize = 8;
}pub struct L2capDisconnectionRsp<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::Storage> L2capDisconnectionRsp<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for L2capDisconnectionRsp<S, ST> {
    fn clone(&self) -> Self {
        Self {
            storage: self.storage.clone(),
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> L2capDisconnectionRsp<S, ST> {
    /**
     * Constructs a view in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    pub fn command_header(&self) -> L2capSignalingCommandHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (4) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        unsafe { L2capSignalingCommandHeader::<S::Sliced<'_>, emboss_runtime::UncheckedState>::new_in_state(storage) }
    }
    pub fn destination_cid(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
    }
    pub fn source_cid(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (6) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
    }

}

pub struct L2capDisconnectionRspMut<S: emboss_runtime::MutStorage> {
    storage: S,
}

impl<S: emboss_runtime::MutStorage> L2capDisconnectionRspMut<S> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
        }
    }
    pub fn into_writer(self) -> L2capDisconnectionRspWriter<S, emboss_runtime::UncheckedState> {
        L2capDisconnectionRspWriter::new(self.storage)
    }
    /** Borrows the mutable view as an immutable view in UncheckedState. */
    pub fn as_view(&self) -> L2capDisconnectionRsp<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        unsafe { L2capDisconnectionRsp::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn command_header(&mut self) -> L2capSignalingCommandHeaderMut<S::SlicedMut<'_>> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (4) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        L2capSignalingCommandHeaderMut::<S::SlicedMut<'_>>::new(storage)
    }
    pub fn destination_cid(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }
    pub fn source_cid(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (6) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }

}

impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for L2capDisconnectionRspMut<S> {
    type Writer = L2capDisconnectionRspWriter<S, emboss_runtime::UncheckedState>;
    fn into_writer(self) -> Self::Writer {
        L2capDisconnectionRspWriter::new(self.storage)
    }
}

pub struct L2capDisconnectionRspWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::MutStorage> L2capDisconnectionRspWriter<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> L2capDisconnectionRspWriter<S, ST> {
    /**
     * Constructs a writer in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    /** Converts the writer into an immutable view in the same typestate. */
    pub fn into_view(self) -> L2capDisconnectionRsp<S, ST> {
        unsafe { L2capDisconnectionRsp::new_in_state(self.storage) }
    }
    /** Borrows the writer as an immutable view in the same typestate. */
    pub fn as_view(&self) -> L2capDisconnectionRsp<S::Sliced<'_>, ST> {
        unsafe { L2capDisconnectionRsp::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn write_destination_cid(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> L2capDisconnectionRspWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { L2capDisconnectionRspWriter::new_in_state(storage) }
    }
    pub fn write_source_cid(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> L2capDisconnectionRspWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (6) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { L2capDisconnectionRspWriter::new_in_state(storage) }
    }

}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for L2capDisconnectionRsp<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self;
        core::result::Result::Ok((8) as usize)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::View for L2capDisconnectionRspMut<S> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <L2capDisconnectionRsp<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for L2capDisconnectionRspWriter<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <L2capDisconnectionRsp<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for L2capDisconnectionRsp<S, emboss_runtime::UncheckedState> {
    type Completed = L2capDisconnectionRsp<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { L2capDisconnectionRsp::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for L2capDisconnectionRspWriter<S, emboss_runtime::UncheckedState> {
    type Completed = L2capDisconnectionRspWriter<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { L2capDisconnectionRspWriter::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capDisconnectionRsp<S, emboss_runtime::UncheckedState> {
    type Ok = L2capDisconnectionRsp<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { L2capDisconnectionRsp::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capDisconnectionRsp<S, emboss_runtime::CompleteState> {
    type Ok = L2capDisconnectionRsp<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { L2capDisconnectionRsp::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capDisconnectionRsp<S, emboss_runtime::OkState> {
    type Ok = L2capDisconnectionRsp<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capDisconnectionRspWriter<S, emboss_runtime::UncheckedState> {
    type Ok = L2capDisconnectionRspWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { L2capDisconnectionRspWriter::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capDisconnectionRspWriter<S, emboss_runtime::CompleteState> {
    type Ok = L2capDisconnectionRspWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { L2capDisconnectionRspWriter::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capDisconnectionRspWriter<S, emboss_runtime::OkState> {
    type Ok = L2capDisconnectionRspWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

pub mod l2cap_disconnection_rsp {
    pub type View<S, ST = emboss_runtime::UncheckedState> = super::L2capDisconnectionRsp<S, ST>;
    pub type ViewMut<S> = super::L2capDisconnectionRspMut<S>;
    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::L2capDisconnectionRspWriter<S, ST>;

    pub const MIN_SIZE_IN_BYTES: usize = 8;
    pub const MAX_SIZE_IN_BYTES: usize = 8;
    pub const SIZE_IN_BYTES: usize = 8;
}pub struct L2capLeCreditBasedConnectionReq<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::Storage> L2capLeCreditBasedConnectionReq<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for L2capLeCreditBasedConnectionReq<S, ST> {
    fn clone(&self) -> Self {
        Self {
            storage: self.storage.clone(),
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> L2capLeCreditBasedConnectionReq<S, ST> {
    /**
     * Constructs a view in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    pub fn command_header(&self) -> L2capSignalingCommandHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (4) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        unsafe { L2capSignalingCommandHeader::<S::Sliced<'_>, emboss_runtime::UncheckedState>::new_in_state(storage) }
    }
    pub fn spsm(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
    }
    pub fn source_cid(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (6) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
    }
    pub fn min_mtu(&self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (23) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn mtu(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (8) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
    }
    pub fn min_mps(&self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (23) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn max_mps(&self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (65533) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn mps(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (10) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
    }
    pub fn max_credit_value(&self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (65535) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn initial_credits(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (12) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
    }

}

pub struct L2capLeCreditBasedConnectionReqMut<S: emboss_runtime::MutStorage> {
    storage: S,
}

impl<S: emboss_runtime::MutStorage> L2capLeCreditBasedConnectionReqMut<S> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
        }
    }
    pub fn into_writer(self) -> L2capLeCreditBasedConnectionReqWriter<S, emboss_runtime::UncheckedState> {
        L2capLeCreditBasedConnectionReqWriter::new(self.storage)
    }
    /** Borrows the mutable view as an immutable view in UncheckedState. */
    pub fn as_view(&self) -> L2capLeCreditBasedConnectionReq<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        unsafe { L2capLeCreditBasedConnectionReq::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn command_header(&mut self) -> L2capSignalingCommandHeaderMut<S::SlicedMut<'_>> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (4) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        L2capSignalingCommandHeaderMut::<S::SlicedMut<'_>>::new(storage)
    }
    pub fn spsm(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }
    pub fn source_cid(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (6) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }
    pub fn min_mtu(&mut self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (23) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn mtu(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (8) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }
    pub fn min_mps(&mut self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (23) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn max_mps(&mut self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (65533) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn mps(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (10) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }
    pub fn max_credit_value(&mut self) -> emboss_runtime::VirtualField<u64> {
        let value = (|| -> core::result::Result<u64, emboss_runtime::Error> {
        core::result::Result::Ok( (65535) as u64 )
    })();
        emboss_runtime::VirtualField::new(value)
    }
    pub fn initial_credits(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (12) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }

}

impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for L2capLeCreditBasedConnectionReqMut<S> {
    type Writer = L2capLeCreditBasedConnectionReqWriter<S, emboss_runtime::UncheckedState>;
    fn into_writer(self) -> Self::Writer {
        L2capLeCreditBasedConnectionReqWriter::new(self.storage)
    }
}

pub struct L2capLeCreditBasedConnectionReqWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::MutStorage> L2capLeCreditBasedConnectionReqWriter<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> L2capLeCreditBasedConnectionReqWriter<S, ST> {
    /**
     * Constructs a writer in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    /** Converts the writer into an immutable view in the same typestate. */
    pub fn into_view(self) -> L2capLeCreditBasedConnectionReq<S, ST> {
        unsafe { L2capLeCreditBasedConnectionReq::new_in_state(self.storage) }
    }
    /** Borrows the writer as an immutable view in the same typestate. */
    pub fn as_view(&self) -> L2capLeCreditBasedConnectionReq<S::Sliced<'_>, ST> {
        unsafe { L2capLeCreditBasedConnectionReq::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn write_spsm(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> L2capLeCreditBasedConnectionReqWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { L2capLeCreditBasedConnectionReqWriter::new_in_state(storage) }
    }
    pub fn write_source_cid(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> L2capLeCreditBasedConnectionReqWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (6) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { L2capLeCreditBasedConnectionReqWriter::new_in_state(storage) }
    }
    pub fn write_mtu(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> L2capLeCreditBasedConnectionReqWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (8) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { L2capLeCreditBasedConnectionReqWriter::new_in_state(storage) }
    }
    pub fn write_mps(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> L2capLeCreditBasedConnectionReqWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (10) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { L2capLeCreditBasedConnectionReqWriter::new_in_state(storage) }
    }
    pub fn write_initial_credits(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> L2capLeCreditBasedConnectionReqWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (12) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { L2capLeCreditBasedConnectionReqWriter::new_in_state(storage) }
    }

}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for L2capLeCreditBasedConnectionReq<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self;
        core::result::Result::Ok((14) as usize)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::View for L2capLeCreditBasedConnectionReqMut<S> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <L2capLeCreditBasedConnectionReq<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for L2capLeCreditBasedConnectionReqWriter<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <L2capLeCreditBasedConnectionReq<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for L2capLeCreditBasedConnectionReq<S, emboss_runtime::UncheckedState> {
    type Completed = L2capLeCreditBasedConnectionReq<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { L2capLeCreditBasedConnectionReq::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for L2capLeCreditBasedConnectionReqWriter<S, emboss_runtime::UncheckedState> {
    type Completed = L2capLeCreditBasedConnectionReqWriter<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { L2capLeCreditBasedConnectionReqWriter::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capLeCreditBasedConnectionReq<S, emboss_runtime::UncheckedState> {
    type Ok = L2capLeCreditBasedConnectionReq<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { L2capLeCreditBasedConnectionReq::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capLeCreditBasedConnectionReq<S, emboss_runtime::CompleteState> {
    type Ok = L2capLeCreditBasedConnectionReq<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { L2capLeCreditBasedConnectionReq::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capLeCreditBasedConnectionReq<S, emboss_runtime::OkState> {
    type Ok = L2capLeCreditBasedConnectionReq<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capLeCreditBasedConnectionReqWriter<S, emboss_runtime::UncheckedState> {
    type Ok = L2capLeCreditBasedConnectionReqWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { L2capLeCreditBasedConnectionReqWriter::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capLeCreditBasedConnectionReqWriter<S, emboss_runtime::CompleteState> {
    type Ok = L2capLeCreditBasedConnectionReqWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { L2capLeCreditBasedConnectionReqWriter::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capLeCreditBasedConnectionReqWriter<S, emboss_runtime::OkState> {
    type Ok = L2capLeCreditBasedConnectionReqWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

pub mod l2cap_le_credit_based_connection_req {
    pub type View<S, ST = emboss_runtime::UncheckedState> = super::L2capLeCreditBasedConnectionReq<S, ST>;
    pub type ViewMut<S> = super::L2capLeCreditBasedConnectionReqMut<S>;
    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::L2capLeCreditBasedConnectionReqWriter<S, ST>;

    pub const MIN_SIZE_IN_BYTES: usize = 14;
    pub const MAX_SIZE_IN_BYTES: usize = 14;
    pub const SIZE_IN_BYTES: usize = 14;
}pub struct L2capFlowControlCreditInd<S: emboss_runtime::Storage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::Storage> L2capFlowControlCreditInd<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage + core::clone::Clone, ST: emboss_runtime::State> core::clone::Clone for L2capFlowControlCreditInd<S, ST> {
    fn clone(&self) -> Self {
        Self {
            storage: self.storage.clone(),
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> L2capFlowControlCreditInd<S, ST> {
    /**
     * Constructs a view in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    pub fn command_header(&self) -> L2capSignalingCommandHeader<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (4) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        unsafe { L2capSignalingCommandHeader::<S::Sliced<'_>, emboss_runtime::UncheckedState>::new_in_state(storage) }
    }
    pub fn cid(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
    }
    pub fn credits(&self) -> UInt<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (6) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::Sliced<'_>, ST>::new(storage)
    }

}

pub struct L2capFlowControlCreditIndMut<S: emboss_runtime::MutStorage> {
    storage: S,
}

impl<S: emboss_runtime::MutStorage> L2capFlowControlCreditIndMut<S> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
        }
    }
    pub fn into_writer(self) -> L2capFlowControlCreditIndWriter<S, emboss_runtime::UncheckedState> {
        L2capFlowControlCreditIndWriter::new(self.storage)
    }
    /** Borrows the mutable view as an immutable view in UncheckedState. */
    pub fn as_view(&self) -> L2capFlowControlCreditInd<S::Sliced<'_>, emboss_runtime::UncheckedState> {
        unsafe { L2capFlowControlCreditInd::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn command_header(&mut self) -> L2capSignalingCommandHeaderMut<S::SlicedMut<'_>> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (0) as usize;
            let len = (4) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        L2capSignalingCommandHeaderMut::<S::SlicedMut<'_>>::new(storage)
    }
    pub fn cid(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }
    pub fn credits(&mut self) -> UInt<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState> {
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (6) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().unwrap_or((usize::MAX, 0));
        let storage = self.storage.slice_mut(offset, len);
        UInt::<16, emboss_runtime::LittleEndian, S::SlicedMut<'_>, emboss_runtime::UncheckedState>::new(storage)
    }

}

impl<S: emboss_runtime::MutStorage> emboss_runtime::IntoWriter for L2capFlowControlCreditIndMut<S> {
    type Writer = L2capFlowControlCreditIndWriter<S, emboss_runtime::UncheckedState>;
    fn into_writer(self) -> Self::Writer {
        L2capFlowControlCreditIndWriter::new(self.storage)
    }
}

pub struct L2capFlowControlCreditIndWriter<S: emboss_runtime::MutStorage, ST: emboss_runtime::State = emboss_runtime::UncheckedState> {
    storage: S,
    _marker: core::marker::PhantomData<ST>,
}

impl<S: emboss_runtime::MutStorage> L2capFlowControlCreditIndWriter<S, emboss_runtime::UncheckedState> {
    pub fn new(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> L2capFlowControlCreditIndWriter<S, ST> {
    /**
     * Constructs a writer in a specific typestate.
     *
     * # Safety
     *
     * The caller must ensure that `storage` satisfies the layout invariants for `ST`.
     */
    pub unsafe fn new_in_state(storage: S) -> Self {
        Self {
            storage,
            _marker: core::marker::PhantomData,
        }
    }
    pub fn into_storage(self) -> S {
        self.storage
    }
    /** Converts the writer into an immutable view in the same typestate. */
    pub fn into_view(self) -> L2capFlowControlCreditInd<S, ST> {
        unsafe { L2capFlowControlCreditInd::new_in_state(self.storage) }
    }
    /** Borrows the writer as an immutable view in the same typestate. */
    pub fn as_view(&self) -> L2capFlowControlCreditInd<S::Sliced<'_>, ST> {
        unsafe { L2capFlowControlCreditInd::new_in_state(self.storage.slice(0, self.storage.len())) }
    }
    pub fn write_cid(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> L2capFlowControlCreditIndWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (4) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { L2capFlowControlCreditIndWriter::new_in_state(storage) }
    }
    pub fn write_credits(self, val: <emboss_runtime::SizeSelector<16> as emboss_runtime::SmallestUInt>::T) -> L2capFlowControlCreditIndWriter<S, ST::OnValidMutation> {
        let view = self.into_view();
        let (offset, len) = (|| -> core::result::Result<(usize, usize), emboss_runtime::Error> {
            let offset = (6) as usize;
            let len = (2) as usize;
            core::result::Result::Ok((offset, len))
        })().expect("valid layout in complete state");
        let mut storage = view.into_storage();
        {
            let slice = storage.slice_mut(offset, len);
            let mut field_view = emboss_runtime::UInt::<16, emboss_runtime::LittleEndian, _>::new(slice);
            field_view.try_write(val).expect("valid write in complete state");
        }
        unsafe { L2capFlowControlCreditIndWriter::new_in_state(storage) }
    }

}

impl<S: emboss_runtime::Storage, ST: emboss_runtime::State> emboss_runtime::View for L2capFlowControlCreditInd<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self;
        core::result::Result::Ok((8) as usize)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::View for L2capFlowControlCreditIndMut<S> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <L2capFlowControlCreditInd<S::Sliced<'_>, emboss_runtime::UncheckedState> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::MutStorage, ST: emboss_runtime::State> emboss_runtime::View for L2capFlowControlCreditIndWriter<S, ST> {
    fn size_in_bytes(&self) -> core::result::Result<usize, emboss_runtime::Error> {
        let view = self.as_view();
        <L2capFlowControlCreditInd<S::Sliced<'_>, ST> as emboss_runtime::View>::size_in_bytes(&view)
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckComplete for L2capFlowControlCreditInd<S, emboss_runtime::UncheckedState> {
    type Completed = L2capFlowControlCreditInd<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { L2capFlowControlCreditInd::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckComplete for L2capFlowControlCreditIndWriter<S, emboss_runtime::UncheckedState> {
    type Completed = L2capFlowControlCreditIndWriter<S, emboss_runtime::CompleteState>;
    fn check_complete(self) -> core::result::Result<Self::Completed, emboss_runtime::Error> {
        let required_size = <Self as emboss_runtime::View>::size_in_bytes(&self)?;
        if self.storage.len() < required_size {
            return core::result::Result::Err(emboss_runtime::Error::OutOfBounds);
        }
        core::result::Result::Ok(unsafe { L2capFlowControlCreditIndWriter::new_in_state(self.storage) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capFlowControlCreditInd<S, emboss_runtime::UncheckedState> {
    type Ok = L2capFlowControlCreditInd<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { L2capFlowControlCreditInd::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capFlowControlCreditInd<S, emboss_runtime::CompleteState> {
    type Ok = L2capFlowControlCreditInd<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { L2capFlowControlCreditInd::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::Storage> emboss_runtime::CheckOk for L2capFlowControlCreditInd<S, emboss_runtime::OkState> {
    type Ok = L2capFlowControlCreditInd<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capFlowControlCreditIndWriter<S, emboss_runtime::UncheckedState> {
    type Ok = L2capFlowControlCreditIndWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        let completed = emboss_runtime::CheckComplete::check_complete(self)?;
        core::result::Result::Ok(unsafe { L2capFlowControlCreditIndWriter::new_in_state(completed.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capFlowControlCreditIndWriter<S, emboss_runtime::CompleteState> {
    type Ok = L2capFlowControlCreditIndWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(unsafe { L2capFlowControlCreditIndWriter::new_in_state(self.into_storage()) })
    }
}

impl<S: emboss_runtime::MutStorage> emboss_runtime::CheckOk for L2capFlowControlCreditIndWriter<S, emboss_runtime::OkState> {
    type Ok = L2capFlowControlCreditIndWriter<S, emboss_runtime::OkState>;
    fn check_ok(self) -> core::result::Result<Self::Ok, emboss_runtime::Error> {
        core::result::Result::Ok(self)
    }
}

pub mod l2cap_flow_control_credit_ind {
    pub type View<S, ST = emboss_runtime::UncheckedState> = super::L2capFlowControlCreditInd<S, ST>;
    pub type ViewMut<S> = super::L2capFlowControlCreditIndMut<S>;
    pub type Writer<S, ST = emboss_runtime::UncheckedState> = super::L2capFlowControlCreditIndWriter<S, ST>;

    pub const MIN_SIZE_IN_BYTES: usize = 8;
    pub const MAX_SIZE_IN_BYTES: usize = 8;
    pub const SIZE_IN_BYTES: usize = 8;
}