Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

61.5 KB
Raw Blame
//
// This code was generated by a tool.
//
//
//   bebopc version:
//       3.1.3
//
//
//   bebopc source:
//       https://github.com/betwixt-labs/bebop
//
//
// Changes to this file may cause incorrect behavior and will be lost if
// the code is regenerated.
//

#![allow(warnings)]

use ::std::io::Write as _;
use ::core::convert::TryInto as _;
use ::bebop::FixedSized as _;

#[derive(Clone, Debug, PartialEq)]
pub enum FromPeer<'raw> {
    /// An unknown type which is likely defined in a newer version of the schema.
    Unknown,

    /// Discriminator 1
    PeerUpdate {
        updates: ::std::vec::Vec<::bebop::SliceWrapper<'raw, u8>>,
        id: &'raw str,
    },

    /// Discriminator 2
    PeerAwareness {
        awareness: ::bebop::SliceWrapper<'raw, u8>,
    },

    /// Discriminator 3
    PeerRequestSince {
        vv: ::bebop::SliceWrapper<'raw, u8>,
    },

    /// Discriminator 4
    PeerRequestSnapshot {
    },

    /// Discriminator 5
    PeerRegisterId {
        peerid: u64,
    },

    /// Discriminator 6
    PeerCommentUpdate {
        updates: ::std::vec::Vec<::bebop::SliceWrapper<'raw, u8>>,
        id: &'raw str,
    },
}

impl<'raw> ::bebop::SubRecord<'raw> for FromPeer<'raw> {
    const MIN_SERIALIZED_SIZE: usize = ::bebop::LEN_SIZE + 1;

    fn serialized_size(&self) -> usize {
        ::bebop::LEN_SIZE + 1 +
        match self {
            FromPeer::Unknown => {
                0
            }
            Self::PeerUpdate {
                updates: ref _updates,
                id: ref _id,
            }
            => {
                _updates.serialized_size() +
                _id.serialized_size()
            }
            Self::PeerAwareness {
                awareness: ref _awareness,
            }
            => {
                _awareness.serialized_size()
            }
            Self::PeerRequestSince {
                vv: ref _vv,
            }
            => {
                _vv.serialized_size()
            }
            Self::PeerRequestSnapshot {
            }
            => {
                0
            }
            Self::PeerRegisterId {
                peerid: ref _peerid,
            }
            => {
                _peerid.serialized_size()
            }
            Self::PeerCommentUpdate {
                updates: ref _updates,
                id: ref _id,
            }
            => {
                _updates.serialized_size() +
                _id.serialized_size()
            }
        }
    }

    ::bebop::define_serialize_chained!(Self => |zelf, dest| {
        let size = zelf.serialized_size();
        ::bebop::write_len(dest, size - ::bebop::LEN_SIZE - 1)?;
        match zelf {
            Self::Unknown => {
                return Err(::bebop::SerializeError::CannotSerializeUnknownUnion);
            }
            Self::PeerUpdate {
                updates: ref _updates,
                id: ref _id,
            }
            => {
                1u8._serialize_chained(dest)?;
                _updates._serialize_chained(dest)?;
                _id._serialize_chained(dest)?;
            }
            Self::PeerAwareness {
                awareness: ref _awareness,
            }
            => {
                2u8._serialize_chained(dest)?;
                _awareness._serialize_chained(dest)?;
            }
            Self::PeerRequestSince {
                vv: ref _vv,
            }
            => {
                3u8._serialize_chained(dest)?;
                _vv._serialize_chained(dest)?;
            }
            Self::PeerRequestSnapshot {
            }
            => {
                4u8._serialize_chained(dest)?;
            }
            Self::PeerRegisterId {
                peerid: ref _peerid,
            }
            => {
                5u8._serialize_chained(dest)?;
                _peerid._serialize_chained(dest)?;
            }
            Self::PeerCommentUpdate {
                updates: ref _updates,
                id: ref _id,
            }
            => {
                6u8._serialize_chained(dest)?;
                _updates._serialize_chained(dest)?;
                _id._serialize_chained(dest)?;
            }
        }
        Ok(size)
    });

    fn _deserialize_chained(raw: &'raw [u8]) -> ::bebop::DeResult<(usize, Self)> {
        let len = ::bebop::read_len(raw)? + ::bebop::LEN_SIZE + 1;
        let mut i = ::bebop::LEN_SIZE + 1;
        let de = match raw[::bebop::LEN_SIZE] {
            1 => {
                let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                i += read;
                let (read, v1) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                i += read;

                FromPeer::PeerUpdate {
                    updates: v0,
                    id: v1,
                }
            }
            2 => {
                let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                i += read;

                FromPeer::PeerAwareness {
                    awareness: v0,
                }
            }
            3 => {
                let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                i += read;

                FromPeer::PeerRequestSince {
                    vv: v0,
                }
            }
            4 => {
                FromPeer::PeerRequestSnapshot {}
            }
            5 => {
                let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                i += read;

                FromPeer::PeerRegisterId {
                    peerid: v0,
                }
            }
            6 => {
                let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                i += read;
                let (read, v1) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                i += read;

                FromPeer::PeerCommentUpdate {
                    updates: v0,
                    id: v1,
                }
            }
            _ => {
                i = len;
                FromPeer::Unknown
            }
        };
        if !cfg!(feature = "unchecked") && i != len {
            debug_assert!(i > len);
            Err(::bebop::DeserializeError::CorruptFrame)
        }
        else {
            Ok((i, de))
        }
    }

}

impl<'raw> ::bebop::Record<'raw> for FromPeer<'raw> {}

#[derive(Clone, Debug, PartialEq)]
pub enum FromRemote<'raw> {
    /// An unknown type which is likely defined in a newer version of the schema.
    Unknown,

    /// Discriminator 1
    RemoteInitialSync {
        snapshot: ::bebop::SliceWrapper<'raw, u8>,
        awareness: ::bebop::SliceWrapper<'raw, u8>,
    },

    /// Discriminator 2
    RemoteUpdate {
        update: ::bebop::SliceWrapper<'raw, u8>,
    },

    /// Discriminator 3
    RemoteAwareness {
        awareness: ::bebop::SliceWrapper<'raw, u8>,
    },

    /// Discriminator 4
    RemoteSnapshot {
        snapshot: ::bebop::SliceWrapper<'raw, u8>,
    },

    /// Discriminator 5
    RemoteUpdateAck {
        id: &'raw str,
    },

    /// Discriminator 6
    RemoteUpdateSince {
        update: ::bebop::SliceWrapper<'raw, u8>,
        vv: ::bebop::SliceWrapper<'raw, u8>,
    },
}

