std_modrpc/

proto.rs

use core::convert::TryFrom;
use mproto::{
    BaseLen, Compatible, Decode, DecodeCursor, DecodeError, DecodeResult, Encode, EncodeCursor,
    Lazy, Owned,
};

#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash)]
pub struct PropertyUpdate<T> {
    pub new_value: T,
}

pub struct PropertyUpdateLazy<'a, T> {
    buffer: &'a [u8],
    offset: usize,
    _t: core::marker::PhantomData<T>,
}

pub struct PropertyUpdateGen<NewValue: Encode> {
    pub new_value: NewValue,
}

impl<T: Owned, NewValue: Encode + Compatible<T>> Compatible<PropertyUpdate<T>>
    for PropertyUpdateGen<NewValue>
{
}
impl<T: Owned, NewValue: Encode + Compatible<T>> Compatible<PropertyUpdateGen<NewValue>>
    for PropertyUpdate<T>
{
}

impl<NewValue: Encode> BaseLen for PropertyUpdateGen<NewValue> {
    const BASE_LEN: usize = NewValue::BASE_LEN;
}

impl<NewValue: Encode> Encode for PropertyUpdateGen<NewValue> {
    fn scratch_len(&self) -> usize {
        self.new_value.scratch_len()
    }

    fn encode(&self, cursor: &mut EncodeCursor) {
        self.new_value.encode(cursor);
    }
}

impl<T: Owned> Owned for PropertyUpdate<T> {
    type Lazy<'a> = PropertyUpdateLazy<'a, T>;

    fn lazy_to_owned(lazy: Self::Lazy<'_>) -> DecodeResult<Self> {
        TryFrom::try_from(lazy)
    }
}

impl<'a, T: Owned> Lazy<'a> for PropertyUpdateLazy<'a, T> {
    type Owned = PropertyUpdate<T>;
}

impl<'a, T: Owned> Compatible<PropertyUpdateLazy<'a, T>> for PropertyUpdateLazy<'a, T> {}
impl<'a, T: Owned> Compatible<PropertyUpdateLazy<'a, T>> for PropertyUpdate<T> {}
impl<T: Owned> Compatible<PropertyUpdate<T>> for PropertyUpdate<T> {}
impl<'a, T: Owned> Compatible<PropertyUpdate<T>> for PropertyUpdateLazy<'a, T> {}

impl<'a, T: Owned> PropertyUpdateLazy<'a, T> {
    pub fn new_value(&self) -> DecodeResult<T::Lazy<'a>> {
        Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 0))
    }
}

impl<T: BaseLen> BaseLen for PropertyUpdate<T> {
    const BASE_LEN: usize = T::BASE_LEN;
}

impl<T: Encode> Encode for PropertyUpdate<T> {
    fn scratch_len(&self) -> usize {
        self.new_value.scratch_len()
    }

    fn encode(&self, cursor: &mut EncodeCursor) {
        self.new_value.encode(cursor);
    }
}

impl<'a, T: Decode<'a>> Decode<'a> for PropertyUpdate<T> {
    fn decode(cursor: &DecodeCursor<'a>) -> DecodeResult<Self> {
        let new_value = Decode::decode(cursor)?;

        Ok(PropertyUpdate { new_value })
    }
}

impl<'a, T: Owned> BaseLen for PropertyUpdateLazy<'a, T> {
    const BASE_LEN: usize = T::BASE_LEN;
}

impl<'a, T: Owned> Encode for PropertyUpdateLazy<'a, T> {
    fn scratch_len(&self) -> usize {
        let new_value: T::Lazy<'a> =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 0)).unwrap();
        new_value.scratch_len()
    }

    fn encode(&self, cursor: &mut EncodeCursor) {
        let new_value: T::Lazy<'a> =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 0)).unwrap();
        new_value.encode(cursor);
    }
}

impl<'a, T: Owned> Decode<'a> for PropertyUpdateLazy<'a, T> {
    fn decode(cursor: &DecodeCursor<'a>) -> DecodeResult<Self> {
        let offset = cursor.offset();
        cursor.advance(Self::BASE_LEN);
        Ok(PropertyUpdateLazy {
            buffer: cursor.buffer(),
            offset,
            _t: core::marker::PhantomData,
        })
    }
}

impl<'a, T: Owned> TryFrom<PropertyUpdateLazy<'a, T>> for PropertyUpdate<T> {
    type Error = DecodeError;

    fn try_from(other: PropertyUpdateLazy<'a, T>) -> Result<Self, Self::Error> {
        let cursor = DecodeCursor::at_offset(other.buffer, other.offset);
        Decode::decode(&cursor)
    }
}

impl<'a, T> Copy for PropertyUpdateLazy<'a, T> {}

impl<'a, T> Clone for PropertyUpdateLazy<'a, T> {
    fn clone(&self) -> Self {
        Self {
            buffer: self.buffer,
            offset: self.offset,
            _t: core::marker::PhantomData,
        }
    }
}

impl<'a, T> core::fmt::Debug for PropertyUpdateLazy<'a, T> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("PropertyUpdateLazy").finish()
    }
}

impl<'a, T: Owned> PartialEq for PropertyUpdateLazy<'a, T> {
    fn eq(&self, other: &Self) -> bool {
        self.new_value().unwrap() == other.new_value().unwrap()
    }
}

#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash)]
pub struct Request<T> {
    pub request_id: u32,
    pub worker: u16,
    pub payload: T,
}

pub struct RequestLazy<'a, T> {
    buffer: &'a [u8],
    offset: usize,
    _t: core::marker::PhantomData<T>,
}

pub struct RequestGen<Payload: Encode> {
    pub request_id: u32,
    pub worker: u16,
    pub payload: Payload,
}

impl<T: Owned, Payload: Encode + Compatible<T>> Compatible<Request<T>> for RequestGen<Payload> {}
impl<T: Owned, Payload: Encode + Compatible<T>> Compatible<RequestGen<Payload>> for Request<T> {}

impl<Payload: Encode> BaseLen for RequestGen<Payload> {
    const BASE_LEN: usize = 6 + Payload::BASE_LEN;
}

impl<Payload: Encode> Encode for RequestGen<Payload> {
    fn scratch_len(&self) -> usize {
        self.request_id.scratch_len() + self.worker.scratch_len() + self.payload.scratch_len()
    }

    fn encode(&self, cursor: &mut EncodeCursor) {
        self.request_id.encode(cursor);
        self.worker.encode(cursor);
        self.payload.encode(cursor);
    }
}

impl<T: Owned> Owned for Request<T> {
    type Lazy<'a> = RequestLazy<'a, T>;

    fn lazy_to_owned(lazy: Self::Lazy<'_>) -> DecodeResult<Self> {
        TryFrom::try_from(lazy)
    }
}

impl<'a, T: Owned> Lazy<'a> for RequestLazy<'a, T> {
    type Owned = Request<T>;
}

impl<'a, T: Owned> Compatible<RequestLazy<'a, T>> for RequestLazy<'a, T> {}
impl<'a, T: Owned> Compatible<RequestLazy<'a, T>> for Request<T> {}
impl<T: Owned> Compatible<Request<T>> for Request<T> {}
impl<'a, T: Owned> Compatible<Request<T>> for RequestLazy<'a, T> {}

impl<'a, T: Owned> RequestLazy<'a, T> {
    pub fn request_id(&self) -> DecodeResult<u32> {
        Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 0))
    }

    pub fn worker(&self) -> DecodeResult<u16> {
        Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 4))
    }

    pub fn payload(&self) -> DecodeResult<T::Lazy<'a>> {
        Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 6))
    }
}

impl<T: BaseLen> BaseLen for Request<T> {
    const BASE_LEN: usize = 6 + T::BASE_LEN;
}

impl<T: Encode> Encode for Request<T> {
    fn scratch_len(&self) -> usize {
        self.request_id.scratch_len() + self.worker.scratch_len() + self.payload.scratch_len()
    }

    fn encode(&self, cursor: &mut EncodeCursor) {
        self.request_id.encode(cursor);
        self.worker.encode(cursor);
        self.payload.encode(cursor);
    }
}

impl<'a, T: Decode<'a>> Decode<'a> for Request<T> {
    fn decode(cursor: &DecodeCursor<'a>) -> DecodeResult<Self> {
        let request_id = Decode::decode(cursor)?;
        let worker = Decode::decode(cursor)?;
        let payload = Decode::decode(cursor)?;

        Ok(Request {
            request_id,
            worker,
            payload,
        })
    }
}

impl<'a, T: Owned> BaseLen for RequestLazy<'a, T> {
    const BASE_LEN: usize = 6 + T::BASE_LEN;
}

impl<'a, T: Owned> Encode for RequestLazy<'a, T> {
    fn scratch_len(&self) -> usize {
        let request_id: u32 =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 0)).unwrap();
        let worker: u16 =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 4)).unwrap();
        let payload: T::Lazy<'a> =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 6)).unwrap();
        request_id.scratch_len() + worker.scratch_len() + payload.scratch_len()
    }

    fn encode(&self, cursor: &mut EncodeCursor) {
        let request_id: u32 =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 0)).unwrap();
        let worker: u16 =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 4)).unwrap();
        let payload: T::Lazy<'a> =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 6)).unwrap();
        request_id.encode(cursor);
        worker.encode(cursor);
        payload.encode(cursor);
    }
}

impl<'a, T: Owned> Decode<'a> for RequestLazy<'a, T> {
    fn decode(cursor: &DecodeCursor<'a>) -> DecodeResult<Self> {
        let offset = cursor.offset();
        cursor.advance(Self::BASE_LEN);
        Ok(RequestLazy {
            buffer: cursor.buffer(),
            offset,
            _t: core::marker::PhantomData,
        })
    }
}

impl<'a, T: Owned> TryFrom<RequestLazy<'a, T>> for Request<T> {
    type Error = DecodeError;

    fn try_from(other: RequestLazy<'a, T>) -> Result<Self, Self::Error> {
        let cursor = DecodeCursor::at_offset(other.buffer, other.offset);
        Decode::decode(&cursor)
    }
}

impl<'a, T> Copy for RequestLazy<'a, T> {}

impl<'a, T> Clone for RequestLazy<'a, T> {
    fn clone(&self) -> Self {
        Self {
            buffer: self.buffer,
            offset: self.offset,
            _t: core::marker::PhantomData,
        }
    }
}

impl<'a, T> core::fmt::Debug for RequestLazy<'a, T> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("RequestLazy").finish()
    }
}

