diff --git a/protocol/cpp/include/solarxr_protocol/generated/all_generated.h b/protocol/cpp/include/solarxr_protocol/generated/all_generated.h
index 1ea0f29b..9da97ca2 100644
--- a/protocol/cpp/include/solarxr_protocol/generated/all_generated.h
+++ b/protocol/cpp/include/solarxr_protocol/generated/all_generated.h
@@ -333,6 +333,9 @@ struct StatusSystemUpdateBuilder;
 struct StatusSystemFixed;
 struct StatusSystemFixedBuilder;
 
+struct StatusPublicNetwork;
+struct StatusPublicNetworkBuilder;
+
 struct StatusMessage;
 struct StatusMessageBuilder;
 
@@ -1997,35 +2000,38 @@ enum class StatusData : uint8_t {
   StatusTrackerError = 2,
   StatusSteamVRDisconnected = 3,
   StatusUnassignedHMD = 4,
+  StatusPublicNetwork = 5,
   MIN = NONE,
-  MAX = StatusUnassignedHMD
+  MAX = StatusPublicNetwork
 };
 
-inline const StatusData (&EnumValuesStatusData())[5] {
+inline const StatusData (&EnumValuesStatusData())[6] {
   static const StatusData values[] = {
     StatusData::NONE,
     StatusData::StatusTrackerReset,
     StatusData::StatusTrackerError,
     StatusData::StatusSteamVRDisconnected,
-    StatusData::StatusUnassignedHMD
+    StatusData::StatusUnassignedHMD,
+    StatusData::StatusPublicNetwork
   };
   return values;
 }
 
 inline const char * const *EnumNamesStatusData() {
-  static const char * const names[6] = {
+  static const char * const names[7] = {
     "NONE",
     "StatusTrackerReset",
     "StatusTrackerError",
     "StatusSteamVRDisconnected",
     "StatusUnassignedHMD",
+    "StatusPublicNetwork",
     nullptr
   };
   return names;
 }
 
 inline const char *EnumNameStatusData(StatusData e) {
-  if (flatbuffers::IsOutRange(e, StatusData::NONE, StatusData::StatusUnassignedHMD)) return "";
+  if (flatbuffers::IsOutRange(e, StatusData::NONE, StatusData::StatusPublicNetwork)) return "";
   const size_t index = static_cast<size_t>(e);
   return EnumNamesStatusData()[index];
 }
@@ -2050,6 +2056,10 @@ template<> struct StatusDataTraits<solarxr_protocol::rpc::StatusUnassignedHMD> {
   static const StatusData enum_value = StatusData::StatusUnassignedHMD;
 };
 
+template<> struct StatusDataTraits<solarxr_protocol::rpc::StatusPublicNetwork> {
+  static const StatusData enum_value = StatusData::StatusPublicNetwork;
+};
+
 bool VerifyStatusData(flatbuffers::Verifier &verifier, const void *obj, StatusData type);
 bool VerifyStatusDataVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<StatusData> *types);
 
@@ -9488,6 +9498,36 @@ inline flatbuffers::Offset<StatusSystemFixed> CreateStatusSystemFixed(
   return builder_.Finish();
 }
 
+/// When the server detects a public network profile
+struct StatusPublicNetwork FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
+  typedef StatusPublicNetworkBuilder Builder;
+  bool Verify(flatbuffers::Verifier &verifier) const {
+    return VerifyTableStart(verifier) &&
+           verifier.EndTable();
+  }
+};
+
+struct StatusPublicNetworkBuilder {
+  typedef StatusPublicNetwork Table;
+  flatbuffers::FlatBufferBuilder &fbb_;
+  flatbuffers::uoffset_t start_;
+  explicit StatusPublicNetworkBuilder(flatbuffers::FlatBufferBuilder &_fbb)
+        : fbb_(_fbb) {
+    start_ = fbb_.StartTable();
+  }
+  flatbuffers::Offset<StatusPublicNetwork> Finish() {
+    const auto end = fbb_.EndTable(start_);
+    auto o = flatbuffers::Offset<StatusPublicNetwork>(end);
+    return o;
+  }
+};
+
+inline flatbuffers::Offset<StatusPublicNetwork> CreateStatusPublicNetwork(
+    flatbuffers::FlatBufferBuilder &_fbb) {
+  StatusPublicNetworkBuilder builder_(_fbb);
+  return builder_.Finish();
+}
+
 /// An status is some kind of warning sent by the server, it's mainly made for
 /// showing problems with the server and need attention from the user.
 struct StatusMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
