@ignex/nova 0.1.1 → 0.1.5

package/src/generated/rust/backend_generated.rs

@@ -2544,6 +2544,7 @@ impl<'a> ::flatbuffers::Follow<'a> for SnapshotRequest<'a> {
 
 impl<'a> SnapshotRequest<'a> {
   pub const VT_TOPIC: ::flatbuffers::VOffsetT = 4;
+  pub const VT_FROM_SEQ: ::flatbuffers::VOffsetT = 6;
 
   #[inline]
   pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
@@ -2555,6 +2556,7 @@ impl<'a> SnapshotRequest<'a> {
     args: &'args SnapshotRequestArgs<'args>
   ) -> ::flatbuffers::WIPOffset<SnapshotRequest<'bldr>> {
     let mut builder = SnapshotRequestBuilder::new(_fbb);
+    builder.add_from_seq(args.from_seq);
     if let Some(x) = args.topic { builder.add_topic(x); }
     builder.finish()
   }
@@ -2567,6 +2569,13 @@ impl<'a> SnapshotRequest<'a> {
     // which contains a valid value in this slot
     unsafe { self._tab.get::<::flatbuffers::ForwardsUOffset<&str>>(SnapshotRequest::VT_TOPIC, None)}
   }
+  #[inline]
+  pub fn from_seq(&self) -> i64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<i64>(SnapshotRequest::VT_FROM_SEQ, Some(0)).unwrap()}
+  }
 }
 
 impl ::flatbuffers::Verifiable for SnapshotRequest<'_> {
@@ -2576,18 +2585,21 @@ impl ::flatbuffers::Verifiable for SnapshotRequest<'_> {
   ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
     v.visit_table(pos)?
      .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("topic", Self::VT_TOPIC, false)?
+     .visit_field::<i64>("from_seq", Self::VT_FROM_SEQ, false)?
      .finish();
     Ok(())
   }
 }
 pub struct SnapshotRequestArgs<'a> {
     pub topic: Option<::flatbuffers::WIPOffset<&'a str>>,
+    pub from_seq: i64,
 }
 impl<'a> Default for SnapshotRequestArgs<'a> {
   #[inline]
   fn default() -> Self {
     SnapshotRequestArgs {
       topic: None,
+      from_seq: 0,
     }
   }
 }
@@ -2602,6 +2614,10 @@ impl<'a: 'b, 'b, A: ::flatbuffers::Allocator + 'a> SnapshotRequestBuilder<'a, 'b
     self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(SnapshotRequest::VT_TOPIC, topic);
   }
   #[inline]
+  pub fn add_from_seq(&mut self, from_seq: i64) {
+    self.fbb_.push_slot::<i64>(SnapshotRequest::VT_FROM_SEQ, from_seq, 0);
+  }
+  #[inline]
   pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> SnapshotRequestBuilder<'a, 'b, A> {
     let start = _fbb.start_table();
     SnapshotRequestBuilder {
@@ -2620,6 +2636,7 @@ impl ::core::fmt::Debug for SnapshotRequest<'_> {
   fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
     let mut ds = f.debug_struct("SnapshotRequest");
       ds.field("topic", &self.topic());
+      ds.field("from_seq", &self.from_seq());
       ds.finish()
   }
 }
@@ -2815,3 +2832,489 @@ impl ::core::fmt::Debug for Pong<'_> {
       ds.finish()
   }
 }