impl<'a, T: Owned> PartialEq for RequestLazy<'a, T> {
    fn eq(&self, other: &Self) -> bool {
        self.request_id().unwrap() == other.request_id().unwrap()
            && self.worker().unwrap() == other.worker().unwrap()
            && self.payload().unwrap() == other.payload().unwrap()
    }
}

#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash)]
pub struct Response<T> {
    pub request_id: u32,
    pub requester: u64,
    pub requester_worker: u16,
    pub payload: T,
}

pub struct ResponseLazy<'a, T> {
    buffer: &'a [u8],
    offset: usize,
    _t: core::marker::PhantomData<T>,
}

pub struct ResponseGen<Payload: Encode> {
    pub request_id: u32,
    pub requester: u64,
    pub requester_worker: u16,
    pub payload: Payload,
}

impl<T: Owned, Payload: Encode + Compatible<T>> Compatible<Response<T>> for ResponseGen<Payload> {}
impl<T: Owned, Payload: Encode + Compatible<T>> Compatible<ResponseGen<Payload>> for Response<T> {}

impl<Payload: Encode> BaseLen for ResponseGen<Payload> {
    const BASE_LEN: usize = 14 + Payload::BASE_LEN;
}

impl<Payload: Encode> Encode for ResponseGen<Payload> {
    fn scratch_len(&self) -> usize {
        self.request_id.scratch_len()
            + self.requester.scratch_len()
            + self.requester_worker.scratch_len()
            + self.payload.scratch_len()
    }

    fn encode(&self, cursor: &mut EncodeCursor) {
        self.request_id.encode(cursor);
        self.requester.encode(cursor);
        self.requester_worker.encode(cursor);
        self.payload.encode(cursor);
    }
}

impl<T: Owned> Owned for Response<T> {
    type Lazy<'a> = ResponseLazy<'a, T>;

    fn lazy_to_owned(lazy: Self::Lazy<'_>) -> DecodeResult<Self> {
        TryFrom::try_from(lazy)
    }
}

impl<'a, T: Owned> Lazy<'a> for ResponseLazy<'a, T> {
    type Owned = Response<T>;
}

impl<'a, T: Owned> Compatible<ResponseLazy<'a, T>> for ResponseLazy<'a, T> {}
impl<'a, T: Owned> Compatible<ResponseLazy<'a, T>> for Response<T> {}
impl<T: Owned> Compatible<Response<T>> for Response<T> {}
impl<'a, T: Owned> Compatible<Response<T>> for ResponseLazy<'a, T> {}

impl<'a, T: Owned> ResponseLazy<'a, T> {
    pub fn request_id(&self) -> DecodeResult<u32> {
        Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 0))
    }

    pub fn requester(&self) -> DecodeResult<u64> {
        Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 4))
    }

    pub fn requester_worker(&self) -> DecodeResult<u16> {
        Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 12))
    }

    pub fn payload(&self) -> DecodeResult<T::Lazy<'a>> {
        Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 14))
    }
}

impl<T: BaseLen> BaseLen for Response<T> {
    const BASE_LEN: usize = 14 + T::BASE_LEN;
}

impl<T: Encode> Encode for Response<T> {
    fn scratch_len(&self) -> usize {
        self.request_id.scratch_len()
            + self.requester.scratch_len()
            + self.requester_worker.scratch_len()
            + self.payload.scratch_len()
    }

    fn encode(&self, cursor: &mut EncodeCursor) {
        self.request_id.encode(cursor);
        self.requester.encode(cursor);
        self.requester_worker.encode(cursor);
        self.payload.encode(cursor);
    }
}

impl<'a, T: Decode<'a>> Decode<'a> for Response<T> {
    fn decode(cursor: &DecodeCursor<'a>) -> DecodeResult<Self> {
        let request_id = Decode::decode(cursor)?;
        let requester = Decode::decode(cursor)?;
        let requester_worker = Decode::decode(cursor)?;
        let payload = Decode::decode(cursor)?;

        Ok(Response {
            request_id,
            requester,
            requester_worker,
            payload,
        })
    }
}

impl<'a, T: Owned> BaseLen for ResponseLazy<'a, T> {
    const BASE_LEN: usize = 14 + T::BASE_LEN;
}

impl<'a, T: Owned> Encode for ResponseLazy<'a, T> {
    fn scratch_len(&self) -> usize {
        let request_id: u32 =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 0)).unwrap();
        let requester: u64 =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 4)).unwrap();
        let requester_worker: u16 =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 12)).unwrap();
        let payload: T::Lazy<'a> =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 14)).unwrap();
        request_id.scratch_len()
            + requester.scratch_len()
            + requester_worker.scratch_len()
            + payload.scratch_len()
    }

    fn encode(&self, cursor: &mut EncodeCursor) {
        let request_id: u32 =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 0)).unwrap();
        let requester: u64 =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 4)).unwrap();
        let requester_worker: u16 =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 12)).unwrap();
        let payload: T::Lazy<'a> =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 14)).unwrap();
        request_id.encode(cursor);
        requester.encode(cursor);
        requester_worker.encode(cursor);
        payload.encode(cursor);
    }
}

impl<'a, T: Owned> Decode<'a> for ResponseLazy<'a, T> {
    fn decode(cursor: &DecodeCursor<'a>) -> DecodeResult<Self> {
        let offset = cursor.offset();
        cursor.advance(Self::BASE_LEN);
        Ok(ResponseLazy {
            buffer: cursor.buffer(),
            offset,
            _t: core::marker::PhantomData,
        })
    }
}

impl<'a, T: Owned> TryFrom<ResponseLazy<'a, T>> for Response<T> {
    type Error = DecodeError;

    fn try_from(other: ResponseLazy<'a, T>) -> Result<Self, Self::Error> {
        let cursor = DecodeCursor::at_offset(other.buffer, other.offset);
        Decode::decode(&cursor)
    }
}

impl<'a, T> Copy for ResponseLazy<'a, T> {}

impl<'a, T> Clone for ResponseLazy<'a, T> {
    fn clone(&self) -> Self {
        Self {
            buffer: self.buffer,
            offset: self.offset,
            _t: core::marker::PhantomData,
        }
    }
}

impl<'a, T> core::fmt::Debug for ResponseLazy<'a, T> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("ResponseLazy").finish()
    }
}

impl<'a, T: Owned> PartialEq for ResponseLazy<'a, T> {
    fn eq(&self, other: &Self) -> bool {
        self.request_id().unwrap() == other.request_id().unwrap()
            && self.requester().unwrap() == other.requester().unwrap()
            && self.requester_worker().unwrap() == other.requester_worker().unwrap()
            && self.payload().unwrap() == other.payload().unwrap()
    }
}

#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash)]
pub struct StreamItem<T> {
    pub seq: u64,
    pub payload: T,
}

pub struct StreamItemLazy<'a, T> {
    buffer: &'a [u8],
    offset: usize,
    _t: core::marker::PhantomData<T>,
}

pub struct StreamItemGen<Payload: Encode> {
    pub seq: u64,
    pub payload: Payload,
}

impl<T: Owned, Payload: Encode + Compatible<T>> Compatible<StreamItem<T>>
    for StreamItemGen<Payload>
{
}
impl<T: Owned, Payload: Encode + Compatible<T>> Compatible<StreamItemGen<Payload>>
    for StreamItem<T>
{
}

impl<Payload: Encode> BaseLen for StreamItemGen<Payload> {
    const BASE_LEN: usize = 8 + Payload::BASE_LEN;
}

impl<Payload: Encode> Encode for StreamItemGen<Payload> {
    fn scratch_len(&self) -> usize {
        self.seq.scratch_len() + self.payload.scratch_len()
    }

    fn encode(&self, cursor: &mut EncodeCursor) {
        self.seq.encode(cursor);
        self.payload.encode(cursor);
    }
}

impl<T: Owned> Owned for StreamItem<T> {
    type Lazy<'a> = StreamItemLazy<'a, T>;

    fn lazy_to_owned(lazy: Self::Lazy<'_>) -> DecodeResult<Self> {
        TryFrom::try_from(lazy)
    }
}

impl<'a, T: Owned> Lazy<'a> for StreamItemLazy<'a, T> {
    type Owned = StreamItem<T>;
}

impl<'a, T: Owned> Compatible<StreamItemLazy<'a, T>> for StreamItemLazy<'a, T> {}
impl<'a, T: Owned> Compatible<StreamItemLazy<'a, T>> for StreamItem<T> {}
impl<T: Owned> Compatible<StreamItem<T>> for StreamItem<T> {}
impl<'a, T: Owned> Compatible<StreamItem<T>> for StreamItemLazy<'a, T> {}

impl<'a, T: Owned> StreamItemLazy<'a, T> {
    pub fn seq(&self) -> DecodeResult<u64> {
        Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 0))
    }

    pub fn payload(&self) -> DecodeResult<T::Lazy<'a>> {
        Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 8))
    }
}

impl<T: BaseLen> BaseLen for StreamItem<T> {
    const BASE_LEN: usize = 8 + T::BASE_LEN;
}

impl<T: Encode> Encode for StreamItem<T> {
    fn scratch_len(&self) -> usize {
        self.seq.scratch_len() + self.payload.scratch_len()
    }

    fn encode(&self, cursor: &mut EncodeCursor) {
        self.seq.encode(cursor);
        self.payload.encode(cursor);
    }
}

impl<'a, T: Decode<'a>> Decode<'a> for StreamItem<T> {
    fn decode(cursor: &DecodeCursor<'a>) -> DecodeResult<Self> {
        let seq = Decode::decode(cursor)?;
        let payload = Decode::decode(cursor)?;

        Ok(StreamItem { seq, payload })
    }
}

impl<'a, T: Owned> BaseLen for StreamItemLazy<'a, T> {
    const BASE_LEN: usize = 8 + T::BASE_LEN;
}

impl<'a, T: Owned> Encode for StreamItemLazy<'a, T> {
    fn scratch_len(&self) -> usize {
        let seq: u64 =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 0)).unwrap();
        let payload: T::Lazy<'a> =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 8)).unwrap();
        seq.scratch_len() + payload.scratch_len()
    }

    fn encode(&self, cursor: &mut EncodeCursor) {
        let seq: u64 =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 0)).unwrap();
        let payload: T::Lazy<'a> =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 8)).unwrap();
        seq.encode(cursor);
        payload.encode(cursor);
    }
}