@@ -9525,6 +9565,9 @@ struct StatusMessage FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
   const solarxr_protocol::rpc::StatusUnassignedHMD *data_as_StatusUnassignedHMD() const {
     return data_type() == solarxr_protocol::rpc::StatusData::StatusUnassignedHMD ? static_cast<const solarxr_protocol::rpc::StatusUnassignedHMD *>(data()) : nullptr;
   }
+  const solarxr_protocol::rpc::StatusPublicNetwork *data_as_StatusPublicNetwork() const {
+    return data_type() == solarxr_protocol::rpc::StatusData::StatusPublicNetwork ? static_cast<const solarxr_protocol::rpc::StatusPublicNetwork *>(data()) : nullptr;
+  }
   bool Verify(flatbuffers::Verifier &verifier) const {
     return VerifyTableStart(verifier) &&
            VerifyField<uint32_t>(verifier, VT_ID, 4) &&
@@ -9552,6 +9595,10 @@ template<> inline const solarxr_protocol::rpc::StatusUnassignedHMD *StatusMessag
   return data_as_StatusUnassignedHMD();
 }
 
+template<> inline const solarxr_protocol::rpc::StatusPublicNetwork *StatusMessage::data_as<solarxr_protocol::rpc::StatusPublicNetwork>() const {
+  return data_as_StatusPublicNetwork();
+}
+
 struct StatusMessageBuilder {
   typedef StatusMessage Table;
   flatbuffers::FlatBufferBuilder &fbb_;
@@ -12202,6 +12249,10 @@ inline bool VerifyStatusData(flatbuffers::Verifier &verifier, const void *obj, S
       auto ptr = reinterpret_cast<const solarxr_protocol::rpc::StatusUnassignedHMD *>(obj);
       return verifier.VerifyTable(ptr);
     }
+    case StatusData::StatusPublicNetwork: {
+      auto ptr = reinterpret_cast<const solarxr_protocol::rpc::StatusPublicNetwork *>(obj);
+      return verifier.VerifyTable(ptr);
+    }
     default: return true;
   }
 }
diff --git a/protocol/java/src/solarxr_protocol/rpc/StatusData.java b/protocol/java/src/solarxr_protocol/rpc/StatusData.java
index 624110c9..62054626 100644
--- a/protocol/java/src/solarxr_protocol/rpc/StatusData.java
+++ b/protocol/java/src/solarxr_protocol/rpc/StatusData.java
@@ -10,8 +10,9 @@ private StatusData() { }
   public static final byte StatusTrackerError = 2;
   public static final byte StatusSteamVRDisconnected = 3;
   public static final byte StatusUnassignedHMD = 4;
+  public static final byte StatusPublicNetwork = 5;
 
-  public static final String[] names = { "NONE", "StatusTrackerReset", "StatusTrackerError", "StatusSteamVRDisconnected", "StatusUnassignedHMD", };
+  public static final String[] names = { "NONE", "StatusTrackerReset", "StatusTrackerError", "StatusSteamVRDisconnected", "StatusUnassignedHMD", "StatusPublicNetwork", };
 
   public static String name(int e) { return names[e]; }
 }
