@ignex/nova 0.1.1 → 0.1.5

package/rust/src/generated/backend.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()
+  }
+}