+pub enum ResumeOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+pub struct Resume<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}
+
+impl<'a> ::flatbuffers::Follow<'a> for Resume<'a> {
+  type Inner = Resume<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
+}
+
+impl<'a> Resume<'a> {
+  pub const VT_LAST_SEQ: ::flatbuffers::VOffsetT = 4;
+
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    Resume { _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 ResumeArgs
+  ) -> ::flatbuffers::WIPOffset<Resume<'bldr>> {
+    let mut builder = ResumeBuilder::new(_fbb);
+    builder.add_last_seq(args.last_seq);
+    builder.finish()
+  }
+
+
+  #[inline]
+  pub fn last_seq(&self) -> i64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<i64>(Resume::VT_LAST_SEQ, Some(0)).unwrap()}
+  }
+}
+
+impl ::flatbuffers::Verifiable for Resume<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.visit_table(pos)?
+     .visit_field::<i64>("last_seq", Self::VT_LAST_SEQ, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct ResumeArgs {
+    pub last_seq: i64,
+}
+impl<'a> Default for ResumeArgs {
+  #[inline]
+  fn default() -> Self {
+    ResumeArgs {
+      last_seq: 0,
+    }
+  }
+}
+
+pub struct ResumeBuilder<'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> ResumeBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_last_seq(&mut self, last_seq: i64) {
+    self.fbb_.push_slot::<i64>(Resume::VT_LAST_SEQ, last_seq, 0);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> ResumeBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    ResumeBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<Resume<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl ::core::fmt::Debug for Resume<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("Resume");
+      ds.field("last_seq", &self.last_seq());
+      ds.finish()
+  }
+}
+pub enum ResumedOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+pub struct Resumed<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}
+
+impl<'a> ::flatbuffers::Follow<'a> for Resumed<'a> {
+  type Inner = Resumed<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
+}
+
+impl<'a> Resumed<'a> {
+  pub const VT_OK: ::flatbuffers::VOffsetT = 4;
+  pub const VT_FROM: ::flatbuffers::VOffsetT = 6;
+
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    Resumed { _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 ResumedArgs
+  ) -> ::flatbuffers::WIPOffset<Resumed<'bldr>> {
+    let mut builder = ResumedBuilder::new(_fbb);
+    builder.add_from(args.from);
+    builder.add_ok(args.ok);
+    builder.finish()
+  }
+
+
+  #[inline]
+  pub fn ok(&self) -> bool {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<bool>(Resumed::VT_OK, Some(false)).unwrap()}
+  }
+  #[inline]
+  pub fn from(&self) -> i64 {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<i64>(Resumed::VT_FROM, Some(0)).unwrap()}
+  }
+}
+
+impl ::flatbuffers::Verifiable for Resumed<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut ::flatbuffers::Verifier, pos: usize
+  ) -> Result<(), ::flatbuffers::InvalidFlatbuffer> {
+    v.visit_table(pos)?
+     .visit_field::<bool>("ok", Self::VT_OK, false)?
+     .visit_field::<i64>("from", Self::VT_FROM, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct ResumedArgs {
+    pub ok: bool,
+    pub from: i64,
+}
+impl<'a> Default for ResumedArgs {
+  #[inline]
+  fn default() -> Self {
+    ResumedArgs {
+      ok: false,
+      from: 0,
+    }
+  }
+}
+
+pub struct ResumedBuilder<'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> ResumedBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_ok(&mut self, ok: bool) {
+    self.fbb_.push_slot::<bool>(Resumed::VT_OK, ok, false);
+  }
+  #[inline]
+  pub fn add_from(&mut self, from: i64) {
+    self.fbb_.push_slot::<i64>(Resumed::VT_FROM, from, 0);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> ResumedBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    ResumedBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<Resumed<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl ::core::fmt::Debug for Resumed<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("Resumed");
+      ds.field("ok", &self.ok());
+      ds.field("from", &self.from());
+      ds.finish()
+  }
+}
+pub enum RpcCallOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+pub struct RpcCall<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}
+
+impl<'a> ::flatbuffers::Follow<'a> for RpcCall<'a> {
+  type Inner = RpcCall<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
+}
+
+impl<'a> RpcCall<'a> {
+  pub const VT_ID: ::flatbuffers::VOffsetT = 4;
+  pub const VT_NAME: ::flatbuffers::VOffsetT = 6;
+  pub const VT_PAYLOAD_B64: ::flatbuffers::VOffsetT = 8;
+
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    RpcCall { _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 RpcCallArgs<'args>
+  ) -> ::flatbuffers::WIPOffset<RpcCall<'bldr>> {
+    let mut builder = RpcCallBuilder::new(_fbb);
+    if let Some(x) = args.payload_b64 { builder.add_payload_b64(x); }
+    if let Some(x) = args.name { builder.add_name(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>>(RpcCall::VT_ID, None)}
+  }
+  #[inline]
+  pub fn name(&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>>(RpcCall::VT_NAME, None)}
+  }
+  #[inline]
+  pub fn payload_b64(&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>>(RpcCall::VT_PAYLOAD_B64, None)}
+  }
+}
+
+impl ::flatbuffers::Verifiable for RpcCall<'_> {
+  #[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>>("name", Self::VT_NAME, false)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("payload_b64", Self::VT_PAYLOAD_B64, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct RpcCallArgs<'a> {
+    pub id: Option<::flatbuffers::WIPOffset<&'a str>>,
+    pub name: Option<::flatbuffers::WIPOffset<&'a str>>,
+    pub payload_b64: Option<::flatbuffers::WIPOffset<&'a str>>,
+}
+impl<'a> Default for RpcCallArgs<'a> {
+  #[inline]
+  fn default() -> Self {
+    RpcCallArgs {
+      id: None,
+      name: None,
+      payload_b64: None,
+    }
+  }
+}
+
+pub struct RpcCallBuilder<'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> RpcCallBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_id(&mut self, id: ::flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(RpcCall::VT_ID, id);
+  }
+  #[inline]
+  pub fn add_name(&mut self, name: ::flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(RpcCall::VT_NAME, name);
+  }
+  #[inline]
+  pub fn add_payload_b64(&mut self, payload_b64: ::flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(RpcCall::VT_PAYLOAD_B64, payload_b64);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> RpcCallBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    RpcCallBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<RpcCall<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl ::core::fmt::Debug for RpcCall<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("RpcCall");
+      ds.field("id", &self.id());
+      ds.field("name", &self.name());
+      ds.field("payload_b64", &self.payload_b64());
+      ds.finish()
+  }
+}
+pub enum RpcResultOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+pub struct RpcResult<'a> {
+  pub _tab: ::flatbuffers::Table<'a>,
+}
+
+impl<'a> ::flatbuffers::Follow<'a> for RpcResult<'a> {
+  type Inner = RpcResult<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: unsafe { ::flatbuffers::Table::new(buf, loc) } }
+  }
+}
+
+impl<'a> RpcResult<'a> {
+  pub const VT_ID: ::flatbuffers::VOffsetT = 4;
+  pub const VT_OK: ::flatbuffers::VOffsetT = 6;
+  pub const VT_ERR: ::flatbuffers::VOffsetT = 8;
+  pub const VT_PAYLOAD_B64: ::flatbuffers::VOffsetT = 10;
+
+  #[inline]
+  pub unsafe fn init_from_table(table: ::flatbuffers::Table<'a>) -> Self {
+    RpcResult { _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 RpcResultArgs<'args>
+  ) -> ::flatbuffers::WIPOffset<RpcResult<'bldr>> {
+    let mut builder = RpcResultBuilder::new(_fbb);
+    if let Some(x) = args.payload_b64 { builder.add_payload_b64(x); }
+    if let Some(x) = args.err { builder.add_err(x); }
+    if let Some(x) = args.id { builder.add_id(x); }
+    builder.add_ok(args.ok);
+    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>>(RpcResult::VT_ID, None)}
+  }
+  #[inline]
+  pub fn ok(&self) -> bool {
+    // Safety:
+    // Created from valid Table for this object
+    // which contains a valid value in this slot
+    unsafe { self._tab.get::<bool>(RpcResult::VT_OK, Some(false)).unwrap()}
+  }
+  #[inline]
+  pub fn err(&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>>(RpcResult::VT_ERR, None)}
+  }
+  #[inline]
+  pub fn payload_b64(&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>>(RpcResult::VT_PAYLOAD_B64, None)}
+  }
+}
+
+impl ::flatbuffers::Verifiable for RpcResult<'_> {
+  #[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::<bool>("ok", Self::VT_OK, false)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("err", Self::VT_ERR, false)?
+     .visit_field::<::flatbuffers::ForwardsUOffset<&str>>("payload_b64", Self::VT_PAYLOAD_B64, false)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct RpcResultArgs<'a> {
+    pub id: Option<::flatbuffers::WIPOffset<&'a str>>,
+    pub ok: bool,
+    pub err: Option<::flatbuffers::WIPOffset<&'a str>>,
+    pub payload_b64: Option<::flatbuffers::WIPOffset<&'a str>>,
+}
+impl<'a> Default for RpcResultArgs<'a> {
+  #[inline]
+  fn default() -> Self {
+    RpcResultArgs {
+      id: None,
+      ok: false,
+      err: None,
+      payload_b64: None,
+    }
+  }
+}
+
+pub struct RpcResultBuilder<'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> RpcResultBuilder<'a, 'b, A> {
+  #[inline]
+  pub fn add_id(&mut self, id: ::flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(RpcResult::VT_ID, id);
+  }
+  #[inline]
+  pub fn add_ok(&mut self, ok: bool) {
+    self.fbb_.push_slot::<bool>(RpcResult::VT_OK, ok, false);
+  }
+  #[inline]
+  pub fn add_err(&mut self, err: ::flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(RpcResult::VT_ERR, err);
+  }
+  #[inline]
+  pub fn add_payload_b64(&mut self, payload_b64: ::flatbuffers::WIPOffset<&'b  str>) {
+    self.fbb_.push_slot_always::<::flatbuffers::WIPOffset<_>>(RpcResult::VT_PAYLOAD_B64, payload_b64);
+  }
+  #[inline]
+  pub fn new(_fbb: &'b mut ::flatbuffers::FlatBufferBuilder<'a, A>) -> RpcResultBuilder<'a, 'b, A> {
+    let start = _fbb.start_table();
+    RpcResultBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> ::flatbuffers::WIPOffset<RpcResult<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    ::flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl ::core::fmt::Debug for RpcResult<'_> {
+  fn fmt(&self, f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
+    let mut ds = f.debug_struct("RpcResult");
+      ds.field("id", &self.id());
+      ds.field("ok", &self.ok());
+      ds.field("err", &self.err());
+      ds.field("payload_b64", &self.payload_b64());
+      ds.finish()
+  }
+}