impl<'raw> ::bebop::SubRecord<'raw> for FromRemote<'raw> {
    const MIN_SERIALIZED_SIZE: usize = ::bebop::LEN_SIZE + 1;

    fn serialized_size(&self) -> usize {
        ::bebop::LEN_SIZE + 1 +
        match self {
            FromRemote::Unknown => {
                0
            }
            Self::RemoteInitialSync {
                snapshot: ref _snapshot,
                awareness: ref _awareness,
            }
            => {
                _snapshot.serialized_size() +
                _awareness.serialized_size()
            }
            Self::RemoteUpdate {
                update: ref _update,
            }
            => {
                _update.serialized_size()
            }
            Self::RemoteAwareness {
                awareness: ref _awareness,
            }
            => {
                _awareness.serialized_size()
            }
            Self::RemoteSnapshot {
                snapshot: ref _snapshot,
            }
            => {
                _snapshot.serialized_size()
            }
            Self::RemoteUpdateAck {
                id: ref _id,
            }
            => {
                _id.serialized_size()
            }
            Self::RemoteUpdateSince {
                update: ref _update,
                vv: ref _vv,
            }
            => {
                _update.serialized_size() +
                _vv.serialized_size()
            }
        }
    }

    ::bebop::define_serialize_chained!(Self => |zelf, dest| {
        let size = zelf.serialized_size();
        ::bebop::write_len(dest, size - ::bebop::LEN_SIZE - 1)?;
        match zelf {
            Self::Unknown => {
                return Err(::bebop::SerializeError::CannotSerializeUnknownUnion);
            }
            Self::RemoteInitialSync {
                snapshot: ref _snapshot,
                awareness: ref _awareness,
            }
            => {
                1u8._serialize_chained(dest)?;
                _snapshot._serialize_chained(dest)?;
                _awareness._serialize_chained(dest)?;
            }
            Self::RemoteUpdate {
                update: ref _update,
            }
            => {
                2u8._serialize_chained(dest)?;
                _update._serialize_chained(dest)?;
            }
            Self::RemoteAwareness {
                awareness: ref _awareness,
            }
            => {
                3u8._serialize_chained(dest)?;
                _awareness._serialize_chained(dest)?;
            }
            Self::RemoteSnapshot {
                snapshot: ref _snapshot,
            }
            => {
                4u8._serialize_chained(dest)?;
                _snapshot._serialize_chained(dest)?;
            }
            Self::RemoteUpdateAck {
                id: ref _id,
            }
            => {
                5u8._serialize_chained(dest)?;
                _id._serialize_chained(dest)?;
            }
            Self::RemoteUpdateSince {
                update: ref _update,
                vv: ref _vv,
            }
            => {
                6u8._serialize_chained(dest)?;
                _update._serialize_chained(dest)?;
                _vv._serialize_chained(dest)?;
            }
        }
        Ok(size)
    });

    fn _deserialize_chained(raw: &'raw [u8]) -> ::bebop::DeResult<(usize, Self)> {
        let len = ::bebop::read_len(raw)? + ::bebop::LEN_SIZE + 1;
        let mut i = ::bebop::LEN_SIZE + 1;
        let de = match raw[::bebop::LEN_SIZE] {
            1 => {
                let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                i += read;
                let (read, v1) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                i += read;

                FromRemote::RemoteInitialSync {
                    snapshot: v0,
                    awareness: v1,
                }
            }
            2 => {
                let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                i += read;

                FromRemote::RemoteUpdate {
                    update: v0,
                }
            }
            3 => {
                let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                i += read;

                FromRemote::RemoteAwareness {
                    awareness: v0,
                }
            }
            4 => {
                let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                i += read;

                FromRemote::RemoteSnapshot {
                    snapshot: v0,
                }
            }
            5 => {
                let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                i += read;

                FromRemote::RemoteUpdateAck {
                    id: v0,
                }
            }
            6 => {
                let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                i += read;
                let (read, v1) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                i += read;

                FromRemote::RemoteUpdateSince {
                    update: v0,
                    vv: v1,
                }
            }
            _ => {
                i = len;
                FromRemote::Unknown
            }
        };
        if !cfg!(feature = "unchecked") && i != len {
            debug_assert!(i > len);
            Err(::bebop::DeserializeError::CorruptFrame)
        }
        else {
            Ok((i, de))
        }
    }

}

impl<'raw> ::bebop::Record<'raw> for FromRemote<'raw> {}

#[derive(Clone, Debug, PartialEq)]
pub struct Operation<'raw> {
    pub update: ::bebop::SliceWrapper<'raw, u8>,
    pub timestamp: ::bebop::Date,
}

impl<'raw> ::bebop::SubRecord<'raw> for Operation<'raw> {
    const MIN_SERIALIZED_SIZE: usize =
        <::bebop::SliceWrapper<'raw, u8>>::MIN_SERIALIZED_SIZE +
        <::bebop::Date>::MIN_SERIALIZED_SIZE;

    #[inline]
    fn serialized_size(&self) -> usize {
        self.update.serialized_size() +
        self.timestamp.serialized_size()
    }

    ::bebop::define_serialize_chained!(Self => |zelf, dest| {
        Ok(
            zelf.update._serialize_chained(dest)? +
            zelf.timestamp._serialize_chained(dest)?
        )
    });

    fn _deserialize_chained(raw: &'raw [u8]) -> ::bebop::DeResult<(usize, Self)> {
        let mut i = 0;
        if raw.len() - i < Self::MIN_SERIALIZED_SIZE {
            let missing = Self::MIN_SERIALIZED_SIZE - (raw.len() - i);
            return Err(::bebop::DeserializeError::MoreDataExpected(missing));
        }

        let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
        i += read;
        let (read, v1) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
        i += read;

        Ok((i, Self {
            update: v0,
            timestamp: v1,
        }))
    }
}

impl<'raw> ::bebop::Record<'raw> for Operation<'raw> {}

#[derive(Clone, Debug, PartialEq)]
pub struct OperationLog<'raw> {
    pub operations: ::std::vec::Vec<Operation<'raw>>,
}

impl<'raw> ::bebop::SubRecord<'raw> for OperationLog<'raw> {
    const MIN_SERIALIZED_SIZE: usize =
        <::std::vec::Vec<Operation<'raw>>>::MIN_SERIALIZED_SIZE;

    #[inline]
    fn serialized_size(&self) -> usize {
        self.operations.serialized_size()
    }

    ::bebop::define_serialize_chained!(Self => |zelf, dest| {
        Ok(
            zelf.operations._serialize_chained(dest)?
        )
    });

    fn _deserialize_chained(raw: &'raw [u8]) -> ::bebop::DeResult<(usize, Self)> {
        let mut i = 0;
        if raw.len() - i < Self::MIN_SERIALIZED_SIZE {
            let missing = Self::MIN_SERIALIZED_SIZE - (raw.len() - i);
            return Err(::bebop::DeserializeError::MoreDataExpected(missing));
        }

        let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
        i += read;

        Ok((i, Self {
            operations: v0,
        }))
    }
}