diff --git a/protocol/java/src/solarxr_protocol/rpc/StatusDataUnion.java b/protocol/java/src/solarxr_protocol/rpc/StatusDataUnion.java
index 506040e7..dcdbb232 100644
--- a/protocol/java/src/solarxr_protocol/rpc/StatusDataUnion.java
+++ b/protocol/java/src/solarxr_protocol/rpc/StatusDataUnion.java
@@ -25,6 +25,7 @@ public StatusDataUnion() {
   public solarxr_protocol.rpc.StatusTrackerErrorT asStatusTrackerError() { return (solarxr_protocol.rpc.StatusTrackerErrorT) value; }
   public solarxr_protocol.rpc.StatusSteamVRDisconnectedT asStatusSteamVRDisconnected() { return (solarxr_protocol.rpc.StatusSteamVRDisconnectedT) value; }
   public solarxr_protocol.rpc.StatusUnassignedHMDT asStatusUnassignedHMD() { return (solarxr_protocol.rpc.StatusUnassignedHMDT) value; }
+  public solarxr_protocol.rpc.StatusPublicNetworkT asStatusPublicNetwork() { return (solarxr_protocol.rpc.StatusPublicNetworkT) value; }
 
   public static int pack(FlatBufferBuilder builder, StatusDataUnion _o) {
     switch (_o.type) {
@@ -32,6 +33,7 @@ public static int pack(FlatBufferBuilder builder, StatusDataUnion _o) {
       case StatusData.StatusTrackerError: return solarxr_protocol.rpc.StatusTrackerError.pack(builder, _o.asStatusTrackerError());
       case StatusData.StatusSteamVRDisconnected: return solarxr_protocol.rpc.StatusSteamVRDisconnected.pack(builder, _o.asStatusSteamVRDisconnected());
       case StatusData.StatusUnassignedHMD: return solarxr_protocol.rpc.StatusUnassignedHMD.pack(builder, _o.asStatusUnassignedHMD());
+      case StatusData.StatusPublicNetwork: return solarxr_protocol.rpc.StatusPublicNetwork.pack(builder, _o.asStatusPublicNetwork());
       default: return 0;
     }
   }
diff --git a/protocol/java/src/solarxr_protocol/rpc/StatusMessage.java b/protocol/java/src/solarxr_protocol/rpc/StatusMessage.java
index 3337e3e7..35f8889b 100644
--- a/protocol/java/src/solarxr_protocol/rpc/StatusMessage.java
+++ b/protocol/java/src/solarxr_protocol/rpc/StatusMessage.java
@@ -90,6 +90,10 @@ public void unpackTo(StatusMessageT _o) {
         _oDataValue = data(new solarxr_protocol.rpc.StatusUnassignedHMD());
         _oData.setValue(_oDataValue != null ? ((solarxr_protocol.rpc.StatusUnassignedHMD) _oDataValue).unpack() : null);
         break;
+      case solarxr_protocol.rpc.StatusData.StatusPublicNetwork:
+        _oDataValue = data(new solarxr_protocol.rpc.StatusPublicNetwork());
+        _oData.setValue(_oDataValue != null ? ((solarxr_protocol.rpc.StatusPublicNetwork) _oDataValue).unpack() : null);
+        break;
       default: break;
     }
     _o.setData(_oData);
diff --git a/protocol/java/src/solarxr_protocol/rpc/StatusPublicNetwork.java b/protocol/java/src/solarxr_protocol/rpc/StatusPublicNetwork.java
new file mode 100644
index 00000000..09814896
--- /dev/null
+++ b/protocol/java/src/solarxr_protocol/rpc/StatusPublicNetwork.java
@@ -0,0 +1,47 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package solarxr_protocol.rpc;
+
+import java.nio.*;
+import java.lang.*;
+import java.util.*;
+import com.google.flatbuffers.*;
+
+/**
+ * When the server detects a public network profile
+ */
+@SuppressWarnings("unused")
+public final class StatusPublicNetwork extends Table {
+  public static void ValidateVersion() { Constants.FLATBUFFERS_22_10_26(); }
+  public static StatusPublicNetwork getRootAsStatusPublicNetwork(ByteBuffer _bb) { return getRootAsStatusPublicNetwork(_bb, new StatusPublicNetwork()); }
+  public static StatusPublicNetwork getRootAsStatusPublicNetwork(ByteBuffer _bb, StatusPublicNetwork obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
+  public StatusPublicNetwork __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+
+  public static void startStatusPublicNetwork(FlatBufferBuilder builder) { builder.startTable(0); }
+  public static int endStatusPublicNetwork(FlatBufferBuilder builder) {
+    int o = builder.endTable();
+    return o;
+  }
+
+  public static final class Vector extends BaseVector {
+    public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+    public StatusPublicNetwork get(int j) { return get(new StatusPublicNetwork(), j); }
+    public StatusPublicNetwork get(StatusPublicNetwork obj, int j) {  return obj.__assign(__indirect(__element(j), bb), bb); }
+  }
+  public StatusPublicNetworkT unpack() {
+    StatusPublicNetworkT _o = new StatusPublicNetworkT();
+    unpackTo(_o);
+    return _o;
+  }
+  public void unpackTo(StatusPublicNetworkT _o) {
+  }
+  public static int pack(FlatBufferBuilder builder, StatusPublicNetworkT _o) {
+    if (_o == null) return 0;
+    startStatusPublicNetwork(builder);
+    return endStatusPublicNetwork(builder);
+  }
+}
+
diff --git a/protocol/java/src/solarxr_protocol/rpc/StatusPublicNetworkT.java b/protocol/java/src/solarxr_protocol/rpc/StatusPublicNetworkT.java
new file mode 100644
index 00000000..7d4fced3
--- /dev/null
+++ b/protocol/java/src/solarxr_protocol/rpc/StatusPublicNetworkT.java
@@ -0,0 +1,16 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package solarxr_protocol.rpc;
+
+import java.nio.*;
+import java.lang.*;
+import java.util.*;
+import com.google.flatbuffers.*;
+
+public class StatusPublicNetworkT {
+
+
+  public StatusPublicNetworkT() {
+  }
+}
+
diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/StatusData.kt b/protocol/kotlin/src/solarxr_protocol/rpc/StatusData.kt
index 4e664e94..d2fecbae 100644
--- a/protocol/kotlin/src/solarxr_protocol/rpc/StatusData.kt
+++ b/protocol/kotlin/src/solarxr_protocol/rpc/StatusData.kt
@@ -10,7 +10,8 @@ class StatusData private constructor() {
         const val StatusTrackerError: UByte = 2u
         const val StatusSteamVRDisconnected: UByte = 3u
         const val StatusUnassignedHMD: UByte = 4u
-        val names : Array<String> = arrayOf("NONE", "StatusTrackerReset", "StatusTrackerError", "StatusSteamVRDisconnected", "StatusUnassignedHMD")
+        const val StatusPublicNetwork: UByte = 5u
+        val names : Array<String> = arrayOf("NONE", "StatusTrackerReset", "StatusTrackerError", "StatusSteamVRDisconnected", "StatusUnassignedHMD", "StatusPublicNetwork")
         @JvmStatic
         fun name(e: Int) : String = names[e]
     }
diff --git a/protocol/kotlin/src/solarxr_protocol/rpc/StatusPublicNetwork.kt b/protocol/kotlin/src/solarxr_protocol/rpc/StatusPublicNetwork.kt
new file mode 100644
index 00000000..de7d3eab
--- /dev/null
+++ b/protocol/kotlin/src/solarxr_protocol/rpc/StatusPublicNetwork.kt
@@ -0,0 +1,40 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package solarxr_protocol.rpc
+
+import java.nio.*
+import kotlin.math.sign
+import com.google.flatbuffers.*
+
+/**
+ * When the server detects a public network profile
+ */
+@Suppress("unused")
+class StatusPublicNetwork : Table() {
+
+    fun __init(_i: Int, _bb: ByteBuffer)  {
+        __reset(_i, _bb)
+    }
+    fun __assign(_i: Int, _bb: ByteBuffer) : StatusPublicNetwork {
+        __init(_i, _bb)
+        return this
+    }
+    companion object {
+        @JvmStatic
+        fun validateVersion() = Constants.FLATBUFFERS_22_10_26()
+        @JvmStatic
+        fun getRootAsStatusPublicNetwork(_bb: ByteBuffer): StatusPublicNetwork = getRootAsStatusPublicNetwork(_bb, StatusPublicNetwork())
+        @JvmStatic
+        fun getRootAsStatusPublicNetwork(_bb: ByteBuffer, obj: StatusPublicNetwork): StatusPublicNetwork {
+            _bb.order(ByteOrder.LITTLE_ENDIAN)
+            return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb))
+        }
+        @JvmStatic
+        fun startStatusPublicNetwork(builder: FlatBufferBuilder) = builder.startTable(0)
+        @JvmStatic
+        fun endStatusPublicNetwork(builder: FlatBufferBuilder) : Int {
+            val o = builder.endTable()
+            return o
+        }
+    }
+}
diff --git a/protocol/rust/src/generated/mod.rs b/protocol/rust/src/generated/mod.rs
index 789869b4..3f6a7cff 100644
--- a/protocol/rust/src/generated/mod.rs
+++ b/protocol/rust/src/generated/mod.rs
@@ -302,6 +302,8 @@ pub mod solarxr_protocol {
     pub use self::status_system_update_generated::*;
     mod status_system_fixed_generated;
     pub use self::status_system_fixed_generated::*;
+    mod status_public_network_generated;
+    pub use self::status_public_network_generated::*;
     mod status_message_generated;
     pub use self::status_message_generated::*;
     mod set_pause_tracking_request_generated;
diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/status_data_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/status_data_generated.rs
index 11121adc..641ced84 100644
--- a/protocol/rust/src/generated/solarxr_protocol/rpc/status_data_generated.rs
+++ b/protocol/rust/src/generated/solarxr_protocol/rpc/status_data_generated.rs
@@ -12,15 +12,16 @@ use super::*;
 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
 pub const ENUM_MIN_STATUS_DATA: u8 = 0;
 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
-pub const ENUM_MAX_STATUS_DATA: u8 = 4;
+pub const ENUM_MAX_STATUS_DATA: u8 = 5;
 #[deprecated(since = "2.0.0", note = "Use associated constants instead. This will no longer be generated in 2021.")]
 #[allow(non_camel_case_types)]
-pub const ENUM_VALUES_STATUS_DATA: [StatusData; 5] = [
+pub const ENUM_VALUES_STATUS_DATA: [StatusData; 6] = [
   StatusData::NONE,
   StatusData::StatusTrackerReset,
   StatusData::StatusTrackerError,
   StatusData::StatusSteamVRDisconnected,
   StatusData::StatusUnassignedHMD,
+  StatusData::StatusPublicNetwork,
 ];
 
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
@@ -33,15 +34,17 @@ impl StatusData {
   pub const StatusTrackerError: Self = Self(2);
   pub const StatusSteamVRDisconnected: Self = Self(3);
   pub const StatusUnassignedHMD: Self = Self(4);
+  pub const StatusPublicNetwork: Self = Self(5);
 
   pub const ENUM_MIN: u8 = 0;
-  pub const ENUM_MAX: u8 = 4;
+  pub const ENUM_MAX: u8 = 5;
   pub const ENUM_VALUES: &'static [Self] = &[
     Self::NONE,
     Self::StatusTrackerReset,
     Self::StatusTrackerError,
     Self::StatusSteamVRDisconnected,
     Self::StatusUnassignedHMD,
+    Self::StatusPublicNetwork,
   ];
   /// Returns the variant's name or "" if unknown.
   pub fn variant_name(self) -> Option<&'static str> {
@@ -51,6 +54,7 @@ impl StatusData {
       Self::StatusTrackerError => Some("StatusTrackerError"),
       Self::StatusSteamVRDisconnected => Some("StatusSteamVRDisconnected"),
       Self::StatusUnassignedHMD => Some("StatusUnassignedHMD"),
+      Self::StatusPublicNetwork => Some("StatusPublicNetwork"),
       _ => None,
     }
   }
diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/status_message_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/status_message_generated.rs
index d5fa56f8..3427a5b7 100644
--- a/protocol/rust/src/generated/solarxr_protocol/rpc/status_message_generated.rs
+++ b/protocol/rust/src/generated/solarxr_protocol/rpc/status_message_generated.rs
@@ -140,6 +140,21 @@ impl<'a> StatusMessage<'a> {
     }
   }
 
+  #[inline]
+  #[allow(non_snake_case)]
+  pub fn data_as_status_public_network(&self) -> Option<StatusPublicNetwork<'a>> {
+    if self.data_type() == StatusData::StatusPublicNetwork {
+      self.data().map(|t| {
+       // Safety:
+       // Created from a valid Table for this object
+       // Which contains a valid union in this slot
+       unsafe { StatusPublicNetwork::init_from_table(t) }
+     })
+    } else {
+      None
+    }
+  }
+
 }
 
 impl flatbuffers::Verifiable for StatusMessage<'_> {