impl<'a, T: Owned> Decode<'a> for StreamItemLazy<'a, T> {
    fn decode(cursor: &DecodeCursor<'a>) -> DecodeResult<Self> {
        let offset = cursor.offset();
        cursor.advance(Self::BASE_LEN);
        Ok(StreamItemLazy {
            buffer: cursor.buffer(),
            offset,
            _t: core::marker::PhantomData,
        })
    }
}

impl<'a, T: Owned> TryFrom<StreamItemLazy<'a, T>> for StreamItem<T> {
    type Error = DecodeError;

    fn try_from(other: StreamItemLazy<'a, T>) -> Result<Self, Self::Error> {
        let cursor = DecodeCursor::at_offset(other.buffer, other.offset);
        Decode::decode(&cursor)
    }
}

impl<'a, T> Copy for StreamItemLazy<'a, T> {}

impl<'a, T> Clone for StreamItemLazy<'a, T> {
    fn clone(&self) -> Self {
        Self {
            buffer: self.buffer,
            offset: self.offset,
            _t: core::marker::PhantomData,
        }
    }
}

impl<'a, T> core::fmt::Debug for StreamItemLazy<'a, T> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("StreamItemLazy").finish()
    }
}

impl<'a, T: Owned> PartialEq for StreamItemLazy<'a, T> {
    fn eq(&self, other: &Self) -> bool {
        self.seq().unwrap() == other.seq().unwrap()
            && self.payload().unwrap() == other.payload().unwrap()
    }
}

#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash)]
pub struct MultiStreamId {
    pub owner: u64,
    pub id: u32,
}

pub struct MultiStreamIdLazy<'a> {
    buffer: &'a [u8],
    offset: usize,
}

pub struct MultiStreamIdGen {
    pub owner: u64,
    pub id: u32,
}

impl Compatible<MultiStreamId> for MultiStreamIdGen {}
impl Compatible<MultiStreamIdGen> for MultiStreamId {}

impl BaseLen for MultiStreamIdGen {
    const BASE_LEN: usize = 12;
}

impl Encode for MultiStreamIdGen {
    fn scratch_len(&self) -> usize {
        self.owner.scratch_len() + self.id.scratch_len()
    }

    fn encode(&self, cursor: &mut EncodeCursor) {
        self.owner.encode(cursor);
        self.id.encode(cursor);
    }
}

impl Owned for MultiStreamId {
    type Lazy<'a> = MultiStreamIdLazy<'a>;

    fn lazy_to_owned(lazy: Self::Lazy<'_>) -> DecodeResult<Self> {
        TryFrom::try_from(lazy)
    }
}

impl<'a> Lazy<'a> for MultiStreamIdLazy<'a> {
    type Owned = MultiStreamId;
}

impl<'a> Compatible<MultiStreamIdLazy<'a>> for MultiStreamIdLazy<'a> {}
impl<'a> Compatible<MultiStreamIdLazy<'a>> for MultiStreamId {}
impl Compatible<MultiStreamId> for MultiStreamId {}
impl<'a> Compatible<MultiStreamId> for MultiStreamIdLazy<'a> {}

impl<'a> MultiStreamIdLazy<'a> {
    pub fn owner(&self) -> DecodeResult<u64> {
        Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 0))
    }

    pub fn id(&self) -> DecodeResult<u32> {
        Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 8))
    }
}

impl BaseLen for MultiStreamId {
    const BASE_LEN: usize = 12;
}

impl Encode for MultiStreamId {
    fn scratch_len(&self) -> usize {
        self.owner.scratch_len() + self.id.scratch_len()
    }

    fn encode(&self, cursor: &mut EncodeCursor) {
        self.owner.encode(cursor);
        self.id.encode(cursor);
    }
}

impl<'a> Decode<'a> for MultiStreamId {
    fn decode(cursor: &DecodeCursor<'a>) -> DecodeResult<Self> {
        let owner = Decode::decode(cursor)?;
        let id = Decode::decode(cursor)?;

        Ok(MultiStreamId { owner, id })
    }
}

impl<'a> BaseLen for MultiStreamIdLazy<'a> {
    const BASE_LEN: usize = 12;
}

impl<'a> Encode for MultiStreamIdLazy<'a> {
    fn scratch_len(&self) -> usize {
        let owner: u64 =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 0)).unwrap();
        let id: u32 =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 8)).unwrap();
        owner.scratch_len() + id.scratch_len()
    }

    fn encode(&self, cursor: &mut EncodeCursor) {
        let owner: u64 =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 0)).unwrap();
        let id: u32 =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 8)).unwrap();
        owner.encode(cursor);
        id.encode(cursor);
    }
}

impl<'a> Decode<'a> for MultiStreamIdLazy<'a> {
    fn decode(cursor: &DecodeCursor<'a>) -> DecodeResult<Self> {
        let offset = cursor.offset();
        cursor.advance(Self::BASE_LEN);
        Ok(MultiStreamIdLazy {
            buffer: cursor.buffer(),
            offset,
        })
    }
}

impl<'a> TryFrom<MultiStreamIdLazy<'a>> for MultiStreamId {
    type Error = DecodeError;

    fn try_from(other: MultiStreamIdLazy<'a>) -> Result<Self, Self::Error> {
        let cursor = DecodeCursor::at_offset(other.buffer, other.offset);
        Decode::decode(&cursor)
    }
}

impl<'a> Copy for MultiStreamIdLazy<'a> {}

impl<'a> Clone for MultiStreamIdLazy<'a> {
    fn clone(&self) -> Self {
        Self {
            buffer: self.buffer,
            offset: self.offset,
        }
    }
}

impl<'a> core::fmt::Debug for MultiStreamIdLazy<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("MultiStreamIdLazy").finish()
    }
}

impl<'a> PartialEq for MultiStreamIdLazy<'a> {
    fn eq(&self, other: &Self) -> bool {
        self.owner().unwrap() == other.owner().unwrap() && self.id().unwrap() == other.id().unwrap()
    }
}

#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash)]
pub struct MultiStreamItem<T> {
    pub stream_id: MultiStreamId,
    pub seq: u64,
    pub payload: Option<T>,
}

pub struct MultiStreamItemLazy<'a, T> {
    buffer: &'a [u8],
    offset: usize,
    _t: core::marker::PhantomData<T>,
}

pub struct MultiStreamItemGen<StreamId: Encode + Compatible<MultiStreamId>, Payload: Encode> {
    pub stream_id: StreamId,
    pub seq: u64,
    pub payload: Payload,
}

impl<
    T: Owned,
    StreamId: Encode + Compatible<MultiStreamId>,
    Payload: Encode + Compatible<Option<T>>,
> Compatible<MultiStreamItem<T>> for MultiStreamItemGen<StreamId, Payload>
{
}
impl<
    T: Owned,
    StreamId: Encode + Compatible<MultiStreamId>,
    Payload: Encode + Compatible<Option<T>>,
> Compatible<MultiStreamItemGen<StreamId, Payload>> for MultiStreamItem<T>
{
}

impl<StreamId: Encode + Compatible<MultiStreamId>, Payload: Encode> BaseLen
    for MultiStreamItemGen<StreamId, Payload>
{
    const BASE_LEN: usize = 8 + StreamId::BASE_LEN + Payload::BASE_LEN;
}

impl<StreamId: Encode + Compatible<MultiStreamId>, Payload: Encode> Encode
    for MultiStreamItemGen<StreamId, Payload>
{
    fn scratch_len(&self) -> usize {
        self.stream_id.scratch_len() + self.seq.scratch_len() + self.payload.scratch_len()
    }

    fn encode(&self, cursor: &mut EncodeCursor) {
        self.stream_id.encode(cursor);
        self.seq.encode(cursor);
        self.payload.encode(cursor);
    }
}

impl<T: Owned> Owned for MultiStreamItem<T> {
    type Lazy<'a> = MultiStreamItemLazy<'a, T>;

    fn lazy_to_owned(lazy: Self::Lazy<'_>) -> DecodeResult<Self> {
        TryFrom::try_from(lazy)
    }
}

impl<'a, T: Owned> Lazy<'a> for MultiStreamItemLazy<'a, T> {
    type Owned = MultiStreamItem<T>;
}

impl<'a, T: Owned> Compatible<MultiStreamItemLazy<'a, T>> for MultiStreamItemLazy<'a, T> {}
impl<'a, T: Owned> Compatible<MultiStreamItemLazy<'a, T>> for MultiStreamItem<T> {}
impl<T: Owned> Compatible<MultiStreamItem<T>> for MultiStreamItem<T> {}
impl<'a, T: Owned> Compatible<MultiStreamItem<T>> for MultiStreamItemLazy<'a, T> {}

impl<'a, T: Owned> MultiStreamItemLazy<'a, T> {
    pub fn stream_id(&self) -> DecodeResult<MultiStreamIdLazy<'a>> {
        Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 0))
    }

    pub fn seq(&self) -> DecodeResult<u64> {
        Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 12))
    }

    pub fn payload(&self) -> DecodeResult<Option<T::Lazy<'a>>> {
        Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 20))
    }
}

impl<T: BaseLen> BaseLen for MultiStreamItem<T> {
    const BASE_LEN: usize = 21 + T::BASE_LEN;
}

impl<T: Encode> Encode for MultiStreamItem<T> {
    fn scratch_len(&self) -> usize {
        self.stream_id.scratch_len() + self.seq.scratch_len() + self.payload.scratch_len()
    }

    fn encode(&self, cursor: &mut EncodeCursor) {
        self.stream_id.encode(cursor);
        self.seq.encode(cursor);
        self.payload.encode(cursor);
    }
}

impl<'a, T: Decode<'a>> Decode<'a> for MultiStreamItem<T> {
    fn decode(cursor: &DecodeCursor<'a>) -> DecodeResult<Self> {
        let stream_id = Decode::decode(cursor)?;
        let seq = Decode::decode(cursor)?;
        let payload = Decode::decode(cursor)?;

        Ok(MultiStreamItem {
            stream_id,
            seq,
            payload,
        })
    }
}

impl<'a, T: Owned> BaseLen for MultiStreamItemLazy<'a, T> {
    const BASE_LEN: usize = 21 + T::BASE_LEN;
}

impl<'a, T: Owned> Encode for MultiStreamItemLazy<'a, T> {
    fn scratch_len(&self) -> usize {
        let stream_id: MultiStreamIdLazy<'a> =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 0)).unwrap();
        let seq: u64 =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 12)).unwrap();
        let payload: Option<T::Lazy<'a>> =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 20)).unwrap();
        stream_id.scratch_len() + seq.scratch_len() + payload.scratch_len()
    }

    fn encode(&self, cursor: &mut EncodeCursor) {
        let stream_id: MultiStreamIdLazy<'a> =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 0)).unwrap();
        let seq: u64 =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 12)).unwrap();
        let payload: Option<T::Lazy<'a>> =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 20)).unwrap();
        stream_id.encode(cursor);
        seq.encode(cursor);
        payload.encode(cursor);
    }
}