package/src/generated/ts/backend.ts

@@ -16,6 +16,10 @@ export { Pong, PongT } from './pong.js';
 export { PortfolioPosition, PortfolioPositionT } from './portfolio-position.js';
 export { PortfolioSnapshot, PortfolioSnapshotT } from './portfolio-snapshot.js';
 export { Quote, QuoteT } from './quote.js';
+export { Resume, ResumeT } from './resume.js';
+export { Resumed, ResumedT } from './resumed.js';
+export { RpcCall, RpcCallT } from './rpc-call.js';
+export { RpcResult, RpcResultT } from './rpc-result.js';
 export { Side } from './side.js';
 export { SnapshotRequest, SnapshotRequestT } from './snapshot-request.js';
 export { Subscribe, SubscribeT } from './subscribe.js';

package/src/generated/ts/resume.ts

@@ -0,0 +1,74 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */
+
+import * as flatbuffers from 'flatbuffers';
+
+
+
+export class Resume implements flatbuffers.IUnpackableObject<ResumeT> {
+  bb: flatbuffers.ByteBuffer|null = null;
+  bb_pos = 0;
+  __init(i:number, bb:flatbuffers.ByteBuffer):Resume {
+  this.bb_pos = i;
+  this.bb = bb;
+  return this;
+}
+
+static getRootAsResume(bb:flatbuffers.ByteBuffer, obj?:Resume):Resume {
+  return (obj || new Resume()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+static getSizePrefixedRootAsResume(bb:flatbuffers.ByteBuffer, obj?:Resume):Resume {
+  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+  return (obj || new Resume()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+lastSeq():bigint {
+  const offset = this.bb!.__offset(this.bb_pos, 4);
+  return offset ? this.bb!.readInt64(this.bb_pos + offset) : BigInt('0');
+}
+
+static startResume(builder:flatbuffers.Builder) {
+  builder.startObject(1);
+}
+
+static addLastSeq(builder:flatbuffers.Builder, lastSeq:bigint) {
+  builder.addFieldInt64(0, lastSeq, BigInt('0'));
+}
+
+static endResume(builder:flatbuffers.Builder):flatbuffers.Offset {
+  const offset = builder.endObject();
+  return offset;
+}
+
+static createResume(builder:flatbuffers.Builder, lastSeq:bigint):flatbuffers.Offset {
+  Resume.startResume(builder);
+  Resume.addLastSeq(builder, lastSeq);
+  return Resume.endResume(builder);
+}
+
+unpack(): ResumeT {
+  return new ResumeT(
+    this.lastSeq()
+  );
+}
+
+
+unpackTo(_o: ResumeT): void {
+  _o.lastSeq = this.lastSeq();
+}
+}
+
+export class ResumeT implements flatbuffers.IGeneratedObject {
+constructor(
+  public lastSeq: bigint = BigInt('0')
+){}
+
+
+pack(builder:flatbuffers.Builder): flatbuffers.Offset {
+  return Resume.createResume(builder,
+    this.lastSeq
+  );
+}
+}