@@ -157,6 +172,7 @@ impl flatbuffers::Verifiable for StatusMessage<'_> {
           StatusData::StatusTrackerError => v.verify_union_variant::<flatbuffers::ForwardsUOffset<StatusTrackerError>>("StatusData::StatusTrackerError", pos),
           StatusData::StatusSteamVRDisconnected => v.verify_union_variant::<flatbuffers::ForwardsUOffset<StatusSteamVRDisconnected>>("StatusData::StatusSteamVRDisconnected", pos),
           StatusData::StatusUnassignedHMD => v.verify_union_variant::<flatbuffers::ForwardsUOffset<StatusUnassignedHMD>>("StatusData::StatusUnassignedHMD", pos),
+          StatusData::StatusPublicNetwork => v.verify_union_variant::<flatbuffers::ForwardsUOffset<StatusPublicNetwork>>("StatusData::StatusPublicNetwork", pos),
           _ => Ok(()),
         }
      })?
@@ -253,6 +269,13 @@ impl core::fmt::Debug for StatusMessage<'_> {
             ds.field("data", &"InvalidFlatbuffer: Union discriminant does not match value.")
           }
         },
+        StatusData::StatusPublicNetwork => {
+          if let Some(x) = self.data_as_status_public_network() {
+            ds.field("data", &x)
+          } else {
+            ds.field("data", &"InvalidFlatbuffer: Union discriminant does not match value.")
+          }
+        },
         _ => {
           let x: Option<()> = None;
           ds.field("data", &x)
diff --git a/protocol/rust/src/generated/solarxr_protocol/rpc/status_public_network_generated.rs b/protocol/rust/src/generated/solarxr_protocol/rpc/status_public_network_generated.rs
new file mode 100644
index 00000000..82ec2685
--- /dev/null
+++ b/protocol/rust/src/generated/solarxr_protocol/rpc/status_public_network_generated.rs
@@ -0,0 +1,91 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+// @generated
+extern crate alloc;
+extern crate flatbuffers;
+use alloc::boxed::Box;
+use alloc::string::{String, ToString};
+use alloc::vec::Vec;
+use core::mem;
+use core::cmp::Ordering;
+use self::flatbuffers::{EndianScalar, Follow};
+use super::*;
+pub enum StatusPublicNetworkOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+/// When the server detects a public network profile
+pub struct StatusPublicNetwork<'a> {
+  pub _tab: flatbuffers::Table<'a>,
+}
+
+impl<'a> flatbuffers::Follow<'a> for StatusPublicNetwork<'a> {
+  type Inner = StatusPublicNetwork<'a>;
+  #[inline]
+  unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    Self { _tab: flatbuffers::Table::new(buf, loc) }
+  }
+}
+
+impl<'a> StatusPublicNetwork<'a> {
+
+  #[inline]
+  pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    StatusPublicNetwork { _tab: table }
+  }
+  #[allow(unused_mut)]
+  pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
+    _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
+    _args: &'args StatusPublicNetworkArgs
+  ) -> flatbuffers::WIPOffset<StatusPublicNetwork<'bldr>> {
+    let mut builder = StatusPublicNetworkBuilder::new(_fbb);
+    builder.finish()
+  }
+
+}
+
+impl flatbuffers::Verifiable for StatusPublicNetwork<'_> {
+  #[inline]
+  fn run_verifier(
+    v: &mut flatbuffers::Verifier, pos: usize
+  ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
+    use self::flatbuffers::Verifiable;
+    v.visit_table(pos)?
+     .finish();
+    Ok(())
+  }
+}
+pub struct StatusPublicNetworkArgs {
+}
+impl<'a> Default for StatusPublicNetworkArgs {
+  #[inline]
+  fn default() -> Self {
+    StatusPublicNetworkArgs {
+    }
+  }
+}
+
+pub struct StatusPublicNetworkBuilder<'a: 'b, 'b> {
+  fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
+  start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+}
+impl<'a: 'b, 'b> StatusPublicNetworkBuilder<'a, 'b> {
+  #[inline]
+  pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> StatusPublicNetworkBuilder<'a, 'b> {
+    let start = _fbb.start_table();
+    StatusPublicNetworkBuilder {
+      fbb_: _fbb,
+      start_: start,
+    }
+  }
+  #[inline]
+  pub fn finish(self) -> flatbuffers::WIPOffset<StatusPublicNetwork<'a>> {
+    let o = self.fbb_.end_table(self.start_);
+    flatbuffers::WIPOffset::new(o.value())
+  }
+}
+
+impl core::fmt::Debug for StatusPublicNetwork<'_> {
+  fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+    let mut ds = f.debug_struct("StatusPublicNetwork");
+      ds.finish()
+  }
+}
diff --git a/protocol/typescript/src/all_generated.ts b/protocol/typescript/src/all_generated.ts
index 7c04b236..626064be 100644
--- a/protocol/typescript/src/all_generated.ts
+++ b/protocol/typescript/src/all_generated.ts
@@ -130,6 +130,7 @@ export { SkeletonResetAllRequest, SkeletonResetAllRequestT } from './solarxr-pro
 export { StartWifiProvisioningRequest, StartWifiProvisioningRequestT } from './solarxr-protocol/rpc/start-wifi-provisioning-request.js';
 export { StatusData, unionToStatusData, unionListToStatusData } from './solarxr-protocol/rpc/status-data.js';
 export { StatusMessage, StatusMessageT } from './solarxr-protocol/rpc/status-message.js';