impl<'a, T: Owned> Decode<'a> for MultiStreamItemLazy<'a, T> {
    fn decode(cursor: &DecodeCursor<'a>) -> DecodeResult<Self> {
        let offset = cursor.offset();
        cursor.advance(Self::BASE_LEN);
        Ok(MultiStreamItemLazy {
            buffer: cursor.buffer(),
            offset,
            _t: core::marker::PhantomData,
        })
    }
}

impl<'a, T: Owned> TryFrom<MultiStreamItemLazy<'a, T>> for MultiStreamItem<T> {
    type Error = DecodeError;

    fn try_from(other: MultiStreamItemLazy<'a, T>) -> Result<Self, Self::Error> {
        let cursor = DecodeCursor::at_offset(other.buffer, other.offset);
        Decode::decode(&cursor)
    }
}

impl<'a, T> Copy for MultiStreamItemLazy<'a, T> {}

impl<'a, T> Clone for MultiStreamItemLazy<'a, T> {
    fn clone(&self) -> Self {
        Self {
            buffer: self.buffer,
            offset: self.offset,
            _t: core::marker::PhantomData,
        }
    }
}

impl<'a, T> core::fmt::Debug for MultiStreamItemLazy<'a, T> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("MultiStreamItemLazy").finish()
    }
}

impl<'a, T: Owned> PartialEq for MultiStreamItemLazy<'a, T> {
    fn eq(&self, other: &Self) -> bool {
        self.stream_id().unwrap() == other.stream_id().unwrap()
            && self.seq().unwrap() == other.seq().unwrap()
            && self.payload().unwrap() == other.payload().unwrap()
    }
}

#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash)]
pub struct PropertyInitState<T> {
    pub value: T,
}

pub struct PropertyInitStateLazy<'a, T> {
    buffer: &'a [u8],
    offset: usize,
    _t: core::marker::PhantomData<T>,
}

pub struct PropertyInitStateGen<Value: Encode> {
    pub value: Value,
}

impl<T: Owned, Value: Encode + Compatible<T>> Compatible<PropertyInitState<T>>
    for PropertyInitStateGen<Value>
{
}
impl<T: Owned, Value: Encode + Compatible<T>> Compatible<PropertyInitStateGen<Value>>
    for PropertyInitState<T>
{
}

impl<Value: Encode> BaseLen for PropertyInitStateGen<Value> {
    const BASE_LEN: usize = Value::BASE_LEN;
}

impl<Value: Encode> Encode for PropertyInitStateGen<Value> {
    fn scratch_len(&self) -> usize {
        self.value.scratch_len()
    }

    fn encode(&self, cursor: &mut EncodeCursor) {
        self.value.encode(cursor);
    }
}

impl<T: Owned> Owned for PropertyInitState<T> {
    type Lazy<'a> = PropertyInitStateLazy<'a, T>;

    fn lazy_to_owned(lazy: Self::Lazy<'_>) -> DecodeResult<Self> {
        TryFrom::try_from(lazy)
    }
}

impl<'a, T: Owned> Lazy<'a> for PropertyInitStateLazy<'a, T> {
    type Owned = PropertyInitState<T>;
}

impl<'a, T: Owned> Compatible<PropertyInitStateLazy<'a, T>> for PropertyInitStateLazy<'a, T> {}
impl<'a, T: Owned> Compatible<PropertyInitStateLazy<'a, T>> for PropertyInitState<T> {}
impl<T: Owned> Compatible<PropertyInitState<T>> for PropertyInitState<T> {}
impl<'a, T: Owned> Compatible<PropertyInitState<T>> for PropertyInitStateLazy<'a, T> {}

impl<'a, T: Owned> PropertyInitStateLazy<'a, T> {
    pub fn value(&self) -> DecodeResult<T::Lazy<'a>> {
        Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 0))
    }
}

impl<T: BaseLen> BaseLen for PropertyInitState<T> {
    const BASE_LEN: usize = T::BASE_LEN;
}

impl<T: Encode> Encode for PropertyInitState<T> {
    fn scratch_len(&self) -> usize {
        self.value.scratch_len()
    }

    fn encode(&self, cursor: &mut EncodeCursor) {
        self.value.encode(cursor);
    }
}

impl<'a, T: Decode<'a>> Decode<'a> for PropertyInitState<T> {
    fn decode(cursor: &DecodeCursor<'a>) -> DecodeResult<Self> {
        let value = Decode::decode(cursor)?;

        Ok(PropertyInitState { value })
    }
}

impl<'a, T: Owned> BaseLen for PropertyInitStateLazy<'a, T> {
    const BASE_LEN: usize = T::BASE_LEN;
}

impl<'a, T: Owned> Encode for PropertyInitStateLazy<'a, T> {
    fn scratch_len(&self) -> usize {
        let value: T::Lazy<'a> =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 0)).unwrap();
        value.scratch_len()
    }

    fn encode(&self, cursor: &mut EncodeCursor) {
        let value: T::Lazy<'a> =
            Decode::decode(&DecodeCursor::at_offset(self.buffer, self.offset + 0)).unwrap();
        value.encode(cursor);
    }
}

impl<'a, T: Owned> Decode<'a> for PropertyInitStateLazy<'a, T> {
    fn decode(cursor: &DecodeCursor<'a>) -> DecodeResult<Self> {
        let offset = cursor.offset();
        cursor.advance(Self::BASE_LEN);
        Ok(PropertyInitStateLazy {
            buffer: cursor.buffer(),
            offset,
            _t: core::marker::PhantomData,
        })
    }
}

impl<'a, T: Owned> TryFrom<PropertyInitStateLazy<'a, T>> for PropertyInitState<T> {
    type Error = DecodeError;

    fn try_from(other: PropertyInitStateLazy<'a, T>) -> Result<Self, Self::Error> {
        let cursor = DecodeCursor::at_offset(other.buffer, other.offset);
        Decode::decode(&cursor)
    }
}

impl<'a, T> Copy for PropertyInitStateLazy<'a, T> {}

impl<'a, T> Clone for PropertyInitStateLazy<'a, T> {
    fn clone(&self) -> Self {
        Self {
            buffer: self.buffer,
            offset: self.offset,
            _t: core::marker::PhantomData,
        }
    }
}

impl<'a, T> core::fmt::Debug for PropertyInitStateLazy<'a, T> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("PropertyInitStateLazy").finish()
    }
}

impl<'a, T: Owned> PartialEq for PropertyInitStateLazy<'a, T> {
    fn eq(&self, other: &Self) -> bool {
        self.value().unwrap() == other.value().unwrap()
    }
}

#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Default)]
pub struct PropertyObserverConfig {}

pub struct PropertyObserverConfigLazy<'a> {
    buffer: &'a [u8],
    offset: usize,
}

pub struct PropertyObserverConfigGen {}

impl Compatible<PropertyObserverConfig> for PropertyObserverConfigGen {}
impl Compatible<PropertyObserverConfigGen> for PropertyObserverConfig {}

impl BaseLen for PropertyObserverConfigGen {
    const BASE_LEN: usize = 0;
}

impl Encode for PropertyObserverConfigGen {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl Owned for PropertyObserverConfig {
    type Lazy<'a> = PropertyObserverConfigLazy<'a>;

    fn lazy_to_owned(lazy: Self::Lazy<'_>) -> DecodeResult<Self> {
        TryFrom::try_from(lazy)
    }
}

impl<'a> Lazy<'a> for PropertyObserverConfigLazy<'a> {
    type Owned = PropertyObserverConfig;
}

impl<'a> Compatible<PropertyObserverConfigLazy<'a>> for PropertyObserverConfigLazy<'a> {}
impl<'a> Compatible<PropertyObserverConfigLazy<'a>> for PropertyObserverConfig {}
impl Compatible<PropertyObserverConfig> for PropertyObserverConfig {}
impl<'a> Compatible<PropertyObserverConfig> for PropertyObserverConfigLazy<'a> {}

impl<'a> PropertyObserverConfigLazy<'a> {}

impl BaseLen for PropertyObserverConfig {
    const BASE_LEN: usize = 0;
}

impl Encode for PropertyObserverConfig {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl<'a> Decode<'a> for PropertyObserverConfig {
    fn decode(_: &DecodeCursor<'a>) -> DecodeResult<Self> {
        Ok(PropertyObserverConfig {})
    }
}

impl<'a> BaseLen for PropertyObserverConfigLazy<'a> {
    const BASE_LEN: usize = 0;
}

impl<'a> Encode for PropertyObserverConfigLazy<'a> {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl<'a> Decode<'a> for PropertyObserverConfigLazy<'a> {
    fn decode(cursor: &DecodeCursor<'a>) -> DecodeResult<Self> {
        let offset = cursor.offset();
        cursor.advance(Self::BASE_LEN);
        Ok(PropertyObserverConfigLazy {
            buffer: cursor.buffer(),
            offset,
        })
    }
}

impl<'a> TryFrom<PropertyObserverConfigLazy<'a>> for PropertyObserverConfig {
    type Error = DecodeError;

    fn try_from(other: PropertyObserverConfigLazy<'a>) -> Result<Self, Self::Error> {
        let cursor = DecodeCursor::at_offset(other.buffer, other.offset);
        Decode::decode(&cursor)
    }
}

impl<'a> Copy for PropertyObserverConfigLazy<'a> {}

impl<'a> Clone for PropertyObserverConfigLazy<'a> {
    fn clone(&self) -> Self {
        Self {
            buffer: self.buffer,
            offset: self.offset,
        }
    }
}

impl<'a> core::fmt::Debug for PropertyObserverConfigLazy<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("PropertyObserverConfigLazy").finish()
    }
}

impl<'a> PartialEq for PropertyObserverConfigLazy<'a> {
    fn eq(&self, _: &Self) -> bool {
        true
    }
}

#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Default)]
pub struct PropertyOwnerConfig {}

pub struct PropertyOwnerConfigLazy<'a> {
    buffer: &'a [u8],
    offset: usize,
}

pub struct PropertyOwnerConfigGen {}

impl Compatible<PropertyOwnerConfig> for PropertyOwnerConfigGen {}
impl Compatible<PropertyOwnerConfigGen> for PropertyOwnerConfig {}