impl<'raw> ::bebop::Record<'raw> for OperationLog<'raw> {}

#[derive(Clone, Debug, PartialEq)]
pub struct InitializeFromSnapshotRequest<'raw> {
    pub snapshot: ::bebop::SliceWrapper<'raw, u8>,
}

impl<'raw> ::bebop::SubRecord<'raw> for InitializeFromSnapshotRequest<'raw> {
    const MIN_SERIALIZED_SIZE: usize =
        <::bebop::SliceWrapper<'raw, u8>>::MIN_SERIALIZED_SIZE;

    #[inline]
    fn serialized_size(&self) -> usize {
        self.snapshot.serialized_size()
    }

    ::bebop::define_serialize_chained!(Self => |zelf, dest| {
        Ok(
            zelf.snapshot._serialize_chained(dest)?
        )
    });

    fn _deserialize_chained(raw: &'raw [u8]) -> ::bebop::DeResult<(usize, Self)> {
        let mut i = 0;
        if raw.len() - i < Self::MIN_SERIALIZED_SIZE {
            let missing = Self::MIN_SERIALIZED_SIZE - (raw.len() - i);
            return Err(::bebop::DeserializeError::MoreDataExpected(missing));
        }

        let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
        i += read;

        Ok((i, Self {
            snapshot: v0,
        }))
    }
}

impl<'raw> ::bebop::Record<'raw> for InitializeFromSnapshotRequest<'raw> {}

/// Multiplex envelope between the browser and the sync-router (rides the
/// dedicated DSS /sync/ws socket as binary frames). Inner payloads are the
/// existing FromPeer/FromRemote unions, already bebop-encoded — the router
/// forwards them without parsing.
#[derive(Clone, Debug, PartialEq)]
pub enum ToRouter<'raw> {
    /// An unknown type which is likely defined in a newer version of the schema.
    Unknown,

    /// Discriminator 1
    RouterSubscribe {
        doc_id: &'raw str,
        token: &'raw str,
    },

    /// Discriminator 2
    RouterUnsubscribe {
        doc_id: &'raw str,
    },

    /// Discriminator 3
    RouterFrame {
        doc_id: &'raw str,
        payload: ::bebop::SliceWrapper<'raw, u8>,
    },
}

impl<'raw> ::bebop::SubRecord<'raw> for ToRouter<'raw> {
    const MIN_SERIALIZED_SIZE: usize = ::bebop::LEN_SIZE + 1;

    fn serialized_size(&self) -> usize {
        ::bebop::LEN_SIZE + 1 +
        match self {
            ToRouter::Unknown => {
                0
            }
            Self::RouterSubscribe {
                doc_id: ref _doc_id,
                token: ref _token,
            }
            => {
                _doc_id.serialized_size() +
                _token.serialized_size()
            }
            Self::RouterUnsubscribe {
                doc_id: ref _doc_id,
            }
            => {
                _doc_id.serialized_size()
            }
            Self::RouterFrame {
                doc_id: ref _doc_id,
                payload: ref _payload,
            }
            => {
                _doc_id.serialized_size() +
                _payload.serialized_size()
            }
        }
    }

    ::bebop::define_serialize_chained!(Self => |zelf, dest| {
        let size = zelf.serialized_size();
        ::bebop::write_len(dest, size - ::bebop::LEN_SIZE - 1)?;
        match zelf {
            Self::Unknown => {
                return Err(::bebop::SerializeError::CannotSerializeUnknownUnion);
            }
            Self::RouterSubscribe {
                doc_id: ref _doc_id,
                token: ref _token,
            }
            => {
                1u8._serialize_chained(dest)?;
                _doc_id._serialize_chained(dest)?;
                _token._serialize_chained(dest)?;
            }
            Self::RouterUnsubscribe {
                doc_id: ref _doc_id,
            }
            => {
                2u8._serialize_chained(dest)?;
                _doc_id._serialize_chained(dest)?;
            }
            Self::RouterFrame {
                doc_id: ref _doc_id,
                payload: ref _payload,
            }
            => {
                3u8._serialize_chained(dest)?;
                _doc_id._serialize_chained(dest)?;
                _payload._serialize_chained(dest)?;
            }
        }
        Ok(size)
    });

    fn _deserialize_chained(raw: &'raw [u8]) -> ::bebop::DeResult<(usize, Self)> {
        let len = ::bebop::read_len(raw)? + ::bebop::LEN_SIZE + 1;
        let mut i = ::bebop::LEN_SIZE + 1;
        let de = match raw[::bebop::LEN_SIZE] {
            1 => {
                let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                i += read;
                let (read, v1) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                i += read;

                ToRouter::RouterSubscribe {
                    doc_id: v0,
                    token: v1,
                }
            }
            2 => {
                let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                i += read;

                ToRouter::RouterUnsubscribe {
                    doc_id: v0,
                }
            }
            3 => {
                let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                i += read;
                let (read, v1) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                i += read;

                ToRouter::RouterFrame {
                    doc_id: v0,
                    payload: v1,
                }
            }
            _ => {
                i = len;
                ToRouter::Unknown
            }
        };
        if !cfg!(feature = "unchecked") && i != len {
            debug_assert!(i > len);
            Err(::bebop::DeserializeError::CorruptFrame)
        }
        else {
            Ok((i, de))
        }
    }

}

impl<'raw> ::bebop::Record<'raw> for ToRouter<'raw> {}

#[derive(Clone, Debug, PartialEq)]
pub enum FromRouter<'raw> {
    /// An unknown type which is likely defined in a newer version of the schema.
    Unknown,

    /// Discriminator 1
    RouterSubscribed {
        doc_id: &'raw str,
    },

    /// Discriminator 2
    RouterSubscribeFailed {
        doc_id: &'raw str,
        reason: &'raw str,
    },

    /// Discriminator 3
    RouterDocFrame {
        doc_id: &'raw str,
        payload: ::bebop::SliceWrapper<'raw, u8>,
    },

    /// Discriminator 4
    RouterDocClosed {
        doc_id: &'raw str,
        reason: &'raw str,
    },
}