+export { StatusPublicNetwork, StatusPublicNetworkT } from './solarxr-protocol/rpc/status-public-network.js';
 export { StatusSteamVRDisconnected, StatusSteamVRDisconnectedT } from './solarxr-protocol/rpc/status-steam-vrdisconnected.js';
 export { StatusSystemFixed, StatusSystemFixedT } from './solarxr-protocol/rpc/status-system-fixed.js';
 export { StatusSystemRequest, StatusSystemRequestT } from './solarxr-protocol/rpc/status-system-request.js';
diff --git a/protocol/typescript/src/solarxr-protocol/rpc/status-data.ts b/protocol/typescript/src/solarxr-protocol/rpc/status-data.ts
index 3a25ffcc..e84f22ed 100644
--- a/protocol/typescript/src/solarxr-protocol/rpc/status-data.ts
+++ b/protocol/typescript/src/solarxr-protocol/rpc/status-data.ts
@@ -1,5 +1,6 @@
 // automatically generated by the FlatBuffers compiler, do not modify
 
+import { StatusPublicNetwork, StatusPublicNetworkT } from '../../solarxr-protocol/rpc/status-public-network.js';
 import { StatusSteamVRDisconnected, StatusSteamVRDisconnectedT } from '../../solarxr-protocol/rpc/status-steam-vrdisconnected.js';
 import { StatusTrackerError, StatusTrackerErrorT } from '../../solarxr-protocol/rpc/status-tracker-error.js';
 import { StatusTrackerReset, StatusTrackerResetT } from '../../solarxr-protocol/rpc/status-tracker-reset.js';