impl BaseLen for PropertyOwnerConfigGen {
    const BASE_LEN: usize = 0;
}

impl Encode for PropertyOwnerConfigGen {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl Owned for PropertyOwnerConfig {
    type Lazy<'a> = PropertyOwnerConfigLazy<'a>;

    fn lazy_to_owned(lazy: Self::Lazy<'_>) -> DecodeResult<Self> {
        TryFrom::try_from(lazy)
    }
}

impl<'a> Lazy<'a> for PropertyOwnerConfigLazy<'a> {
    type Owned = PropertyOwnerConfig;
}

impl<'a> Compatible<PropertyOwnerConfigLazy<'a>> for PropertyOwnerConfigLazy<'a> {}
impl<'a> Compatible<PropertyOwnerConfigLazy<'a>> for PropertyOwnerConfig {}
impl Compatible<PropertyOwnerConfig> for PropertyOwnerConfig {}
impl<'a> Compatible<PropertyOwnerConfig> for PropertyOwnerConfigLazy<'a> {}

impl<'a> PropertyOwnerConfigLazy<'a> {}

impl BaseLen for PropertyOwnerConfig {
    const BASE_LEN: usize = 0;
}

impl Encode for PropertyOwnerConfig {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl<'a> Decode<'a> for PropertyOwnerConfig {
    fn decode(_: &DecodeCursor<'a>) -> DecodeResult<Self> {
        Ok(PropertyOwnerConfig {})
    }
}

impl<'a> BaseLen for PropertyOwnerConfigLazy<'a> {
    const BASE_LEN: usize = 0;
}

impl<'a> Encode for PropertyOwnerConfigLazy<'a> {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl<'a> Decode<'a> for PropertyOwnerConfigLazy<'a> {
    fn decode(cursor: &DecodeCursor<'a>) -> DecodeResult<Self> {
        let offset = cursor.offset();
        cursor.advance(Self::BASE_LEN);
        Ok(PropertyOwnerConfigLazy {
            buffer: cursor.buffer(),
            offset,
        })
    }
}

impl<'a> TryFrom<PropertyOwnerConfigLazy<'a>> for PropertyOwnerConfig {
    type Error = DecodeError;

    fn try_from(other: PropertyOwnerConfigLazy<'a>) -> Result<Self, Self::Error> {
        let cursor = DecodeCursor::at_offset(other.buffer, other.offset);
        Decode::decode(&cursor)
    }
}

impl<'a> Copy for PropertyOwnerConfigLazy<'a> {}

impl<'a> Clone for PropertyOwnerConfigLazy<'a> {
    fn clone(&self) -> Self {
        Self {
            buffer: self.buffer,
            offset: self.offset,
        }
    }
}

impl<'a> core::fmt::Debug for PropertyOwnerConfigLazy<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("PropertyOwnerConfigLazy").finish()
    }
}

impl<'a> PartialEq for PropertyOwnerConfigLazy<'a> {
    fn eq(&self, _: &Self) -> bool {
        true
    }
}

#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Default)]
pub struct RequestInitState {}

pub struct RequestInitStateLazy<'a> {
    buffer: &'a [u8],
    offset: usize,
}

pub struct RequestInitStateGen {}

impl Compatible<RequestInitState> for RequestInitStateGen {}
impl Compatible<RequestInitStateGen> for RequestInitState {}

impl BaseLen for RequestInitStateGen {
    const BASE_LEN: usize = 0;
}

impl Encode for RequestInitStateGen {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl Owned for RequestInitState {
    type Lazy<'a> = RequestInitStateLazy<'a>;

    fn lazy_to_owned(lazy: Self::Lazy<'_>) -> DecodeResult<Self> {
        TryFrom::try_from(lazy)
    }
}

impl<'a> Lazy<'a> for RequestInitStateLazy<'a> {
    type Owned = RequestInitState;
}

impl<'a> Compatible<RequestInitStateLazy<'a>> for RequestInitStateLazy<'a> {}
impl<'a> Compatible<RequestInitStateLazy<'a>> for RequestInitState {}
impl Compatible<RequestInitState> for RequestInitState {}
impl<'a> Compatible<RequestInitState> for RequestInitStateLazy<'a> {}

impl<'a> RequestInitStateLazy<'a> {}

impl BaseLen for RequestInitState {
    const BASE_LEN: usize = 0;
}

impl Encode for RequestInitState {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl<'a> Decode<'a> for RequestInitState {
    fn decode(_: &DecodeCursor<'a>) -> DecodeResult<Self> {
        Ok(RequestInitState {})
    }
}

impl<'a> BaseLen for RequestInitStateLazy<'a> {
    const BASE_LEN: usize = 0;
}

impl<'a> Encode for RequestInitStateLazy<'a> {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl<'a> Decode<'a> for RequestInitStateLazy<'a> {
    fn decode(cursor: &DecodeCursor<'a>) -> DecodeResult<Self> {
        let offset = cursor.offset();
        cursor.advance(Self::BASE_LEN);
        Ok(RequestInitStateLazy {
            buffer: cursor.buffer(),
            offset,
        })
    }
}

impl<'a> TryFrom<RequestInitStateLazy<'a>> for RequestInitState {
    type Error = DecodeError;

    fn try_from(other: RequestInitStateLazy<'a>) -> Result<Self, Self::Error> {
        let cursor = DecodeCursor::at_offset(other.buffer, other.offset);
        Decode::decode(&cursor)
    }
}

impl<'a> Copy for RequestInitStateLazy<'a> {}

impl<'a> Clone for RequestInitStateLazy<'a> {
    fn clone(&self) -> Self {
        Self {
            buffer: self.buffer,
            offset: self.offset,
        }
    }
}

impl<'a> core::fmt::Debug for RequestInitStateLazy<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("RequestInitStateLazy").finish()
    }
}

impl<'a> PartialEq for RequestInitStateLazy<'a> {
    fn eq(&self, _: &Self) -> bool {
        true
    }
}

#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Default)]
pub struct RequestClientConfig {}

pub struct RequestClientConfigLazy<'a> {
    buffer: &'a [u8],
    offset: usize,
}

pub struct RequestClientConfigGen {}

impl Compatible<RequestClientConfig> for RequestClientConfigGen {}
impl Compatible<RequestClientConfigGen> for RequestClientConfig {}

impl BaseLen for RequestClientConfigGen {
    const BASE_LEN: usize = 0;
}

impl Encode for RequestClientConfigGen {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl Owned for RequestClientConfig {
    type Lazy<'a> = RequestClientConfigLazy<'a>;

    fn lazy_to_owned(lazy: Self::Lazy<'_>) -> DecodeResult<Self> {
        TryFrom::try_from(lazy)
    }
}

impl<'a> Lazy<'a> for RequestClientConfigLazy<'a> {
    type Owned = RequestClientConfig;
}

impl<'a> Compatible<RequestClientConfigLazy<'a>> for RequestClientConfigLazy<'a> {}
impl<'a> Compatible<RequestClientConfigLazy<'a>> for RequestClientConfig {}
impl Compatible<RequestClientConfig> for RequestClientConfig {}
impl<'a> Compatible<RequestClientConfig> for RequestClientConfigLazy<'a> {}

impl<'a> RequestClientConfigLazy<'a> {}

impl BaseLen for RequestClientConfig {
    const BASE_LEN: usize = 0;
}

impl Encode for RequestClientConfig {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl<'a> Decode<'a> for RequestClientConfig {
    fn decode(_: &DecodeCursor<'a>) -> DecodeResult<Self> {
        Ok(RequestClientConfig {})
    }
}

impl<'a> BaseLen for RequestClientConfigLazy<'a> {
    const BASE_LEN: usize = 0;
}

impl<'a> Encode for RequestClientConfigLazy<'a> {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl<'a> Decode<'a> for RequestClientConfigLazy<'a> {
    fn decode(cursor: &DecodeCursor<'a>) -> DecodeResult<Self> {
        let offset = cursor.offset();
        cursor.advance(Self::BASE_LEN);
        Ok(RequestClientConfigLazy {
            buffer: cursor.buffer(),
            offset,
        })
    }
}

impl<'a> TryFrom<RequestClientConfigLazy<'a>> for RequestClientConfig {
    type Error = DecodeError;

    fn try_from(other: RequestClientConfigLazy<'a>) -> Result<Self, Self::Error> {
        let cursor = DecodeCursor::at_offset(other.buffer, other.offset);
        Decode::decode(&cursor)
    }
}

impl<'a> Copy for RequestClientConfigLazy<'a> {}

impl<'a> Clone for RequestClientConfigLazy<'a> {
    fn clone(&self) -> Self {
        Self {
            buffer: self.buffer,
            offset: self.offset,
        }
    }
}

impl<'a> core::fmt::Debug for RequestClientConfigLazy<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("RequestClientConfigLazy").finish()
    }
}

impl<'a> PartialEq for RequestClientConfigLazy<'a> {
    fn eq(&self, _: &Self) -> bool {
        true
    }
}

#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Default)]
pub struct RequestServerConfig {}

pub struct RequestServerConfigLazy<'a> {
    buffer: &'a [u8],
    offset: usize,
}

pub struct RequestServerConfigGen {}

impl Compatible<RequestServerConfig> for RequestServerConfigGen {}
impl Compatible<RequestServerConfigGen> for RequestServerConfig {}

impl BaseLen for RequestServerConfigGen {
    const BASE_LEN: usize = 0;
}

impl Encode for RequestServerConfigGen {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl Owned for RequestServerConfig {
    type Lazy<'a> = RequestServerConfigLazy<'a>;

    fn lazy_to_owned(lazy: Self::Lazy<'_>) -> DecodeResult<Self> {
        TryFrom::try_from(lazy)
    }
}

impl<'a> Lazy<'a> for RequestServerConfigLazy<'a> {
    type Owned = RequestServerConfig;
}

impl<'a> Compatible<RequestServerConfigLazy<'a>> for RequestServerConfigLazy<'a> {}
impl<'a> Compatible<RequestServerConfigLazy<'a>> for RequestServerConfig {}
impl Compatible<RequestServerConfig> for RequestServerConfig {}
impl<'a> Compatible<RequestServerConfig> for RequestServerConfigLazy<'a> {}

impl<'a> RequestServerConfigLazy<'a> {}

impl BaseLen for RequestServerConfig {
    const BASE_LEN: usize = 0;
}