impl<'raw> ::bebop::SubRecord<'raw> for FromRouter<'raw> {
    const MIN_SERIALIZED_SIZE: usize = ::bebop::LEN_SIZE + 1;

    fn serialized_size(&self) -> usize {
        ::bebop::LEN_SIZE + 1 +
        match self {
            FromRouter::Unknown => {
                0
            }
            Self::RouterSubscribed {
                doc_id: ref _doc_id,
            }
            => {
                _doc_id.serialized_size()
            }
            Self::RouterSubscribeFailed {
                doc_id: ref _doc_id,
                reason: ref _reason,
            }
            => {
                _doc_id.serialized_size() +
                _reason.serialized_size()
            }
            Self::RouterDocFrame {
                doc_id: ref _doc_id,
                payload: ref _payload,
            }
            => {
                _doc_id.serialized_size() +
                _payload.serialized_size()
            }
            Self::RouterDocClosed {
                doc_id: ref _doc_id,
                reason: ref _reason,
            }
            => {
                _doc_id.serialized_size() +
                _reason.serialized_size()
            }
        }
    }

    ::bebop::define_serialize_chained!(Self => |zelf, dest| {
        let size = zelf.serialized_size();
        ::bebop::write_len(dest, size - ::bebop::LEN_SIZE - 1)?;
        match zelf {
            Self::Unknown => {
                return Err(::bebop::SerializeError::CannotSerializeUnknownUnion);
            }
            Self::RouterSubscribed {
                doc_id: ref _doc_id,
            }
            => {
                1u8._serialize_chained(dest)?;
                _doc_id._serialize_chained(dest)?;
            }
            Self::RouterSubscribeFailed {
                doc_id: ref _doc_id,
                reason: ref _reason,
            }
            => {
                2u8._serialize_chained(dest)?;
                _doc_id._serialize_chained(dest)?;
                _reason._serialize_chained(dest)?;
            }
            Self::RouterDocFrame {
                doc_id: ref _doc_id,
                payload: ref _payload,
            }
            => {
                3u8._serialize_chained(dest)?;
                _doc_id._serialize_chained(dest)?;
                _payload._serialize_chained(dest)?;
            }
            Self::RouterDocClosed {
                doc_id: ref _doc_id,
                reason: ref _reason,
            }
            => {
                4u8._serialize_chained(dest)?;
                _doc_id._serialize_chained(dest)?;
                _reason._serialize_chained(dest)?;
            }
        }
        Ok(size)
    });

    fn _deserialize_chained(raw: &'raw [u8]) -> ::bebop::DeResult<(usize, Self)> {
        let len = ::bebop::read_len(raw)? + ::bebop::LEN_SIZE + 1;
        let mut i = ::bebop::LEN_SIZE + 1;
        let de = match raw[::bebop::LEN_SIZE] {
            1 => {
                let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                i += read;

                FromRouter::RouterSubscribed {
                    doc_id: v0,
                }
            }
            2 => {
                let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                i += read;
                let (read, v1) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                i += read;

                FromRouter::RouterSubscribeFailed {
                    doc_id: v0,
                    reason: v1,
                }
            }
            3 => {
                let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                i += read;
                let (read, v1) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                i += read;

                FromRouter::RouterDocFrame {
                    doc_id: v0,
                    payload: v1,
                }
            }
            4 => {
                let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                i += read;
                let (read, v1) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                i += read;

                FromRouter::RouterDocClosed {
                    doc_id: v0,
                    reason: v1,
                }
            }
            _ => {
                i = len;
                FromRouter::Unknown
            }
        };
        if !cfg!(feature = "unchecked") && i != len {
            debug_assert!(i > len);
            Err(::bebop::DeserializeError::CorruptFrame)
        }
        else {
            Ok((i, de))
        }
    }

}

impl<'raw> ::bebop::Record<'raw> for FromRouter<'raw> {}

#[cfg(feature = "bebop-owned-all")]
pub mod owned {
    #![allow(warnings)]

    use ::std::io::Write as _;
    use ::core::convert::TryInto as _;
    use ::bebop::FixedSized as _;

    #[derive(Clone, Debug, PartialEq)]
    pub enum FromPeer {
        /// An unknown type which is likely defined in a newer version of the schema.
        Unknown,

        /// Discriminator 1
        PeerUpdate {
            updates: ::std::vec::Vec<::std::vec::Vec<u8>>,
            id: String,
        },

        /// Discriminator 2
        PeerAwareness {
            awareness: ::std::vec::Vec<u8>,
        },

        /// Discriminator 3
        PeerRequestSince {
            vv: ::std::vec::Vec<u8>,
        },

        /// Discriminator 4
        PeerRequestSnapshot {
        },

        /// Discriminator 5
        PeerRegisterId {
            peerid: u64,
        },

        /// Discriminator 6
        PeerCommentUpdate {
            updates: ::std::vec::Vec<::std::vec::Vec<u8>>,
            id: String,
        },
    }

    impl<'raw> ::core::convert::From<super::FromPeer<'raw>> for FromPeer {
        fn from(value: super::FromPeer) -> Self {
            match value {
                super::FromPeer::Unknown => {
                    Self::Unknown
                }
                super::FromPeer::PeerUpdate {
                    updates: _updates,
                    id: _id,
                }
                => {
                    Self::PeerUpdate {
                        updates: _updates.into_iter().map(|value| value.iter().map(|value| value).collect()).collect(),
                        id: _id.into(),
                    }
                }
                super::FromPeer::PeerAwareness {
                    awareness: _awareness,
                }
                => {
                    Self::PeerAwareness {
                        awareness: _awareness.iter().map(|value| value).collect(),
                    }
                }
                super::FromPeer::PeerRequestSince {
                    vv: _vv,
                }
                => {
                    Self::PeerRequestSince {
                        vv: _vv.iter().map(|value| value).collect(),
                    }
                }
                super::FromPeer::PeerRequestSnapshot {
                }
                => {
                    Self::PeerRequestSnapshot {
                    }
                }
                super::FromPeer::PeerRegisterId {
                    peerid: _peerid,
                }
                => {
                    Self::PeerRegisterId {
                        peerid: _peerid,
                    }
                }
                super::FromPeer::PeerCommentUpdate {
                    updates: _updates,
                    id: _id,
                }
                => {
                    Self::PeerCommentUpdate {
                        updates: _updates.into_iter().map(|value| value.iter().map(|value| value).collect()).collect(),
                        id: _id.into(),
                    }
                }
            }
        }

    }
    impl<'raw> ::bebop::SubRecord<'raw> for FromPeer {
        const MIN_SERIALIZED_SIZE: usize = ::bebop::LEN_SIZE + 1;