@@ -11,34 +12,37 @@ export enum StatusData {
   StatusTrackerReset = 1,
   StatusTrackerError = 2,
   StatusSteamVRDisconnected = 3,
-  StatusUnassignedHMD = 4
+  StatusUnassignedHMD = 4,
+  StatusPublicNetwork = 5
 }
 
 export function unionToStatusData(
   type: StatusData,
-  accessor: (obj:StatusSteamVRDisconnected|StatusTrackerError|StatusTrackerReset|StatusUnassignedHMD) => StatusSteamVRDisconnected|StatusTrackerError|StatusTrackerReset|StatusUnassignedHMD|null
-): StatusSteamVRDisconnected|StatusTrackerError|StatusTrackerReset|StatusUnassignedHMD|null {
+  accessor: (obj:StatusPublicNetwork|StatusSteamVRDisconnected|StatusTrackerError|StatusTrackerReset|StatusUnassignedHMD) => StatusPublicNetwork|StatusSteamVRDisconnected|StatusTrackerError|StatusTrackerReset|StatusUnassignedHMD|null
+): StatusPublicNetwork|StatusSteamVRDisconnected|StatusTrackerError|StatusTrackerReset|StatusUnassignedHMD|null {
   switch(StatusData[type]) {
     case 'NONE': return null; 
     case 'StatusTrackerReset': return accessor(new StatusTrackerReset())! as StatusTrackerReset;
     case 'StatusTrackerError': return accessor(new StatusTrackerError())! as StatusTrackerError;
     case 'StatusSteamVRDisconnected': return accessor(new StatusSteamVRDisconnected())! as StatusSteamVRDisconnected;
     case 'StatusUnassignedHMD': return accessor(new StatusUnassignedHMD())! as StatusUnassignedHMD;
+    case 'StatusPublicNetwork': return accessor(new StatusPublicNetwork())! as StatusPublicNetwork;
     default: return null;
   }
 }
 
 export function unionListToStatusData(
   type: StatusData, 
-  accessor: (index: number, obj:StatusSteamVRDisconnected|StatusTrackerError|StatusTrackerReset|StatusUnassignedHMD) => StatusSteamVRDisconnected|StatusTrackerError|StatusTrackerReset|StatusUnassignedHMD|null, 
+  accessor: (index: number, obj:StatusPublicNetwork|StatusSteamVRDisconnected|StatusTrackerError|StatusTrackerReset|StatusUnassignedHMD) => StatusPublicNetwork|StatusSteamVRDisconnected|StatusTrackerError|StatusTrackerReset|StatusUnassignedHMD|null, 
   index: number
-): StatusSteamVRDisconnected|StatusTrackerError|StatusTrackerReset|StatusUnassignedHMD|null {
+): StatusPublicNetwork|StatusSteamVRDisconnected|StatusTrackerError|StatusTrackerReset|StatusUnassignedHMD|null {
   switch(StatusData[type]) {
     case 'NONE': return null; 
     case 'StatusTrackerReset': return accessor(index, new StatusTrackerReset())! as StatusTrackerReset;
     case 'StatusTrackerError': return accessor(index, new StatusTrackerError())! as StatusTrackerError;
     case 'StatusSteamVRDisconnected': return accessor(index, new StatusSteamVRDisconnected())! as StatusSteamVRDisconnected;
     case 'StatusUnassignedHMD': return accessor(index, new StatusUnassignedHMD())! as StatusUnassignedHMD;
+    case 'StatusPublicNetwork': return accessor(index, new StatusPublicNetwork())! as StatusPublicNetwork;
     default: return null;
   }
 }