impl Encode for RequestServerConfig {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl<'a> Decode<'a> for RequestServerConfig {
    fn decode(_: &DecodeCursor<'a>) -> DecodeResult<Self> {
        Ok(RequestServerConfig {})
    }
}

impl<'a> BaseLen for RequestServerConfigLazy<'a> {
    const BASE_LEN: usize = 0;
}

impl<'a> Encode for RequestServerConfigLazy<'a> {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl<'a> Decode<'a> for RequestServerConfigLazy<'a> {
    fn decode(cursor: &DecodeCursor<'a>) -> DecodeResult<Self> {
        let offset = cursor.offset();
        cursor.advance(Self::BASE_LEN);
        Ok(RequestServerConfigLazy {
            buffer: cursor.buffer(),
            offset,
        })
    }
}

impl<'a> TryFrom<RequestServerConfigLazy<'a>> for RequestServerConfig {
    type Error = DecodeError;

    fn try_from(other: RequestServerConfigLazy<'a>) -> Result<Self, Self::Error> {
        let cursor = DecodeCursor::at_offset(other.buffer, other.offset);
        Decode::decode(&cursor)
    }
}

impl<'a> Copy for RequestServerConfigLazy<'a> {}

impl<'a> Clone for RequestServerConfigLazy<'a> {
    fn clone(&self) -> Self {
        Self {
            buffer: self.buffer,
            offset: self.offset,
        }
    }
}

impl<'a> core::fmt::Debug for RequestServerConfigLazy<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("RequestServerConfigLazy").finish()
    }
}

impl<'a> PartialEq for RequestServerConfigLazy<'a> {
    fn eq(&self, _: &Self) -> bool {
        true
    }
}

#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Default)]
pub struct StreamInitState {}

pub struct StreamInitStateLazy<'a> {
    buffer: &'a [u8],
    offset: usize,
}

pub struct StreamInitStateGen {}

impl Compatible<StreamInitState> for StreamInitStateGen {}
impl Compatible<StreamInitStateGen> for StreamInitState {}

impl BaseLen for StreamInitStateGen {
    const BASE_LEN: usize = 0;
}

impl Encode for StreamInitStateGen {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl Owned for StreamInitState {
    type Lazy<'a> = StreamInitStateLazy<'a>;

    fn lazy_to_owned(lazy: Self::Lazy<'_>) -> DecodeResult<Self> {
        TryFrom::try_from(lazy)
    }
}

impl<'a> Lazy<'a> for StreamInitStateLazy<'a> {
    type Owned = StreamInitState;
}

impl<'a> Compatible<StreamInitStateLazy<'a>> for StreamInitStateLazy<'a> {}
impl<'a> Compatible<StreamInitStateLazy<'a>> for StreamInitState {}
impl Compatible<StreamInitState> for StreamInitState {}
impl<'a> Compatible<StreamInitState> for StreamInitStateLazy<'a> {}

impl<'a> StreamInitStateLazy<'a> {}

impl BaseLen for StreamInitState {
    const BASE_LEN: usize = 0;
}

impl Encode for StreamInitState {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl<'a> Decode<'a> for StreamInitState {
    fn decode(_: &DecodeCursor<'a>) -> DecodeResult<Self> {
        Ok(StreamInitState {})
    }
}

impl<'a> BaseLen for StreamInitStateLazy<'a> {
    const BASE_LEN: usize = 0;
}

impl<'a> Encode for StreamInitStateLazy<'a> {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl<'a> Decode<'a> for StreamInitStateLazy<'a> {
    fn decode(cursor: &DecodeCursor<'a>) -> DecodeResult<Self> {
        let offset = cursor.offset();
        cursor.advance(Self::BASE_LEN);
        Ok(StreamInitStateLazy {
            buffer: cursor.buffer(),
            offset,
        })
    }
}

impl<'a> TryFrom<StreamInitStateLazy<'a>> for StreamInitState {
    type Error = DecodeError;

    fn try_from(other: StreamInitStateLazy<'a>) -> Result<Self, Self::Error> {
        let cursor = DecodeCursor::at_offset(other.buffer, other.offset);
        Decode::decode(&cursor)
    }
}

impl<'a> Copy for StreamInitStateLazy<'a> {}

impl<'a> Clone for StreamInitStateLazy<'a> {
    fn clone(&self) -> Self {
        Self {
            buffer: self.buffer,
            offset: self.offset,
        }
    }
}

impl<'a> core::fmt::Debug for StreamInitStateLazy<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("StreamInitStateLazy").finish()
    }
}

impl<'a> PartialEq for StreamInitStateLazy<'a> {
    fn eq(&self, _: &Self) -> bool {
        true
    }
}

#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Default)]
pub struct StreamReceiverConfig {}

pub struct StreamReceiverConfigLazy<'a> {
    buffer: &'a [u8],
    offset: usize,
}

pub struct StreamReceiverConfigGen {}

impl Compatible<StreamReceiverConfig> for StreamReceiverConfigGen {}
impl Compatible<StreamReceiverConfigGen> for StreamReceiverConfig {}

impl BaseLen for StreamReceiverConfigGen {
    const BASE_LEN: usize = 0;
}

impl Encode for StreamReceiverConfigGen {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl Owned for StreamReceiverConfig {
    type Lazy<'a> = StreamReceiverConfigLazy<'a>;

    fn lazy_to_owned(lazy: Self::Lazy<'_>) -> DecodeResult<Self> {
        TryFrom::try_from(lazy)
    }
}

impl<'a> Lazy<'a> for StreamReceiverConfigLazy<'a> {
    type Owned = StreamReceiverConfig;
}

impl<'a> Compatible<StreamReceiverConfigLazy<'a>> for StreamReceiverConfigLazy<'a> {}
impl<'a> Compatible<StreamReceiverConfigLazy<'a>> for StreamReceiverConfig {}
impl Compatible<StreamReceiverConfig> for StreamReceiverConfig {}
impl<'a> Compatible<StreamReceiverConfig> for StreamReceiverConfigLazy<'a> {}

impl<'a> StreamReceiverConfigLazy<'a> {}

impl BaseLen for StreamReceiverConfig {
    const BASE_LEN: usize = 0;
}

impl Encode for StreamReceiverConfig {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl<'a> Decode<'a> for StreamReceiverConfig {
    fn decode(_: &DecodeCursor<'a>) -> DecodeResult<Self> {
        Ok(StreamReceiverConfig {})
    }
}

impl<'a> BaseLen for StreamReceiverConfigLazy<'a> {
    const BASE_LEN: usize = 0;
}

impl<'a> Encode for StreamReceiverConfigLazy<'a> {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl<'a> Decode<'a> for StreamReceiverConfigLazy<'a> {
    fn decode(cursor: &DecodeCursor<'a>) -> DecodeResult<Self> {
        let offset = cursor.offset();
        cursor.advance(Self::BASE_LEN);
        Ok(StreamReceiverConfigLazy {
            buffer: cursor.buffer(),
            offset,
        })
    }
}

impl<'a> TryFrom<StreamReceiverConfigLazy<'a>> for StreamReceiverConfig {
    type Error = DecodeError;

    fn try_from(other: StreamReceiverConfigLazy<'a>) -> Result<Self, Self::Error> {
        let cursor = DecodeCursor::at_offset(other.buffer, other.offset);
        Decode::decode(&cursor)
    }
}

impl<'a> Copy for StreamReceiverConfigLazy<'a> {}

impl<'a> Clone for StreamReceiverConfigLazy<'a> {
    fn clone(&self) -> Self {
        Self {
            buffer: self.buffer,
            offset: self.offset,
        }
    }
}

impl<'a> core::fmt::Debug for StreamReceiverConfigLazy<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("StreamReceiverConfigLazy").finish()
    }
}

impl<'a> PartialEq for StreamReceiverConfigLazy<'a> {
    fn eq(&self, _: &Self) -> bool {
        true
    }
}

#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Default)]
pub struct StreamSenderConfig {}

pub struct StreamSenderConfigLazy<'a> {
    buffer: &'a [u8],
    offset: usize,
}

pub struct StreamSenderConfigGen {}

impl Compatible<StreamSenderConfig> for StreamSenderConfigGen {}
impl Compatible<StreamSenderConfigGen> for StreamSenderConfig {}

impl BaseLen for StreamSenderConfigGen {
    const BASE_LEN: usize = 0;
}

impl Encode for StreamSenderConfigGen {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl Owned for StreamSenderConfig {
    type Lazy<'a> = StreamSenderConfigLazy<'a>;

    fn lazy_to_owned(lazy: Self::Lazy<'_>) -> DecodeResult<Self> {
        TryFrom::try_from(lazy)
    }
}

impl<'a> Lazy<'a> for StreamSenderConfigLazy<'a> {
    type Owned = StreamSenderConfig;
}

impl<'a> Compatible<StreamSenderConfigLazy<'a>> for StreamSenderConfigLazy<'a> {}
impl<'a> Compatible<StreamSenderConfigLazy<'a>> for StreamSenderConfig {}
impl Compatible<StreamSenderConfig> for StreamSenderConfig {}
impl<'a> Compatible<StreamSenderConfig> for StreamSenderConfigLazy<'a> {}

impl<'a> StreamSenderConfigLazy<'a> {}

impl BaseLen for StreamSenderConfig {
    const BASE_LEN: usize = 0;
}

impl Encode for StreamSenderConfig {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl<'a> Decode<'a> for StreamSenderConfig {
    fn decode(_: &DecodeCursor<'a>) -> DecodeResult<Self> {
        Ok(StreamSenderConfig {})
    }
}

impl<'a> BaseLen for StreamSenderConfigLazy<'a> {
    const BASE_LEN: usize = 0;
}

impl<'a> Encode for StreamSenderConfigLazy<'a> {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl<'a> Decode<'a> for StreamSenderConfigLazy<'a> {
    fn decode(cursor: &DecodeCursor<'a>) -> DecodeResult<Self> {
        let offset = cursor.offset();
        cursor.advance(Self::BASE_LEN);
        Ok(StreamSenderConfigLazy {
            buffer: cursor.buffer(),
            offset,
        })
    }
}

impl<'a> TryFrom<StreamSenderConfigLazy<'a>> for StreamSenderConfig {
    type Error = DecodeError;

    fn try_from(other: StreamSenderConfigLazy<'a>) -> Result<Self, Self::Error> {
        let cursor = DecodeCursor::at_offset(other.buffer, other.offset);
        Decode::decode(&cursor)
    }
}

impl<'a> Copy for StreamSenderConfigLazy<'a> {}

impl<'a> Clone for StreamSenderConfigLazy<'a> {
    fn clone(&self) -> Self {
        Self {
            buffer: self.buffer,
            offset: self.offset,
        }
    }
}

impl<'a> core::fmt::Debug for StreamSenderConfigLazy<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("StreamSenderConfigLazy").finish()
    }
}