        fn serialized_size(&self) -> usize {
            ::bebop::LEN_SIZE + 1 +
            match self {
                FromPeer::Unknown => {
                    0
                }
                Self::PeerUpdate {
                    updates: ref _updates,
                    id: ref _id,
                }
                => {
                    _updates.serialized_size() +
                    _id.serialized_size()
                }
                Self::PeerAwareness {
                    awareness: ref _awareness,
                }
                => {
                    _awareness.serialized_size()
                }
                Self::PeerRequestSince {
                    vv: ref _vv,
                }
                => {
                    _vv.serialized_size()
                }
                Self::PeerRequestSnapshot {
                }
                => {
                    0
                }
                Self::PeerRegisterId {
                    peerid: ref _peerid,
                }
                => {
                    _peerid.serialized_size()
                }
                Self::PeerCommentUpdate {
                    updates: ref _updates,
                    id: ref _id,
                }
                => {
                    _updates.serialized_size() +
                    _id.serialized_size()
                }
            }
        }

        ::bebop::define_serialize_chained!(Self => |zelf, dest| {
            let size = zelf.serialized_size();
            ::bebop::write_len(dest, size - ::bebop::LEN_SIZE - 1)?;
            match zelf {
                Self::Unknown => {
                    return Err(::bebop::SerializeError::CannotSerializeUnknownUnion);
                }
                Self::PeerUpdate {
                    updates: ref _updates,
                    id: ref _id,
                }
                => {
                    1u8._serialize_chained(dest)?;
                    _updates._serialize_chained(dest)?;
                    _id._serialize_chained(dest)?;
                }
                Self::PeerAwareness {
                    awareness: ref _awareness,
                }
                => {
                    2u8._serialize_chained(dest)?;
                    _awareness._serialize_chained(dest)?;
                }
                Self::PeerRequestSince {
                    vv: ref _vv,
                }
                => {
                    3u8._serialize_chained(dest)?;
                    _vv._serialize_chained(dest)?;
                }
                Self::PeerRequestSnapshot {
                }
                => {
                    4u8._serialize_chained(dest)?;
                }
                Self::PeerRegisterId {
                    peerid: ref _peerid,
                }
                => {
                    5u8._serialize_chained(dest)?;
                    _peerid._serialize_chained(dest)?;
                }
                Self::PeerCommentUpdate {
                    updates: ref _updates,
                    id: ref _id,
                }
                => {
                    6u8._serialize_chained(dest)?;
                    _updates._serialize_chained(dest)?;
                    _id._serialize_chained(dest)?;
                }
            }
            Ok(size)
        });

        fn _deserialize_chained(raw: &'raw [u8]) -> ::bebop::DeResult<(usize, Self)> {
            let len = ::bebop::read_len(raw)? + ::bebop::LEN_SIZE + 1;
            let mut i = ::bebop::LEN_SIZE + 1;
            let de = match raw[::bebop::LEN_SIZE] {
                1 => {
                    let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                    i += read;
                    let (read, v1) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                    i += read;

                    FromPeer::PeerUpdate {
                        updates: v0,
                        id: v1,
                    }
                }
                2 => {
                    let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                    i += read;

                    FromPeer::PeerAwareness {
                        awareness: v0,
                    }
                }
                3 => {
                    let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                    i += read;

                    FromPeer::PeerRequestSince {
                        vv: v0,
                    }
                }
                4 => {
                    FromPeer::PeerRequestSnapshot {}
                }
                5 => {
                    let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                    i += read;

                    FromPeer::PeerRegisterId {
                        peerid: v0,
                    }
                }
                6 => {
                    let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                    i += read;
                    let (read, v1) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                    i += read;

                    FromPeer::PeerCommentUpdate {
                        updates: v0,
                        id: v1,
                    }
                }
                _ => {
                    i = len;
                    FromPeer::Unknown
                }
            };
            if !cfg!(feature = "unchecked") && i != len {
                debug_assert!(i > len);
                Err(::bebop::DeserializeError::CorruptFrame)
            }
            else {
                Ok((i, de))
            }
        }

    }

    impl<'raw> ::bebop::Record<'raw> for FromPeer {}

    #[derive(Clone, Debug, PartialEq)]
    pub enum FromRemote {
        /// An unknown type which is likely defined in a newer version of the schema.
        Unknown,

        /// Discriminator 1
        RemoteInitialSync {
            snapshot: ::std::vec::Vec<u8>,
            awareness: ::std::vec::Vec<u8>,
        },

        /// Discriminator 2
        RemoteUpdate {
            update: ::std::vec::Vec<u8>,
        },

        /// Discriminator 3
        RemoteAwareness {
            awareness: ::std::vec::Vec<u8>,
        },

        /// Discriminator 4
        RemoteSnapshot {
            snapshot: ::std::vec::Vec<u8>,
        },

        /// Discriminator 5
        RemoteUpdateAck {
            id: String,
        },

        /// Discriminator 6
        RemoteUpdateSince {
            update: ::std::vec::Vec<u8>,
            vv: ::std::vec::Vec<u8>,
        },
    }

    impl<'raw> ::core::convert::From<super::FromRemote<'raw>> for FromRemote {
        fn from(value: super::FromRemote) -> Self {
            match value {
                super::FromRemote::Unknown => {
                    Self::Unknown
                }
                super::FromRemote::RemoteInitialSync {
                    snapshot: _snapshot,
                    awareness: _awareness,
                }
                => {
                    Self::RemoteInitialSync {
                        snapshot: _snapshot.iter().map(|value| value).collect(),
                        awareness: _awareness.iter().map(|value| value).collect(),
                    }
                }
                super::FromRemote::RemoteUpdate {
                    update: _update,
                }
                => {
                    Self::RemoteUpdate {
                        update: _update.iter().map(|value| value).collect(),
                    }
                }
                super::FromRemote::RemoteAwareness {
                    awareness: _awareness,
                }
                => {
                    Self::RemoteAwareness {
                        awareness: _awareness.iter().map(|value| value).collect(),
                    }
                }
                super::FromRemote::RemoteSnapshot {
                    snapshot: _snapshot,
                }
                => {
                    Self::RemoteSnapshot {
                        snapshot: _snapshot.iter().map(|value| value).collect(),
                    }
                }
                super::FromRemote::RemoteUpdateAck {
                    id: _id,
                }
                => {
                    Self::RemoteUpdateAck {
                        id: _id.into(),
                    }
                }
                super::FromRemote::RemoteUpdateSince {
                    update: _update,
                    vv: _vv,
                }
                => {
                    Self::RemoteUpdateSince {
                        update: _update.iter().map(|value| value).collect(),
                        vv: _vv.iter().map(|value| value).collect(),
                    }
                }
            }
        }

    }
    impl<'raw> ::bebop::SubRecord<'raw> for FromRemote {
        const MIN_SERIALIZED_SIZE: usize = ::bebop::LEN_SIZE + 1;