diff --git a/protocol/typescript/src/solarxr-protocol/rpc/status-message.ts b/protocol/typescript/src/solarxr-protocol/rpc/status-message.ts
index c7a1a759..2e3d7b95 100644
--- a/protocol/typescript/src/solarxr-protocol/rpc/status-message.ts
+++ b/protocol/typescript/src/solarxr-protocol/rpc/status-message.ts
@@ -3,6 +3,7 @@
 import * as flatbuffers from 'flatbuffers';
 
 import { StatusData, unionToStatusData, unionListToStatusData } from '../../solarxr-protocol/rpc/status-data.js';
+import { StatusPublicNetwork, StatusPublicNetworkT } from '../../solarxr-protocol/rpc/status-public-network.js';
 import { StatusSteamVRDisconnected, StatusSteamVRDisconnectedT } from '../../solarxr-protocol/rpc/status-steam-vrdisconnected.js';
 import { StatusTrackerError, StatusTrackerErrorT } from '../../solarxr-protocol/rpc/status-tracker-error.js';
 import { StatusTrackerReset, StatusTrackerResetT } from '../../solarxr-protocol/rpc/status-tracker-reset.js';
@@ -122,7 +123,7 @@ constructor(
   public id: number = 0,
   public prioritized: boolean = false,
   public dataType: StatusData = StatusData.NONE,
-  public data: StatusSteamVRDisconnectedT|StatusTrackerErrorT|StatusTrackerResetT|StatusUnassignedHMDT|null = null
+  public data: StatusPublicNetworkT|StatusSteamVRDisconnectedT|StatusTrackerErrorT|StatusTrackerResetT|StatusUnassignedHMDT|null = null
 ){}
 
 