impl<'a> PartialEq for StreamSenderConfigLazy<'a> {
    fn eq(&self, _: &Self) -> bool {
        true
    }
}

#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Default)]
pub struct MultiStreamInitState {}

pub struct MultiStreamInitStateLazy<'a> {
    buffer: &'a [u8],
    offset: usize,
}

pub struct MultiStreamInitStateGen {}

impl Compatible<MultiStreamInitState> for MultiStreamInitStateGen {}
impl Compatible<MultiStreamInitStateGen> for MultiStreamInitState {}

impl BaseLen for MultiStreamInitStateGen {
    const BASE_LEN: usize = 0;
}

impl Encode for MultiStreamInitStateGen {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl Owned for MultiStreamInitState {
    type Lazy<'a> = MultiStreamInitStateLazy<'a>;

    fn lazy_to_owned(lazy: Self::Lazy<'_>) -> DecodeResult<Self> {
        TryFrom::try_from(lazy)
    }
}

impl<'a> Lazy<'a> for MultiStreamInitStateLazy<'a> {
    type Owned = MultiStreamInitState;
}

impl<'a> Compatible<MultiStreamInitStateLazy<'a>> for MultiStreamInitStateLazy<'a> {}
impl<'a> Compatible<MultiStreamInitStateLazy<'a>> for MultiStreamInitState {}
impl Compatible<MultiStreamInitState> for MultiStreamInitState {}
impl<'a> Compatible<MultiStreamInitState> for MultiStreamInitStateLazy<'a> {}

impl<'a> MultiStreamInitStateLazy<'a> {}

impl BaseLen for MultiStreamInitState {
    const BASE_LEN: usize = 0;
}

impl Encode for MultiStreamInitState {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl<'a> Decode<'a> for MultiStreamInitState {
    fn decode(_: &DecodeCursor<'a>) -> DecodeResult<Self> {
        Ok(MultiStreamInitState {})
    }
}

impl<'a> BaseLen for MultiStreamInitStateLazy<'a> {
    const BASE_LEN: usize = 0;
}

impl<'a> Encode for MultiStreamInitStateLazy<'a> {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl<'a> Decode<'a> for MultiStreamInitStateLazy<'a> {
    fn decode(cursor: &DecodeCursor<'a>) -> DecodeResult<Self> {
        let offset = cursor.offset();
        cursor.advance(Self::BASE_LEN);
        Ok(MultiStreamInitStateLazy {
            buffer: cursor.buffer(),
            offset,
        })
    }
}

impl<'a> TryFrom<MultiStreamInitStateLazy<'a>> for MultiStreamInitState {
    type Error = DecodeError;

    fn try_from(other: MultiStreamInitStateLazy<'a>) -> Result<Self, Self::Error> {
        let cursor = DecodeCursor::at_offset(other.buffer, other.offset);
        Decode::decode(&cursor)
    }
}

impl<'a> Copy for MultiStreamInitStateLazy<'a> {}

impl<'a> Clone for MultiStreamInitStateLazy<'a> {
    fn clone(&self) -> Self {
        Self {
            buffer: self.buffer,
            offset: self.offset,
        }
    }
}

impl<'a> core::fmt::Debug for MultiStreamInitStateLazy<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("MultiStreamInitStateLazy").finish()
    }
}

impl<'a> PartialEq for MultiStreamInitStateLazy<'a> {
    fn eq(&self, _: &Self) -> bool {
        true
    }
}

#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Default)]
pub struct MultiStreamReceiverConfig {}

pub struct MultiStreamReceiverConfigLazy<'a> {
    buffer: &'a [u8],
    offset: usize,
}

pub struct MultiStreamReceiverConfigGen {}

impl Compatible<MultiStreamReceiverConfig> for MultiStreamReceiverConfigGen {}
impl Compatible<MultiStreamReceiverConfigGen> for MultiStreamReceiverConfig {}

impl BaseLen for MultiStreamReceiverConfigGen {
    const BASE_LEN: usize = 0;
}

impl Encode for MultiStreamReceiverConfigGen {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl Owned for MultiStreamReceiverConfig {
    type Lazy<'a> = MultiStreamReceiverConfigLazy<'a>;

    fn lazy_to_owned(lazy: Self::Lazy<'_>) -> DecodeResult<Self> {
        TryFrom::try_from(lazy)
    }
}

impl<'a> Lazy<'a> for MultiStreamReceiverConfigLazy<'a> {
    type Owned = MultiStreamReceiverConfig;
}

impl<'a> Compatible<MultiStreamReceiverConfigLazy<'a>> for MultiStreamReceiverConfigLazy<'a> {}
impl<'a> Compatible<MultiStreamReceiverConfigLazy<'a>> for MultiStreamReceiverConfig {}
impl Compatible<MultiStreamReceiverConfig> for MultiStreamReceiverConfig {}
impl<'a> Compatible<MultiStreamReceiverConfig> for MultiStreamReceiverConfigLazy<'a> {}

impl<'a> MultiStreamReceiverConfigLazy<'a> {}

impl BaseLen for MultiStreamReceiverConfig {
    const BASE_LEN: usize = 0;
}

impl Encode for MultiStreamReceiverConfig {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl<'a> Decode<'a> for MultiStreamReceiverConfig {
    fn decode(_: &DecodeCursor<'a>) -> DecodeResult<Self> {
        Ok(MultiStreamReceiverConfig {})
    }
}

impl<'a> BaseLen for MultiStreamReceiverConfigLazy<'a> {
    const BASE_LEN: usize = 0;
}

impl<'a> Encode for MultiStreamReceiverConfigLazy<'a> {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl<'a> Decode<'a> for MultiStreamReceiverConfigLazy<'a> {
    fn decode(cursor: &DecodeCursor<'a>) -> DecodeResult<Self> {
        let offset = cursor.offset();
        cursor.advance(Self::BASE_LEN);
        Ok(MultiStreamReceiverConfigLazy {
            buffer: cursor.buffer(),
            offset,
        })
    }
}

impl<'a> TryFrom<MultiStreamReceiverConfigLazy<'a>> for MultiStreamReceiverConfig {
    type Error = DecodeError;

    fn try_from(other: MultiStreamReceiverConfigLazy<'a>) -> Result<Self, Self::Error> {
        let cursor = DecodeCursor::at_offset(other.buffer, other.offset);
        Decode::decode(&cursor)
    }
}

impl<'a> Copy for MultiStreamReceiverConfigLazy<'a> {}

impl<'a> Clone for MultiStreamReceiverConfigLazy<'a> {
    fn clone(&self) -> Self {
        Self {
            buffer: self.buffer,
            offset: self.offset,
        }
    }
}

impl<'a> core::fmt::Debug for MultiStreamReceiverConfigLazy<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("MultiStreamReceiverConfigLazy").finish()
    }
}

impl<'a> PartialEq for MultiStreamReceiverConfigLazy<'a> {
    fn eq(&self, _: &Self) -> bool {
        true
    }
}

#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Default)]
pub struct MultiStreamSenderConfig {}

pub struct MultiStreamSenderConfigLazy<'a> {
    buffer: &'a [u8],
    offset: usize,
}

pub struct MultiStreamSenderConfigGen {}

impl Compatible<MultiStreamSenderConfig> for MultiStreamSenderConfigGen {}
impl Compatible<MultiStreamSenderConfigGen> for MultiStreamSenderConfig {}

impl BaseLen for MultiStreamSenderConfigGen {
    const BASE_LEN: usize = 0;
}

impl Encode for MultiStreamSenderConfigGen {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl Owned for MultiStreamSenderConfig {
    type Lazy<'a> = MultiStreamSenderConfigLazy<'a>;

    fn lazy_to_owned(lazy: Self::Lazy<'_>) -> DecodeResult<Self> {
        TryFrom::try_from(lazy)
    }
}

impl<'a> Lazy<'a> for MultiStreamSenderConfigLazy<'a> {
    type Owned = MultiStreamSenderConfig;
}

impl<'a> Compatible<MultiStreamSenderConfigLazy<'a>> for MultiStreamSenderConfigLazy<'a> {}
impl<'a> Compatible<MultiStreamSenderConfigLazy<'a>> for MultiStreamSenderConfig {}
impl Compatible<MultiStreamSenderConfig> for MultiStreamSenderConfig {}
impl<'a> Compatible<MultiStreamSenderConfig> for MultiStreamSenderConfigLazy<'a> {}

impl<'a> MultiStreamSenderConfigLazy<'a> {}

impl BaseLen for MultiStreamSenderConfig {
    const BASE_LEN: usize = 0;
}

impl Encode for MultiStreamSenderConfig {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl<'a> Decode<'a> for MultiStreamSenderConfig {
    fn decode(_: &DecodeCursor<'a>) -> DecodeResult<Self> {
        Ok(MultiStreamSenderConfig {})
    }
}

impl<'a> BaseLen for MultiStreamSenderConfigLazy<'a> {
    const BASE_LEN: usize = 0;
}

impl<'a> Encode for MultiStreamSenderConfigLazy<'a> {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl<'a> Decode<'a> for MultiStreamSenderConfigLazy<'a> {
    fn decode(cursor: &DecodeCursor<'a>) -> DecodeResult<Self> {
        let offset = cursor.offset();
        cursor.advance(Self::BASE_LEN);
        Ok(MultiStreamSenderConfigLazy {
            buffer: cursor.buffer(),
            offset,
        })
    }
}

impl<'a> TryFrom<MultiStreamSenderConfigLazy<'a>> for MultiStreamSenderConfig {
    type Error = DecodeError;

    fn try_from(other: MultiStreamSenderConfigLazy<'a>) -> Result<Self, Self::Error> {
        let cursor = DecodeCursor::at_offset(other.buffer, other.offset);
        Decode::decode(&cursor)
    }
}

impl<'a> Copy for MultiStreamSenderConfigLazy<'a> {}

impl<'a> Clone for MultiStreamSenderConfigLazy<'a> {
    fn clone(&self) -> Self {
        Self {
            buffer: self.buffer,
            offset: self.offset,
        }
    }
}

impl<'a> core::fmt::Debug for MultiStreamSenderConfigLazy<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("MultiStreamSenderConfigLazy").finish()
    }
}

impl<'a> PartialEq for MultiStreamSenderConfigLazy<'a> {
    fn eq(&self, _: &Self) -> bool {
        true
    }
}