        fn serialized_size(&self) -> usize {
            ::bebop::LEN_SIZE + 1 +
            match self {
                FromRemote::Unknown => {
                    0
                }
                Self::RemoteInitialSync {
                    snapshot: ref _snapshot,
                    awareness: ref _awareness,
                }
                => {
                    _snapshot.serialized_size() +
                    _awareness.serialized_size()
                }
                Self::RemoteUpdate {
                    update: ref _update,
                }
                => {
                    _update.serialized_size()
                }
                Self::RemoteAwareness {
                    awareness: ref _awareness,
                }
                => {
                    _awareness.serialized_size()
                }
                Self::RemoteSnapshot {
                    snapshot: ref _snapshot,
                }
                => {
                    _snapshot.serialized_size()
                }
                Self::RemoteUpdateAck {
                    id: ref _id,
                }
                => {
                    _id.serialized_size()
                }
                Self::RemoteUpdateSince {
                    update: ref _update,
                    vv: ref _vv,
                }
                => {
                    _update.serialized_size() +
                    _vv.serialized_size()
                }
            }
        }

        ::bebop::define_serialize_chained!(Self => |zelf, dest| {
            let size = zelf.serialized_size();
            ::bebop::write_len(dest, size - ::bebop::LEN_SIZE - 1)?;
            match zelf {
                Self::Unknown => {
                    return Err(::bebop::SerializeError::CannotSerializeUnknownUnion);
                }
                Self::RemoteInitialSync {
                    snapshot: ref _snapshot,
                    awareness: ref _awareness,
                }
                => {
                    1u8._serialize_chained(dest)?;
                    _snapshot._serialize_chained(dest)?;
                    _awareness._serialize_chained(dest)?;
                }
                Self::RemoteUpdate {
                    update: ref _update,
                }
                => {
                    2u8._serialize_chained(dest)?;
                    _update._serialize_chained(dest)?;
                }
                Self::RemoteAwareness {
                    awareness: ref _awareness,
                }
                => {
                    3u8._serialize_chained(dest)?;
                    _awareness._serialize_chained(dest)?;
                }
                Self::RemoteSnapshot {
                    snapshot: ref _snapshot,
                }
                => {
                    4u8._serialize_chained(dest)?;
                    _snapshot._serialize_chained(dest)?;
                }
                Self::RemoteUpdateAck {
                    id: ref _id,
                }
                => {
                    5u8._serialize_chained(dest)?;
                    _id._serialize_chained(dest)?;
                }
                Self::RemoteUpdateSince {
                    update: ref _update,
                    vv: ref _vv,
                }
                => {
                    6u8._serialize_chained(dest)?;
                    _update._serialize_chained(dest)?;
                    _vv._serialize_chained(dest)?;
                }
            }
            Ok(size)
        });

        fn _deserialize_chained(raw: &'raw [u8]) -> ::bebop::DeResult<(usize, Self)> {
            let len = ::bebop::read_len(raw)? + ::bebop::LEN_SIZE + 1;
            let mut i = ::bebop::LEN_SIZE + 1;
            let de = match raw[::bebop::LEN_SIZE] {
                1 => {
                    let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                    i += read;
                    let (read, v1) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                    i += read;

                    FromRemote::RemoteInitialSync {
                        snapshot: v0,
                        awareness: v1,
                    }
                }
                2 => {
                    let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                    i += read;

                    FromRemote::RemoteUpdate {
                        update: v0,
                    }
                }
                3 => {
                    let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                    i += read;

                    FromRemote::RemoteAwareness {
                        awareness: v0,
                    }
                }
                4 => {
                    let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                    i += read;

                    FromRemote::RemoteSnapshot {
                        snapshot: v0,
                    }
                }
                5 => {
                    let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                    i += read;

                    FromRemote::RemoteUpdateAck {
                        id: v0,
                    }
                }
                6 => {
                    let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                    i += read;
                    let (read, v1) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                    i += read;

                    FromRemote::RemoteUpdateSince {
                        update: v0,
                        vv: v1,
                    }
                }
                _ => {
                    i = len;
                    FromRemote::Unknown
                }
            };
            if !cfg!(feature = "unchecked") && i != len {
                debug_assert!(i > len);
                Err(::bebop::DeserializeError::CorruptFrame)
            }
            else {
                Ok((i, de))
            }
        }

    }

    impl<'raw> ::bebop::Record<'raw> for FromRemote {}

    #[derive(Clone, Debug, PartialEq)]
    pub struct Operation {
        pub update: ::std::vec::Vec<u8>,
        pub timestamp: ::bebop::Date,
    }

    impl<'raw> ::core::convert::From<super::Operation<'raw>> for Operation {
        fn from(value: super::Operation) -> Self {
            Self {
                update: value.update.iter().map(|value| value).collect(),
                timestamp: value.timestamp,
            }
        }
    }

    impl<'raw> ::bebop::SubRecord<'raw> for Operation {
        const MIN_SERIALIZED_SIZE: usize =
            <::std::vec::Vec<u8>>::MIN_SERIALIZED_SIZE +
            <::bebop::Date>::MIN_SERIALIZED_SIZE;

        #[inline]
        fn serialized_size(&self) -> usize {
            self.update.serialized_size() +
            self.timestamp.serialized_size()
        }

        ::bebop::define_serialize_chained!(Self => |zelf, dest| {
            Ok(
                zelf.update._serialize_chained(dest)? +
                zelf.timestamp._serialize_chained(dest)?
            )
        });

        fn _deserialize_chained(raw: &'raw [u8]) -> ::bebop::DeResult<(usize, Self)> {
            let mut i = 0;
            if raw.len() - i < Self::MIN_SERIALIZED_SIZE {
                let missing = Self::MIN_SERIALIZED_SIZE - (raw.len() - i);
                return Err(::bebop::DeserializeError::MoreDataExpected(missing));
            }

            let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
            i += read;
            let (read, v1) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
            i += read;

            Ok((i, Self {
                update: v0,
                timestamp: v1,
            }))
        }
    }

    impl<'raw> ::bebop::Record<'raw> for Operation {}

    #[derive(Clone, Debug, PartialEq)]
    pub struct OperationLog {
        pub operations: ::std::vec::Vec<Operation>,
    }

    impl<'raw> ::core::convert::From<super::OperationLog<'raw>> for OperationLog {
        fn from(value: super::OperationLog) -> Self {
            Self {
                operations: value.operations.into_iter().map(|value| value.into()).collect(),
            }
        }
    }