diff --git a/protocol/typescript/src/solarxr-protocol/rpc/status-public-network.ts b/protocol/typescript/src/solarxr-protocol/rpc/status-public-network.ts
new file mode 100644
index 00000000..6a81c0fc
--- /dev/null
+++ b/protocol/typescript/src/solarxr-protocol/rpc/status-public-network.ts
@@ -0,0 +1,57 @@
+// automatically generated by the FlatBuffers compiler, do not modify
+
+import * as flatbuffers from 'flatbuffers';
+
+
+
+/**
+ * When the server detects a public network profile
+ */
+export class StatusPublicNetwork implements flatbuffers.IUnpackableObject<StatusPublicNetworkT> {
+  bb: flatbuffers.ByteBuffer|null = null;
+  bb_pos = 0;
+  __init(i:number, bb:flatbuffers.ByteBuffer):StatusPublicNetwork {
+  this.bb_pos = i;
+  this.bb = bb;
+  return this;
+}
+
+static getRootAsStatusPublicNetwork(bb:flatbuffers.ByteBuffer, obj?:StatusPublicNetwork):StatusPublicNetwork {
+  return (obj || new StatusPublicNetwork()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+static getSizePrefixedRootAsStatusPublicNetwork(bb:flatbuffers.ByteBuffer, obj?:StatusPublicNetwork):StatusPublicNetwork {
+  bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH);
+  return (obj || new StatusPublicNetwork()).__init(bb.readInt32(bb.position()) + bb.position(), bb);
+}
+
+static startStatusPublicNetwork(builder:flatbuffers.Builder) {
+  builder.startObject(0);
+}
+
+static endStatusPublicNetwork(builder:flatbuffers.Builder):flatbuffers.Offset {
+  const offset = builder.endObject();
+  return offset;
+}
+
+static createStatusPublicNetwork(builder:flatbuffers.Builder):flatbuffers.Offset {
+  StatusPublicNetwork.startStatusPublicNetwork(builder);
+  return StatusPublicNetwork.endStatusPublicNetwork(builder);
+}
+
+unpack(): StatusPublicNetworkT {
+  return new StatusPublicNetworkT();
+}
+
+
+unpackTo(_o: StatusPublicNetworkT): void {}
+}
+
+export class StatusPublicNetworkT implements flatbuffers.IGeneratedObject {
+constructor(){}
+
+
+pack(builder:flatbuffers.Builder): flatbuffers.Offset {
+  return StatusPublicNetwork.createStatusPublicNetwork(builder);
+}
+}
diff --git a/schema/rpc.fbs b/schema/rpc.fbs
index 57d1f816..f2fe0948 100644
--- a/schema/rpc.fbs
+++ b/schema/rpc.fbs
@@ -538,6 +538,7 @@ union StatusData {
     StatusTrackerError,
     StatusSteamVRDisconnected,
     StatusUnassignedHMD,
+    StatusPublicNetwork,
 }
 
 /// Tracker requires full reset
@@ -579,6 +580,9 @@ table StatusSystemFixed {
     fixed_status_id: uint32;
 }
 
+/// When the server detects a public network profile
+table StatusPublicNetwork {}
+
 /// An status is some kind of warning sent by the server, it's mainly made for
 /// showing problems with the server and need attention from the user.
 table StatusMessage {