#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Default)]
pub struct ByteStreamInitState {}

pub struct ByteStreamInitStateLazy<'a> {
    buffer: &'a [u8],
    offset: usize,
}

pub struct ByteStreamInitStateGen {}

impl Compatible<ByteStreamInitState> for ByteStreamInitStateGen {}
impl Compatible<ByteStreamInitStateGen> for ByteStreamInitState {}

impl BaseLen for ByteStreamInitStateGen {
    const BASE_LEN: usize = 0;
}

impl Encode for ByteStreamInitStateGen {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl Owned for ByteStreamInitState {
    type Lazy<'a> = ByteStreamInitStateLazy<'a>;

    fn lazy_to_owned(lazy: Self::Lazy<'_>) -> DecodeResult<Self> {
        TryFrom::try_from(lazy)
    }
}

impl<'a> Lazy<'a> for ByteStreamInitStateLazy<'a> {
    type Owned = ByteStreamInitState;
}

impl<'a> Compatible<ByteStreamInitStateLazy<'a>> for ByteStreamInitStateLazy<'a> {}
impl<'a> Compatible<ByteStreamInitStateLazy<'a>> for ByteStreamInitState {}
impl Compatible<ByteStreamInitState> for ByteStreamInitState {}
impl<'a> Compatible<ByteStreamInitState> for ByteStreamInitStateLazy<'a> {}

impl<'a> ByteStreamInitStateLazy<'a> {}

impl BaseLen for ByteStreamInitState {
    const BASE_LEN: usize = 0;
}

impl Encode for ByteStreamInitState {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl<'a> Decode<'a> for ByteStreamInitState {
    fn decode(_: &DecodeCursor<'a>) -> DecodeResult<Self> {
        Ok(ByteStreamInitState {})
    }
}

impl<'a> BaseLen for ByteStreamInitStateLazy<'a> {
    const BASE_LEN: usize = 0;
}

impl<'a> Encode for ByteStreamInitStateLazy<'a> {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl<'a> Decode<'a> for ByteStreamInitStateLazy<'a> {
    fn decode(cursor: &DecodeCursor<'a>) -> DecodeResult<Self> {
        let offset = cursor.offset();
        cursor.advance(Self::BASE_LEN);
        Ok(ByteStreamInitStateLazy {
            buffer: cursor.buffer(),
            offset,
        })
    }
}

impl<'a> TryFrom<ByteStreamInitStateLazy<'a>> for ByteStreamInitState {
    type Error = DecodeError;

    fn try_from(other: ByteStreamInitStateLazy<'a>) -> Result<Self, Self::Error> {
        let cursor = DecodeCursor::at_offset(other.buffer, other.offset);
        Decode::decode(&cursor)
    }
}

impl<'a> Copy for ByteStreamInitStateLazy<'a> {}

impl<'a> Clone for ByteStreamInitStateLazy<'a> {
    fn clone(&self) -> Self {
        Self {
            buffer: self.buffer,
            offset: self.offset,
        }
    }
}

impl<'a> core::fmt::Debug for ByteStreamInitStateLazy<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("ByteStreamInitStateLazy").finish()
    }
}

impl<'a> PartialEq for ByteStreamInitStateLazy<'a> {
    fn eq(&self, _: &Self) -> bool {
        true
    }
}

#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Default)]
pub struct ByteStreamReceiverConfig {}

pub struct ByteStreamReceiverConfigLazy<'a> {
    buffer: &'a [u8],
    offset: usize,
}

pub struct ByteStreamReceiverConfigGen {}

impl Compatible<ByteStreamReceiverConfig> for ByteStreamReceiverConfigGen {}
impl Compatible<ByteStreamReceiverConfigGen> for ByteStreamReceiverConfig {}

impl BaseLen for ByteStreamReceiverConfigGen {
    const BASE_LEN: usize = 0;
}

impl Encode for ByteStreamReceiverConfigGen {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl Owned for ByteStreamReceiverConfig {
    type Lazy<'a> = ByteStreamReceiverConfigLazy<'a>;

    fn lazy_to_owned(lazy: Self::Lazy<'_>) -> DecodeResult<Self> {
        TryFrom::try_from(lazy)
    }
}

impl<'a> Lazy<'a> for ByteStreamReceiverConfigLazy<'a> {
    type Owned = ByteStreamReceiverConfig;
}

impl<'a> Compatible<ByteStreamReceiverConfigLazy<'a>> for ByteStreamReceiverConfigLazy<'a> {}
impl<'a> Compatible<ByteStreamReceiverConfigLazy<'a>> for ByteStreamReceiverConfig {}
impl Compatible<ByteStreamReceiverConfig> for ByteStreamReceiverConfig {}
impl<'a> Compatible<ByteStreamReceiverConfig> for ByteStreamReceiverConfigLazy<'a> {}

impl<'a> ByteStreamReceiverConfigLazy<'a> {}

impl BaseLen for ByteStreamReceiverConfig {
    const BASE_LEN: usize = 0;
}

impl Encode for ByteStreamReceiverConfig {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl<'a> Decode<'a> for ByteStreamReceiverConfig {
    fn decode(_: &DecodeCursor<'a>) -> DecodeResult<Self> {
        Ok(ByteStreamReceiverConfig {})
    }
}

impl<'a> BaseLen for ByteStreamReceiverConfigLazy<'a> {
    const BASE_LEN: usize = 0;
}

impl<'a> Encode for ByteStreamReceiverConfigLazy<'a> {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl<'a> Decode<'a> for ByteStreamReceiverConfigLazy<'a> {
    fn decode(cursor: &DecodeCursor<'a>) -> DecodeResult<Self> {
        let offset = cursor.offset();
        cursor.advance(Self::BASE_LEN);
        Ok(ByteStreamReceiverConfigLazy {
            buffer: cursor.buffer(),
            offset,
        })
    }
}

impl<'a> TryFrom<ByteStreamReceiverConfigLazy<'a>> for ByteStreamReceiverConfig {
    type Error = DecodeError;

    fn try_from(other: ByteStreamReceiverConfigLazy<'a>) -> Result<Self, Self::Error> {
        let cursor = DecodeCursor::at_offset(other.buffer, other.offset);
        Decode::decode(&cursor)
    }
}

impl<'a> Copy for ByteStreamReceiverConfigLazy<'a> {}

impl<'a> Clone for ByteStreamReceiverConfigLazy<'a> {
    fn clone(&self) -> Self {
        Self {
            buffer: self.buffer,
            offset: self.offset,
        }
    }
}

impl<'a> core::fmt::Debug for ByteStreamReceiverConfigLazy<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("ByteStreamReceiverConfigLazy").finish()
    }
}

impl<'a> PartialEq for ByteStreamReceiverConfigLazy<'a> {
    fn eq(&self, _: &Self) -> bool {
        true
    }
}

#[derive(Copy, Clone, Debug, PartialEq, PartialOrd, Eq, Ord, Hash, Default)]
pub struct ByteStreamSenderConfig {}

pub struct ByteStreamSenderConfigLazy<'a> {
    buffer: &'a [u8],
    offset: usize,
}

pub struct ByteStreamSenderConfigGen {}

impl Compatible<ByteStreamSenderConfig> for ByteStreamSenderConfigGen {}
impl Compatible<ByteStreamSenderConfigGen> for ByteStreamSenderConfig {}

impl BaseLen for ByteStreamSenderConfigGen {
    const BASE_LEN: usize = 0;
}

impl Encode for ByteStreamSenderConfigGen {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl Owned for ByteStreamSenderConfig {
    type Lazy<'a> = ByteStreamSenderConfigLazy<'a>;

    fn lazy_to_owned(lazy: Self::Lazy<'_>) -> DecodeResult<Self> {
        TryFrom::try_from(lazy)
    }
}

impl<'a> Lazy<'a> for ByteStreamSenderConfigLazy<'a> {
    type Owned = ByteStreamSenderConfig;
}

impl<'a> Compatible<ByteStreamSenderConfigLazy<'a>> for ByteStreamSenderConfigLazy<'a> {}
impl<'a> Compatible<ByteStreamSenderConfigLazy<'a>> for ByteStreamSenderConfig {}
impl Compatible<ByteStreamSenderConfig> for ByteStreamSenderConfig {}
impl<'a> Compatible<ByteStreamSenderConfig> for ByteStreamSenderConfigLazy<'a> {}

impl<'a> ByteStreamSenderConfigLazy<'a> {}

impl BaseLen for ByteStreamSenderConfig {
    const BASE_LEN: usize = 0;
}

impl Encode for ByteStreamSenderConfig {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl<'a> Decode<'a> for ByteStreamSenderConfig {
    fn decode(_: &DecodeCursor<'a>) -> DecodeResult<Self> {
        Ok(ByteStreamSenderConfig {})
    }
}

impl<'a> BaseLen for ByteStreamSenderConfigLazy<'a> {
    const BASE_LEN: usize = 0;
}

impl<'a> Encode for ByteStreamSenderConfigLazy<'a> {
    fn scratch_len(&self) -> usize {
        0
    }

    fn encode(&self, _: &mut EncodeCursor) {}
}

impl<'a> Decode<'a> for ByteStreamSenderConfigLazy<'a> {
    fn decode(cursor: &DecodeCursor<'a>) -> DecodeResult<Self> {
        let offset = cursor.offset();
        cursor.advance(Self::BASE_LEN);
        Ok(ByteStreamSenderConfigLazy {
            buffer: cursor.buffer(),
            offset,
        })
    }
}

impl<'a> TryFrom<ByteStreamSenderConfigLazy<'a>> for ByteStreamSenderConfig {
    type Error = DecodeError;

    fn try_from(other: ByteStreamSenderConfigLazy<'a>) -> Result<Self, Self::Error> {
        let cursor = DecodeCursor::at_offset(other.buffer, other.offset);
        Decode::decode(&cursor)
    }
}

impl<'a> Copy for ByteStreamSenderConfigLazy<'a> {}

impl<'a> Clone for ByteStreamSenderConfigLazy<'a> {
    fn clone(&self) -> Self {
        Self {
            buffer: self.buffer,
            offset: self.offset,
        }
    }
}

impl<'a> core::fmt::Debug for ByteStreamSenderConfigLazy<'a> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("ByteStreamSenderConfigLazy").finish()
    }
}

impl<'a> PartialEq for ByteStreamSenderConfigLazy<'a> {
    fn eq(&self, _: &Self) -> bool {
        true
    }
}