    impl<'raw> ::bebop::SubRecord<'raw> for OperationLog {
        const MIN_SERIALIZED_SIZE: usize =
            <::std::vec::Vec<Operation>>::MIN_SERIALIZED_SIZE;

        #[inline]
        fn serialized_size(&self) -> usize {
            self.operations.serialized_size()
        }

        ::bebop::define_serialize_chained!(Self => |zelf, dest| {
            Ok(
                zelf.operations._serialize_chained(dest)?
            )
        });

        fn _deserialize_chained(raw: &'raw [u8]) -> ::bebop::DeResult<(usize, Self)> {
            let mut i = 0;
            if raw.len() - i < Self::MIN_SERIALIZED_SIZE {
                let missing = Self::MIN_SERIALIZED_SIZE - (raw.len() - i);
                return Err(::bebop::DeserializeError::MoreDataExpected(missing));
            }

            let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
            i += read;

            Ok((i, Self {
                operations: v0,
            }))
        }
    }

    impl<'raw> ::bebop::Record<'raw> for OperationLog {}

    #[derive(Clone, Debug, PartialEq)]
    pub struct InitializeFromSnapshotRequest {
        pub snapshot: ::std::vec::Vec<u8>,
    }

    impl<'raw> ::core::convert::From<super::InitializeFromSnapshotRequest<'raw>> for InitializeFromSnapshotRequest {
        fn from(value: super::InitializeFromSnapshotRequest) -> Self {
            Self {
                snapshot: value.snapshot.iter().map(|value| value).collect(),
            }
        }
    }

    impl<'raw> ::bebop::SubRecord<'raw> for InitializeFromSnapshotRequest {
        const MIN_SERIALIZED_SIZE: usize =
            <::std::vec::Vec<u8>>::MIN_SERIALIZED_SIZE;

        #[inline]
        fn serialized_size(&self) -> usize {
            self.snapshot.serialized_size()
        }

        ::bebop::define_serialize_chained!(Self => |zelf, dest| {
            Ok(
                zelf.snapshot._serialize_chained(dest)?
            )
        });

        fn _deserialize_chained(raw: &'raw [u8]) -> ::bebop::DeResult<(usize, Self)> {
            let mut i = 0;
            if raw.len() - i < Self::MIN_SERIALIZED_SIZE {
                let missing = Self::MIN_SERIALIZED_SIZE - (raw.len() - i);
                return Err(::bebop::DeserializeError::MoreDataExpected(missing));
            }

            let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
            i += read;

            Ok((i, Self {
                snapshot: v0,
            }))
        }
    }

    impl<'raw> ::bebop::Record<'raw> for InitializeFromSnapshotRequest {}

    #[derive(Clone, Debug, PartialEq)]
    pub enum ToRouter {
        /// An unknown type which is likely defined in a newer version of the schema.
        Unknown,

        /// Discriminator 1
        RouterSubscribe {
            doc_id: String,
            token: String,
        },

        /// Discriminator 2
        RouterUnsubscribe {
            doc_id: String,
        },

        /// Discriminator 3
        RouterFrame {
            doc_id: String,
            payload: ::std::vec::Vec<u8>,
        },
    }

    impl<'raw> ::core::convert::From<super::ToRouter<'raw>> for ToRouter {
        fn from(value: super::ToRouter) -> Self {
            match value {
                super::ToRouter::Unknown => {
                    Self::Unknown
                }
                super::ToRouter::RouterSubscribe {
                    doc_id: _doc_id,
                    token: _token,
                }
                => {
                    Self::RouterSubscribe {
                        doc_id: _doc_id.into(),
                        token: _token.into(),
                    }
                }
                super::ToRouter::RouterUnsubscribe {
                    doc_id: _doc_id,
                }
                => {
                    Self::RouterUnsubscribe {
                        doc_id: _doc_id.into(),
                    }
                }
                super::ToRouter::RouterFrame {
                    doc_id: _doc_id,
                    payload: _payload,
                }
                => {
                    Self::RouterFrame {
                        doc_id: _doc_id.into(),
                        payload: _payload.iter().map(|value| value).collect(),
                    }
                }
            }
        }

    }
    impl<'raw> ::bebop::SubRecord<'raw> for ToRouter {
        const MIN_SERIALIZED_SIZE: usize = ::bebop::LEN_SIZE + 1;

        fn serialized_size(&self) -> usize {
            ::bebop::LEN_SIZE + 1 +
            match self {
                ToRouter::Unknown => {
                    0
                }
                Self::RouterSubscribe {
                    doc_id: ref _doc_id,
                    token: ref _token,
                }
                => {
                    _doc_id.serialized_size() +
                    _token.serialized_size()
                }
                Self::RouterUnsubscribe {
                    doc_id: ref _doc_id,
                }
                => {
                    _doc_id.serialized_size()
                }
                Self::RouterFrame {
                    doc_id: ref _doc_id,
                    payload: ref _payload,
                }
                => {
                    _doc_id.serialized_size() +
                    _payload.serialized_size()
                }
            }
        }

        ::bebop::define_serialize_chained!(Self => |zelf, dest| {
            let size = zelf.serialized_size();
            ::bebop::write_len(dest, size - ::bebop::LEN_SIZE - 1)?;
            match zelf {
                Self::Unknown => {
                    return Err(::bebop::SerializeError::CannotSerializeUnknownUnion);
                }
                Self::RouterSubscribe {
                    doc_id: ref _doc_id,
                    token: ref _token,
                }
                => {
                    1u8._serialize_chained(dest)?;
                    _doc_id._serialize_chained(dest)?;
                    _token._serialize_chained(dest)?;
                }
                Self::RouterUnsubscribe {
                    doc_id: ref _doc_id,
                }
                => {
                    2u8._serialize_chained(dest)?;
                    _doc_id._serialize_chained(dest)?;
                }
                Self::RouterFrame {
                    doc_id: ref _doc_id,
                    payload: ref _payload,
                }
                => {
                    3u8._serialize_chained(dest)?;
                    _doc_id._serialize_chained(dest)?;
                    _payload._serialize_chained(dest)?;
                }
            }
            Ok(size)
        });

