// automatically generated by the FlatBuffers compiler, do not modify
// @generated
extern crate alloc;

#[allow(unused_imports, dead_code)]
pub mod nmp {

    #[allow(unused_imports, dead_code)]
    pub mod note_feed {

        pub enum RepostAttributionOffset {}
        #[derive(Copy, Clone, PartialEq)]

        pub struct RepostAttribution<'a> {
            pub _tab: ::flatbuffers::Table<'a>,
        }

        impl<'a> ::flatbuffers::Follow<'a> for RepostAttribution<'a> {
            type Inner = RepostAttribution<'a>;
            #[inline]
            unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
                Self {
                    _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
                }
            }
        }

        impl<'a> RepostAttribution<'a> {
            pub const VT_AUTHOR_PUBKEY: ::flatbuffers::VOffsetT = 4;
            pub const VT_NOTE_CREATED_AT: ::flatbuffers::VOffsetT = 6;

            #[inline]
            pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
                RepostAttribution { _tab: table }
            }
            #[allow(unused_mut)]
            pub fn create<
                'bldr: 'args,
                'args: 'mut_bldr,
                'mut_bldr,
                A: ::flatbuffers::Allocator + 'bldr,
            >(
                _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
                args: &'args RepostAttributionArgs<'args>,
            ) -> ::flatbuffers::WIPOffset<RepostAttribution<'bldr>> {
                let mut builder = RepostAttributionBuilder::new(_fbb);
                builder.add_note_created_at(args.note_created_at);
                if let Some(x) = args.author_pubkey {
                    builder.add_author_pubkey(x);
                }
                builder.finish()
            }

            #[inline]
            pub fn author_pubkey(&self) -> Option<&'a str> {
                // Safety:
                // Created from valid Table for this object
                // which contains a valid value in this slot
                unsafe {
                    self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(
                        RepostAttribution::VT_AUTHOR_PUBKEY,
                        None,
                    )
                }
            }
            #[inline]
            pub fn note_created_at(&self) -> u64 {
                // Safety:
                // Created from valid Table for this object
                // which contains a valid value in this slot
                unsafe {
                    self._tab
                        .get::<u64>(RepostAttribution::VT_NOTE_CREATED_AT, Some(0))
                        .unwrap()
                }
            }
        }

        impl ::flatbuffers::Verifiable for RepostAttribution<'_> {
            #[inline]
            fn run_verifier(
                v: &mut ::flatbuffers::Verifier,
                pos: usize,
            ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
                v.visit_table(pos)?
                    .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                        "author_pubkey",
                        Self::VT_AUTHOR_PUBKEY,
                        false,
                    )?
                    .visit_field::<u64>("note_created_at", Self::VT_NOTE_CREATED_AT, false)?
                    .finish();
                Ok(())
            }
        }
        pub struct RepostAttributionArgs<'a> {
            pub author_pubkey: Option<::flatbuffers::WIPOffset<&'a str>>,
            pub note_created_at: u64,
        }
        impl<'a> Default for RepostAttributionArgs<'a> {
            #[inline]
            fn default() -> Self {
                RepostAttributionArgs {
                    author_pubkey: None,
                    note_created_at: 0,
                }
            }
        }

        pub struct RepostAttributionBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
            fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
            start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
        }
        impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> RepostAttributionBuilder<'a, 'b, A> {
            #[inline]
            pub fn add_author_pubkey(&mut self, author_pubkey: ::flatbuffers::WIPOffset<&'b str>) {
                self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                    RepostAttribution::VT_AUTHOR_PUBKEY,
                    author_pubkey,
                );
            }
            #[inline]
            pub fn add_note_created_at(&mut self, note_created_at: u64) {
                self.fbb_.push_slot::<u64>(
                    RepostAttribution::VT_NOTE_CREATED_AT,
                    note_created_at,
                    0,
                );
            }
            #[inline]
            pub fn new(
                _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
            ) -> RepostAttributionBuilder<'a, 'b, A> {
                let start = _fbb.start_table();
                RepostAttributionBuilder {
                    fbb_: _fbb,
                    start_: start,
                }
            }
            #[inline]
            pub fn finish(self) -> ::flatbuffers::WIPOffset<RepostAttribution<'a>> {
                let o = self.fbb_.end_table(self.start_);
                ::flatbuffers::WIPOffset::new(o.value())
            }
        }

        impl ::core::fmt::Debug for RepostAttribution<'_> {
            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                let mut ds = f.debug_struct("RepostAttribution");
                ds.field("author_pubkey", &self.author_pubkey());
                ds.field("note_created_at", &self.note_created_at());
                ds.finish()
            }
        }
        pub enum HostedGroupContextOffset {}
        #[derive(Copy, Clone, PartialEq)]

        pub struct HostedGroupContext<'a> {
            pub _tab: ::flatbuffers::Table<'a>,
        }

        impl<'a> ::flatbuffers::Follow<'a> for HostedGroupContext<'a> {
            type Inner = HostedGroupContext<'a>;
            #[inline]
            unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
                Self {
                    _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
                }
            }
        }

        impl<'a> HostedGroupContext<'a> {
            pub const VT_HOST_RELAY_URL: ::flatbuffers::VOffsetT = 4;
            pub const VT_LOCAL_ID: ::flatbuffers::VOffsetT = 6;

            #[inline]
            pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
                HostedGroupContext { _tab: table }
            }
            #[allow(unused_mut)]
            pub fn create<
                'bldr: 'args,
                'args: 'mut_bldr,
                'mut_bldr,
                A: ::flatbuffers::Allocator + 'bldr,
            >(
                _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
                args: &'args HostedGroupContextArgs<'args>,
            ) -> ::flatbuffers::WIPOffset<HostedGroupContext<'bldr>> {
                let mut builder = HostedGroupContextBuilder::new(_fbb);
                if let Some(x) = args.local_id {
                    builder.add_local_id(x);
                }
                if let Some(x) = args.host_relay_url {
                    builder.add_host_relay_url(x);
                }
                builder.finish()
            }

            #[inline]
            pub fn host_relay_url(&self) -> Option<&'a str> {
                // Safety:
                // Created from valid Table for this object
                // which contains a valid value in this slot
                unsafe {
                    self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(
                        HostedGroupContext::VT_HOST_RELAY_URL,
                        None,
                    )
                }
            }
            #[inline]
            pub fn local_id(&self) -> Option<&'a str> {
                // Safety:
                // Created from valid Table for this object
                // which contains a valid value in this slot
                unsafe {
                    self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(
                        HostedGroupContext::VT_LOCAL_ID,
                        None,
                    )
                }
            }
        }

        impl ::flatbuffers::Verifiable for HostedGroupContext<'_> {
            #[inline]
            fn run_verifier(
                v: &mut ::flatbuffers::Verifier,
                pos: usize,
            ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
                v.visit_table(pos)?
                    .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                        "host_relay_url",
                        Self::VT_HOST_RELAY_URL,
                        false,
                    )?
                    .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                        "local_id",
                        Self::VT_LOCAL_ID,
                        false,
                    )?
                    .finish();
                Ok(())
            }
        }
        pub struct HostedGroupContextArgs<'a> {
            pub host_relay_url: Option<::flatbuffers::WIPOffset<&'a str>>,
            pub local_id: Option<::flatbuffers::WIPOffset<&'a str>>,
        }
        impl<'a> Default for HostedGroupContextArgs<'a> {
            #[inline]
            fn default() -> Self {
                HostedGroupContextArgs {
                    host_relay_url: None,
                    local_id: None,
                }
            }
        }

        pub struct HostedGroupContextBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
            fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
            start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
        }
        impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> HostedGroupContextBuilder<'a, 'b, A> {
            #[inline]
            pub fn add_host_relay_url(
                &mut self,
                host_relay_url: ::flatbuffers::WIPOffset<&'b str>,
            ) {
                self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                    HostedGroupContext::VT_HOST_RELAY_URL,
                    host_relay_url,
                );
            }
            #[inline]
            pub fn add_local_id(&mut self, local_id: ::flatbuffers::WIPOffset<&'b str>) {
                self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                    HostedGroupContext::VT_LOCAL_ID,
                    local_id,
                );
            }
            #[inline]
            pub fn new(
                _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
            ) -> HostedGroupContextBuilder<'a, 'b, A> {
                let start = _fbb.start_table();
                HostedGroupContextBuilder {
                    fbb_: _fbb,
                    start_: start,
                }
            }
            #[inline]
            pub fn finish(self) -> ::flatbuffers::WIPOffset<HostedGroupContext<'a>> {
                let o = self.fbb_.end_table(self.start_);
                ::flatbuffers::WIPOffset::new(o.value())
            }
        }

        impl ::core::fmt::Debug for HostedGroupContext<'_> {
            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                let mut ds = f.debug_struct("HostedGroupContext");
                ds.field("host_relay_url", &self.host_relay_url());
                ds.field("local_id", &self.local_id());
                ds.finish()
            }
        }
        pub enum NoteFeedItemOffset {}
        #[derive(Copy, Clone, PartialEq)]

        pub struct NoteFeedItem<'a> {
            pub _tab: ::flatbuffers::Table<'a>,
        }

        impl<'a> ::flatbuffers::Follow<'a> for NoteFeedItem<'a> {
            type Inner = NoteFeedItem<'a>;
            #[inline]
            unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
                Self {
                    _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
                }
            }
        }

        impl<'a> NoteFeedItem<'a> {
            pub const VT_ID: ::flatbuffers::VOffsetT = 4;
            pub const VT_AUTHOR_PUBKEY: ::flatbuffers::VOffsetT = 6;
            pub const VT_KIND: ::flatbuffers::VOffsetT = 8;
            pub const VT_CREATED_AT: ::flatbuffers::VOffsetT = 10;
            pub const VT_CONTENT: ::flatbuffers::VOffsetT = 12;
            pub const VT_CONTENT_TREE_BYTES: ::flatbuffers::VOffsetT = 14;
            pub const VT_RELAY_PROVENANCE: ::flatbuffers::VOffsetT = 16;
            pub const VT_REPOSTED_BY: ::flatbuffers::VOffsetT = 18;
            pub const VT_HOSTED_GROUP: ::flatbuffers::VOffsetT = 20;

            #[inline]
            pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
                NoteFeedItem { _tab: table }
            }
            #[allow(unused_mut)]
            pub fn create<
                'bldr: 'args,
                'args: 'mut_bldr,
                'mut_bldr,
                A: ::flatbuffers::Allocator + 'bldr,
            >(
                _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
                args: &'args NoteFeedItemArgs<'args>,
            ) -> ::flatbuffers::WIPOffset<NoteFeedItem<'bldr>> {
                let mut builder = NoteFeedItemBuilder::new(_fbb);
                builder.add_created_at(args.created_at);
                if let Some(x) = args.hosted_group {
                    builder.add_hosted_group(x);
                }
                if let Some(x) = args.reposted_by {
                    builder.add_reposted_by(x);
                }
                if let Some(x) = args.relay_provenance {
                    builder.add_relay_provenance(x);
                }
                if let Some(x) = args.content_tree_bytes {
                    builder.add_content_tree_bytes(x);
                }
                if let Some(x) = args.content {
                    builder.add_content(x);
                }
                builder.add_kind(args.kind);
                if let Some(x) = args.author_pubkey {
                    builder.add_author_pubkey(x);
                }
                if let Some(x) = args.id {
                    builder.add_id(x);
                }
                builder.finish()
            }

            #[inline]
            pub fn id(&self) -> Option<&'a str> {
                // Safety:
                // Created from valid Table for this object
                // which contains a valid value in this slot
                unsafe {
                    self._tab
                        .get::<::flatbuffers::ForwardsUOffset<&str>>(NoteFeedItem::VT_ID, None)
                }
            }
            #[inline]
            pub fn author_pubkey(&self) -> Option<&'a str> {
                // Safety:
                // Created from valid Table for this object
                // which contains a valid value in this slot
                unsafe {
                    self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(
                        NoteFeedItem::VT_AUTHOR_PUBKEY,
                        None,
                    )
                }
            }
            #[inline]
            pub fn kind(&self) -> u32 {
                // Safety:
                // Created from valid Table for this object
                // which contains a valid value in this slot
                unsafe {
                    self._tab
                        .get::<u32>(NoteFeedItem::VT_KIND, Some(0))
                        .unwrap()
                }
            }
            #[inline]
            pub fn created_at(&self) -> u64 {
                // Safety:
                // Created from valid Table for this object
                // which contains a valid value in this slot
                unsafe {
                    self._tab
                        .get::<u64>(NoteFeedItem::VT_CREATED_AT, Some(0))
                        .unwrap()
                }
            }
            #[inline]
            pub fn content(&self) -> Option<&'a str> {
                // Safety:
                // Created from valid Table for this object
                // which contains a valid value in this slot
                unsafe {
                    self._tab
                        .get::<::flatbuffers::ForwardsUOffset<&str>>(NoteFeedItem::VT_CONTENT, None)
                }
            }
            #[inline]
            pub fn content_tree_bytes(&self) -> Option<::flatbuffers::Vector<'a, u8>> {
                // Safety:
                // Created from valid Table for this object
                // which contains a valid value in this slot
                unsafe {
                    self._tab
                        .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                            NoteFeedItem::VT_CONTENT_TREE_BYTES,
                            None,
                        )
                }
            }
            #[inline]
            pub fn relay_provenance(
                &self,
            ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>>
            {
                // Safety:
                // Created from valid Table for this object
                // which contains a valid value in this slot
                unsafe {
                    self._tab.get::<::flatbuffers::ForwardsUOffset<
                        ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
                    >>(NoteFeedItem::VT_RELAY_PROVENANCE, None)
                }
            }
            #[inline]
            pub fn reposted_by(&self) -> Option<RepostAttribution<'a>> {
                // Safety:
                // Created from valid Table for this object
                // which contains a valid value in this slot
                unsafe {
                    self._tab
                        .get::<::flatbuffers::ForwardsUOffset<RepostAttribution>>(
                            NoteFeedItem::VT_REPOSTED_BY,
                            None,
                        )
                }
            }
            #[inline]
            pub fn hosted_group(&self) -> Option<HostedGroupContext<'a>> {
                // Safety:
                // Created from valid Table for this object
                // which contains a valid value in this slot
                unsafe {
                    self._tab
                        .get::<::flatbuffers::ForwardsUOffset<HostedGroupContext>>(
                            NoteFeedItem::VT_HOSTED_GROUP,
                            None,
                        )
                }
            }
        }

        impl ::flatbuffers::Verifiable for NoteFeedItem<'_> {
            #[inline]
            fn run_verifier(
                v: &mut ::flatbuffers::Verifier,
                pos: usize,
            ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
                v.visit_table(pos)?
                    .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("id", Self::VT_ID, false)?
                    .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                        "author_pubkey",
                        Self::VT_AUTHOR_PUBKEY,
                        false,
                    )?
                    .visit_field::<u32>("kind", Self::VT_KIND, false)?
                    .visit_field::<u64>("created_at", Self::VT_CREATED_AT, false)?
                    .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                        "content",
                        Self::VT_CONTENT,
                        false,
                    )?
                    .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                        "content_tree_bytes",
                        Self::VT_CONTENT_TREE_BYTES,
                        false,
                    )?
                    .visit_field::<::flatbuffers::ForwardsUOffset<
                        ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<&'_ str>>,
                    >>("relay_provenance", Self::VT_RELAY_PROVENANCE, false)?
                    .visit_field::<::flatbuffers::ForwardsUOffset<RepostAttribution>>(
                        "reposted_by",
                        Self::VT_REPOSTED_BY,
                        false,
                    )?
                    .visit_field::<::flatbuffers::ForwardsUOffset<HostedGroupContext>>(
                        "hosted_group",
                        Self::VT_HOSTED_GROUP,
                        false,
                    )?
                    .finish();
                Ok(())
            }
        }
        pub struct NoteFeedItemArgs<'a> {
            pub id: Option<::flatbuffers::WIPOffset<&'a str>>,
            pub author_pubkey: Option<::flatbuffers::WIPOffset<&'a str>>,
            pub kind: u32,
            pub created_at: u64,
            pub content: Option<::flatbuffers::WIPOffset<&'a str>>,
            pub content_tree_bytes: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
            pub relay_provenance: Option<
                ::flatbuffers::WIPOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<&'a str>>,
                >,
            >,
            pub reposted_by: Option<::flatbuffers::WIPOffset<RepostAttribution<'a>>>,
            pub hosted_group: Option<::flatbuffers::WIPOffset<HostedGroupContext<'a>>>,
        }
        impl<'a> Default for NoteFeedItemArgs<'a> {
            #[inline]
            fn default() -> Self {
                NoteFeedItemArgs {
                    id: None,
                    author_pubkey: None,
                    kind: 0,
                    created_at: 0,
                    content: None,
                    content_tree_bytes: None,
                    relay_provenance: None,
                    reposted_by: None,
                    hosted_group: None,
                }
            }
        }

        pub struct NoteFeedItemBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
            fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
            start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
        }
        impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> NoteFeedItemBuilder<'a, 'b, A> {
            #[inline]
            pub fn add_id(&mut self, id: ::flatbuffers::WIPOffset<&'b str>) {
                self.fbb_
                    .push_slot_always::<::flatbuffers::WIPOffset<_>>(NoteFeedItem::VT_ID, id);
            }
            #[inline]
            pub fn add_author_pubkey(&mut self, author_pubkey: ::flatbuffers::WIPOffset<&'b str>) {
                self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                    NoteFeedItem::VT_AUTHOR_PUBKEY,
                    author_pubkey,
                );
            }
            #[inline]
            pub fn add_kind(&mut self, kind: u32) {
                self.fbb_.push_slot::<u32>(NoteFeedItem::VT_KIND, kind, 0);
            }
            #[inline]
            pub fn add_created_at(&mut self, created_at: u64) {
                self.fbb_
                    .push_slot::<u64>(NoteFeedItem::VT_CREATED_AT, created_at, 0);
            }
            #[inline]
            pub fn add_content(&mut self, content: ::flatbuffers::WIPOffset<&'b str>) {
                self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                    NoteFeedItem::VT_CONTENT,
                    content,
                );
            }
            #[inline]
            pub fn add_content_tree_bytes(
                &mut self,
                content_tree_bytes: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
            ) {
                self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                    NoteFeedItem::VT_CONTENT_TREE_BYTES,
                    content_tree_bytes,
                );
            }
            #[inline]
            pub fn add_relay_provenance(
                &mut self,
                relay_provenance: ::flatbuffers::WIPOffset<
                    ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<&'b str>>,
                >,
            ) {
                self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                    NoteFeedItem::VT_RELAY_PROVENANCE,
                    relay_provenance,
                );
            }
            #[inline]
            pub fn add_reposted_by(
                &mut self,
                reposted_by: ::flatbuffers::WIPOffset<RepostAttribution<'b>>,
            ) {
                self.fbb_
                    .push_slot_always::<::flatbuffers::WIPOffset<RepostAttribution>>(
                        NoteFeedItem::VT_REPOSTED_BY,
                        reposted_by,
                    );
            }
            #[inline]
            pub fn add_hosted_group(
                &mut self,
                hosted_group: ::flatbuffers::WIPOffset<HostedGroupContext<'b>>,
            ) {
                self.fbb_
                    .push_slot_always::<::flatbuffers::WIPOffset<HostedGroupContext>>(
                        NoteFeedItem::VT_HOSTED_GROUP,
                        hosted_group,
                    );
            }
            #[inline]
            pub fn new(
                _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
            ) -> NoteFeedItemBuilder<'a, 'b, A> {
                let start = _fbb.start_table();
                NoteFeedItemBuilder {
                    fbb_: _fbb,
                    start_: start,
                }
            }
            #[inline]
            pub fn finish(self) -> ::flatbuffers::WIPOffset<NoteFeedItem<'a>> {
                let o = self.fbb_.end_table(self.start_);
                ::flatbuffers::WIPOffset::new(o.value())
            }
        }

        impl ::core::fmt::Debug for NoteFeedItem<'_> {
            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                let mut ds = f.debug_struct("NoteFeedItem");
                ds.field("id", &self.id());
                ds.field("author_pubkey", &self.author_pubkey());
                ds.field("kind", &self.kind());
                ds.field("created_at", &self.created_at());
                ds.field("content", &self.content());
                ds.field("content_tree_bytes", &self.content_tree_bytes());
                ds.field("relay_provenance", &self.relay_provenance());
                ds.field("reposted_by", &self.reposted_by());
                ds.field("hosted_group", &self.hosted_group());
                ds.finish()
            }
        }
        pub enum ReplyAttributionOffset {}
        #[derive(Copy, Clone, PartialEq)]

        pub struct ReplyAttribution<'a> {
            pub _tab: ::flatbuffers::Table<'a>,
        }

        impl<'a> ::flatbuffers::Follow<'a> for ReplyAttribution<'a> {
            type Inner = ReplyAttribution<'a>;
            #[inline]
            unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
                Self {
                    _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
                }
            }
        }

        impl<'a> ReplyAttribution<'a> {
            pub const VT_AUTHOR_PUBKEY: ::flatbuffers::VOffsetT = 4;
            pub const VT_REPLY_EVENT_ID: ::flatbuffers::VOffsetT = 6;
            pub const VT_REPLY_CREATED_AT: ::flatbuffers::VOffsetT = 8;

            #[inline]
            pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
                ReplyAttribution { _tab: table }
            }
            #[allow(unused_mut)]
            pub fn create<
                'bldr: 'args,
                'args: 'mut_bldr,
                'mut_bldr,
                A: ::flatbuffers::Allocator + 'bldr,
            >(
                _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
                args: &'args ReplyAttributionArgs<'args>,
            ) -> ::flatbuffers::WIPOffset<ReplyAttribution<'bldr>> {
                let mut builder = ReplyAttributionBuilder::new(_fbb);
                builder.add_reply_created_at(args.reply_created_at);
                if let Some(x) = args.reply_event_id {
                    builder.add_reply_event_id(x);
                }
                if let Some(x) = args.author_pubkey {
                    builder.add_author_pubkey(x);
                }
                builder.finish()
            }

            #[inline]
            pub fn author_pubkey(&self) -> Option<&'a str> {
                // Safety:
                // Created from valid Table for this object
                // which contains a valid value in this slot
                unsafe {
                    self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(
                        ReplyAttribution::VT_AUTHOR_PUBKEY,
                        None,
                    )
                }
            }
            #[inline]
            pub fn reply_event_id(&self) -> Option<&'a str> {
                // Safety:
                // Created from valid Table for this object
                // which contains a valid value in this slot
                unsafe {
                    self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(
                        ReplyAttribution::VT_REPLY_EVENT_ID,
                        None,
                    )
                }
            }
            #[inline]
            pub fn reply_created_at(&self) -> u64 {
                // Safety:
                // Created from valid Table for this object
                // which contains a valid value in this slot
                unsafe {
                    self._tab
                        .get::<u64>(ReplyAttribution::VT_REPLY_CREATED_AT, Some(0))
                        .unwrap()
                }
            }
        }

        impl ::flatbuffers::Verifiable for ReplyAttribution<'_> {
            #[inline]
            fn run_verifier(
                v: &mut ::flatbuffers::Verifier,
                pos: usize,
            ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
                v.visit_table(pos)?
                    .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                        "author_pubkey",
                        Self::VT_AUTHOR_PUBKEY,
                        false,
                    )?
                    .visit_field::<::flatbuffers::ForwardsUOffset<&str>>(
                        "reply_event_id",
                        Self::VT_REPLY_EVENT_ID,
                        false,
                    )?
                    .visit_field::<u64>("reply_created_at", Self::VT_REPLY_CREATED_AT, false)?
                    .finish();
                Ok(())
            }
        }
        pub struct ReplyAttributionArgs<'a> {
            pub author_pubkey: Option<::flatbuffers::WIPOffset<&'a str>>,
            pub reply_event_id: Option<::flatbuffers::WIPOffset<&'a str>>,
            pub reply_created_at: u64,
        }
        impl<'a> Default for ReplyAttributionArgs<'a> {
            #[inline]
            fn default() -> Self {
                ReplyAttributionArgs {
                    author_pubkey: None,
                    reply_event_id: None,
                    reply_created_at: 0,
                }
            }
        }

        pub struct ReplyAttributionBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
            fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
            start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
        }
        impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> ReplyAttributionBuilder<'a, 'b, A> {
            #[inline]
            pub fn add_author_pubkey(&mut self, author_pubkey: ::flatbuffers::WIPOffset<&'b str>) {
                self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                    ReplyAttribution::VT_AUTHOR_PUBKEY,
                    author_pubkey,
                );
            }
            #[inline]
            pub fn add_reply_event_id(
                &mut self,
                reply_event_id: ::flatbuffers::WIPOffset<&'b str>,
            ) {
                self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                    ReplyAttribution::VT_REPLY_EVENT_ID,
                    reply_event_id,
                );
            }
            #[inline]
            pub fn add_reply_created_at(&mut self, reply_created_at: u64) {
                self.fbb_.push_slot::<u64>(
                    ReplyAttribution::VT_REPLY_CREATED_AT,
                    reply_created_at,
                    0,
                );
            }
            #[inline]
            pub fn new(
                _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
            ) -> ReplyAttributionBuilder<'a, 'b, A> {
                let start = _fbb.start_table();
                ReplyAttributionBuilder {
                    fbb_: _fbb,
                    start_: start,
                }
            }
            #[inline]
            pub fn finish(self) -> ::flatbuffers::WIPOffset<ReplyAttribution<'a>> {
                let o = self.fbb_.end_table(self.start_);
                ::flatbuffers::WIPOffset::new(o.value())
            }
        }

        impl ::core::fmt::Debug for ReplyAttribution<'_> {
            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                let mut ds = f.debug_struct("ReplyAttribution");
                ds.field("author_pubkey", &self.author_pubkey());
                ds.field("reply_event_id", &self.reply_event_id());
                ds.field("reply_created_at", &self.reply_created_at());
                ds.finish()
            }
        }
        pub enum RootItemOffset {}
        #[derive(Copy, Clone, PartialEq)]

        pub struct RootItem<'a> {
            pub _tab: ::flatbuffers::Table<'a>,
        }

        impl<'a> ::flatbuffers::Follow<'a> for RootItem<'a> {
            type Inner = RootItem<'a>;
            #[inline]
            unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
                Self {
                    _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
                }
            }
        }

        impl<'a> RootItem<'a> {
            pub const VT_ITEM: ::flatbuffers::VOffsetT = 4;
            pub const VT_ATTRIBUTION: ::flatbuffers::VOffsetT = 6;

            #[inline]
            pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
                RootItem { _tab: table }
            }
            #[allow(unused_mut)]
            pub fn create<
                'bldr: 'args,
                'args: 'mut_bldr,
                'mut_bldr,
                A: ::flatbuffers::Allocator + 'bldr,
            >(
                _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
                args: &'args RootItemArgs<'args>,
            ) -> ::flatbuffers::WIPOffset<RootItem<'bldr>> {
                let mut builder = RootItemBuilder::new(_fbb);
                if let Some(x) = args.attribution {
                    builder.add_attribution(x);
                }
                if let Some(x) = args.item {
                    builder.add_item(x);
                }
                builder.finish()
            }

            #[inline]
            pub fn item(&self) -> Option<NoteFeedItem<'a>> {
                // Safety:
                // Created from valid Table for this object
                // which contains a valid value in this slot
                unsafe {
                    self._tab
                        .get::<::flatbuffers::ForwardsUOffset<NoteFeedItem>>(
                            RootItem::VT_ITEM,
                            None,
                        )
                }
            }
            #[inline]
            pub fn attribution(
                &self,
            ) -> Option<
                ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ReplyAttribution<'a>>>,
            > {
                // Safety:
                // Created from valid Table for this object
                // which contains a valid value in this slot
                unsafe {
                    self._tab.get::<::flatbuffers::ForwardsUOffset<
                        ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ReplyAttribution>>,
                    >>(RootItem::VT_ATTRIBUTION, None)
                }
            }
        }

        impl ::flatbuffers::Verifiable for RootItem<'_> {
            #[inline]
            fn run_verifier(
                v: &mut ::flatbuffers::Verifier,
                pos: usize,
            ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
                v.visit_table(pos)?
                    .visit_field::<::flatbuffers::ForwardsUOffset<NoteFeedItem>>(
                        "item",
                        Self::VT_ITEM,
                        false,
                    )?
                    .visit_field::<::flatbuffers::ForwardsUOffset<
                        ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<ReplyAttribution>>,
                    >>("attribution", Self::VT_ATTRIBUTION, false)?
                    .finish();
                Ok(())
            }
        }
        pub struct RootItemArgs<'a> {
            pub item: Option<::flatbuffers::WIPOffset<NoteFeedItem<'a>>>,
            pub attribution: Option<
                ::flatbuffers::WIPOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<ReplyAttribution<'a>>>,
                >,
            >,
        }
        impl<'a> Default for RootItemArgs<'a> {
            #[inline]
            fn default() -> Self {
                RootItemArgs {
                    item: None,
                    attribution: None,
                }
            }
        }

        pub struct RootItemBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
            fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
            start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
        }
        impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> RootItemBuilder<'a, 'b, A> {
            #[inline]
            pub fn add_item(&mut self, item: ::flatbuffers::WIPOffset<NoteFeedItem<'b>>) {
                self.fbb_
                    .push_slot_always::<::flatbuffers::WIPOffset<NoteFeedItem>>(
                        RootItem::VT_ITEM,
                        item,
                    );
            }
            #[inline]
            pub fn add_attribution(
                &mut self,
                attribution: ::flatbuffers::WIPOffset<
                    ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<ReplyAttribution<'b>>>,
                >,
            ) {
                self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                    RootItem::VT_ATTRIBUTION,
                    attribution,
                );
            }
            #[inline]
            pub fn new(
                _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
            ) -> RootItemBuilder<'a, 'b, A> {
                let start = _fbb.start_table();
                RootItemBuilder {
                    fbb_: _fbb,
                    start_: start,
                }
            }
            #[inline]
            pub fn finish(self) -> ::flatbuffers::WIPOffset<RootItem<'a>> {
                let o = self.fbb_.end_table(self.start_);
                ::flatbuffers::WIPOffset::new(o.value())
            }
        }

        impl ::core::fmt::Debug for RootItem<'_> {
            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                let mut ds = f.debug_struct("RootItem");
                ds.field("item", &self.item());
                ds.field("attribution", &self.attribution());
                ds.finish()
            }
        }
        pub enum OpFeedSnapshotOffset {}
        #[derive(Copy, Clone, PartialEq)]

        pub struct OpFeedSnapshot<'a> {
            pub _tab: ::flatbuffers::Table<'a>,
        }

        impl<'a> ::flatbuffers::Follow<'a> for OpFeedSnapshot<'a> {
            type Inner = OpFeedSnapshot<'a>;
            #[inline]
            unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
                Self {
                    _tab: unsafe { ::flatbuffers::Table::new(buf, loc) },
                }
            }
        }

        impl<'a> OpFeedSnapshot<'a> {
            pub const VT_SCHEMA_VERSION: ::flatbuffers::VOffsetT = 4;
            pub const VT_ITEMS: ::flatbuffers::VOffsetT = 6;
            pub const VT_FEED_WINDOW_BYTES: ::flatbuffers::VOffsetT = 8;
            pub const VT_HAS_PAGE: ::flatbuffers::VOffsetT = 10;
            pub const VT_HAS_METRICS: ::flatbuffers::VOffsetT = 12;

            #[inline]
            pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
                OpFeedSnapshot { _tab: table }
            }
            #[allow(unused_mut)]
            pub fn create<
                'bldr: 'args,
                'args: 'mut_bldr,
                'mut_bldr,
                A: ::flatbuffers::Allocator + 'bldr,
            >(
                _fbb: &'mut_bldr mut ::flatbuffers::FlatBufferBuilder<'bldr, A>,
                args: &'args OpFeedSnapshotArgs<'args>,
            ) -> ::flatbuffers::WIPOffset<OpFeedSnapshot<'bldr>> {
                let mut builder = OpFeedSnapshotBuilder::new(_fbb);
                if let Some(x) = args.feed_window_bytes {
                    builder.add_feed_window_bytes(x);
                }
                if let Some(x) = args.items {
                    builder.add_items(x);
                }
                builder.add_schema_version(args.schema_version);
                builder.add_has_metrics(args.has_metrics);
                builder.add_has_page(args.has_page);
                builder.finish()
            }

            #[inline]
            pub fn schema_version(&self) -> u32 {
                // Safety:
                // Created from valid Table for this object
                // which contains a valid value in this slot
                unsafe {
                    self._tab
                        .get::<u32>(OpFeedSnapshot::VT_SCHEMA_VERSION, Some(1))
                        .unwrap()
                }
            }
            #[inline]
            pub fn items(
                &self,
            ) -> Option<::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<RootItem<'a>>>>
            {
                // Safety:
                // Created from valid Table for this object
                // which contains a valid value in this slot
                unsafe {
                    self._tab.get::<::flatbuffers::ForwardsUOffset<
                        ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<RootItem>>,
                    >>(OpFeedSnapshot::VT_ITEMS, None)
                }
            }
            #[inline]
            pub fn feed_window_bytes(&self) -> Option<::flatbuffers::Vector<'a, u8>> {
                // Safety:
                // Created from valid Table for this object
                // which contains a valid value in this slot
                unsafe {
                    self._tab
                        .get::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'a, u8>>>(
                            OpFeedSnapshot::VT_FEED_WINDOW_BYTES,
                            None,
                        )
                }
            }
            #[inline]
            pub fn has_page(&self) -> bool {
                // Safety:
                // Created from valid Table for this object
                // which contains a valid value in this slot
                unsafe {
                    self._tab
                        .get::<bool>(OpFeedSnapshot::VT_HAS_PAGE, Some(false))
                        .unwrap()
                }
            }
            #[inline]
            pub fn has_metrics(&self) -> bool {
                // Safety:
                // Created from valid Table for this object
                // which contains a valid value in this slot
                unsafe {
                    self._tab
                        .get::<bool>(OpFeedSnapshot::VT_HAS_METRICS, Some(false))
                        .unwrap()
                }
            }
        }

        impl ::flatbuffers::Verifiable for OpFeedSnapshot<'_> {
            #[inline]
            fn run_verifier(
                v: &mut ::flatbuffers::Verifier,
                pos: usize,
            ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
                v.visit_table(pos)?
                    .visit_field::<u32>("schema_version", Self::VT_SCHEMA_VERSION, false)?
                    .visit_field::<::flatbuffers::ForwardsUOffset<
                        ::flatbuffers::Vector<'_, ::flatbuffers::ForwardsUOffset<RootItem>>,
                    >>("items", Self::VT_ITEMS, false)?
                    .visit_field::<::flatbuffers::ForwardsUOffset<::flatbuffers::Vector<'_, u8>>>(
                        "feed_window_bytes",
                        Self::VT_FEED_WINDOW_BYTES,
                        false,
                    )?
                    .visit_field::<bool>("has_page", Self::VT_HAS_PAGE, false)?
                    .visit_field::<bool>("has_metrics", Self::VT_HAS_METRICS, false)?
                    .finish();
                Ok(())
            }
        }
        pub struct OpFeedSnapshotArgs<'a> {
            pub schema_version: u32,
            pub items: Option<
                ::flatbuffers::WIPOffset<
                    ::flatbuffers::Vector<'a, ::flatbuffers::ForwardsUOffset<RootItem<'a>>>,
                >,
            >,
            pub feed_window_bytes: Option<::flatbuffers::WIPOffset<::flatbuffers::Vector<'a, u8>>>,
            pub has_page: bool,
            pub has_metrics: bool,
        }
        impl<'a> Default for OpFeedSnapshotArgs<'a> {
            #[inline]
            fn default() -> Self {
                OpFeedSnapshotArgs {
                    schema_version: 1,
                    items: None,
                    feed_window_bytes: None,
                    has_page: false,
                    has_metrics: false,
                }
            }
        }

        pub struct OpFeedSnapshotBuilder<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> {
            fbb_: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
            start_: ::flatbuffers::WIPOffset<::flatbuffers::TableUnfinishedWIPOffset>,
        }
        impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> OpFeedSnapshotBuilder<'a, 'b, A> {
            #[inline]
            pub fn add_schema_version(&mut self, schema_version: u32) {
                self.fbb_
                    .push_slot::<u32>(OpFeedSnapshot::VT_SCHEMA_VERSION, schema_version, 1);
            }
            #[inline]
            pub fn add_items(
                &mut self,
                items: ::flatbuffers::WIPOffset<
                    ::flatbuffers::Vector<'b, ::flatbuffers::ForwardsUOffset<RootItem<'b>>>,
                >,
            ) {
                self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                    OpFeedSnapshot::VT_ITEMS,
                    items,
                );
            }
            #[inline]
            pub fn add_feed_window_bytes(
                &mut self,
                feed_window_bytes: ::flatbuffers::WIPOffset<::flatbuffers::Vector<'b, u8>>,
            ) {
                self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(
                    OpFeedSnapshot::VT_FEED_WINDOW_BYTES,
                    feed_window_bytes,
                );
            }
            #[inline]
            pub fn add_has_page(&mut self, has_page: bool) {
                self.fbb_
                    .push_slot::<bool>(OpFeedSnapshot::VT_HAS_PAGE, has_page, false);
            }
            #[inline]
            pub fn add_has_metrics(&mut self, has_metrics: bool) {
                self.fbb_
                    .push_slot::<bool>(OpFeedSnapshot::VT_HAS_METRICS, has_metrics, false);
            }
            #[inline]
            pub fn new(
                _fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
            ) -> OpFeedSnapshotBuilder<'a, 'b, A> {
                let start = _fbb.start_table();
                OpFeedSnapshotBuilder {
                    fbb_: _fbb,
                    start_: start,
                }
            }
            #[inline]
            pub fn finish(self) -> ::flatbuffers::WIPOffset<OpFeedSnapshot<'a>> {
                let o = self.fbb_.end_table(self.start_);
                ::flatbuffers::WIPOffset::new(o.value())
            }
        }

        impl ::core::fmt::Debug for OpFeedSnapshot<'_> {
            fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
                let mut ds = f.debug_struct("OpFeedSnapshot");
                ds.field("schema_version", &self.schema_version());
                ds.field("items", &self.items());
                ds.field("feed_window_bytes", &self.feed_window_bytes());
                ds.field("has_page", &self.has_page());
                ds.field("has_metrics", &self.has_metrics());
                ds.finish()
            }
        }
        #[inline]
        /// Verifies that a buffer of bytes contains a `OpFeedSnapshot`
        /// and returns it.
        /// Note that verification is still experimental and may not
        /// catch every error, or be maximally performant. For the
        /// previous, unchecked, behavior use
        /// `root_as_op_feed_snapshot_unchecked`.
        pub fn root_as_op_feed_snapshot(
            buf: &[u8],
        ) -> Result<OpFeedSnapshot<'_>, ::flatbuffers::InvalidFlatbuffer> {
            ::flatbuffers::root::<OpFeedSnapshot>(buf)
        }
        #[inline]
        /// Verifies that a buffer of bytes contains a size prefixed
        /// `OpFeedSnapshot` and returns it.
        /// Note that verification is still experimental and may not
        /// catch every error, or be maximally performant. For the
        /// previous, unchecked, behavior use
        /// `size_prefixed_root_as_op_feed_snapshot_unchecked`.
        pub fn size_prefixed_root_as_op_feed_snapshot(
            buf: &[u8],
        ) -> Result<OpFeedSnapshot<'_>, ::flatbuffers::InvalidFlatbuffer> {
            ::flatbuffers::size_prefixed_root::<OpFeedSnapshot>(buf)
        }
        #[inline]
        /// Verifies, with the given options, that a buffer of bytes
        /// contains a `OpFeedSnapshot` and returns it.
        /// Note that verification is still experimental and may not
        /// catch every error, or be maximally performant. For the
        /// previous, unchecked, behavior use
        /// `root_as_op_feed_snapshot_unchecked`.
        pub fn root_as_op_feed_snapshot_with_opts<'b, 'o>(
            opts: &'o ::flatbuffers::VerifierOptions,
            buf: &'b [u8],
        ) -> Result<OpFeedSnapshot<'b>, ::flatbuffers::InvalidFlatbuffer> {
            ::flatbuffers::root_with_opts::<OpFeedSnapshot<'b>>(opts, buf)
        }
        #[inline]
        /// Verifies, with the given verifier options, that a buffer of
        /// bytes contains a size prefixed `OpFeedSnapshot` and returns
        /// it. Note that verification is still experimental and may not
        /// catch every error, or be maximally performant. For the
        /// previous, unchecked, behavior use
        /// `root_as_op_feed_snapshot_unchecked`.
        pub fn size_prefixed_root_as_op_feed_snapshot_with_opts<'b, 'o>(
            opts: &'o ::flatbuffers::VerifierOptions,
            buf: &'b [u8],
        ) -> Result<OpFeedSnapshot<'b>, ::flatbuffers::InvalidFlatbuffer> {
            ::flatbuffers::size_prefixed_root_with_opts::<OpFeedSnapshot<'b>>(opts, buf)
        }
        #[inline]
        /// Assumes, without verification, that a buffer of bytes contains a OpFeedSnapshot and returns it.
        /// # Safety
        /// Callers must trust the given bytes do indeed contain a valid `OpFeedSnapshot`.
        pub unsafe fn root_as_op_feed_snapshot_unchecked(buf: &[u8]) -> OpFeedSnapshot<'_> {
            unsafe { ::flatbuffers::root_unchecked::<OpFeedSnapshot>(buf) }
        }
        #[inline]
        /// Assumes, without verification, that a buffer of bytes contains a size prefixed OpFeedSnapshot and returns it.
        /// # Safety
        /// Callers must trust the given bytes do indeed contain a valid size prefixed `OpFeedSnapshot`.
        pub unsafe fn size_prefixed_root_as_op_feed_snapshot_unchecked(
            buf: &[u8],
        ) -> OpFeedSnapshot<'_> {
            unsafe { ::flatbuffers::size_prefixed_root_unchecked::<OpFeedSnapshot>(buf) }
        }
        pub const OP_FEED_SNAPSHOT_IDENTIFIER: &str = "NNFS";

        #[inline]
        pub fn op_feed_snapshot_buffer_has_identifier(buf: &[u8]) -> bool {
            ::flatbuffers::buffer_has_identifier(buf, OP_FEED_SNAPSHOT_IDENTIFIER, false)
        }

        #[inline]
        pub fn op_feed_snapshot_size_prefixed_buffer_has_identifier(buf: &[u8]) -> bool {
            ::flatbuffers::buffer_has_identifier(buf, OP_FEED_SNAPSHOT_IDENTIFIER, true)
        }

        #[inline]
        pub fn finish_op_feed_snapshot_buffer<'a, 'b, A: ::flatbuffers::Allocator + 'a>(
            fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
            root: ::flatbuffers::WIPOffset<OpFeedSnapshot<'a>>,
        ) {
            fbb.finish(root, Some(OP_FEED_SNAPSHOT_IDENTIFIER));
        }

        #[inline]
        pub fn finish_size_prefixed_op_feed_snapshot_buffer<
            'a,
            'b,
            A: ::flatbuffers::Allocator + 'a,
        >(
            fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>,
            root: ::flatbuffers::WIPOffset<OpFeedSnapshot<'a>>,
        ) {
            fbb.finish_size_prefixed(root, Some(OP_FEED_SNAPSHOT_IDENTIFIER));
        }
    } // pub mod note_feed
} // pub mod nmp
