@ignex/nova 0.1.1

package/rust/src/transcode/generated.rs

@@ -0,0 +1,1352 @@
+// @generated by scripts/rust-glue-gen.ts — DO NOT EDIT
+#![allow(clippy::all)]
+#![allow(dead_code)]
+#![allow(unused_imports)]
+
+use std::cell::RefCell;
+use std::ffi::CStr;
+use std::os::raw::c_char;
+use serde::Deserialize;
+use crate::generated::backend;
+
+pub const WIRE_VERSION: u8 = 1;
+pub const WIRE_HEADER_LEN: usize = 5; // [version:1][event_id:u32 LE]
+
+thread_local! {
+    static FBB: RefCell<flatbuffers::FlatBufferBuilder<'static>> =
+        RefCell::new(flatbuffers::FlatBufferBuilder::new());
+}
+
+fn copy_finished<T>(
+    out: &mut [u8],
+    build: impl FnOnce(&mut flatbuffers::FlatBufferBuilder<'static>) -> flatbuffers::WIPOffset<T>,
+) -> Result<usize, TranscodeError> {
+    FBB.with(|cell| {
+        let mut fbb = cell.borrow_mut();
+        fbb.reset();
+        let root = build(&mut fbb);
+        fbb.finish_size_prefixed(root, Some("IGNX"));
+        let data = fbb.finished_data();
+        if data.len() > out.len() {
+            return Ok(data.len());
+        }
+        out[..data.len()].copy_from_slice(data);
+        Ok(data.len())
+    })
+}
+
+#[derive(Debug)]
+pub enum TranscodeError {
+    Parse,
+    UnknownEvent,
+}
+
+fn de_i64<'de, D>(d: D) -> Result<i64, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let v = serde_json::Value::deserialize(d)?;
+    Ok(v.as_i64().or_else(|| v.as_f64().map(|f| f as i64)).unwrap_or(0))
+}
+
+fn side_from_str(s: &str) -> backend::Side {
+    match s {
+        "buy" => backend::Side::BUY,
+        "sell" => backend::Side::SELL,
+        _ => backend::Side::default(),
+    }
+}
+
+fn tags_from_str(s: &str) -> backend::Tags {
+    match s {
+        "hot" => backend::Tags::HOT,
+        "new" => backend::Tags::NEW,
+        "sale" => backend::Tags::SALE,
+        _ => backend::Tags::default(),
+    }
+}
+
+#[derive(Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct QuoteJson {
+    #[serde(default)]
+    pub symbol: String,
+    #[serde(default)]
+    pub bid: f64,
+    #[serde(default)]
+    pub ask: f64,
+    #[serde(default, deserialize_with = "de_i64")]
+    pub bid_size: i64,
+    #[serde(default, deserialize_with = "de_i64")]
+    pub ask_size: i64,
+    #[serde(default, deserialize_with = "de_i64")]
+    pub ts: i64,
+}
+
+pub fn build_quote<'a>(fbb: &mut flatbuffers::FlatBufferBuilder<'a>, j: &QuoteJson) -> flatbuffers::WIPOffset<backend::Quote<'a>> {
+    let symbol = fbb.create_string(&j.symbol);
+    backend::Quote::create(fbb, &backend::QuoteArgs {
+        symbol: Some(symbol),
+        bid: j.bid,
+        ask: j.ask,
+        bid_size: j.bid_size,
+        ask_size: j.ask_size,
+        ts: j.ts,
+        ..Default::default()
+    })
+}
+
+#[derive(Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct TradeJson {
+    #[serde(default)]
+    pub symbol: String,
+    #[serde(default)]
+    pub price: f64,
+    #[serde(default, deserialize_with = "de_i64")]
+    pub volume: i64,
+    #[serde(default)]
+    pub side: Option<String>,
+    #[serde(default, deserialize_with = "de_i64")]
+    pub ts: i64,
+}
+
+pub fn build_trade<'a>(fbb: &mut flatbuffers::FlatBufferBuilder<'a>, j: &TradeJson) -> flatbuffers::WIPOffset<backend::Trade<'a>> {
+    let symbol = fbb.create_string(&j.symbol);
+    let side = j.side.as_deref().map(side_from_str).unwrap_or_default();
+    backend::Trade::create(fbb, &backend::TradeArgs {
+        symbol: Some(symbol),
+        price: j.price,
+        volume: j.volume,
+        side,
+        ts: j.ts,
+        ..Default::default()
+    })
+}
+
+#[derive(Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct PortfolioSnapshotJson {
+    #[serde(default)]
+    pub account_id: String,
+    #[serde(default)]
+    pub positions: Vec<PortfolioPositionJson>,
+    #[serde(default)]
+    pub total_value: f64,
+    #[serde(default)]
+    pub cash: f64,
+    #[serde(default, deserialize_with = "de_i64")]
+    pub ts: i64,
+    #[serde(default)]
+    pub updated_by: Option<String>,
+}
+
+pub fn build_portfolio_snapshot<'a>(fbb: &mut flatbuffers::FlatBufferBuilder<'a>, j: &PortfolioSnapshotJson) -> flatbuffers::WIPOffset<backend::PortfolioSnapshot<'a>> {
+    let account_id = fbb.create_string(&j.account_id);
+    let positions = if j.positions.is_empty() { None } else { let offs: Vec<flatbuffers::WIPOffset<backend::PortfolioPosition<'a>>> = j.positions.iter().map(|c| build_portfolio_position(fbb, c)).collect(); Some(fbb.create_vector(&offs)) };
+    let updated_by = j.updated_by.as_deref().map(|s| fbb.create_string(s));
+    backend::PortfolioSnapshot::create(fbb, &backend::PortfolioSnapshotArgs {
+        account_id: Some(account_id),
+        positions,
+        total_value: j.total_value,
+        cash: j.cash,
+        ts: j.ts,
+        updated_by,
+        ..Default::default()
+    })
+}
+
+#[derive(Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct PortfolioPositionJson {
+    #[serde(default)]
+    pub symbol: String,
+    #[serde(default, deserialize_with = "de_i64")]
+    pub quantity: i64,
+    #[serde(default)]
+    pub avg_price: f64,
+    #[serde(default)]
+    pub pnl: f64,
+}
+
+pub fn build_portfolio_position<'a>(fbb: &mut flatbuffers::FlatBufferBuilder<'a>, j: &PortfolioPositionJson) -> flatbuffers::WIPOffset<backend::PortfolioPosition<'a>> {
+    let symbol = fbb.create_string(&j.symbol);
+    backend::PortfolioPosition::create(fbb, &backend::PortfolioPositionArgs {
+        symbol: Some(symbol),
+        quantity: j.quantity,
+        avg_price: j.avg_price,
+        pnl: j.pnl,
+        ..Default::default()
+    })
+}
+
+#[derive(Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct ComplexJson {
+    #[serde(default)]
+    pub id: String,
+    #[serde(default)]
+    pub names: Vec<String>,
+    #[serde(default)]
+    pub prices: Vec<f64>,
+    #[serde(default)]
+    pub counts: Vec<i64>,
+    #[serde(default)]
+    pub flags: Vec<bool>,
+    #[serde(default)]
+    pub tags: Vec<String>,
+    #[serde(default)]
+    pub active: bool,
+    #[serde(default)]
+    pub total: f64,
+    #[serde(default, deserialize_with = "de_i64")]
+    pub ts: i64,
+}
+
+pub fn build_complex<'a>(fbb: &mut flatbuffers::FlatBufferBuilder<'a>, j: &ComplexJson) -> flatbuffers::WIPOffset<backend::Complex<'a>> {
+    let id = fbb.create_string(&j.id);
+    let names = if j.names.is_empty() { None } else { let offs: Vec<flatbuffers::WIPOffset<&str>> = j.names.iter().map(|s| fbb.create_string(s)).collect(); Some(fbb.create_vector(&offs)) };
+    let prices = if j.prices.is_empty() { None } else { Some(fbb.create_vector(&j.prices)) };
+    let counts = if j.counts.is_empty() { None } else { Some(fbb.create_vector(&j.counts)) };
+    let flags = if j.flags.is_empty() { None } else { Some(fbb.create_vector(&j.flags)) };
+    let tags = if j.tags.is_empty() { None } else { let vals: Vec<backend::Tags> = j.tags.iter().map(|s| tags_from_str(s)).collect(); Some(fbb.create_vector(&vals)) };
+    backend::Complex::create(fbb, &backend::ComplexArgs {
+        id: Some(id),
+        names,
+        prices,
+        counts,
+        flags,
+        tags,
+        active: j.active,
+        total: j.total,
+        ts: j.ts,
+        ..Default::default()
+    })
+}
+
+#[derive(Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct OrderJson {
+    #[serde(default)]
+    pub order_id: String,
+    #[serde(default)]
+    pub customer: Option<CustomerJson>,
+    #[serde(default)]
+    pub lines: Vec<OrderLineJson>,
+    #[serde(default)]
+    pub notes: Vec<String>,
+    #[serde(default)]
+    pub discounts: Vec<f64>,
+    #[serde(default)]
+    pub active: bool,
+    #[serde(default, deserialize_with = "de_i64")]
+    pub created_at: i64,
+    #[serde(default)]
+    pub billing: Option<OrderBillingJson>,
+}
+
+pub fn build_order<'a>(fbb: &mut flatbuffers::FlatBufferBuilder<'a>, j: &OrderJson) -> flatbuffers::WIPOffset<backend::Order<'a>> {
+    let order_id = fbb.create_string(&j.order_id);
+    let customer = j.customer.as_ref().map(|c| build_customer(fbb, c));
+    let lines = if j.lines.is_empty() { None } else { let offs: Vec<flatbuffers::WIPOffset<backend::OrderLine<'a>>> = j.lines.iter().map(|c| build_order_line(fbb, c)).collect(); Some(fbb.create_vector(&offs)) };
+    let notes = if j.notes.is_empty() { None } else { let offs: Vec<flatbuffers::WIPOffset<&str>> = j.notes.iter().map(|s| fbb.create_string(s)).collect(); Some(fbb.create_vector(&offs)) };
+    let discounts = if j.discounts.is_empty() { None } else { Some(fbb.create_vector(&j.discounts)) };
+    let billing = j.billing.as_ref().map(|c| build_order_billing(fbb, c));
+    backend::Order::create(fbb, &backend::OrderArgs {
+        order_id: Some(order_id),
+        customer,
+        lines,
+        notes,
+        discounts,
+        active: j.active,
+        created_at: j.created_at,
+        billing,
+        ..Default::default()
+    })
+}
+
+#[derive(Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct CustomerJson {
+    #[serde(default)]
+    pub id: String,
+    #[serde(default)]
+    pub name: String,
+    #[serde(default)]
+    pub vip: bool,
+    #[serde(default, deserialize_with = "de_i64")]
+    pub loyalty_points: i64,
+    #[serde(default)]
+    pub rating: f64,
+}
+
+pub fn build_customer<'a>(fbb: &mut flatbuffers::FlatBufferBuilder<'a>, j: &CustomerJson) -> flatbuffers::WIPOffset<backend::Customer<'a>> {
+    let id = fbb.create_string(&j.id);
+    let name = fbb.create_string(&j.name);
+    backend::Customer::create(fbb, &backend::CustomerArgs {
+        id: Some(id),
+        name: Some(name),
+        vip: j.vip,
+        loyalty_points: j.loyalty_points,
+        rating: j.rating,
+        ..Default::default()
+    })
+}
+
+#[derive(Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct OrderLineJson {
+    #[serde(default)]
+    pub sku: String,
+    #[serde(default, deserialize_with = "de_i64")]
+    pub qty: i64,
+    #[serde(default)]
+    pub unit_price: f64,
+    #[serde(default)]
+    pub tags: Vec<String>,
+}
+
+pub fn build_order_line<'a>(fbb: &mut flatbuffers::FlatBufferBuilder<'a>, j: &OrderLineJson) -> flatbuffers::WIPOffset<backend::OrderLine<'a>> {
+    let sku = fbb.create_string(&j.sku);
+    let tags = if j.tags.is_empty() { None } else { let vals: Vec<backend::Tags> = j.tags.iter().map(|s| tags_from_str(s)).collect(); Some(fbb.create_vector(&vals)) };
+    backend::OrderLine::create(fbb, &backend::OrderLineArgs {
+        sku: Some(sku),
+        qty: j.qty,
+        unit_price: j.unit_price,
+        tags,
+        ..Default::default()
+    })
+}
+
+#[derive(Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct OrderBillingJson {
+    #[serde(default)]
+    pub id: String,
+    #[serde(default)]
+    pub name: String,
+    #[serde(default)]
+    pub vip: bool,
+    #[serde(default, deserialize_with = "de_i64")]
+    pub loyalty_points: i64,
+    #[serde(default)]
+    pub rating: f64,
+}
+
+pub fn build_order_billing<'a>(fbb: &mut flatbuffers::FlatBufferBuilder<'a>, j: &OrderBillingJson) -> flatbuffers::WIPOffset<backend::OrderBilling<'a>> {
+    let id = fbb.create_string(&j.id);
+    let name = fbb.create_string(&j.name);
+    backend::OrderBilling::create(fbb, &backend::OrderBillingArgs {
+        id: Some(id),
+        name: Some(name),
+        vip: j.vip,
+        loyalty_points: j.loyalty_points,
+        rating: j.rating,
+        ..Default::default()
+    })
+}
+
+#[derive(Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct BigValJson {
+    #[serde(default)]
+    pub id: String,
+    #[serde(default, deserialize_with = "de_i64")]
+    pub seq: i64,
+    #[serde(default, deserialize_with = "de_i64")]
+    pub when: i64,
+}
+
+pub fn build_big_val<'a>(fbb: &mut flatbuffers::FlatBufferBuilder<'a>, j: &BigValJson) -> flatbuffers::WIPOffset<backend::BigVal<'a>> {
+    let id = fbb.create_string(&j.id);
+    backend::BigVal::create(fbb, &backend::BigValArgs {
+        id: Some(id),
+        seq: j.seq,
+        when: j.when,
+        ..Default::default()
+    })
+}
+
+#[derive(Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct HelloJson {
+    #[serde(default, deserialize_with = "de_i64")]
+    pub version: i64,
+    #[serde(default)]
+    pub caps: Vec<String>,
+    #[serde(default, deserialize_with = "de_i64")]
+    pub last_seq: i64,
+}
+
+pub fn build_hello<'a>(fbb: &mut flatbuffers::FlatBufferBuilder<'a>, j: &HelloJson) -> flatbuffers::WIPOffset<backend::Hello<'a>> {
+    let caps = if j.caps.is_empty() { None } else { let offs: Vec<flatbuffers::WIPOffset<&str>> = j.caps.iter().map(|s| fbb.create_string(s)).collect(); Some(fbb.create_vector(&offs)) };
+    backend::Hello::create(fbb, &backend::HelloArgs {
+        version: j.version,
+        caps,
+        last_seq: j.last_seq,
+        ..Default::default()
+    })
+}
+
+#[derive(Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct WelcomeJson {
+    #[serde(default)]
+    pub client_id: String,
+    #[serde(default)]
+    pub groups: Vec<String>,
+}
+
+pub fn build_welcome<'a>(fbb: &mut flatbuffers::FlatBufferBuilder<'a>, j: &WelcomeJson) -> flatbuffers::WIPOffset<backend::Welcome<'a>> {
+    let client_id = fbb.create_string(&j.client_id);
+    let groups = if j.groups.is_empty() { None } else { let offs: Vec<flatbuffers::WIPOffset<&str>> = j.groups.iter().map(|s| fbb.create_string(s)).collect(); Some(fbb.create_vector(&offs)) };
+    backend::Welcome::create(fbb, &backend::WelcomeArgs {
+        client_id: Some(client_id),
+        groups,
+        ..Default::default()
+    })
+}
+
+#[derive(Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct SubscribeJson {
+    #[serde(default)]
+    pub topic: String,
+}
+
+pub fn build_subscribe<'a>(fbb: &mut flatbuffers::FlatBufferBuilder<'a>, j: &SubscribeJson) -> flatbuffers::WIPOffset<backend::Subscribe<'a>> {
+    let topic = fbb.create_string(&j.topic);
+    backend::Subscribe::create(fbb, &backend::SubscribeArgs {
+        topic: Some(topic),
+        ..Default::default()
+    })
+}
+
+#[derive(Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct UnsubscribeJson {
+    #[serde(default)]
+    pub topic: String,
+}
+
+pub fn build_unsubscribe<'a>(fbb: &mut flatbuffers::FlatBufferBuilder<'a>, j: &UnsubscribeJson) -> flatbuffers::WIPOffset<backend::Unsubscribe<'a>> {
+    let topic = fbb.create_string(&j.topic);
+    backend::Unsubscribe::create(fbb, &backend::UnsubscribeArgs {
+        topic: Some(topic),
+        ..Default::default()
+    })
+}
+
+#[derive(Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct JoinGroupJson {
+    #[serde(default)]
+    pub group: String,
+}
+
+pub fn build_join_group<'a>(fbb: &mut flatbuffers::FlatBufferBuilder<'a>, j: &JoinGroupJson) -> flatbuffers::WIPOffset<backend::JoinGroup<'a>> {
+    let group = fbb.create_string(&j.group);
+    backend::JoinGroup::create(fbb, &backend::JoinGroupArgs {
+        group: Some(group),
+        ..Default::default()
+    })
+}
+
+#[derive(Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct LeaveGroupJson {
+    #[serde(default)]
+    pub group: String,
+}
+
+pub fn build_leave_group<'a>(fbb: &mut flatbuffers::FlatBufferBuilder<'a>, j: &LeaveGroupJson) -> flatbuffers::WIPOffset<backend::LeaveGroup<'a>> {
+    let group = fbb.create_string(&j.group);
+    backend::LeaveGroup::create(fbb, &backend::LeaveGroupArgs {
+        group: Some(group),
+        ..Default::default()
+    })
+}
+
+#[derive(Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct SnapshotRequestJson {
+    #[serde(default)]
+    pub topic: String,
+}
+
+pub fn build_snapshot_request<'a>(fbb: &mut flatbuffers::FlatBufferBuilder<'a>, j: &SnapshotRequestJson) -> flatbuffers::WIPOffset<backend::SnapshotRequest<'a>> {
+    let topic = fbb.create_string(&j.topic);
+    backend::SnapshotRequest::create(fbb, &backend::SnapshotRequestArgs {
+        topic: Some(topic),
+        ..Default::default()
+    })
+}
+
+#[derive(Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct PingJson {
+    #[serde(default, deserialize_with = "de_i64")]
+    pub ts: i64,
+}
+
+pub fn build_ping<'a>(fbb: &mut flatbuffers::FlatBufferBuilder<'a>, j: &PingJson) -> flatbuffers::WIPOffset<backend::Ping<'a>> {
+    
+    backend::Ping::create(fbb, &backend::PingArgs {
+        ts: j.ts,
+        ..Default::default()
+    })
+}
+
+#[derive(Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct PongJson {
+    #[serde(default, deserialize_with = "de_i64")]
+    pub ts: i64,
+}
+
+pub fn build_pong<'a>(fbb: &mut flatbuffers::FlatBufferBuilder<'a>, j: &PongJson) -> flatbuffers::WIPOffset<backend::Pong<'a>> {
+    
+    backend::Pong::create(fbb, &backend::PongArgs {
+        ts: j.ts,
+        ..Default::default()
+    })
+}
+
+pub fn serialize_quote(json: &[u8], out: &mut [u8]) -> Result<usize, TranscodeError> {
+    let j: QuoteJson = serde_json::from_slice(json).map_err(|_| TranscodeError::Parse)?;
+    copy_finished(out, |fbb| build_quote(fbb, &j))
+}
+
+pub fn serialize_trade(json: &[u8], out: &mut [u8]) -> Result<usize, TranscodeError> {
+    let j: TradeJson = serde_json::from_slice(json).map_err(|_| TranscodeError::Parse)?;
+    copy_finished(out, |fbb| build_trade(fbb, &j))
+}
+
+pub fn serialize_portfolio(json: &[u8], out: &mut [u8]) -> Result<usize, TranscodeError> {
+    let j: PortfolioSnapshotJson = serde_json::from_slice(json).map_err(|_| TranscodeError::Parse)?;
+    copy_finished(out, |fbb| build_portfolio_snapshot(fbb, &j))
+}
+
+pub fn serialize_complex(json: &[u8], out: &mut [u8]) -> Result<usize, TranscodeError> {
+    let j: ComplexJson = serde_json::from_slice(json).map_err(|_| TranscodeError::Parse)?;
+    copy_finished(out, |fbb| build_complex(fbb, &j))
+}
+
+pub fn serialize_order(json: &[u8], out: &mut [u8]) -> Result<usize, TranscodeError> {
+    let j: OrderJson = serde_json::from_slice(json).map_err(|_| TranscodeError::Parse)?;
+    copy_finished(out, |fbb| build_order(fbb, &j))
+}
+
+pub fn serialize_big_val(json: &[u8], out: &mut [u8]) -> Result<usize, TranscodeError> {
+    let j: BigValJson = serde_json::from_slice(json).map_err(|_| TranscodeError::Parse)?;
+    copy_finished(out, |fbb| build_big_val(fbb, &j))
+}
+
+pub fn serialize_hello(json: &[u8], out: &mut [u8]) -> Result<usize, TranscodeError> {
+    let j: HelloJson = serde_json::from_slice(json).map_err(|_| TranscodeError::Parse)?;
+    copy_finished(out, |fbb| build_hello(fbb, &j))
+}
+
+pub fn serialize_welcome(json: &[u8], out: &mut [u8]) -> Result<usize, TranscodeError> {
+    let j: WelcomeJson = serde_json::from_slice(json).map_err(|_| TranscodeError::Parse)?;
+    copy_finished(out, |fbb| build_welcome(fbb, &j))
+}
+
+pub fn serialize_subscribe(json: &[u8], out: &mut [u8]) -> Result<usize, TranscodeError> {
+    let j: SubscribeJson = serde_json::from_slice(json).map_err(|_| TranscodeError::Parse)?;
+    copy_finished(out, |fbb| build_subscribe(fbb, &j))
+}
+
+pub fn serialize_unsubscribe(json: &[u8], out: &mut [u8]) -> Result<usize, TranscodeError> {
+    let j: UnsubscribeJson = serde_json::from_slice(json).map_err(|_| TranscodeError::Parse)?;
+    copy_finished(out, |fbb| build_unsubscribe(fbb, &j))
+}
+
+pub fn serialize_join_group(json: &[u8], out: &mut [u8]) -> Result<usize, TranscodeError> {
+    let j: JoinGroupJson = serde_json::from_slice(json).map_err(|_| TranscodeError::Parse)?;
+    copy_finished(out, |fbb| build_join_group(fbb, &j))
+}
+
+pub fn serialize_leave_group(json: &[u8], out: &mut [u8]) -> Result<usize, TranscodeError> {
+    let j: LeaveGroupJson = serde_json::from_slice(json).map_err(|_| TranscodeError::Parse)?;
+    copy_finished(out, |fbb| build_leave_group(fbb, &j))
+}
+
+pub fn serialize_snapshot_request(json: &[u8], out: &mut [u8]) -> Result<usize, TranscodeError> {
+    let j: SnapshotRequestJson = serde_json::from_slice(json).map_err(|_| TranscodeError::Parse)?;
+    copy_finished(out, |fbb| build_snapshot_request(fbb, &j))
+}
+
+pub fn serialize_ping(json: &[u8], out: &mut [u8]) -> Result<usize, TranscodeError> {
+    let j: PingJson = serde_json::from_slice(json).map_err(|_| TranscodeError::Parse)?;
+    copy_finished(out, |fbb| build_ping(fbb, &j))
+}
+
+pub fn serialize_pong(json: &[u8], out: &mut [u8]) -> Result<usize, TranscodeError> {
+    let j: PongJson = serde_json::from_slice(json).map_err(|_| TranscodeError::Parse)?;
+    copy_finished(out, |fbb| build_pong(fbb, &j))
+}
+
+fn read_u32(b: &[u8], off: &mut usize) -> u32 {
+    let v = u32::from_le_bytes([b[*off], b[*off + 1], b[*off + 2], b[*off + 3]]);
+    *off += 4;
+    v
+}
+
+fn read_i64(b: &[u8], off: &mut usize) -> i64 {
+    let mut buf = [0u8; 8];
+    buf.copy_from_slice(&b[*off..*off + 8]);
+    *off += 8;
+    i64::from_le_bytes(buf)
+}
+
+fn read_f64(b: &[u8], off: &mut usize) -> f64 {
+    f64::from_bits(read_i64(b, off) as u64)
+}
+
+fn read_packed_portfolio_snapshot_positions<'a>(fbb: &mut flatbuffers::FlatBufferBuilder<'a>, ptr: *const u8, len: usize) -> Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<backend::PortfolioPosition<'a>>>>> {
+    if ptr.is_null() || len == 0 { return None; }
+    let b = unsafe { std::slice::from_raw_parts(ptr, len) };
+    let mut off = 0usize;
+    let count = read_u32(b, &mut off) as usize;
+    let mut offsets: Vec<flatbuffers::WIPOffset<backend::PortfolioPosition<'a>>> = Vec::with_capacity(count);
+    for _ in 0..count {
+        let symbol_len = read_u32(b, &mut off) as usize; let symbol = std::str::from_utf8(&b[off..off + symbol_len]).unwrap_or(""); off += symbol_len; let symbol_off = fbb.create_string(symbol);
+        let quantity = read_i64(b, &mut off);
+        let avg_price = read_f64(b, &mut off);
+        let pnl = read_f64(b, &mut off);
+        let item = backend::PortfolioPosition::create(fbb, &backend::PortfolioPositionArgs {
+            symbol: Some(symbol_off),
+            quantity,
+            avg_price,
+            pnl,
+            ..Default::default()
+        });
+        offsets.push(item);
+    }
+    Some(fbb.create_vector(&offsets))
+}
+
+fn read_packed_complex_names<'a>(fbb: &mut flatbuffers::FlatBufferBuilder<'a>, ptr: *const u8, len: usize) -> Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>> {
+    if ptr.is_null() || len == 0 { return None; }
+    let b = unsafe { std::slice::from_raw_parts(ptr, len) };
+    let mut off = 0usize;
+    let count = read_u32(b, &mut off) as usize;
+    let mut vals: Vec<flatbuffers::WIPOffset<&'a str>> = Vec::with_capacity(count);
+    for _ in 0..count {
+        let l = read_u32(b, &mut off) as usize; let s = std::str::from_utf8(&b[off..off + l]).unwrap_or(""); off += l; vals.push(fbb.create_string(s));
+    }
+    Some(fbb.create_vector(&vals))
+}
+
+fn read_packed_complex_prices<'a>(fbb: &mut flatbuffers::FlatBufferBuilder<'a>, ptr: *const u8, len: usize) -> Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, f64>>> {
+    if ptr.is_null() || len == 0 { return None; }
+    let b = unsafe { std::slice::from_raw_parts(ptr, len) };
+    let mut off = 0usize;
+    let count = read_u32(b, &mut off) as usize;
+    let mut vals: Vec<f64> = Vec::with_capacity(count);
+    for _ in 0..count {
+        vals.push(read_f64(b, &mut off));
+    }
+    Some(fbb.create_vector(&vals))
+}
+
+fn read_packed_complex_counts<'a>(fbb: &mut flatbuffers::FlatBufferBuilder<'a>, ptr: *const u8, len: usize) -> Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, i64>>> {
+    if ptr.is_null() || len == 0 { return None; }
+    let b = unsafe { std::slice::from_raw_parts(ptr, len) };
+    let mut off = 0usize;
+    let count = read_u32(b, &mut off) as usize;
+    let mut vals: Vec<i64> = Vec::with_capacity(count);
+    for _ in 0..count {
+        vals.push(read_i64(b, &mut off));
+    }
+    Some(fbb.create_vector(&vals))
+}
+
+fn read_packed_complex_flags<'a>(fbb: &mut flatbuffers::FlatBufferBuilder<'a>, ptr: *const u8, len: usize) -> Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, bool>>> {
+    if ptr.is_null() || len == 0 { return None; }
+    let b = unsafe { std::slice::from_raw_parts(ptr, len) };
+    let mut off = 0usize;
+    let count = read_u32(b, &mut off) as usize;
+    let mut vals: Vec<bool> = Vec::with_capacity(count);
+    for _ in 0..count {
+        vals.push(b[off] != 0); off += 1;
+    }
+    Some(fbb.create_vector(&vals))
+}
+
+fn read_packed_complex_tags<'a>(fbb: &mut flatbuffers::FlatBufferBuilder<'a>, ptr: *const u8, len: usize) -> Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, backend::Tags>>> {
+    if ptr.is_null() || len == 0 { return None; }
+    let b = unsafe { std::slice::from_raw_parts(ptr, len) };
+    let mut off = 0usize;
+    let count = read_u32(b, &mut off) as usize;
+    let mut vals: Vec<backend::Tags> = Vec::with_capacity(count);
+    for _ in 0..count {
+        vals.push(backend::Tags(read_u32(b, &mut off) as i32));
+    }
+    Some(fbb.create_vector(&vals))
+}
+
+fn read_packed_hello_caps<'a>(fbb: &mut flatbuffers::FlatBufferBuilder<'a>, ptr: *const u8, len: usize) -> Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>> {
+    if ptr.is_null() || len == 0 { return None; }
+    let b = unsafe { std::slice::from_raw_parts(ptr, len) };
+    let mut off = 0usize;
+    let count = read_u32(b, &mut off) as usize;
+    let mut vals: Vec<flatbuffers::WIPOffset<&'a str>> = Vec::with_capacity(count);
+    for _ in 0..count {
+        let l = read_u32(b, &mut off) as usize; let s = std::str::from_utf8(&b[off..off + l]).unwrap_or(""); off += l; vals.push(fbb.create_string(s));
+    }
+    Some(fbb.create_vector(&vals))
+}
+
+fn read_packed_welcome_groups<'a>(fbb: &mut flatbuffers::FlatBufferBuilder<'a>, ptr: *const u8, len: usize) -> Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<&'a str>>>> {
+    if ptr.is_null() || len == 0 { return None; }
+    let b = unsafe { std::slice::from_raw_parts(ptr, len) };
+    let mut off = 0usize;
+    let count = read_u32(b, &mut off) as usize;
+    let mut vals: Vec<flatbuffers::WIPOffset<&'a str>> = Vec::with_capacity(count);
+    for _ in 0..count {
+        let l = read_u32(b, &mut off) as usize; let s = std::str::from_utf8(&b[off..off + l]).unwrap_or(""); off += l; vals.push(fbb.create_string(s));
+    }
+    Some(fbb.create_vector(&vals))
+}
+
+
+#[no_mangle]
+pub unsafe extern "C" fn fb_quote_serialize(
+    symbol: *const c_char,
+    bid: f64,
+    ask: f64,
+    bid_size: i64,
+    ask_size: i64,
+    ts: i64,
+    out: *mut u8,
+    out_cap: usize,
+) -> usize {
+    std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+        if out.is_null() && out_cap != 0 {
+            return 0;
+        }
+        let symbol = if symbol.is_null() { "" } else { std::str::from_utf8_unchecked(CStr::from_ptr(symbol).to_bytes()) };
+        // envelope = [WIRE_VERSION:1][event_id:u32 LE]; flatbuffer payload follows
+        let payload: &mut [u8] = if out_cap < WIRE_HEADER_LEN {
+            &mut []
+        } else {
+            std::slice::from_raw_parts_mut(out.add(WIRE_HEADER_LEN), out_cap - WIRE_HEADER_LEN)
+        };
+        match copy_finished(payload, |fbb| {
+            let symbol = fbb.create_string(symbol);
+            backend::Quote::create(fbb, &backend::QuoteArgs {
+                symbol: Some(symbol),
+                bid: bid,
+                ask: ask,
+                bid_size: bid_size,
+                ask_size: ask_size,
+                ts: ts,
+                ..Default::default()
+            })
+        }) {
+            Ok(written) => {
+                let needed = written + WIRE_HEADER_LEN;
+                if needed <= out_cap {
+                    *out.add(0) = WIRE_VERSION;
+                    let id_bytes = 2995289047u32.to_le_bytes();
+                    std::ptr::copy_nonoverlapping(id_bytes.as_ptr(), out.add(1), 4);
+                }
+                needed
+            }
+            Err(_) => 0,
+        }
+    }))
+    .unwrap_or(0)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn fb_trade_serialize(
+    symbol: *const c_char,
+    price: f64,
+    volume: i64,
+    side: u32,
+    ts: i64,
+    out: *mut u8,
+    out_cap: usize,
+) -> usize {
+    std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+        if out.is_null() && out_cap != 0 {
+            return 0;
+        }
+        let symbol = if symbol.is_null() { "" } else { std::str::from_utf8_unchecked(CStr::from_ptr(symbol).to_bytes()) };
+        let side = backend::Side(side as i32);
+        // envelope = [WIRE_VERSION:1][event_id:u32 LE]; flatbuffer payload follows
+        let payload: &mut [u8] = if out_cap < WIRE_HEADER_LEN {
+            &mut []
+        } else {
+            std::slice::from_raw_parts_mut(out.add(WIRE_HEADER_LEN), out_cap - WIRE_HEADER_LEN)
+        };
+        match copy_finished(payload, |fbb| {
+            let symbol = fbb.create_string(symbol);
+            backend::Trade::create(fbb, &backend::TradeArgs {
+                symbol: Some(symbol),
+                price: price,
+                volume: volume,
+                side,
+                ts: ts,
+                ..Default::default()
+            })
+        }) {
+            Ok(written) => {
+                let needed = written + WIRE_HEADER_LEN;
+                if needed <= out_cap {
+                    *out.add(0) = WIRE_VERSION;
+                    let id_bytes = 1362521689u32.to_le_bytes();
+                    std::ptr::copy_nonoverlapping(id_bytes.as_ptr(), out.add(1), 4);
+                }
+                needed
+            }
+            Err(_) => 0,
+        }
+    }))
+    .unwrap_or(0)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn fb_portfolio_serialize(
+    account_id: *const c_char,
+    positions_ptr: *const u8,
+    positions_len: usize,
+    total_value: f64,
+    cash: f64,
+    ts: i64,
+    updated_by: *const c_char,
+    out: *mut u8,
+    out_cap: usize,
+) -> usize {
+    std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+        if out.is_null() && out_cap != 0 {
+            return 0;
+        }
+        let account_id = if account_id.is_null() { "" } else { std::str::from_utf8_unchecked(CStr::from_ptr(account_id).to_bytes()) };
+        let updated_by = if updated_by.is_null() { None } else { Some(std::str::from_utf8_unchecked(CStr::from_ptr(updated_by).to_bytes())) };
+        // envelope = [WIRE_VERSION:1][event_id:u32 LE]; flatbuffer payload follows
+        let payload: &mut [u8] = if out_cap < WIRE_HEADER_LEN {
+            &mut []
+        } else {
+            std::slice::from_raw_parts_mut(out.add(WIRE_HEADER_LEN), out_cap - WIRE_HEADER_LEN)
+        };
+        match copy_finished(payload, |fbb| {
+            let account_id = fbb.create_string(account_id);
+            let positions = read_packed_portfolio_snapshot_positions(fbb, positions_ptr, positions_len);
+            let updated_by = updated_by.map(|s| fbb.create_string(s));
+            backend::PortfolioSnapshot::create(fbb, &backend::PortfolioSnapshotArgs {
+                account_id: Some(account_id),
+                positions,
+                total_value: total_value,
+                cash: cash,
+                ts: ts,
+                updated_by,
+                ..Default::default()
+            })
+        }) {
+            Ok(written) => {
+                let needed = written + WIRE_HEADER_LEN;
+                if needed <= out_cap {
+                    *out.add(0) = WIRE_VERSION;
+                    let id_bytes = 464274147u32.to_le_bytes();
+                    std::ptr::copy_nonoverlapping(id_bytes.as_ptr(), out.add(1), 4);
+                }
+                needed
+            }
+            Err(_) => 0,
+        }
+    }))
+    .unwrap_or(0)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn fb_complex_serialize(
+    id: *const c_char,
+    names_ptr: *const u8,
+    names_len: usize,
+    prices_ptr: *const u8,
+    prices_len: usize,
+    counts_ptr: *const u8,
+    counts_len: usize,
+    flags_ptr: *const u8,
+    flags_len: usize,
+    tags_ptr: *const u8,
+    tags_len: usize,
+    active: u8,
+    total: f64,
+    ts: i64,
+    out: *mut u8,
+    out_cap: usize,
+) -> usize {
+    std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+        if out.is_null() && out_cap != 0 {
+            return 0;
+        }
+        let id = if id.is_null() { "" } else { std::str::from_utf8_unchecked(CStr::from_ptr(id).to_bytes()) };
+        // envelope = [WIRE_VERSION:1][event_id:u32 LE]; flatbuffer payload follows
+        let payload: &mut [u8] = if out_cap < WIRE_HEADER_LEN {
+            &mut []
+        } else {
+            std::slice::from_raw_parts_mut(out.add(WIRE_HEADER_LEN), out_cap - WIRE_HEADER_LEN)
+        };
+        match copy_finished(payload, |fbb| {
+            let id = fbb.create_string(id);
+            let names = read_packed_complex_names(fbb, names_ptr, names_len);
+            let prices = read_packed_complex_prices(fbb, prices_ptr, prices_len);
+            let counts = read_packed_complex_counts(fbb, counts_ptr, counts_len);
+            let flags = read_packed_complex_flags(fbb, flags_ptr, flags_len);
+            let tags = read_packed_complex_tags(fbb, tags_ptr, tags_len);
+            backend::Complex::create(fbb, &backend::ComplexArgs {
+                id: Some(id),
+                names,
+                prices,
+                counts,
+                flags,
+                tags,
+                active: active != 0,
+                total: total,
+                ts: ts,
+                ..Default::default()
+            })
+        }) {
+            Ok(written) => {
+                let needed = written + WIRE_HEADER_LEN;
+                if needed <= out_cap {
+                    *out.add(0) = WIRE_VERSION;
+                    let id_bytes = 2318166199u32.to_le_bytes();
+                    std::ptr::copy_nonoverlapping(id_bytes.as_ptr(), out.add(1), 4);
+                }
+                needed
+            }
+            Err(_) => 0,
+        }
+    }))
+    .unwrap_or(0)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn fb_big_val_serialize(
+    id: *const c_char,
+    seq: i64,
+    when: i64,
+    out: *mut u8,
+    out_cap: usize,
+) -> usize {
+    std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+        if out.is_null() && out_cap != 0 {
+            return 0;
+        }
+        let id = if id.is_null() { "" } else { std::str::from_utf8_unchecked(CStr::from_ptr(id).to_bytes()) };
+        // envelope = [WIRE_VERSION:1][event_id:u32 LE]; flatbuffer payload follows
+        let payload: &mut [u8] = if out_cap < WIRE_HEADER_LEN {
+            &mut []
+        } else {
+            std::slice::from_raw_parts_mut(out.add(WIRE_HEADER_LEN), out_cap - WIRE_HEADER_LEN)
+        };
+        match copy_finished(payload, |fbb| {
+            let id = fbb.create_string(id);
+            backend::BigVal::create(fbb, &backend::BigValArgs {
+                id: Some(id),
+                seq: seq,
+                when: when,
+                ..Default::default()
+            })
+        }) {
+            Ok(written) => {
+                let needed = written + WIRE_HEADER_LEN;
+                if needed <= out_cap {
+                    *out.add(0) = WIRE_VERSION;
+                    let id_bytes = 3211729064u32.to_le_bytes();
+                    std::ptr::copy_nonoverlapping(id_bytes.as_ptr(), out.add(1), 4);
+                }
+                needed
+            }
+            Err(_) => 0,
+        }
+    }))
+    .unwrap_or(0)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn fb_hello_serialize(
+    version: i64,
+    caps_ptr: *const u8,
+    caps_len: usize,
+    last_seq: i64,
+    out: *mut u8,
+    out_cap: usize,
+) -> usize {
+    std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+        if out.is_null() && out_cap != 0 {
+            return 0;
+        }
+        
+        // envelope = [WIRE_VERSION:1][event_id:u32 LE]; flatbuffer payload follows
+        let payload: &mut [u8] = if out_cap < WIRE_HEADER_LEN {
+            &mut []
+        } else {
+            std::slice::from_raw_parts_mut(out.add(WIRE_HEADER_LEN), out_cap - WIRE_HEADER_LEN)
+        };
+        match copy_finished(payload, |fbb| {
+            let caps = read_packed_hello_caps(fbb, caps_ptr, caps_len);
+            backend::Hello::create(fbb, &backend::HelloArgs {
+                version: version,
+                caps,
+                last_seq: last_seq,
+                ..Default::default()
+            })
+        }) {
+            Ok(written) => {
+                let needed = written + WIRE_HEADER_LEN;
+                if needed <= out_cap {
+                    *out.add(0) = WIRE_VERSION;
+                    let id_bytes = 1335831723u32.to_le_bytes();
+                    std::ptr::copy_nonoverlapping(id_bytes.as_ptr(), out.add(1), 4);
+                }
+                needed
+            }
+            Err(_) => 0,
+        }
+    }))
+    .unwrap_or(0)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn fb_welcome_serialize(
+    client_id: *const c_char,
+    groups_ptr: *const u8,
+    groups_len: usize,
+    out: *mut u8,
+    out_cap: usize,
+) -> usize {
+    std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+        if out.is_null() && out_cap != 0 {
+            return 0;
+        }
+        let client_id = if client_id.is_null() { "" } else { std::str::from_utf8_unchecked(CStr::from_ptr(client_id).to_bytes()) };
+        // envelope = [WIRE_VERSION:1][event_id:u32 LE]; flatbuffer payload follows
+        let payload: &mut [u8] = if out_cap < WIRE_HEADER_LEN {
+            &mut []
+        } else {
+            std::slice::from_raw_parts_mut(out.add(WIRE_HEADER_LEN), out_cap - WIRE_HEADER_LEN)
+        };
+        match copy_finished(payload, |fbb| {
+            let client_id = fbb.create_string(client_id);
+            let groups = read_packed_welcome_groups(fbb, groups_ptr, groups_len);
+            backend::Welcome::create(fbb, &backend::WelcomeArgs {
+                client_id: Some(client_id),
+                groups,
+                ..Default::default()
+            })
+        }) {
+            Ok(written) => {
+                let needed = written + WIRE_HEADER_LEN;
+                if needed <= out_cap {
+                    *out.add(0) = WIRE_VERSION;
+                    let id_bytes = 669089267u32.to_le_bytes();
+                    std::ptr::copy_nonoverlapping(id_bytes.as_ptr(), out.add(1), 4);
+                }
+                needed
+            }
+            Err(_) => 0,
+        }
+    }))
+    .unwrap_or(0)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn fb_subscribe_serialize(
+    topic: *const c_char,
+    out: *mut u8,
+    out_cap: usize,
+) -> usize {
+    std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+        if out.is_null() && out_cap != 0 {
+            return 0;
+        }
+        let topic = if topic.is_null() { "" } else { std::str::from_utf8_unchecked(CStr::from_ptr(topic).to_bytes()) };
+        // envelope = [WIRE_VERSION:1][event_id:u32 LE]; flatbuffer payload follows
+        let payload: &mut [u8] = if out_cap < WIRE_HEADER_LEN {
+            &mut []
+        } else {
+            std::slice::from_raw_parts_mut(out.add(WIRE_HEADER_LEN), out_cap - WIRE_HEADER_LEN)
+        };
+        match copy_finished(payload, |fbb| {
+            let topic = fbb.create_string(topic);
+            backend::Subscribe::create(fbb, &backend::SubscribeArgs {
+                topic: Some(topic),
+                ..Default::default()
+            })
+        }) {
+            Ok(written) => {
+                let needed = written + WIRE_HEADER_LEN;
+                if needed <= out_cap {
+                    *out.add(0) = WIRE_VERSION;
+                    let id_bytes = 2946386435u32.to_le_bytes();
+                    std::ptr::copy_nonoverlapping(id_bytes.as_ptr(), out.add(1), 4);
+                }
+                needed
+            }
+            Err(_) => 0,
+        }
+    }))
+    .unwrap_or(0)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn fb_unsubscribe_serialize(
+    topic: *const c_char,
+    out: *mut u8,
+    out_cap: usize,
+) -> usize {
+    std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+        if out.is_null() && out_cap != 0 {
+            return 0;
+        }
+        let topic = if topic.is_null() { "" } else { std::str::from_utf8_unchecked(CStr::from_ptr(topic).to_bytes()) };
+        // envelope = [WIRE_VERSION:1][event_id:u32 LE]; flatbuffer payload follows
+        let payload: &mut [u8] = if out_cap < WIRE_HEADER_LEN {
+            &mut []
+        } else {
+            std::slice::from_raw_parts_mut(out.add(WIRE_HEADER_LEN), out_cap - WIRE_HEADER_LEN)
+        };
+        match copy_finished(payload, |fbb| {
+            let topic = fbb.create_string(topic);
+            backend::Unsubscribe::create(fbb, &backend::UnsubscribeArgs {
+                topic: Some(topic),
+                ..Default::default()
+            })
+        }) {
+            Ok(written) => {
+                let needed = written + WIRE_HEADER_LEN;
+                if needed <= out_cap {
+                    *out.add(0) = WIRE_VERSION;
+                    let id_bytes = 4190043798u32.to_le_bytes();
+                    std::ptr::copy_nonoverlapping(id_bytes.as_ptr(), out.add(1), 4);
+                }
+                needed
+            }
+            Err(_) => 0,
+        }
+    }))
+    .unwrap_or(0)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn fb_join_group_serialize(
+    group: *const c_char,
+    out: *mut u8,
+    out_cap: usize,
+) -> usize {
+    std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+        if out.is_null() && out_cap != 0 {
+            return 0;
+        }
+        let group = if group.is_null() { "" } else { std::str::from_utf8_unchecked(CStr::from_ptr(group).to_bytes()) };
+        // envelope = [WIRE_VERSION:1][event_id:u32 LE]; flatbuffer payload follows
+        let payload: &mut [u8] = if out_cap < WIRE_HEADER_LEN {
+            &mut []
+        } else {
+            std::slice::from_raw_parts_mut(out.add(WIRE_HEADER_LEN), out_cap - WIRE_HEADER_LEN)
+        };
+        match copy_finished(payload, |fbb| {
+            let group = fbb.create_string(group);
+            backend::JoinGroup::create(fbb, &backend::JoinGroupArgs {
+                group: Some(group),
+                ..Default::default()
+            })
+        }) {
+            Ok(written) => {
+                let needed = written + WIRE_HEADER_LEN;
+                if needed <= out_cap {
+                    *out.add(0) = WIRE_VERSION;
+                    let id_bytes = 3026600144u32.to_le_bytes();
+                    std::ptr::copy_nonoverlapping(id_bytes.as_ptr(), out.add(1), 4);
+                }
+                needed
+            }
+            Err(_) => 0,
+        }
+    }))
+    .unwrap_or(0)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn fb_leave_group_serialize(
+    group: *const c_char,
+    out: *mut u8,
+    out_cap: usize,
+) -> usize {
+    std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+        if out.is_null() && out_cap != 0 {
+            return 0;
+        }
+        let group = if group.is_null() { "" } else { std::str::from_utf8_unchecked(CStr::from_ptr(group).to_bytes()) };
+        // envelope = [WIRE_VERSION:1][event_id:u32 LE]; flatbuffer payload follows
+        let payload: &mut [u8] = if out_cap < WIRE_HEADER_LEN {
+            &mut []
+        } else {
+            std::slice::from_raw_parts_mut(out.add(WIRE_HEADER_LEN), out_cap - WIRE_HEADER_LEN)
+        };
+        match copy_finished(payload, |fbb| {
+            let group = fbb.create_string(group);
+            backend::LeaveGroup::create(fbb, &backend::LeaveGroupArgs {
+                group: Some(group),
+                ..Default::default()
+            })
+        }) {
+            Ok(written) => {
+                let needed = written + WIRE_HEADER_LEN;
+                if needed <= out_cap {
+                    *out.add(0) = WIRE_VERSION;
+                    let id_bytes = 3755061443u32.to_le_bytes();
+                    std::ptr::copy_nonoverlapping(id_bytes.as_ptr(), out.add(1), 4);
+                }
+                needed
+            }
+            Err(_) => 0,
+        }
+    }))
+    .unwrap_or(0)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn fb_snapshot_request_serialize(
+    topic: *const c_char,
+    out: *mut u8,
+    out_cap: usize,
+) -> usize {
+    std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+        if out.is_null() && out_cap != 0 {
+            return 0;
+        }
+        let topic = if topic.is_null() { "" } else { std::str::from_utf8_unchecked(CStr::from_ptr(topic).to_bytes()) };
+        // envelope = [WIRE_VERSION:1][event_id:u32 LE]; flatbuffer payload follows
+        let payload: &mut [u8] = if out_cap < WIRE_HEADER_LEN {
+            &mut []
+        } else {
+            std::slice::from_raw_parts_mut(out.add(WIRE_HEADER_LEN), out_cap - WIRE_HEADER_LEN)
+        };
+        match copy_finished(payload, |fbb| {
+            let topic = fbb.create_string(topic);
+            backend::SnapshotRequest::create(fbb, &backend::SnapshotRequestArgs {
+                topic: Some(topic),
+                ..Default::default()
+            })
+        }) {
+            Ok(written) => {
+                let needed = written + WIRE_HEADER_LEN;
+                if needed <= out_cap {
+                    *out.add(0) = WIRE_VERSION;
+                    let id_bytes = 1249175018u32.to_le_bytes();
+                    std::ptr::copy_nonoverlapping(id_bytes.as_ptr(), out.add(1), 4);
+                }
+                needed
+            }
+            Err(_) => 0,
+        }
+    }))
+    .unwrap_or(0)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn fb_ping_serialize(
+    ts: i64,
+    out: *mut u8,
+    out_cap: usize,
+) -> usize {
+    std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+        if out.is_null() && out_cap != 0 {
+            return 0;
+        }
+        
+        // envelope = [WIRE_VERSION:1][event_id:u32 LE]; flatbuffer payload follows
+        let payload: &mut [u8] = if out_cap < WIRE_HEADER_LEN {
+            &mut []
+        } else {
+            std::slice::from_raw_parts_mut(out.add(WIRE_HEADER_LEN), out_cap - WIRE_HEADER_LEN)
+        };
+        match copy_finished(payload, |fbb| {
+            
+            backend::Ping::create(fbb, &backend::PingArgs {
+                ts: ts,
+                ..Default::default()
+            })
+        }) {
+            Ok(written) => {
+                let needed = written + WIRE_HEADER_LEN;
+                if needed <= out_cap {
+                    *out.add(0) = WIRE_VERSION;
+                    let id_bytes = 375255177u32.to_le_bytes();
+                    std::ptr::copy_nonoverlapping(id_bytes.as_ptr(), out.add(1), 4);
+                }
+                needed
+            }
+            Err(_) => 0,
+        }
+    }))
+    .unwrap_or(0)
+}
+
+#[no_mangle]
+pub unsafe extern "C" fn fb_pong_serialize(
+    ts: i64,
+    out: *mut u8,
+    out_cap: usize,
+) -> usize {
+    std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+        if out.is_null() && out_cap != 0 {
+            return 0;
+        }
+        
+        // envelope = [WIRE_VERSION:1][event_id:u32 LE]; flatbuffer payload follows
+        let payload: &mut [u8] = if out_cap < WIRE_HEADER_LEN {
+            &mut []
+        } else {
+            std::slice::from_raw_parts_mut(out.add(WIRE_HEADER_LEN), out_cap - WIRE_HEADER_LEN)
+        };
+        match copy_finished(payload, |fbb| {
+            
+            backend::Pong::create(fbb, &backend::PongArgs {
+                ts: ts,
+                ..Default::default()
+            })
+        }) {
+            Ok(written) => {
+                let needed = written + WIRE_HEADER_LEN;
+                if needed <= out_cap {
+                    *out.add(0) = WIRE_VERSION;
+                    let id_bytes = 2061178551u32.to_le_bytes();
+                    std::ptr::copy_nonoverlapping(id_bytes.as_ptr(), out.add(1), 4);
+                }
+                needed
+            }
+            Err(_) => 0,
+        }
+    }))
+    .unwrap_or(0)
+}
+
+pub fn serialize_event(event_id: u32, json: &[u8], out: &mut [u8]) -> Result<usize, TranscodeError> {
+    match event_id {
+        2995289047 => serialize_quote(json, out),
+        1362521689 => serialize_trade(json, out),
+        464274147 => serialize_portfolio(json, out),
+        2318166199 => serialize_complex(json, out),
+        1932267671 => serialize_order(json, out),
+        3211729064 => serialize_big_val(json, out),
+        1335831723 => serialize_hello(json, out),
+        669089267 => serialize_welcome(json, out),
+        2946386435 => serialize_subscribe(json, out),
+        4190043798 => serialize_unsubscribe(json, out),
+        3026600144 => serialize_join_group(json, out),
+        3755061443 => serialize_leave_group(json, out),
+        1249175018 => serialize_snapshot_request(json, out),
+        375255177 => serialize_ping(json, out),
+        2061178551 => serialize_pong(json, out),
+        _ => Err(TranscodeError::UnknownEvent),
+    }
+}