        fn _deserialize_chained(raw: &'raw [u8]) -> ::bebop::DeResult<(usize, Self)> {
            let len = ::bebop::read_len(raw)? + ::bebop::LEN_SIZE + 1;
            let mut i = ::bebop::LEN_SIZE + 1;
            let de = match raw[::bebop::LEN_SIZE] {
                1 => {
                    let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                    i += read;
                    let (read, v1) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                    i += read;

                    ToRouter::RouterSubscribe {
                        doc_id: v0,
                        token: v1,
                    }
                }
                2 => {
                    let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                    i += read;

                    ToRouter::RouterUnsubscribe {
                        doc_id: v0,
                    }
                }
                3 => {
                    let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                    i += read;
                    let (read, v1) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                    i += read;

                    ToRouter::RouterFrame {
                        doc_id: v0,
                        payload: v1,
                    }
                }
                _ => {
                    i = len;
                    ToRouter::Unknown
                }
            };
            if !cfg!(feature = "unchecked") && i != len {
                debug_assert!(i > len);
                Err(::bebop::DeserializeError::CorruptFrame)
            }
            else {
                Ok((i, de))
            }
        }

    }

    impl<'raw> ::bebop::Record<'raw> for ToRouter {}

    #[derive(Clone, Debug, PartialEq)]
    pub enum FromRouter {
        /// An unknown type which is likely defined in a newer version of the schema.
        Unknown,

        /// Discriminator 1
        RouterSubscribed {
            doc_id: String,
        },

        /// Discriminator 2
        RouterSubscribeFailed {
            doc_id: String,
            reason: String,
        },

        /// Discriminator 3
        RouterDocFrame {
            doc_id: String,
            payload: ::std::vec::Vec<u8>,
        },

        /// Discriminator 4
        RouterDocClosed {
            doc_id: String,
            reason: String,
        },
    }

    impl<'raw> ::core::convert::From<super::FromRouter<'raw>> for FromRouter {
        fn from(value: super::FromRouter) -> Self {
            match value {
                super::FromRouter::Unknown => {
                    Self::Unknown
                }
                super::FromRouter::RouterSubscribed {
                    doc_id: _doc_id,
                }
                => {
                    Self::RouterSubscribed {
                        doc_id: _doc_id.into(),
                    }
                }
                super::FromRouter::RouterSubscribeFailed {
                    doc_id: _doc_id,
                    reason: _reason,
                }
                => {
                    Self::RouterSubscribeFailed {
                        doc_id: _doc_id.into(),
                        reason: _reason.into(),
                    }
                }
                super::FromRouter::RouterDocFrame {
                    doc_id: _doc_id,
                    payload: _payload,
                }
                => {
                    Self::RouterDocFrame {
                        doc_id: _doc_id.into(),
                        payload: _payload.iter().map(|value| value).collect(),
                    }
                }
                super::FromRouter::RouterDocClosed {
                    doc_id: _doc_id,
                    reason: _reason,
                }
                => {
                    Self::RouterDocClosed {
                        doc_id: _doc_id.into(),
                        reason: _reason.into(),
                    }
                }
            }
        }

    }
    impl<'raw> ::bebop::SubRecord<'raw> for FromRouter {
        const MIN_SERIALIZED_SIZE: usize = ::bebop::LEN_SIZE + 1;

        fn serialized_size(&self) -> usize {
            ::bebop::LEN_SIZE + 1 +
            match self {
                FromRouter::Unknown => {
                    0
                }
                Self::RouterSubscribed {
                    doc_id: ref _doc_id,
                }
                => {
                    _doc_id.serialized_size()
                }
                Self::RouterSubscribeFailed {
                    doc_id: ref _doc_id,
                    reason: ref _reason,
                }
                => {
                    _doc_id.serialized_size() +
                    _reason.serialized_size()
                }
                Self::RouterDocFrame {
                    doc_id: ref _doc_id,
                    payload: ref _payload,
                }
                => {
                    _doc_id.serialized_size() +
                    _payload.serialized_size()
                }
                Self::RouterDocClosed {
                    doc_id: ref _doc_id,
                    reason: ref _reason,
                }
                => {
                    _doc_id.serialized_size() +
                    _reason.serialized_size()
                }
            }
        }

        ::bebop::define_serialize_chained!(Self => |zelf, dest| {
            let size = zelf.serialized_size();
            ::bebop::write_len(dest, size - ::bebop::LEN_SIZE - 1)?;
            match zelf {
                Self::Unknown => {
                    return Err(::bebop::SerializeError::CannotSerializeUnknownUnion);
                }
                Self::RouterSubscribed {
                    doc_id: ref _doc_id,
                }
                => {
                    1u8._serialize_chained(dest)?;
                    _doc_id._serialize_chained(dest)?;
                }
                Self::RouterSubscribeFailed {
                    doc_id: ref _doc_id,
                    reason: ref _reason,
                }
                => {
                    2u8._serialize_chained(dest)?;
                    _doc_id._serialize_chained(dest)?;
                    _reason._serialize_chained(dest)?;
                }
                Self::RouterDocFrame {
                    doc_id: ref _doc_id,
                    payload: ref _payload,
                }
                => {
                    3u8._serialize_chained(dest)?;
                    _doc_id._serialize_chained(dest)?;
                    _payload._serialize_chained(dest)?;
                }
                Self::RouterDocClosed {
                    doc_id: ref _doc_id,
                    reason: ref _reason,
                }
                => {
                    4u8._serialize_chained(dest)?;
                    _doc_id._serialize_chained(dest)?;
                    _reason._serialize_chained(dest)?;
                }
            }
            Ok(size)
        });

        fn _deserialize_chained(raw: &'raw [u8]) -> ::bebop::DeResult<(usize, Self)> {
            let len = ::bebop::read_len(raw)? + ::bebop::LEN_SIZE + 1;
            let mut i = ::bebop::LEN_SIZE + 1;
            let de = match raw[::bebop::LEN_SIZE] {
                1 => {
                    let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                    i += read;

                    FromRouter::RouterSubscribed {
                        doc_id: v0,
                    }
                }
                2 => {
                    let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                    i += read;
                    let (read, v1) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                    i += read;

                    FromRouter::RouterSubscribeFailed {
                        doc_id: v0,
                        reason: v1,
                    }
                }
                3 => {
                    let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                    i += read;
                    let (read, v1) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                    i += read;

                    FromRouter::RouterDocFrame {
                        doc_id: v0,
                        payload: v1,
                    }
                }
                4 => {
                    let (read, v0) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                    i += read;
                    let (read, v1) = ::bebop::SubRecord::_deserialize_chained(&raw[i..])?;
                    i += read;

                    FromRouter::RouterDocClosed {
                        doc_id: v0,
                        reason: v1,
                    }
                }
                _ => {
                    i = len;
                    FromRouter::Unknown
                }
            };
            if !cfg!(feature = "unchecked") && i != len {
                debug_assert!(i > len);
                Err(::bebop::DeserializeError::CorruptFrame)
            }
            else {
                Ok((i, de))
            }
        }

    }

    impl<'raw> ::bebop::Record<'raw> for FromRouter {}}